How to Install and Use Pydantic-AI for AI Application Development 🚀

Sunday, Dec 15, 2024 | 7 minute read

GitHub Trend

Revolutionize AI app development with a powerful Python framework that ensures type safety, flexibility, and robust support across various models! It offers real-time monitoring, easy dependency injection, and seamless control flow for unparalleled efficiency! 🚀✨

Exploring Pydantic-AI: A New Way to Build AI Applications 🌟

“Pydantic-AI is changing the game for AI agents, allowing developers to implement their ideas more simply and efficiently!”

In this dazzling digital age, artificial intelligence is transforming the way we live and work! With the rapid rise of generative AI, businesses and developers are on the lookout for efficient and flexible tools to better construct intelligent applications. Enter Pydantic-AI! 🔥

Pydantic-AI is an agent framework specifically designed for Python, aimed at simplifying the process of developing production-grade applications using generative AI. This framework is meticulously crafted by the esteemed Pydantic team, leveraging Pydantic’s robust data validation capabilities to ensure data integrity. As a result, Pydantic-AI has been widely adopted in numerous Python projects. With this powerful framework, developers can quickly and efficiently build AI agents that meet a variety of business needs across many application scenarios! 💡

The Unique Appeal of Pydantic-AI: Key Features Breakdown 🏆

1. Model Agnosticism: Pydantic-AI supports various AI models, including OpenAI, Gemini, Anthropic, Groq, and Mistral, among others. Users can also easily extend compatibility to adapt to the ever-changing model requirements. 🔄
2. Type Safety: By integrating Python’s native type system, Pydantic-AI provides structured guarantees for response validation, significantly reducing the risk of runtime errors. 🛡️
3. Flexible Control Flow: Standard Python is used for control flow writing, encouraging developers to follow best practices ensure that code is more concise and maintainable. 🔧
4. Dependency Injection: The framework offers an innovative and type-safe dependency injection system, helping developers improve product reliability during testing and iterative development. ⚙️
5. Real-Time Monitoring: Through integration with Logfire, developers can perform real-time debugging and performance monitoring, quickly identifying and fixing potential issues. 🔍

Currently, Pydantic-AI is in the early testing phase, and the API may undergo changes, allowing developers to provide feedback for continuous improvement of the framework experience. 🛠️

Why Are Developers Raving About Pydantic-AI? 🤔

1. Ease of Use: Pydantic-AI features a simple interface and standard specifications, enabling developers to get up to speed quickly, lowering the learning curve, and allowing them to focus on implementing business logic. 📈
2. Production Readiness: This framework provides a solid infrastructure capable of supporting complex application developments, such as banking support agents, greatly enhancing the project’s maintainability. 🏦
3. Model Flexibility: Seamless support for various AI models allows developers to freely choose the right model according to their needs, creating vibrant applications. 🎨

With these unique features, Pydantic-AI has become an essential choice for many developers building AI agents! It has captured developers’ hearts and minds with its distinct charm and powerful capabilities! Whether in the initial development phase or during later application maintenance, Pydantic-AI provides developers with a highly efficient and flexible solution to foster the growth of AI applications! 🌈

Getting Started with Pydantic-AI: Installation and Examples 📚

Installing Pydantic-AI 🚀

If you’re ready to explore the powerful features of Pydantic-AI, the first step is to install the library! 🍃 Just run the following command:

pip install pydantic-ai

This simple command will help you download and install Pydantic-AI along with all necessary dependencies, ensuring you can get started immediately in your development environment.

Examples and Use Cases 💡

Now, let’s look at some example code to help you understand the different uses of Pydantic-AI and how to apply them in practice. 🎉 Each example will showcase unique functionalities and usages.

Example 1: Basic Agent Usage 🚀

First, let’s create a simple Agent instance:

from pydantic_ai import Agent

# Create an Agent instance and set the model and system prompt
# Here, we specify the model name and system prompt, which will guide the Agent's response style
agent = Agent('gemini-1.5-flash', system_prompt='Be concise, reply with one sentence.')

# Execute a synchronous request
result = agent.run_sync('Where does "hello world" come from?')  
# Use the run_sync method to ask a question and wait for the result to be returned
print(result.data)   # Output the returned information

In this code snippet, the agent instance is defined as an AI assistant with a concise system prompt. We call the run_sync method to inquire about the origins of “hello world,” yielding relevant historical information. 🌍

Example 2: Customer Support Agent 🏦

Let’s create an Agent for banking customer support to provide more specialized services:

