Response from ADK Answering Agent (experimental, answer may be inaccurate)

TLDR: Currently, you can't directly instantiate the LiteLlm model wrapper from within a YAML configuration file. The recommended approach is to define your LlmAgent with the LiteLlm model in a Python file and then either use it directly or, if you are building a multi-agent system, reference it from your YAML configuration.

Hello! That's a great question. You are right that most examples focus on Gemini models. Integrating other models like those from OpenAI, Anthropic, or local models is a key feature of ADK, and it's achieved using our LiteLlm wrapper.

While you can't define the LiteLlm model directly inside the root_agent.yaml, here is the standard way to accomplish your goal:

1. Define the Agent in Python

The most direct and documented way to use litellm is to configure your agent in a Python file. This gives you the full flexibility of Python.

First, ensure you have litellm installed and your API keys are set as environment variables [1, 2]. For OpenAI, you would set:

export OPENAI_API_KEY="YOUR_OPENAI_API_KEY"

Next, create a Python file (e.g., my_openai_agent.py) and define your agent like this:

from google.adk.agents import LlmAgent
from google.adk.models.lite_llm import LiteLlm

# --- Agent using OpenAI's GPT-4o via LiteLLM ---
my_agent = LlmAgent(
    model=LiteLlm(model="openai/gpt-4o"), 
    name="openai_agent",
    instruction="You are a helpful assistant powered by GPT-4o.",
    # You can still define tools and other parameters here
    # tools=[...]
)

You can now use my_agent directly in your application runner.

2. Referencing a Python-defined Agent from YAML

If you are using a YAML-centric workflow for a multi-agent setup (e.g., a Supervisor agent with sub-agents), you can define your litellm-powered agent in Python as shown above, and then reference that Python object from your YAML config.

For instance, if you have a supervisor agent defined in supervisor.yaml, you could list the Python-based agent as a sub-agent [4]:

my_agents.py

from google.adk.agents import LlmAgent
from google.adk.models.lite_llm import LiteLlm

openai_tool_agent = LlmAgent(
    model=LiteLlm(model="openai/gpt-4o"),
    name="openai_tool_agent",
    description="An agent that can perform tasks using OpenAI.",
    # ... tools, etc.
)

supervisor.yaml

agent_class: Supervisor
name: my_supervisor
# ... other supervisor config
sub_agents:
  - code: my_agents.openai_tool_agent # This points to the Python object
  - config_path: some_other_gemini_agent.yaml

This approach allows you to keep your agent configurations modular while seamlessly integrating agents that use different model backends.

For more details on using different models, you can refer to the official documentation [1].

Let us know if you have any more questions!

[1] https://google.github.io/adk-docs/agents/models
[2] https://google.github.io/adk-docs/tutorials/agent-team
[4] https://github.com/google/adk-python/blob/main/src/google/adk/agents/common_configs.py

Let's use the other discussion thread.