Strands Agents SDK 実践 — Structured Output で LLM の出力を型安全にする

from strands import Agent
from strands.models import BedrockModel
from pydantic import BaseModel, Field
 
bedrock_model = BedrockModel(
    model_id="us.anthropic.claude-sonnet-4-20250514-v1:0",
    region_name="us-east-1",
)
 
class PersonInfo(BaseModel):
    """Information about a person."""
    name: str = Field(description="Full name of the person")
    age: int = Field(description="Age in years")
    occupation: str = Field(description="Current occupation")
 
agent = Agent(model=bedrock_model, callback_handler=None)
result = agent(
    "John Smith is a 30 year-old software engineer",
    structured_output_model=PersonInfo,
)
 
person = result.structured_output
print(f"Name: {person.name}")
print(f"Age: {person.age}")
print(f"Occupation: {person.occupation}")
print(f"Type: {type(person).__name__}")

from strands import Agent, tool
from strands.models import BedrockModel
from pydantic import BaseModel, Field
import json
 
bedrock_model = BedrockModel(
    model_id="us.anthropic.claude-sonnet-4-20250514-v1:0",
    region_name="us-east-1",
)
 
@tool
def get_exchange_rate(base: str, target: str) -> dict:
    """Get the current exchange rate between two currencies.
 
    Args:
        base: The base currency code (e.g. USD, EUR, JPY)
        target: The target currency code (e.g. USD, EUR, JPY)
 
    Returns:
        dict: Exchange rate information
    """
    rates = {
        ("USD", "JPY"): 149.50,
        ("EUR", "USD"): 1.08,
        ("EUR", "JPY"): 161.46,
    }
    rate = rates.get((base.upper(), target.upper()))
    if rate is None:
        return {"error": f"Rate not found for {base}/{target}"}
    return {"base": base.upper(), "target": target.upper(), "rate": rate}
 
class ConversionResult(BaseModel):
    """Currency conversion result."""
    base_currency: str = Field(description="Source currency code")
    target_currency: str = Field(description="Target currency code")
    exchange_rate: float = Field(description="Exchange rate used")
    original_amount: float = Field(description="Original amount")
    converted_amount: float = Field(description="Converted amount")
 
agent = Agent(model=bedrock_model, tools=[get_exchange_rate], callback_handler=None)
result = agent("Convert 250 USD to JPY", structured_output_model=ConversionResult)
 
conv = result.structured_output
print(f"Result: {conv.original_amount} {conv.base_currency} = {conv.converted_amount} {conv.target_currency}")
print(f"Rate: {conv.exchange_rate}")
 
print("\n--- Metrics ---")
print(json.dumps(result.metrics.get_summary(), indent=2, default=str))

from strands import Agent
from strands.models import BedrockModel
from pydantic import BaseModel, Field, field_validator
 
bedrock_model = BedrockModel(
    model_id="us.anthropic.claude-sonnet-4-20250514-v1:0",
    region_name="us-east-1",
)
 
class UserName(BaseModel):
    """A user's name with a required suffix."""
    first_name: str = Field(description="First name of the person")
 
    @field_validator("first_name")
    @classmethod
    def validate_first_name(cls, value: str) -> str:
        if not value.endswith("_verified"):
            raise ValueError("first_name must end with '_verified' suffix")
        return value
 
agent = Agent(model=bedrock_model, callback_handler=None)
result = agent("What is Aaron's first name?", structured_output_model=UserName)
print(f"Result: {result.structured_output}")

from strands import Agent
from strands.models import BedrockModel
from pydantic import BaseModel, Field
from typing import Optional
 
bedrock_model = BedrockModel(
    model_id="us.anthropic.claude-sonnet-4-20250514-v1:0",
    region_name="us-east-1",
)
 
agent = Agent(model=bedrock_model, callback_handler=None)
agent("My name is Taro and I work as a data scientist at a startup in Tokyo.")
agent("I've been using Python for 5 years and recently started learning Rust.")
 
class ProfileSummary(BaseModel):
    """Summary of a person's profile from conversation."""
    name: str = Field(description="Person's name")
    occupation: str = Field(description="Current job title")
    location: str = Field(description="Where they work")
    primary_language: str = Field(description="Main programming language")
    learning: Optional[str] = Field(description="Language currently learning", default=None)
 
result = agent(
    "Based on our conversation, extract my profile information.",
    structured_output_model=ProfileSummary,
)
 
profile = result.structured_output
print(f"Name: {profile.name}")
print(f"Occupation: {profile.occupation}")
print(f"Location: {profile.location}")
print(f"Primary: {profile.primary_language}")
print(f"Learning: {profile.learning}")
print(f"\nMessages in history: {len(agent.messages)}")