from dataclasses import dataclass
from pydantic import BaseModel, Field
from pydantic_ai import Agent, RunContext
from bank_database import DatabaseConn

# Here we define the dependency structure required for support
@dataclass
class SupportDependencies:
    customer_id: int
    db: DatabaseConn

# Define the data model for support results
class SupportResult(BaseModel):
    support_advice: str = Field(description='Advice returned to the customer')
    block_card: bool = Field(description="Whether to block the customer's card")
    risk: int = Field(description='Risk level of query', ge=0, le=10)

# Create a support Agent instance
support_agent = Agent(
    'openai:gpt-4o',
    deps_type=SupportDependencies,
    result_type=SupportResult,
    system_prompt='You are a support agent in our bank...'
)

# Provide a system prompt to get the customer’s name
@support_agent.system_prompt
async def add_customer_name(ctx: RunContext[SupportDependencies]) -> str:
    # Fetch the customer's name from the database
    customer_name = await ctx.deps.db.customer_name(id=ctx.deps.customer_id)
    return f"The customer's name is {customer_name!r}"

# Define a helper function to handle customer balances
@support_agent.tool
async def customer_balance(ctx: RunContext[SupportDependencies], include_pending: bool) -> float:
    """Returns the customer's current account balance."""
    # Fetch the customer balance from the database
    balance = await ctx.deps.db.customer_balance(
        id=ctx.deps.customer_id,
        include_pending=include_pending,
    )
    return balance

async def main():
    deps = SupportDependencies(customer_id=123, db=DatabaseConn())
    # Query the customer's balance
    result = await support_agent.run('What is my balance?', deps=deps)
    print(result.data)

    # Report a lost card request
    result = await support_agent.run('I just lost my card!', deps=deps)
    print(result.data)

In this example, we defined the SupportDependencies type to describe the dependencies needed for support, while SupportResult specifies the type for returned results. 🌟 The support_agent interacts with the database to fetch functionalities like retrieving customer names and balances, enhancing the customer service experience.

Example 3: Basic Synchronous and Asynchronous Queries 💬

Let’s demonstrate how to conduct both synchronous and asynchronous queries:

from pydantic_ai import Agent

agent = Agent('openai:gpt-4o')

# Execute a synchronous query
result_sync = agent.run_sync('What is the capital of Italy?')
print(result_sync.data)

async def main():
    # Execute an asynchronous query
    result = await agent.run('What is the capital of France?') 
    print(result.data)

    async with agent.run_stream('What is the capital of the UK?') as response: 
        # Use the run_stream method to handle streaming responses
        print(await response.get_data())

In this example, run_sync is used for synchronous queries, while the run method implements asynchronous queries. ⏱️ By utilizing streaming responses, we can retrieve data in real-time, enhancing user experience.

Example 4: Using Message History 📜

This example demonstrates how to leverage message history for improved query fluency:

from pydantic_ai import Agent

agent = Agent('openai:gpt-4o')

result = agent.run_sync('Who was Albert Einstein?')
print(result.data)

result2 = agent.run_sync(
    'What was his most famous equation?',
    message_history=result.new_messages(),  # Utilize previous message context
)
print(result2.data)

In this example, message_history is used during the second query to ensure response coherence, helping to maintain contextual information and thereby improving interaction quality. 📜

Example 5: Tool Usage with Retry Mechanism 🔄

The final example showcases how to utilize a tool with a retry mechanism to ensure query stability:

from pydantic import BaseModel
from pydantic_ai import Agent, RunContext, ModelRetry
from fake_database import DatabaseConn

class ChatResult(BaseModel):
    user_id: int
    message: str

agent = Agent(
    'openai:gpt-4o',
    deps_type=DatabaseConn,
    result_type=ChatResult,
)

@agent.tool(retries=2)  # Specify the number of retries
def get_user_by_name(ctx: RunContext[DatabaseConn], name: str) -> int:
    """Get a user's ID from their full name."""
    user_id = ctx.deps.users.get(name=name)
    if user_id is None:
        # If no user is found, raise a retry exception
        raise ModelRetry(f'No user found with name {name!r}')
    return user_id

result = agent.run_sync('Send a message to John Doe asking for coffee next week', deps=DatabaseConn())
print(result.data)

In this code example, we define a get_user_by_name tool that employs a retry mechanism to handle potential errors, ensuring that users receive accurate service. ✨

These examples cover the basic usage and various implementations of Pydantic-AI. Applying these methods in your applications can greatly enhance user experience and interaction fluidity!