mirror of
https://github.com/onyx-dot-app/litellm.git
synced 2026-07-01 20:44:04 -04:00
[Docs] Using litellm with Google ADK (#10777)
* docs litellm ADK usage * docs litellm google adk * docs litellm ADK * docs litellm with ADK usage examples * docs litellm proxy with ADK * cookbook litellm ADK
This commit is contained in:
Ishaan Jaff
+412
@@ -0,0 +1,412 @@
|
||||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "7aa8875d",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# Google ADK with LiteLLM\n",
|
||||
"\n",
|
||||
"Use Google ADK with LiteLLM Python SDK, LiteLLM Proxy.\n",
|
||||
"\n",
|
||||
"This tutorial shows you how to create intelligent agents using Agent Development Kit (ADK) with support for multiple Large Language Model (LLM) providers through LiteLLM."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "a4d249c3",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Overview\n",
|
||||
"\n",
|
||||
"ADK (Agent Development Kit) allows you to build intelligent agents powered by LLMs. By integrating with LiteLLM, you can:\n",
|
||||
"\n",
|
||||
"- Use multiple LLM providers (OpenAI, Anthropic, Google, etc.)\n",
|
||||
"- Switch easily between models from different providers\n",
|
||||
"- Connect to a LiteLLM proxy for centralized model management"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "a0bbb56b",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Prerequisites\n",
|
||||
"\n",
|
||||
"- Python environment setup\n",
|
||||
"- API keys for model providers (OpenAI, Anthropic, Google AI Studio)\n",
|
||||
"- Basic understanding of LLMs and agent concepts"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "7fee50a8",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Installation"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"id": "44106a23",
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Install dependencies\n",
|
||||
"!pip install google-adk litellm"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "2171740a",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 1. Setting Up Environment"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"id": "6695807e",
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Setup environment and API keys\n",
|
||||
"import os\n",
|
||||
"import asyncio\n",
|
||||
"from google.adk.agents import Agent\n",
|
||||
"from google.adk.models.lite_llm import LiteLlm # For multi-model support\n",
|
||||
"from google.adk.sessions import InMemorySessionService\n",
|
||||
"from google.adk.runners import Runner\n",
|
||||
"from google.genai import types\n",
|
||||
"import litellm # Import for proxy configuration\n",
|
||||
"\n",
|
||||
"# Set your API keys\n",
|
||||
"os.environ['GOOGLE_API_KEY'] = 'your-google-api-key' # For Gemini models\n",
|
||||
"os.environ['OPENAI_API_KEY'] = 'your-openai-api-key' # For OpenAI models\n",
|
||||
"os.environ['ANTHROPIC_API_KEY'] = 'your-anthropic-api-key' # For Claude models\n",
|
||||
"\n",
|
||||
"# Define model constants for cleaner code\n",
|
||||
"MODEL_GEMINI_PRO = 'gemini-1.5-pro'\n",
|
||||
"MODEL_GPT_4O = 'openai/gpt-4o'\n",
|
||||
"MODEL_CLAUDE_SONNET = 'anthropic/claude-3-sonnet-20240229'"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "d2b1ed59",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 2. Define a Simple Tool"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"id": "04b3ef5b",
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Weather tool implementation\n",
|
||||
"def get_weather(city: str) -> dict:\n",
|
||||
" \"\"\"Retrieves the current weather report for a specified city.\"\"\"\n",
|
||||
" print(f'Tool: get_weather called for city: {city}')\n",
|
||||
"\n",
|
||||
" # Mock weather data\n",
|
||||
" mock_weather_db = {\n",
|
||||
" 'newyork': {\n",
|
||||
" 'status': 'success',\n",
|
||||
" 'report': 'The weather in New York is sunny with a temperature of 25°C.'\n",
|
||||
" },\n",
|
||||
" 'london': {\n",
|
||||
" 'status': 'success',\n",
|
||||
" 'report': \"It's cloudy in London with a temperature of 15°C.\"\n",
|
||||
" },\n",
|
||||
" 'tokyo': {\n",
|
||||
" 'status': 'success',\n",
|
||||
" 'report': 'Tokyo is experiencing light rain and a temperature of 18°C.'\n",
|
||||
" },\n",
|
||||
" }\n",
|
||||
"\n",
|
||||
" city_normalized = city.lower().replace(' ', '')\n",
|
||||
"\n",
|
||||
" if city_normalized in mock_weather_db:\n",
|
||||
" return mock_weather_db[city_normalized]\n",
|
||||
" else:\n",
|
||||
" return {\n",
|
||||
" 'status': 'error',\n",
|
||||
" 'error_message': f\"Sorry, I don't have weather information for '{city}'.\"\n",
|
||||
" }"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "727b15c9",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 3. Helper Function for Agent Interaction"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"id": "f77449bf",
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Agent interaction helper function\n",
|
||||
"async def call_agent_async(query: str, runner, user_id, session_id):\n",
|
||||
" \"\"\"Sends a query to the agent and prints the final response.\"\"\"\n",
|
||||
" print(f'\\n>>> User Query: {query}')\n",
|
||||
"\n",
|
||||
" content = types.Content(role='user', parts=[types.Part(text=query)])\n",
|
||||
" final_response_text = 'Agent did not produce a final response.'\n",
|
||||
"\n",
|
||||
" async for event in runner.run_async(\n",
|
||||
" user_id=user_id,\n",
|
||||
" session_id=session_id,\n",
|
||||
" new_message=content\n",
|
||||
" ):\n",
|
||||
" if event.is_final_response():\n",
|
||||
" if event.content and event.content.parts:\n",
|
||||
" final_response_text = event.content.parts[0].text\n",
|
||||
" break\n",
|
||||
" print(f'<<< Agent Response: {final_response_text}')"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "0ac87987",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 4. Using Different Model Providers with ADK\n",
|
||||
"\n",
|
||||
"### 4.1 Using OpenAI Models"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"id": "e167d557",
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# OpenAI model implementation\n",
|
||||
"weather_agent_gpt = Agent(\n",
|
||||
" name='weather_agent_gpt',\n",
|
||||
" model=LiteLlm(model=MODEL_GPT_4O),\n",
|
||||
" description='Provides weather information using OpenAI\\'s GPT.',\n",
|
||||
" instruction=(\n",
|
||||
" 'You are a helpful weather assistant powered by GPT-4o. '\n",
|
||||
" \"Use the 'get_weather' tool for city weather requests. \"\n",
|
||||
" 'Present information clearly.'\n",
|
||||
" ),\n",
|
||||
" tools=[get_weather],\n",
|
||||
")\n",
|
||||
"\n",
|
||||
"session_service_gpt = InMemorySessionService()\n",
|
||||
"session_gpt = session_service_gpt.create_session(\n",
|
||||
" app_name='weather_app', user_id='user_1', session_id='session_gpt'\n",
|
||||
")\n",
|
||||
"\n",
|
||||
"runner_gpt = Runner(\n",
|
||||
" agent=weather_agent_gpt,\n",
|
||||
" app_name='weather_app',\n",
|
||||
" session_service=session_service_gpt,\n",
|
||||
")\n",
|
||||
"\n",
|
||||
"async def test_gpt_agent():\n",
|
||||
" print('\\n--- Testing GPT Agent ---')\n",
|
||||
" await call_agent_async(\n",
|
||||
" \"What's the weather in London?\",\n",
|
||||
" runner=runner_gpt,\n",
|
||||
" user_id='user_1',\n",
|
||||
" session_id='session_gpt',\n",
|
||||
" )\n",
|
||||
"\n",
|
||||
"# To execute in a notebook cell:\n",
|
||||
"# await test_gpt_agent()"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "f9cb0613",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### 4.2 Using Anthropic Models"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"id": "1c653665",
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Anthropic model implementation\n",
|
||||
"weather_agent_claude = Agent(\n",
|
||||
" name='weather_agent_claude',\n",
|
||||
" model=LiteLlm(model=MODEL_CLAUDE_SONNET),\n",
|
||||
" description='Provides weather information using Anthropic\\'s Claude.',\n",
|
||||
" instruction=(\n",
|
||||
" 'You are a helpful weather assistant powered by Claude Sonnet. '\n",
|
||||
" \"Use the 'get_weather' tool for city weather requests. \"\n",
|
||||
" 'Present information clearly.'\n",
|
||||
" ),\n",
|
||||
" tools=[get_weather],\n",
|
||||
")\n",
|
||||
"\n",
|
||||
"session_service_claude = InMemorySessionService()\n",
|
||||
"session_claude = session_service_claude.create_session(\n",
|
||||
" app_name='weather_app', user_id='user_1', session_id='session_claude'\n",
|
||||
")\n",
|
||||
"\n",
|
||||
"runner_claude = Runner(\n",
|
||||
" agent=weather_agent_claude,\n",
|
||||
" app_name='weather_app',\n",
|
||||
" session_service=session_service_claude,\n",
|
||||
")\n",
|
||||
"\n",
|
||||
"async def test_claude_agent():\n",
|
||||
" print('\\n--- Testing Claude Agent ---')\n",
|
||||
" await call_agent_async(\n",
|
||||
" \"What's the weather in Tokyo?\",\n",
|
||||
" runner=runner_claude,\n",
|
||||
" user_id='user_1',\n",
|
||||
" session_id='session_claude',\n",
|
||||
" )\n",
|
||||
"\n",
|
||||
"# To execute in a notebook cell:\n",
|
||||
"# await test_claude_agent()"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "bf9d863b",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### 4.3 Using Google's Gemini Models"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"id": "83f49d0a",
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# Gemini model implementation\n",
|
||||
"weather_agent_gemini = Agent(\n",
|
||||
" name='weather_agent_gemini',\n",
|
||||
" model=MODEL_GEMINI_PRO,\n",
|
||||
" description='Provides weather information using Google\\'s Gemini.',\n",
|
||||
" instruction=(\n",
|
||||
" 'You are a helpful weather assistant powered by Gemini Pro. '\n",
|
||||
" \"Use the 'get_weather' tool for city weather requests. \"\n",
|
||||
" 'Present information clearly.'\n",
|
||||
" ),\n",
|
||||
" tools=[get_weather],\n",
|
||||
")\n",
|
||||
"\n",
|
||||
"session_service_gemini = InMemorySessionService()\n",
|
||||
"session_gemini = session_service_gemini.create_session(\n",
|
||||
" app_name='weather_app', user_id='user_1', session_id='session_gemini'\n",
|
||||
")\n",
|
||||
"\n",
|
||||
"runner_gemini = Runner(\n",
|
||||
" agent=weather_agent_gemini,\n",
|
||||
" app_name='weather_app',\n",
|
||||
" session_service=session_service_gemini,\n",
|
||||
")\n",
|
||||
"\n",
|
||||
"async def test_gemini_agent():\n",
|
||||
" print('\\n--- Testing Gemini Agent ---')\n",
|
||||
" await call_agent_async(\n",
|
||||
" \"What's the weather in New York?\",\n",
|
||||
" runner=runner_gemini,\n",
|
||||
" user_id='user_1',\n",
|
||||
" session_id='session_gemini',\n",
|
||||
" )\n",
|
||||
"\n",
|
||||
"# To execute in a notebook cell:\n",
|
||||
"# await test_gemini_agent()"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "93bc5fd0",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 5. Using LiteLLM Proxy with ADK"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"id": "b4275151",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"| Variable | Description |\n",
|
||||
"|----------|-------------|\n",
|
||||
"| `LITELLM_PROXY_API_KEY` | The API key for the LiteLLM proxy |\n",
|
||||
"| `LITELLM_PROXY_API_BASE` | The base URL for the LiteLLM proxy |\n",
|
||||
"| `USE_LITELLM_PROXY` or `litellm.use_litellm_proxy` | When set to True, your request will be sent to LiteLLM proxy. |"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"id": "256530a6",
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# LiteLLM proxy integration\n",
|
||||
"os.environ['LITELLM_PROXY_API_KEY'] = 'your-litellm-proxy-api-key'\n",
|
||||
"os.environ['LITELLM_PROXY_API_BASE'] = 'your-litellm-proxy-url' # e.g., 'http://localhost:4000'\n",
|
||||
"litellm.use_litellm_proxy = True\n",
|
||||
"\n",
|
||||
"weather_agent_proxy_env = Agent(\n",
|
||||
" name='weather_agent_proxy_env',\n",
|
||||
" model=LiteLlm(model='gpt-4o'),\n",
|
||||
" description='Provides weather information using a model from LiteLLM proxy.',\n",
|
||||
" instruction=(\n",
|
||||
" 'You are a helpful weather assistant. '\n",
|
||||
" \"Use the 'get_weather' tool for city weather requests. \"\n",
|
||||
" 'Present information clearly.'\n",
|
||||
" ),\n",
|
||||
" tools=[get_weather],\n",
|
||||
")\n",
|
||||
"\n",
|
||||
"session_service_proxy_env = InMemorySessionService()\n",
|
||||
"session_proxy_env = session_service_proxy_env.create_session(\n",
|
||||
" app_name='weather_app', user_id='user_1', session_id='session_proxy_env'\n",
|
||||
")\n",
|
||||
"\n",
|
||||
"runner_proxy_env = Runner(\n",
|
||||
" agent=weather_agent_proxy_env,\n",
|
||||
" app_name='weather_app',\n",
|
||||
" session_service=session_service_proxy_env,\n",
|
||||
")\n",
|
||||
"\n",
|
||||
"async def test_proxy_env_agent():\n",
|
||||
" print('\\n--- Testing Proxy-enabled Agent (Environment Variables) ---')\n",
|
||||
" await call_agent_async(\n",
|
||||
" \"What's the weather in London?\",\n",
|
||||
" runner=runner_proxy_env,\n",
|
||||
" user_id='user_1',\n",
|
||||
" session_id='session_proxy_env',\n",
|
||||
" )\n",
|
||||
"\n",
|
||||
"# To execute in a notebook cell:\n",
|
||||
"# await test_proxy_env_agent()"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"language_info": {
|
||||
"name": "python"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 5
|
||||
}
|
||||
@@ -0,0 +1,324 @@
|
||||
import Tabs from '@theme/Tabs';
|
||||
import TabItem from '@theme/TabItem';
|
||||
import Image from '@theme/IdealImage';
|
||||
|
||||
|
||||
# Google ADK with LiteLLM
|
||||
|
||||
<Image
|
||||
img={require('../../img/litellm_adk.png')}
|
||||
style={{width: '90%', display: 'block', margin: '2rem 0'}}
|
||||
/>
|
||||
<p style={{textAlign: 'left', color: '#666'}}>
|
||||
Use Google ADK with LiteLLM Python SDK, LiteLLM Proxy
|
||||
</p>
|
||||
|
||||
|
||||
This tutorial shows you how to create intelligent agents using Agent Development Kit (ADK) with support for multiple Large Language Model (LLM) providers with LiteLLM.
|
||||
|
||||
|
||||
|
||||
## Overview
|
||||
|
||||
ADK (Agent Development Kit) allows you to build intelligent agents powered by LLMs. By integrating with LiteLLM, you can:
|
||||
|
||||
- Use multiple LLM providers (OpenAI, Anthropic, Google, etc.)
|
||||
- Switch easily between models from different providers
|
||||
- Connect to a LiteLLM proxy for centralized model management
|
||||
|
||||
## Prerequisites
|
||||
|
||||
- Python environment setup
|
||||
- API keys for model providers (OpenAI, Anthropic, Google AI Studio)
|
||||
- Basic understanding of LLMs and agent concepts
|
||||
|
||||
## Installation
|
||||
|
||||
```bash showLineNumbers title="Install dependencies"
|
||||
pip install google-adk litellm
|
||||
```
|
||||
|
||||
## 1. Setting Up Environment
|
||||
|
||||
First, import the necessary libraries and set up your API keys:
|
||||
|
||||
```python showLineNumbers title="Setup environment and API keys"
|
||||
import os
|
||||
import asyncio
|
||||
from google.adk.agents import Agent
|
||||
from google.adk.models.lite_llm import LiteLlm # For multi-model support
|
||||
from google.adk.sessions import InMemorySessionService
|
||||
from google.adk.runners import Runner
|
||||
from google.genai import types
|
||||
import litellm # Import for proxy configuration
|
||||
|
||||
# Set your API keys
|
||||
os.environ["GOOGLE_API_KEY"] = "your-google-api-key" # For Gemini models
|
||||
os.environ["OPENAI_API_KEY"] = "your-openai-api-key" # For OpenAI models
|
||||
os.environ["ANTHROPIC_API_KEY"] = "your-anthropic-api-key" # For Claude models
|
||||
|
||||
# Define model constants for cleaner code
|
||||
MODEL_GEMINI_PRO = "gemini-1.5-pro"
|
||||
MODEL_GPT_4O = "openai/gpt-4o"
|
||||
MODEL_CLAUDE_SONNET = "anthropic/claude-3-sonnet-20240229"
|
||||
```
|
||||
|
||||
## 2. Define a Simple Tool
|
||||
|
||||
Create a tool that your agent can use:
|
||||
|
||||
```python showLineNumbers title="Weather tool implementation"
|
||||
def get_weather(city: str) -> dict:
|
||||
"""Retrieves the current weather report for a specified city.
|
||||
|
||||
Args:
|
||||
city (str): The name of the city (e.g., "New York", "London", "Tokyo").
|
||||
|
||||
Returns:
|
||||
dict: A dictionary containing the weather information.
|
||||
Includes a 'status' key ('success' or 'error').
|
||||
If 'success', includes a 'report' key with weather details.
|
||||
If 'error', includes an 'error_message' key.
|
||||
"""
|
||||
print(f"Tool: get_weather called for city: {city}")
|
||||
|
||||
# Mock weather data
|
||||
mock_weather_db = {
|
||||
"newyork": {"status": "success", "report": "The weather in New York is sunny with a temperature of 25°C."},
|
||||
"london": {"status": "success", "report": "It's cloudy in London with a temperature of 15°C."},
|
||||
"tokyo": {"status": "success", "report": "Tokyo is experiencing light rain and a temperature of 18°C."},
|
||||
}
|
||||
|
||||
city_normalized = city.lower().replace(" ", "")
|
||||
|
||||
if city_normalized in mock_weather_db:
|
||||
return mock_weather_db[city_normalized]
|
||||
else:
|
||||
return {"status": "error", "error_message": f"Sorry, I don't have weather information for '{city}'."}
|
||||
```
|
||||
|
||||
## 3. Helper Function for Agent Interaction
|
||||
|
||||
Create a helper function to facilitate agent interaction:
|
||||
|
||||
```python showLineNumbers title="Agent interaction helper function"
|
||||
async def call_agent_async(query: str, runner, user_id, session_id):
|
||||
"""Sends a query to the agent and prints the final response."""
|
||||
print(f"\n>>> User Query: {query}")
|
||||
|
||||
# Prepare the user's message in ADK format
|
||||
content = types.Content(role='user', parts=[types.Part(text=query)])
|
||||
|
||||
final_response_text = "Agent did not produce a final response."
|
||||
|
||||
# Execute the agent and find the final response
|
||||
async for event in runner.run_async(
|
||||
user_id=user_id,
|
||||
session_id=session_id,
|
||||
new_message=content
|
||||
):
|
||||
if event.is_final_response():
|
||||
if event.content and event.content.parts:
|
||||
final_response_text = event.content.parts[0].text
|
||||
break
|
||||
|
||||
print(f"<<< Agent Response: {final_response_text}")
|
||||
```
|
||||
|
||||
## 4. Using Different Model Providers with ADK
|
||||
|
||||
### 4.1 Using OpenAI Models
|
||||
|
||||
```python showLineNumbers title="OpenAI model implementation"
|
||||
# Create an agent powered by OpenAI's GPT model
|
||||
weather_agent_gpt = Agent(
|
||||
name="weather_agent_gpt",
|
||||
model=LiteLlm(model=MODEL_GPT_4O), # Use OpenAI's GPT model
|
||||
description="Provides weather information using OpenAI's GPT.",
|
||||
instruction="You are a helpful weather assistant powered by GPT-4o. "
|
||||
"Use the 'get_weather' tool for city weather requests. "
|
||||
"Present information clearly.",
|
||||
tools=[get_weather],
|
||||
)
|
||||
|
||||
# Set up session and runner
|
||||
session_service_gpt = InMemorySessionService()
|
||||
session_gpt = session_service_gpt.create_session(
|
||||
app_name="weather_app",
|
||||
user_id="user_1",
|
||||
session_id="session_gpt"
|
||||
)
|
||||
|
||||
runner_gpt = Runner(
|
||||
agent=weather_agent_gpt,
|
||||
app_name="weather_app",
|
||||
session_service=session_service_gpt
|
||||
)
|
||||
|
||||
# Test the GPT agent
|
||||
async def test_gpt_agent():
|
||||
print("\n--- Testing GPT Agent ---")
|
||||
await call_agent_async(
|
||||
"What's the weather in London?",
|
||||
runner=runner_gpt,
|
||||
user_id="user_1",
|
||||
session_id="session_gpt"
|
||||
)
|
||||
|
||||
# Execute the conversation with the GPT agent
|
||||
await test_gpt_agent()
|
||||
|
||||
# Or if running as a standard Python script:
|
||||
# if __name__ == "__main__":
|
||||
# asyncio.run(test_gpt_agent())
|
||||
```
|
||||
|
||||
### 4.2 Using Anthropic Models
|
||||
|
||||
```python showLineNumbers title="Anthropic model implementation"
|
||||
# Create an agent powered by Anthropic's Claude model
|
||||
weather_agent_claude = Agent(
|
||||
name="weather_agent_claude",
|
||||
model=LiteLlm(model=MODEL_CLAUDE_SONNET), # Use Anthropic's Claude model
|
||||
description="Provides weather information using Anthropic's Claude.",
|
||||
instruction="You are a helpful weather assistant powered by Claude Sonnet. "
|
||||
"Use the 'get_weather' tool for city weather requests. "
|
||||
"Present information clearly.",
|
||||
tools=[get_weather],
|
||||
)
|
||||
|
||||
# Set up session and runner
|
||||
session_service_claude = InMemorySessionService()
|
||||
session_claude = session_service_claude.create_session(
|
||||
app_name="weather_app",
|
||||
user_id="user_1",
|
||||
session_id="session_claude"
|
||||
)
|
||||
|
||||
runner_claude = Runner(
|
||||
agent=weather_agent_claude,
|
||||
app_name="weather_app",
|
||||
session_service=session_service_claude
|
||||
)
|
||||
|
||||
# Test the Claude agent
|
||||
async def test_claude_agent():
|
||||
print("\n--- Testing Claude Agent ---")
|
||||
await call_agent_async(
|
||||
"What's the weather in Tokyo?",
|
||||
runner=runner_claude,
|
||||
user_id="user_1",
|
||||
session_id="session_claude"
|
||||
)
|
||||
|
||||
# Execute the conversation with the Claude agent
|
||||
await test_claude_agent()
|
||||
|
||||
# Or if running as a standard Python script:
|
||||
# if __name__ == "__main__":
|
||||
# asyncio.run(test_claude_agent())
|
||||
```
|
||||
|
||||
### 4.3 Using Google's Gemini Models
|
||||
|
||||
```python showLineNumbers title="Gemini model implementation"
|
||||
# Create an agent powered by Google's Gemini model
|
||||
weather_agent_gemini = Agent(
|
||||
name="weather_agent_gemini",
|
||||
model=MODEL_GEMINI_PRO, # Use Gemini model directly (no LiteLlm wrapper needed)
|
||||
description="Provides weather information using Google's Gemini.",
|
||||
instruction="You are a helpful weather assistant powered by Gemini Pro. "
|
||||
"Use the 'get_weather' tool for city weather requests. "
|
||||
"Present information clearly.",
|
||||
tools=[get_weather],
|
||||
)
|
||||
|
||||
# Set up session and runner
|
||||
session_service_gemini = InMemorySessionService()
|
||||
session_gemini = session_service_gemini.create_session(
|
||||
app_name="weather_app",
|
||||
user_id="user_1",
|
||||
session_id="session_gemini"
|
||||
)
|
||||
|
||||
runner_gemini = Runner(
|
||||
agent=weather_agent_gemini,
|
||||
app_name="weather_app",
|
||||
session_service=session_service_gemini
|
||||
)
|
||||
|
||||
# Test the Gemini agent
|
||||
async def test_gemini_agent():
|
||||
print("\n--- Testing Gemini Agent ---")
|
||||
await call_agent_async(
|
||||
"What's the weather in New York?",
|
||||
runner=runner_gemini,
|
||||
user_id="user_1",
|
||||
session_id="session_gemini"
|
||||
)
|
||||
|
||||
# Execute the conversation with the Gemini agent
|
||||
await test_gemini_agent()
|
||||
|
||||
# Or if running as a standard Python script:
|
||||
# if __name__ == "__main__":
|
||||
# asyncio.run(test_gemini_agent())
|
||||
```
|
||||
|
||||
## 5. Using LiteLLM Proxy with ADK
|
||||
|
||||
LiteLLM proxy provides a unified API endpoint for multiple models, simplifying deployment and centralized management.
|
||||
|
||||
Required settings for using litellm proxy
|
||||
|
||||
| Variable | Description |
|
||||
|----------|-------------|
|
||||
| `LITELLM_PROXY_API_KEY` | The API key for the LiteLLM proxy |
|
||||
| `LITELLM_PROXY_API_BASE` | The base URL for the LiteLLM proxy |
|
||||
| `USE_LITELLM_PROXY` or `litellm.use_litellm_proxy` | When set to True, your request will be sent to litellm proxy. |
|
||||
|
||||
```python showLineNumbers title="LiteLLM proxy integration"
|
||||
# Set your LiteLLM Proxy credentials as environment variables
|
||||
os.environ["LITELLM_PROXY_API_KEY"] = "your-litellm-proxy-api-key"
|
||||
os.environ["LITELLM_PROXY_API_BASE"] = "your-litellm-proxy-url" # e.g., "http://localhost:4000"
|
||||
# Enable the use_litellm_proxy flag
|
||||
litellm.use_litellm_proxy = True
|
||||
|
||||
# Create a proxy-enabled agent (using environment variables)
|
||||
weather_agent_proxy_env = Agent(
|
||||
name="weather_agent_proxy_env",
|
||||
model=LiteLlm(model="gpt-4o"), # this will call the `gpt-4o` model on LiteLLM proxy
|
||||
description="Provides weather information using a model from LiteLLM proxy.",
|
||||
instruction="You are a helpful weather assistant. "
|
||||
"Use the 'get_weather' tool for city weather requests. "
|
||||
"Present information clearly.",
|
||||
tools=[get_weather],
|
||||
)
|
||||
|
||||
# Set up session and runner
|
||||
session_service_proxy_env = InMemorySessionService()
|
||||
session_proxy_env = session_service_proxy_env.create_session(
|
||||
app_name="weather_app",
|
||||
user_id="user_1",
|
||||
session_id="session_proxy_env"
|
||||
)
|
||||
|
||||
runner_proxy_env = Runner(
|
||||
agent=weather_agent_proxy_env,
|
||||
app_name="weather_app",
|
||||
session_service=session_service_proxy_env
|
||||
)
|
||||
|
||||
# Test the proxy-enabled agent (environment variables method)
|
||||
async def test_proxy_env_agent():
|
||||
print("\n--- Testing Proxy-enabled Agent (Environment Variables) ---")
|
||||
await call_agent_async(
|
||||
"What's the weather in London?",
|
||||
runner=runner_proxy_env,
|
||||
user_id="user_1",
|
||||
session_id="session_proxy_env"
|
||||
)
|
||||
|
||||
# Execute the conversation
|
||||
await test_proxy_env_agent()
|
||||
```
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 196 KiB |
@@ -494,7 +494,7 @@ const sidebars = {
|
||||
type: "category",
|
||||
label: "LiteLLM Python SDK Tutorials",
|
||||
items: [
|
||||
|
||||
'tutorials/google_adk',
|
||||
'tutorials/azure_openai',
|
||||
'tutorials/instructor',
|
||||
"tutorials/gradio_integration",
|
||||
|
||||
Reference in New Issue
Block a user