Pydantic AIとLangGraphで同じエージェントを書き比べてみる

Python 3.13.15
pydantic-ai-slim 2.51.0
pydantic 2.13.5
boto3 1.43.105
anthropic 1.9.0
openai 3.22.0

$ uv pip install "pydantic-ai-slim[bedrock,anthropic,openai]"

from langchain.agents import create_agent
from langchain_core.tools import tool
from langchain_litellm import ChatLiteLLM

@tool
def get_weather(city: str) -> str:
    """指定された都市の現在の天気を取得します。"""
    weather_data = {
        "東京": "晴れ、気温25°C、湿度60%",
        "大阪": "曇り、気温23°C、湿度70%",
        "札幌": "雪、気温-2°C、湿度80%",
        "福岡": "晴れ、気温22°C、湿度55%",
    }
    return weather_data.get(city, f"{city}の天気データは見つかりませんでした")

# calculate ツールの定義は Pydantic AI 版と同じ内容のため省略

llm = ChatLiteLLM(model="anthropic/claude-sonnet-4-6")
agent = create_agent(llm, tools=[get_weather, calculate])

result = agent.invoke(
    {"messages": [{"role": "user", "content": "東京と大阪の天気を調べて、気温の差を計算してください"}]}
)

for msg in result["messages"]:
    print(f"[{msg.type}] {msg.content}")

from pydantic_ai import Agent
from pydantic_ai.usage import UsageLimits

agent = Agent(
    "bedrock:jp.anthropic.claude-haiku-4-5-20251001-v1:0",
    instructions="ユーザーの質問にツールを使って答えてください。",
)

@agent.tool_plain
def get_weather(city: str) -> str:
    """指定された都市の現在の天気を取得します。"""
    weather_data = {
        "東京": "晴れ、気温25°C、湿度60%",
        "大阪": "曇り、気温23°C、湿度70%",
        "札幌": "雪、気温-2°C、湿度80%",
        "福岡": "晴れ、気温22°C、湿度55%",
    }
    return weather_data.get(city, f"{city}の天気データは見つかりませんでした")

@agent.tool_plain
def calculate(expression: str) -> str:
    """数式を計算します。四則演算に対応しています。"""
    allowed_chars = set("0123456789+-*/.() ")
    if not all(c in allowed_chars for c in expression):
        return "エラー: 許可されていない文字が含まれています"
    try:
        result = eval(expression)  # noqa: S307
        return str(result)
    except Exception as e:
        return f"計算エラー: {e}"

result = agent.run_sync(
    "東京と大阪の天気を調べて、気温の差を計算してください",
    usage_limits=UsageLimits(request_limit=6),
)

for msg in result.all_messages():
    for part in msg.parts:
        kind = part.part_kind
        if kind == "user-prompt":
            print(f"[user] {part.content}")
        elif kind == "text":
            print(f"[text] {part.content}")
        elif kind == "tool-call":
            print(f"[tool-call] {part.tool_name}({part.args})")
        elif kind == "tool-return":
            print(f"[tool-return] {part.content}")

print()
print(f"出力    : {result.output}")
print(f"モデル呼び出し回数: {result.usage.requests} / ツール呼び出し回数: {result.usage.tool_calls}")

$ python basic_agent.py
[user] 東京と大阪の天気を調べて、気温の差を計算してください
[text] 東京と大阪の天気を調べて、気温の差を計算いたします。
[tool-call] get_weather({'city': '東京'})
[tool-call] get_weather({'city': '大阪'})
[tool-return] 晴れ、気温25°C、湿度60%
[tool-return] 曇り、気温23°C、湿度70%
[text] それでは気温の差を計算します。
[tool-call] calculate({'expression': '25 - 23'})
[tool-return] 2
[text] 結果をまとめます：

**天気情報：**
- **東京**：晴れ、気温 25°C、湿度 60%
- **大阪**：曇り、気温 23°C、湿度 70%

**気温の差：** 2°C
（東京が大阪より2°C暖かいです）

出力    : 結果をまとめます：
（以下同じ内容のため省略）
モデル呼び出し回数: 3 / ツール呼び出し回数: 3

response = completion(
    model="openai/gpt-5.4",
    messages=[
        {"role": "system", "content": "ユーザー入力からタスク情報を抽出してください。"},
        {"role": "user", "content": user_input},
    ],
    response_format=TaskExtraction,
)

raw = response.choices[0].message.content
task = TaskExtraction.model_validate_json(raw)

from pydantic import BaseModel, Field
from pydantic_ai import Agent
from pydantic_ai.usage import UsageLimits

class TaskExtraction(BaseModel):
    """ユーザーの自然文からタスクを抽出する。"""

    title: str = Field(..., description="タスクの短いタイトル")
    priority: str = Field(..., description="high / medium / low のいずれか")
    due_date: str | None = Field(None, description="期限。YYYY-MM-DD 形式、なければnull")
    tags: list[str] = Field(default_factory=list, description="関連するタグ")

agent = Agent(
    "bedrock:jp.anthropic.claude-haiku-4-5-20251001-v1:0",
    output_type=TaskExtraction,
    instructions="ユーザー入力からタスク情報を抽出してください。今日は2026-09-13です。",
)

user_input = "明日までに取引先に提案書を送る、優先度高め。タグは営業と提案書"
result = agent.run_sync(user_input, usage_limits=UsageLimits(request_limit=4))
task = result.output

print("=== 構造化されたタスク ===")
print(f"  型       : {type(task).__name__}")
print(f"  title    : {task.title}")
print(f"  priority : {task.priority}")
print(f"  due_date : {task.due_date}")
print(f"  tags     : {task.tags}")
print(f"モデル呼び出し回数: {result.usage.requests}")

