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.

The list the planner sees is not the same as the list of tools you can attach to an Agent in Python — the resolver knows about many more than the frozen legacy list. If you added a tool but --auto doesn’t pick it up, check that it appears in praisonai tools list.

---

How It Works

The OpenAI fallback runs through the core-owned praisonaiagents.llm.openai_client.OpenAIClient, which uses beta.chat.completions.parse under the hood. This means the fallback automatically picks up SDK-level features like OPENAI_MAX_RETRIES — see OpenAI Client Retries.

Step	What happens
1. LiteLLM attempt	Calls litellm.completion(model=..., response_format=PydanticModel)
2. Runtime fallback	If LiteLLM raises (auth error, timeout, unsupported model), logs a warning and continues
3. OpenAI fallback	Delegates to the core-owned OpenAIClient.parse_structured_output(...), which calls beta.chat.completions.parse under the hood. Inherits OPENAI_MAX_RETRIES automatically.
4. No providers	Raises ImportError with install instructions

The fallback warning message is: LiteLLM structured completion failed (...); falling back to OpenAI SDK. Watch your logs for this — it means LiteLLM is degrading silently.

---

Which Provider Should I Use?

---

Install Matrix

Installed	Auto mode behaviour
openai only	OpenAI SDK used directly via beta.chat.completions.parse
litellm only	LiteLLM used; if it raises, the call fails (no fallback)
both	LiteLLM first; on runtime error, falls back to OpenAI with a warning
neither	ImportError: Structured output requires either litellm or openai...

---

Configuration

Environment variable	What it does
OPENAI_API_KEY	API key used by both LiteLLM and OpenAI paths
OPENAI_MODEL_NAME	Model passed to whichever provider runs. For LiteLLM use prefixed names: anthropic/claude-sonnet-4, gemini/gemini-2.0-flash, ollama/llama3
OPENAI_API_BASE	Forwarded as base_url to the OpenAI client (overrides default endpoint)
ANTHROPIC_API_KEY	Required when OPENAI_MODEL_NAME=anthropic/...
GEMINI_API_KEY	Required when OPENAI_MODEL_NAME=gemini/...
OPENAI_MAX_RETRIES	Applied automatically to the OpenAI fallback leg (via the core OpenAIClient). See OpenAI Client Retries for details.

Auto Module SDK Reference

Full API reference for AutoGenerator, WorkflowAutoGenerator, and BaseAutoGenerator

---

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"

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 fall back to OpenAI automatically
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

Install both litellm and openai in production

Install both packages so transient LiteLLM failures (rate limits, network blips, provider outages) don’t break agent generation:

pip install litellm openai

LiteLLM runs first; OpenAI silently catches any runtime errors.

Watch logs for the fallback warning

The warning LiteLLM structured completion failed (...); falling back to OpenAI SDK. means LiteLLM silently degraded. Check:

• Is your provider API key set correctly?
• Does the model support response_format (structured output)?
• Is the provider having an outage?

Investigate before relying on the fallback long-term.

Pin model names in config_list for concurrent generators

If your code runs multiple AutoGenerator instances in parallel, set model names in config_list rather than OPENAI_MODEL_NAME to avoid environment variable races:

from praisonai import AutoGenerator

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

Do not import litellm at module scope

Lazy loading is on by default — litellm is never imported at module load time. Do not add import litellm at the top of your files. Let AutoGenerator pull it in on demand. This keeps startup fast and avoids import-time side effects.

---

Related

Auto Mode CLI

Command-line reference for praisonai --auto

AutoAgents

Automatically create and run agents from a prompt

Structured Output

Control agent output format with Pydantic models

YAML Workflows

The agents.yaml format generated by auto mode

Turn on SDK-level retries for the OpenAI fallback path