from pydantic import BaseModel
from pydantic_ai import Agent

# Định nghĩa chính xác những gì bạn mong đợi
class WeatherResponse(BaseModel):
    temperature: int
    condition: str
    humidity: float
    forecast_confidence: str # "cao", "trung bình", "thấp"

# Tạo một agent mà PHẢI trả về cấu trúc này
weather_agent = Agent('openai:gpt-4o', result_type=WeatherResponse)

# Điều này sẽ LUÔN trả về một đối tượng WeatherResponse, không bao giờ là chuỗi
result = await weather_agent.run("Thời tiết ở New York thế nào?")
print(f"Nhiệt độ: {result.data.temperature}°F") # Truy cập kiểu an toàn

from typing import List, Optional
from enum import Enum

class Priority(str, Enum):
    LOW = "thấp"
    MEDIUM = "trung bình" 
    HIGH = "cao"

class Task(BaseModel):
    title: str
    description: str
    priority: Priority
    due_date: Optional[str] = None
    tags: List[str] = []

from pydantic_ai import ModelRetry

@agent.tool
def validate_email(email: str) -> str:
    """Xác thực định dạng địa chỉ email."""
    if "@" not in email or "." not in email.split("@")[1]:
        raise ModelRetry("Vui lòng cung cấp một địa chỉ email hợp lệ với @ và miền")
    return email

pip install pydantic-ai
export OPENAI_API_KEY='your-api-key-here'

from pydantic import BaseModel
from pydantic_ai import Agent
import asyncio

# Bước 1: Định nghĩa cấu trúc phản hồi của bạn
class BookRecommendation(BaseModel):
    title: str
    author: str
    genre: str
    rating: float # 1.0 đến 5.0
    reason: str
    similar_books: list[str] = []

# Bước 2: Tạo một agent với cấu trúc phản hồi này
book_agent = Agent(
    'openai:gpt-4o',
    result_type=BookRecommendation,
    system_prompt="""Bạn là một thủ thư có kiến thức. Khi đề xuất sách, 
    luôn cung cấp xếp hạng từ 1.0 đến 5.0, và gợi ý 2-3 cuốn sách tương tự."""
)

# Bước 3: Sử dụng agent
async def get_recommendation():
    result = await book_agent.run("Tôi thích tiểu thuyết trinh thám với các nhân vật phức tạp")
    book = result.data # Đảm bảo đây là một đối tượng BookRecommendation

    print(f"📚 {book.title} của {book.author}")
    print(f"⭐ Xếp hạng: {book.rating}/5.0")
    print(f"📝 Lý do: {book.reason}")
    print(f"📖 Sách tương tự: {', '.join(book.similar_books)}")

# Chạy ví dụ
asyncio.run(get_recommendation())

from pydantic_ai import Agent
from datetime import datetime
import httpx

# Tạo một agent có thể truy cập các chức năng bên ngoài
weather_agent = Agent('openai:gpt-4o')

@weather_agent.tool
async def get_current_weather(city: str) -> dict:
    """Lấy thời tiết hiện tại cho một thành phố cụ thể bằng cách sử dụng API thời tiết."""
    # Gọi API giả lập (trong sản xuất, sử dụng một API thời tiết thực)
    weather_data = {
        "temperature": 72,
        "condition": "nắng",
        "humidity": 45,
        "wind_speed": 8
    }
    return weather_data

@weather_agent.tool  
async def get_current_time() -> str:
    """Lấy ngày và giờ hiện tại."""
    return datetime.now().strftime("%Y-%m-%d %H:%M:%S")

@weather_agent.tool
async def calculate_comfort_index(temperature: int, humidity: int) -> str:
    """Tính chỉ số thoải mái dựa trên nhiệt độ và độ ẩm."""
    if temperature < 60 or temperature > 80:
        return "không thoải mái"
    elif humidity > 60:
        return "khó chịu"
    else:
        return "thoải mái"

# Sử dụng agent với quyền truy cập vào tất cả các công cụ này
async def weather_demo():
    result = await weather_agent.run(
        "Thời tiết ở San Francisco thế nào và nó có thoải mái không?"
    )
    print(result.data)

from pydantic_ai import Agent, RunContext
from pydantic import BaseModel

class UserPreferences(BaseModel):
    user_id: str
    preferences: dict
    conversation_history: list = []
    session_data: dict = {}

class PersonalizedResponse(BaseModel):
    response: str
    personalization_used: list[str]
    recommendations: list[str] = []

# Agent với ngữ cảnh bền vững
personal_assistant = Agent(
    'openai:gpt-4o',
    deps_type=UserPreferences,
    result_type=PersonalizedResponse,
    system_prompt="""Bạn là một trợ lý cá nhân. Sử dụng sở thích của người dùng 
    và lịch sử cuộc hội thoại để cung cấp phản hồi cá nhân hóa."""
)

@personal_assistant.tool
async def save_preference(preference_key: str, preference_value: str, ctx: RunContext[UserPreferences]) -> str:
    """Lưu một sở thích của người dùng cho các cuộc hội thoại sau."""
    ctx.deps.preferences[preference_key] = preference_value
    return f"Đã lưu sở thích: {preference_key} = {preference_value}"

@personal_assistant.tool
async def get_user_history(ctx: RunContext[UserPreferences]) -> list:
    """Lấy lịch sử cuộc hội thoại của người dùng."""
    return ctx.deps.conversation_history[-5:] # 5 tương tác cuối

async def personalized_conversation():
    # Khởi tạo ngữ cảnh người dùng
    user_context = UserPreferences(
        user_id="user123",
        preferences={"communication_style": "thân thiện", "interests": ["công nghệ", "sách"]},
        conversation_history=["Hỏi về các tutorial Python", "Quan tâm đến phát triển AI"]
    )

    result = await personal_assistant.run(
        "Tôi muốn tìm hiểu thêm về phát triển web",
        deps=user_context
    )

    print(f"Phản hồi: {result.data.response}")
    print(f"Cá nhân hóa đã sử dụng: {result.data.personalization_used}")
    print(f"Gợi ý: {result.data.recommendations}")