Pydantic AI

from portkey_ai import AsyncPortkey
from pydantic import BaseModel, Field
from pydantic_ai import Agent
from pydantic_ai.models.openai import OpenAIModel
from pydantic_ai.providers.openai import OpenAIProvider

# Set up Portkey client with tracing and metadata
portkey_client = AsyncPortkey(
    api_key="YOUR_PORTKEY_API_KEY",
    virtual_key="YOUR_OPENAI_VIRTUAL_KEY",
    trace_id="f1-data-request",
    metadata={"app_env": "production", "_user": "user_123"}
)

# Define structured output using Pydantic
class F1GrandPrix(BaseModel):
    gp_name: str = Field(description="Grand Prix name, e.g. `Emilia Romagna Grand Prix`")
    year: int = Field(description="The year of the Grand Prix")
    constructor_winner: str = Field(description="The winning constructor of the Grand Prix")
    podium: list[str] = Field(description="Names of the podium drivers (1st, 2nd, 3rd)")

# Create the agent with structured output type
f1_gp_agent = Agent[None, F1GrandPrix](
    model=OpenAIModel(
        model_name="gpt-4o",
        provider=OpenAIProvider(openai_client=portkey_client),
    ),
    output_type=F1GrandPrix,
    system_prompt="Assist the user by providing data about the specified Formula 1 Grand Prix"
)

# Run the agent
async def main():
    result = await f1_gp_agent.run("Las Vegas 2023")
    print(result.output)

if __name__ == "__main__":
    import asyncio
    asyncio.run(main())

gp_name='Las Vegas Grand Prix'
year=2023
constructor_winner='Red Bull Racing'
podium=['Max Verstappen', 'Charles Leclerc', 'Sergio Pérez']

result = f1_gp_agent.run_sync("Las Vegas 2023")
print(result.output)

from portkey_ai import AsyncPortkey
from pydantic_ai import Agent, ImageUrl
from pydantic_ai.models.openai import OpenAIModel
from pydantic_ai.providers.openai import OpenAIProvider

# Set up Portkey client
portkey_client = AsyncPortkey(
    api_key="YOUR_PORTKEY_API_KEY",
    virtual_key="YOUR_OPENAI_VIRTUAL_KEY",
    trace_id="vision-request",
    metadata={"request_type": "image_analysis"}
)

# Create a vision-capable agent
vision_agent = Agent(
    model=OpenAIModel(
        model_name="gpt-4o",  # Vision-capable model
        provider=OpenAIProvider(openai_client=portkey_client),
    ),
    system_prompt="Analyze images and provide detailed descriptions."
)

# Process an image
result = vision_agent.run_sync([
    'What company is this logo from?',
    ImageUrl(url='https://iili.io/3Hs4FMg.png'),
])
print(result.output)

import random
from portkey_ai import AsyncPortkey
from pydantic_ai import Agent, RunContext
from pydantic_ai.models.openai import OpenAIModel
from pydantic_ai.providers.openai import OpenAIProvider

# Set up Portkey client
portkey_client = AsyncPortkey(
    api_key="YOUR_PORTKEY_API_KEY",
    virtual_key="YOUR_OPENAI_VIRTUAL_KEY",
    trace_id="dice-game-session",
    metadata={"game_type": "dice"}
)

# Create an agent with dependency injection (player name)
dice_agent = Agent(
    model=OpenAIModel(
        model_name="gpt-4o",
        provider=OpenAIProvider(openai_client=portkey_client),
    ),
    deps_type=str,  # Dependency type (player name as string)
    system_prompt=(
        "You're a dice game host. Roll the die and see if it matches "
        "the user's guess. If so, tell them they're a winner. "
        "Use the player's name in your response."
    ),
)

# Define a plain tool (no context needed)
@dice_agent.tool_plain
def roll_die() -> str:
    """Roll a six-sided die and return the result."""
    return str(random.randint(1, 6))

