Build Your Own Agent

GEMINI_API_KEY=your-gemini-api-key-here

from dotenv import load_dotenv
from pydantic_ai import Agent

load_dotenv()

agent = Agent('gemini-2.5-flash')
result = agent.run_sync('Say "Hello, Workshop!" and nothing else.')
print(result.output)

from dotenv import load_dotenv
from pydantic_ai import Agent

load_dotenv()

# Create the agent with a system prompt
agent = Agent(
    'gemini-2.5-flash',
    system_prompt="""You are a helpful research assistant. 
You provide clear, accurate, and well-structured answers.
When you don't know something, you say so honestly.
Keep responses concise but informative."""
)

# Run a simple query
def main():
    result = agent.run_sync('What is the capital of France?')
    print("Answer:", result.output)
    
    # Try another query
    result = agent.run_sync('Explain photosynthesis in simple terms.')
    print("Answer:", result.output)

if __name__ == "__main__":
    main()

from dotenv import load_dotenv
from pydantic_ai import Agent, RunContext
import httpx
import math

load_dotenv()

agent = Agent(
    'gemini-2.5-flash',
    system_prompt="""You are a research assistant with access to tools.
Use the calculator for math. Use web search for current information.
Always cite your sources when using search results."""
)

@agent.tool
def calculate(ctx: RunContext[None], expression: str) -> str:
    """Evaluate a mathematical expression.
    
    Args:
        expression: A Python math expression like '2 + 2' or 'math.sqrt(16)'
    """
    try:
        # Safe eval with only math operations
        allowed = {"__builtins__": {}, "math": math}
        result = eval(expression, allowed)
        return f"Result: {result}"
    except Exception as e:
        return f"Error: {e}"

@agent.tool
async def search_web(ctx: RunContext[None], query: str) -> str:
    """Search the web for information.
    
    Args:
        query: The search query
    """
    # Using a free API for demo (DuckDuckGo Instant Answer)
    async with httpx.AsyncClient() as client:
        response = await client.get(
            "https://api.duckduckgo.com/",
            params={"q": query, "format": "json", "no_html": "1"}
        )
        data = response.json()
        
        if data.get("Abstract"):
            return f"{data['Abstract']} (Source: {data.get('AbstractSource', 'DuckDuckGo')})"
        elif data.get("RelatedTopics"):
            topics = data["RelatedTopics"][:3]
            results = [t.get("Text", "") for t in topics if "Text" in t]
            return "Related info: " + " | ".join(results)
        else:
            return "No results found."

# Test the agent
async def main():
    # Math question
    result = await agent.run('What is 15% of 847?')
    print("Math:", result.output)
    
    # Search question
    result = await agent.run('What is Python programming language?')
    print("Search:", result.output)

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

from dotenv import load_dotenv
from pydantic_ai import Agent
from pydantic import BaseModel, Field
from typing import Literal

load_dotenv()

# Define the output structure
class ResearchResult(BaseModel):
    """Structured research output."""
    topic: str = Field(description="The main topic researched")
    summary: str = Field(description="A 2-3 sentence summary")
    key_points: list[str] = Field(description="3-5 key points")
    confidence: Literal["high", "medium", "low"] = Field(
        description="Confidence in the accuracy of the information"
    )
    sources_needed: bool = Field(
        description="Whether external sources should be consulted"
    )

# Create agent with structured output type
agent = Agent(
    'gemini-2.5-flash',
    output_type=ResearchResult,  # Specify the return type!
    system_prompt="You are a research assistant. Provide structured analysis."
)

def main():
    result = agent.run_sync('Explain the benefits of renewable energy')
    
    # result.output is now a ResearchResult instance!
    research = result.output
    
    print(f"Topic: {research.topic}")
    print(f"Summary: {research.summary}")
    print(f"Confidence: {research.confidence}")
    print("Key Points:")
    for point in research.key_points:
        print(f"  • {point}")

if __name__ == "__main__":
    main()

from dotenv import load_dotenv
from pydantic_ai import Agent
from pydantic_ai.messages import ModelMessage

load_dotenv()

agent = Agent(
    'gemini-2.5-flash',
    system_prompt="You are a helpful assistant with memory of our conversation."
)

def chat():
    """Interactive chat with memory."""
    message_history: list[ModelMessage] = []
    
    print("Chat started! Type 'quit' to exit.\n")
    
    while True:
        user_input = input("You: ").strip()
        
        if user_input.lower() == 'quit':
            print("Goodbye!")
            break
        
        if not user_input:
            continue
        
        # Run with message history
        result = agent.run_sync(
            user_input,
            message_history=message_history  # Pass previous messages
        )
        
        print(f"Agent: {result.output}\n")
        
        # Update history with new messages
        message_history = result.all_messages()

if __name__ == "__main__":
    chat()