Auto Mode Providers

Use any of 100+ LLM providers with praisonai –auto via LiteLLM, with automatic OpenAI fallback

from praisonaiagents import Agent

agent = Agent(name="generator", instructions="Auto-generate content using configured providers.")
agent.start("Generate a product description for a smart speaker.")

Auto mode picks a provider for you: LiteLLM first (100+ providers), OpenAI as a safety net. The user describes a task in auto mode; the generator picks LiteLLM or falls back to OpenAI and writes the resulting agents YAML.

Quick Start

1. Default (OpenAI only)

   Install PraisonAI and set your OpenAI key:

   pip install "praisonai-frameworks[crewai]"

   export OPENAI_API_KEY=sk-...

   Run auto mode:

   praisonai --auto "research AI trends"

   Or programmatically:

   from praisonai import AutoGenerator
   
   generator = AutoGenerator(topic="research AI trends")
   result = generator.generate()
   print(result)

2. Unlock 100+ Providers with LiteLLM

   Install LiteLLM to use Anthropic, Google, Azure, Bedrock, Ollama, and more:

   pip install litellm

   Switch to Anthropic Claude:

   export ANTHROPIC_API_KEY=sk-ant-...
   export OPENAI_MODEL_NAME=anthropic/claude-sonnet-4
   praisonai --auto "research AI trends"

   Switch to Google Gemini:

   export GEMINI_API_KEY=...
   export OPENAI_MODEL_NAME=gemini/gemini-2.0-flash
   praisonai --auto "research AI trends"

   Switch to a local Ollama model:

   export OPENAI_MODEL_NAME=ollama/llama3
   praisonai --auto "research AI trends"

3. Programmatic Use (Sync & Async)

   Both sync and async paths honour the LiteLLM → OpenAI fallback:

   from praisonai import AutoGenerator
   
   generator = AutoGenerator(topic="summarise recent AI papers")
   agents_yaml = generator.generate()
   print(agents_yaml)

   Async version:

   import asyncio
   from praisonai import AutoGenerator
   
   async def main():
       generator = AutoGenerator(topic="summarise recent AI papers")
       agents_yaml = await generator.agenerate()
       print(agents_yaml)
   
   asyncio.run(main())

4. Calling from an existing event loop (FastAPI, Jupyter)

   AutoGenerator.generate() can now be called from inside a running event loop — it offloads to a worker thread automatically instead of raising RuntimeError: This event loop is already running.

   from fastapi import FastAPI
   from praisonai import AutoGenerator
   
   app = FastAPI()
   
   @app.get("/generate")
   async def generate(topic: str):
       generator = AutoGenerator(topic=topic)
       # Safe to call .generate() here — no RuntimeError
       agents_yaml = generator.generate()
       return {"yaml": agents_yaml}

   Prefer await generator.agenerate() when you are already in an async context — it avoids the thread-offload overhead. The sync .generate() form is provided as a safe fallback.

Tool inventory in --auto

praisonai --auto shows the planner a live list of installed tools, sourced from the canonical ToolResolver. What the planner sees always matches what your agents can actually call at run time — no drift.

If the resolver is unavailable (e.g. praisonai_tools and praisonaiagents.tools both fail to import), the planner falls back to a frozen list so --auto still produces a working plan.

One warm resolver cache per run. The AutoGenerator planning step and the downstream AgentsGenerator execution step share the same context-local resolver — installed-tool discovery only runs once per --auto invocation.

Safe by Default

praisonai --auto treats your topic as untrusted input, so shell tools stay opt-in and the generation prompt is fenced against injection.

# No shell tool is added — the topic never asks for code execution
praisonai --auto "research AI trends"

execute_command is attached only when the topic matches a code_execution keyword (execute, run code, python, script, command, shell), and a server-side gate strips it from any role whose task did not trigger that intent.

How It Works

Automatic Retries on LiteLLM

A transient rate limit or server error no longer breaks praisonai --auto — the LiteLLM leg retries before anything else happens.

Each retry logs a warning:

Transient LLM error (<exc>); retrying in <delay>s (attempt N/2).

When retries run out, the existing OpenAI fallback runs and the LiteLLM error is chained as the cause.

Which Provider Should I Use?

Install Matrix

Configuration

Job-workflow generation honours your configured model

The praisonai --auto ... --workflow job-workflow generator now emits YAML that matches your configured model instead of hard-coding gpt-4o-mini:

• The generation prompt advertises the workspace’s configured model (config_list[0]["model"]) to the LLM, and instructs it: “Do NOT invent model names. If unsure, omit the model key entirely and it will inherit the workspace default.”
• The YAML writer only pins model: on an agent step when the generator supplied a real value. When the model is omitted, the step inherits default_llm (the workspace default) at execution time.

Anthropic / Bedrock / Ollama users get a runnable generated workflow with no manual model editing.

# Before — every agent step hard-coded OpenAI, unusable without an OpenAI key
steps:
  - name: Generate release notes
    agent:
      role: Writer
      model: gpt-4o-mini

# After — model is omitted (inherits your workspace default), or names your configured model
steps:
  - name: Generate release notes
    agent:
      role: Writer
      # no model: → inherits default_llm (e.g. ollama/llama3)

Common Patterns

Switch from OpenAI to Anthropic:

pip install litellm
export ANTHROPIC_API_KEY=sk-ant-...
export OPENAI_MODEL_NAME=anthropic/claude-sonnet-4
praisonai --auto "write a market analysis report"

Run against a local Ollama model (no cloud keys needed):

pip install litellm
# Ollama must be running locally on port 11434
export OPENAI_MODEL_NAME=ollama/llama3
praisonai --auto "summarise today's news"

Generate a job workflow on Ollama (emitted YAML matches your model):

pip install litellm
export OPENAI_MODEL_NAME=ollama/llama3
praisonai --auto "generate a release job workflow" --workflow

The generated workflow YAML either omits model: (steps inherit ollama/llama3 from the workspace) or names ollama/llama3 directly — it runs without an OpenAI key, where previously every step said model: gpt-4o-mini and failed at execution.

Belt-and-braces production setup (LiteLLM + OpenAI fallback):

pip install litellm openai
export ANTHROPIC_API_KEY=sk-ant-...
export OPENAI_API_KEY=sk-...
export OPENAI_MODEL_NAME=anthropic/claude-sonnet-4
# LiteLLM runs first; transient errors retry on LiteLLM, and only after retries are exhausted does the call fall back to OpenAI
praisonai --auto "generate a weekly status report"

Async programmatic use:

import asyncio
from praisonai import AutoGenerator

async def run():
    async with AutoGenerator(topic="competitor analysis") as gen:
        yaml_config = await gen.agenerate()
        print(yaml_config)

asyncio.run(run())

Best Practices

pip install litellm openai

from praisonai import AutoGenerator

gen = AutoGenerator(
    topic="topic",
    config_list=[{
        "model": "anthropic/claude-sonnet-4",
        "api_key": "sk-ant-...",
    }]
)

Related