# Define a tool that uses the dependency
@dice_agent.tool
def get_player_name(ctx: RunContext[str]) -> str:
    """Get the player's name."""
    return ctx.deps

# Run the agent
dice_result = dice_agent.run_sync('My guess is 4', deps='Anne')
print(dice_result.output)

from portkey_ai import AsyncPortkey

# Create Portkey client with fallback config
portkey_client = AsyncPortkey(
    api_key="YOUR_PORTKEY_API_KEY",
    config={
        "strategy": {
            "mode": "fallback"
        },
        "targets": [
            {
                "provider": "openai",
                "api_key": "YOUR_OPENAI_API_KEY",
                "override_params": {"model": "gpt-4o"}
            },
            {
                "provider": "anthropic",
                "api_key": "YOUR_ANTHROPIC_API_KEY",
                "override_params": {"model": "claude-3-opus-20240229"}
            }
        ]
    }
)

from portkey_ai import AsyncPortkey
from pydantic_ai import Agent
from pydantic_ai.models.openai import OpenAIModel
from pydantic_ai.providers.openai import OpenAIProvider

# Create Portkey client with guardrails
portkey_client = AsyncPortkey(
    api_key="YOUR_PORTKEY_API_KEY",
    virtual_key="YOUR_OPENAI_VIRTUAL_KEY",
    config={
        "input_guardrails": ["guardrails-id-xxx", "guardrails-id-yyy"],
        "output_guardrails": ["guardrails-id-zzz"]
    }
)

# Create agent with Portkey-enabled client
agent = Agent(
    model=OpenAIModel(
        model_name="gpt-4o",
        provider=OpenAIProvider(openai_client=portkey_client),
    ),
    system_prompt="You are a helpful assistant."
)

from portkey_ai import AsyncPortkey
from pydantic_ai import Agent
from pydantic_ai.models.openai import OpenAIModel
from pydantic_ai.providers.openai import OpenAIProvider

# Configure client with user tracking
portkey_client = AsyncPortkey(
    api_key="YOUR_PORTKEY_API_KEY",
    virtual_key="YOUR_OPENAI_VIRTUAL_KEY",
    metadata={
        "_user": "user_123",  # Special _user field for user analytics
        "user_tier": "premium",
        "user_company": "Acme Corp",
        "session_id": "abc-123"
    }
)

# Create agent with Portkey client
agent = Agent(
    model=OpenAIModel(
        model_name="gpt-4o",
        provider=OpenAIProvider(openai_client=portkey_client),
    ),
    system_prompt="You are a helpful assistant."
)

from portkey_ai import AsyncPortkey
from pydantic_ai import Agent
from pydantic_ai.models.openai import OpenAIModel
from pydantic_ai.providers.openai import OpenAIProvider

# OpenAI with Portkey
portkey_openai = AsyncPortkey(
    api_key="YOUR_PORTKEY_API_KEY",
    virtual_key="YOUR_OPENAI_VIRTUAL_KEY"
)

# Anthropic with Portkey
portkey_anthropic = AsyncPortkey(
    api_key="YOUR_PORTKEY_API_KEY",
    virtual_key="YOUR_ANTHROPIC_VIRTUAL_KEY"
)

# Create agents with different models
openai_agent = Agent(
    model=OpenAIModel(
        model_name="gpt-4o",
        provider=OpenAIProvider(openai_client=portkey_openai),
    ),
    system_prompt="You are a helpful assistant."
)

anthropic_agent = Agent(
    model=OpenAIModel(
        model_name="claude-3-opus-20240229",
        provider=OpenAIProvider(anthropic_client=portkey_anthropic),
    ),
    system_prompt="You are a helpful assistant."
)

# Choose which agent to use based on your needs
active_agent = openai_agent  # or anthropic_agent

result = active_agent.run_sync("Tell me about quantum computing.")
print(result.output)