$ python structured_output.py
=== 構造化されたタスク ===
  型       : TaskExtraction
  title    : 取引先に提案書を送る
  priority : high
  due_date : 2026-09-14
  tags     : ['営業', '提案書']
モデル呼び出し回数: 1

from dataclasses import dataclass

from pydantic_ai import Agent, RunContext
from pydantic_ai.usage import UsageLimits

@dataclass
class UserContext:
    """1 リクエストぶんの実行コンテキスト。"""

    user_id: str
    home_city: str
    plan: str

agent = Agent(
    "bedrock:jp.anthropic.claude-haiku-4-5-20251001-v1:0",
    deps_type=UserContext,
    instructions="ユーザーの居住地を踏まえて、ツールで調べた情報から簡潔に答えてください。",
)

@agent.instructions
def add_user_info(ctx: RunContext[UserContext]) -> str:
    """システムプロンプトを実行時の依存から組み立てる。"""
    return f"問い合わせ元のユーザーは {ctx.deps.user_id}、居住地は {ctx.deps.home_city}、契約プランは {ctx.deps.plan} です。"

@agent.tool
def get_weather(ctx: RunContext[UserContext], city: str | None = None) -> str:
    """都市の天気を取得します。city を省略するとユーザーの居住地を使います。"""
    target = city or ctx.deps.home_city
    weather_data = {
        "東京": "晴れ、気温25°C、湿度60%",
        "大阪": "曇り、気温23°C、湿度70%",
        "札幌": "雪、気温-2°C、湿度80%",
        "福岡": "晴れ、気温22°C、湿度55%",
    }
    return f"{target}: {weather_data.get(target, 'データなし')}"

@agent.tool
def get_alert_quota(ctx: RunContext[UserContext]) -> str:
    """契約プランに応じた通知の上限を返します。"""
    quota = {"free": 3, "pro": 50}.get(ctx.deps.plan, 0)
    return f"プラン {ctx.deps.plan} の通知上限は 1 日 {quota} 件です。"

for deps in [
    UserContext(user_id="U001", home_city="札幌", plan="free"),
    UserContext(user_id="U002", home_city="福岡", plan="pro"),
]:
    result = agent.run_sync(
        "今日の天気と、私が受け取れる通知の上限を教えてください",
        deps=deps,
        usage_limits=UsageLimits(request_limit=4),
    )
    print(f"--- {deps.user_id} ({deps.home_city} / {deps.plan}) ---")
    print(result.output)
    print(f"モデル呼び出し回数: {result.usage.requests} / ツール呼び出し回数: {result.usage.tool_calls}")
    print()

$ python deps_injection.py
--- U001 (札幌 / free) ---
ご確認させます：

**📍 札幌の天気**
- 雪
- 気温：-2°C
- 湿度：80%

**📬 通知の上限**
- free プランでは **1日3件** までの通知をお受け取りいただけます

お出かけの際は暖かくしてお過ごしくださいね。
モデル呼び出し回数: 2 / ツール呼び出し回数: 2

--- U002 (福岡 / pro) ---
お答えします。

**今日の福岡の天気：**
晴れ、気温22°C、湿度55%

**通知の上限：**
pro プランでは、1日50件の通知を受け取ることができます。
モデル呼び出し回数: 2 / ツール呼び出し回数: 2

from pydantic_ai import Agent
from pydantic_ai.usage import UsageLimits

agent = Agent(instructions="ユーザーの質問にツールを使って答えてください。")

@agent.tool_plain
def get_weather(city: str) -> str:
    """指定された都市の現在の天気を取得します。"""
    weather_data = {
        "東京": "晴れ、気温25°C、湿度60%",
        "大阪": "曇り、気温23°C、湿度70%",
    }
    return weather_data.get(city, f"{city}の天気データは見つかりませんでした")

@agent.tool_plain
def calculate(expression: str) -> str:
    """数式を計算します。四則演算に対応しています。"""
    allowed_chars = set("0123456789+-*/.() ")
    if not all(c in allowed_chars for c in expression):
        return "エラー: 許可されていない文字が含まれています"
    try:
        return str(eval(expression))  # noqa: S307
    except Exception as e:
        return f"計算エラー: {e}"

MODELS = [
    "bedrock:jp.anthropic.claude-haiku-4-5-20251001-v1:0",
    "anthropic:claude-haiku-4-5-20251001",
    "openai:gpt-6-luna",
]

question = "東京と大阪の気温差は何度ですか"

for model in MODELS:
    result = agent.run_sync(question, model=model, usage_limits=UsageLimits(request_limit=6))
    answer = result.output.replace("\n", " ")[:60]
    print(f"{model}")
    print(f"  出力: {answer}")
    print(f"  モデル呼び出し {result.usage.requests} 回 / ツール呼び出し {result.usage.tool_calls} 回")

$ python model_switch.py
bedrock:jp.anthropic.claude-haiku-4-5-20251001-v1:0
  出力: **結果：**  - **東京**：晴れ、気温25°C、湿度60% - **大阪**：曇り、気温23°C、湿度70%  
  モデル呼び出し 3 回 / ツール呼び出し 3 回
anthropic:claude-haiku-4-5-20251001
  出力: 現在の気温は以下の通りです：  - **東京**：25°C（晴れ、湿度60%） - **大阪**：23°C（曇り、湿度7
  モデル呼び出し 2 回 / ツール呼び出し 2 回
openai:gpt-6-luna
  出力: 東京は25°C、大阪は23°Cなので、気温差は**2°C**です。
  モデル呼び出し 2 回 / ツール呼び出し 2 回