Thought: 現在の状況を分析し、次の行動を計画する。
Action: 外部ツールを呼び出す、または環境と相互作用する。
Observation: Actionの結果を観察する。
...（繰り返し）
Thought: 十分な情報が集まったので、最終回答を生成する。

Thought: まず、AppleのUSDでの現在の時価総額を確認する必要がある。
Action: search("Apple current market cap USD")
Observation: Appleの時価総額は約3.4兆ドルである。
Thought: 次に、現在のUSD/JPYの為替レートを確認する必要がある。
Action: search("current USD JPY exchange rate")
Observation: 1 USD = 150 JPY
Thought: 3.4兆 * 150 = 510兆円。最終回答を生成する。
Answer: Appleの時価総額は約510兆円です。

import anthropic

client = anthropic.Anthropic()

# ツール定義
tools = [
    {
        "name": "get_weather",
        "description": "Get the current weather in a given location",
        "input_schema": {
            "type": "object",
            "properties": {
                "location": {
                    "type": "string",
                    "description": "The city and state, e.g. San Francisco, CA"
                },
                "unit": {
                    "type": "string",
                    "enum": ["celsius", "fahrenheit"],
                    "description": "Temperature unit"
                }
            },
            "required": ["location"]
        }
    }
]

# API呼び出し
response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    tools=tools,
    messages=[
        {"role": "user", "content": "What's the weather like in Seoul?"}
    ]
)

# 2. Claudeの応答からtool_useブロックを抽出
tool_use_block = next(
    block for block in response.content if block.type == "tool_use"
)
tool_name = tool_use_block.name        # "get_weather"
tool_input = tool_use_block.input      # {"location": "Seoul, South Korea"}
tool_use_id = tool_use_block.id        # ユニーク識別子

# 3. 実際にツールを実行（開発者が実装）
weather_result = call_weather_api(tool_input["location"])

# 4. ツール結果をClaudeに送信
follow_up = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    tools=tools,
    messages=[
        {"role": "user", "content": "What's the weather like in Seoul?"},
        {"role": "assistant", "content": response.content},
        {
            "role": "user",
            "content": [
                {
                    "type": "tool_result",
                    "tool_use_id": tool_use_id,
                    "content": weather_result
                }
            ]
        }
    ]
)

from openai import OpenAI

client = OpenAI()

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Compare the weather in Seoul and Tokyo"}],
    tools=[{
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get weather for a location",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {"type": "string"}
                },
                "required": ["location"]
            }
        }
    }],
    parallel_tool_calls=True  # ソウルと東京を同時に呼び出し
)

[ユーザークエリ]
     |
     v
[Planner LLM] --> ステップ1、ステップ2、ステップ3、...
     |
     v
[Executor] --> ステップ1を実行 --> ステップ2を実行 --> ステップ3を実行
     |
     v
[Re-planner] --> 必要に応じて計画を修正
     |
     v
[最終回答]

                    [問題]
                   /  |  \
              [思考1] [思考2] [思考3]    <-- 複数のパスを生成
              /  \      |      \
         [1-a] [1-b]  [2-a]   [3-a]    <-- 各パスを展開
           |     |      |       |
        [評価] [評価]  [評価]   [評価]   <-- 自己評価
           |            |
        [選択]         [選択]            <-- 最適パスを選択

# 短期記憶：メッセージとして会話履歴を管理
messages = [
    {"role": "user", "content": "私の名前はキムヨンジュです"},
    {"role": "assistant", "content": "こんにちは、キムヨンジュさん！"},
    {"role": "user", "content": "私の名前は何と言いましたか？"},
    # コンテキストウィンドウ内で以前の会話を参照可能
]

from langchain_community.vectorstores import Chroma
from langchain_openai import OpenAIEmbeddings

# 長期記憶：Vector DBに保存
vectorstore = Chroma(
    collection_name="agent_memory",
    embedding_function=OpenAIEmbeddings()
)

# 過去のやり取りを保存
vectorstore.add_texts([
    "ユーザーはPythonとデータ分析に関心がある。",
    "ユーザーはソウル在住で日本語を好む。",
    "前回のセッションでユーザーはpandas DataFrameについて質問した。"
])

# 関連する記憶を検索
relevant_memories = vectorstore.similarity_search(
    "ユーザーのプログラミングに対する関心", k=3
)

# エンティティ記憶の構造例
entity_store = {
    "キムヨンジュ": {
        "occupation": "データエンジニア",
        "interests": ["LLM", "データパイプライン", "Kubernetes"],
        "preferred_language": "Python",
        "recent_question_topic": "LangGraphエージェントの構築"
    },
    "Project_A": {
        "status": "進行中",
        "tech_stack": ["LangGraph", "Claude API", "PostgreSQL"],
        "goal": "社内データ分析エージェントの構築"
    }
}

from langgraph.graph import StateGraph, START, END
from langgraph.graph import MessagesState

# MessagesStateはメッセージリストを管理する組み込みState
graph = StateGraph(MessagesState)

from typing import TypedDict, Annotated
from langgraph.graph.message import add_messages

class AgentState(TypedDict):
    messages: Annotated[list, add_messages]
    plan: list[str]
    current_step: int
    final_answer: str

from langchain_anthropic import ChatAnthropic

model = ChatAnthropic(model="claude-sonnet-4-20250514")
model_with_tools = model.bind_tools(tools)

def call_model(state: AgentState):
    """LLMを呼び出すノード"""
    response = model_with_tools.invoke(state["messages"])
    return {"messages": [response]}

def execute_tool(state: AgentState):
    """ツールを実行するノード"""
    last_message = state["messages"][-1]
    results = []
    for tool_call in last_message.tool_calls:
        result = tool_map[tool_call["name"]].invoke(tool_call["args"])
        results.append(
            ToolMessage(content=str(result), tool_call_id=tool_call["id"])
        )
    return {"messages": results}

# ノードの追加
graph.add_node("agent", call_model)
graph.add_node("tools", execute_tool)

graph.add_edge(START, "agent")     # 開始 -> agentノード
graph.add_edge("tools", "agent")   # tools -> agentノード（結果を伝達）

def should_continue(state: AgentState):
    """ツール呼び出しが必要かどうかを判定"""
    last_message = state["messages"][-1]
    if last_message.tool_calls:
        return "tools"
    return END

graph.add_conditional_edges("agent", should_continue)

from langgraph.checkpoint.memory import MemorySaver

checkpointer = MemorySaver()
app = graph.compile(checkpointer=checkpointer)

# 実行
result = app.invoke(
    {"messages": [("user", "ソウルの現在の天気を教えてください")]},
    config={"configurable": {"thread_id": "session-001"}}
)

# コンパイル時にブレークポイントを設定
app = graph.compile(
    checkpointer=checkpointer,
    interrupt_before=["execute_tool"],   # ツール実行前にInterrupt
    # interrupt_after=["execute_tool"],  # ツール実行後にInterrupt
)

# execute_toolノードの直前で実行が停止
result = app.invoke(
    {"messages": [("user", "このデータを削除してください")]},
    config={"configurable": {"thread_id": "session-002"}}
)

# ユーザーの承認後に再開
app.invoke(None, config={"configurable": {"thread_id": "session-002"}})

from langgraph.types import interrupt, Command

def sensitive_tool_node(state: AgentState):
    """センシティブな操作の前にユーザーの承認を求めるノード"""
    last_message = state["messages"][-1]

    for tool_call in last_message.tool_calls:
        if tool_call["name"] in ["delete_data", "send_email", "execute_query"]:
            # 実行を中断してユーザーの承認を要求
            user_response = interrupt(
                f"'{tool_call['name']}'ツールを実行しようとしています。"
                f"入力: {tool_call['args']}。承認しますか？"
            )

            if user_response != "approved":
                return {"messages": [
                    ToolMessage(
                        content="ユーザーが実行を拒否しました。",
                        tool_call_id=tool_call["id"]
                    )
                ]}

        # 承認された場合は実行
        result = tool_map[tool_call["name"]].invoke(tool_call["args"])
        return {"messages": [
            ToolMessage(content=str(result), tool_call_id=tool_call["id"])
        ]}

# Interrupt状態からユーザーが承認
app.invoke(
    Command(resume="approved"),
    config={"configurable": {"thread_id": "session-002"}}
)

                    [ユーザークエリ]
                         |
                         v
                   [Supervisorエージェント]
                   /       |        \
                  v        v         v
          [Research    [Code       [Data
           Agent]      Agent]      Agent]
              |           |           |
              v           v           v
         [Web検索]    [コード実行] [SQLクエリ]

from langgraph.graph import StateGraph, MessagesState, START, END

# 各専門エージェントの定義
def research_agent(state: MessagesState):
    """Web検索専門エージェント"""
    model = ChatAnthropic(model="claude-sonnet-4-20250514")
    model_with_search = model.bind_tools([web_search_tool])
    response = model_with_search.invoke(state["messages"])
    return {"messages": [response]}

def code_agent(state: MessagesState):
    """コード作成・実行専門エージェント"""
    model = ChatAnthropic(model="claude-sonnet-4-20250514")
    model_with_code = model.bind_tools([code_execution_tool])
    response = model_with_code.invoke(state["messages"])
    return {"messages": [response]}

def data_agent(state: MessagesState):
    """データ分析専門エージェント"""
    model = ChatAnthropic(model="claude-sonnet-4-20250514")
    model_with_data = model.bind_tools([sql_query_tool, chart_tool])
    response = model_with_data.invoke(state["messages"])
    return {"messages": [response]}

# Supervisorルーティング関数
def supervisor(state: MessagesState):
    """タスクをどのエージェントに委任するかを決定"""
    model = ChatAnthropic(model="claude-sonnet-4-20250514")
    system_prompt = """あなたはSupervisorです。ユーザーのリクエストを分析し、
    適切な専門エージェントに委任してください。
    - research: 情報検索が必要な場合
    - code: コードの作成/実行が必要な場合
    - data: データ分析/可視化が必要な場合
    - FINISH: タスクが完了した場合"""

    response = model.invoke([
        {"role": "system", "content": system_prompt},
        *state["messages"]
    ])
    return {"messages": [response]}

def route_supervisor(state: MessagesState):
    """Supervisorの決定に基づいてルーティング"""
    last_message = state["messages"][-1].content
    if "research" in last_message.lower():
        return "research_agent"
    elif "code" in last_message.lower():
        return "code_agent"
    elif "data" in last_message.lower():
        return "data_agent"
    return END

# グラフの構成
workflow = StateGraph(MessagesState)
workflow.add_node("supervisor", supervisor)
workflow.add_node("research_agent", research_agent)
workflow.add_node("code_agent", code_agent)
workflow.add_node("data_agent", data_agent)

workflow.add_edge(START, "supervisor")
workflow.add_conditional_edges("supervisor", route_supervisor)
workflow.add_edge("research_agent", "supervisor")
workflow.add_edge("code_agent", "supervisor")
workflow.add_edge("data_agent", "supervisor")

app = workflow.compile()

[LLMアプリケーション（MCPクライアント）]
         |
    [MCPプロトコル]
         |
[MCPサーバーA]  [MCPサーバーB]  [MCPサーバーC]
     |               |               |
[GitHub API]   [データベース]   [ファイルシステム]

# 評価指標の例
evaluation = {
    "correct_tool_selected": True,      # 正しいツールが選択されたか？
    "correct_parameters": True,         # パラメータは正確か？
    "unnecessary_tool_calls": 0,        # 不要な呼び出しの回数
    "total_tool_calls": 3,             # 総呼び出し回数
    "optimal_tool_calls": 2,           # 最適な呼び出し回数
    "efficiency": 2/3                  # 効率性
}

import pandas as pd
from typing import TypedDict, Annotated
from langchain_anthropic import ChatAnthropic
from langchain_core.messages import ToolMessage, HumanMessage
from langchain_core.tools import tool
from langgraph.graph import StateGraph, START, END, MessagesState
from langgraph.graph.message import add_messages
from langgraph.checkpoint.memory import MemorySaver
from langgraph.prebuilt import ToolNode, tools_condition


# ============================================
# 1. ツール定義
# ============================================

@tool
def load_csv(file_path: str) -> str:
    """CSVファイルを読み込み、基本情報を返す。"""
    df = pd.read_csv(file_path)
    info = {
        "shape": df.shape,
        "columns": list(df.columns),
        "dtypes": df.dtypes.to_dict(),
        "head": df.head().to_string(),
        "describe": df.describe().to_string()
    }
    return str(info)


@tool
def run_analysis(file_path: str, query: str) -> str:
    """pandasを使用してCSVデータに対する分析クエリを実行する。

    Args:
        file_path: CSVファイルのパス
        query: 実行するpandasクエリ（例: 'df.groupby("category").mean()'）
    """
    df = pd.read_csv(file_path)
    try:
        result = eval(query, {"df": df, "pd": pd})
        if isinstance(result, pd.DataFrame):
            return result.to_string()
        elif isinstance(result, pd.Series):
            return result.to_string()
        return str(result)
    except Exception as e:
        return f"クエリ実行エラー: {str(e)}"


@tool
def generate_summary(analysis_results: str, user_question: str) -> str:
    """分析結果をユーザーフレンドリーなサマリーに変換する。

    Args:
        analysis_results: 分析結果のテキスト
        user_question: 元のユーザーの質問
    """
    summary = f"""
    ## 分析サマリー

    **質問**: {user_question}

    **結果**:
    {analysis_results}
    """
    return summary


# ============================================
# 2. エージェント設定
# ============================================

# ツールリスト
tools = [load_csv, run_analysis, generate_summary]

# LLM設定
model = ChatAnthropic(
    model="claude-sonnet-4-20250514",
    temperature=0,
    max_tokens=4096
)
model_with_tools = model.bind_tools(tools)


# エージェントノードの定義
def agent_node(state: MessagesState):
    """エージェントが推論し、必要に応じてツールを呼び出す。"""
    system_message = {
        "role": "system",
        "content": """あなたはデータ分析専門エージェントです。
        ユーザーの質問に答えるため、以下のステップに従ってください：
        1. まずload_csvでデータを読み込み、構造を把握する。
        2. run_analysisで適切なpandasクエリを実行する。
        3. generate_summaryで結果をまとめる。
        常にステップバイステップで考え、必要なツールを呼び出してください。"""
    }
    messages = [system_message] + state["messages"]
    response = model_with_tools.invoke(messages)
    return {"messages": [response]}


# ============================================
# 3. グラフ構築
# ============================================

# StateGraphの作成
workflow = StateGraph(MessagesState)

# ノードの追加
workflow.add_node("agent", agent_node)
workflow.add_node("tools", ToolNode(tools))

# エッジの追加
workflow.add_edge(START, "agent")
workflow.add_conditional_edges(
    "agent",
    tools_condition,  # tool_callsがあれば"tools"、なければEND
)
workflow.add_edge("tools", "agent")  # ツール結果をエージェントに伝達

# コンパイル
checkpointer = MemorySaver()
app = workflow.compile(checkpointer=checkpointer)


# ============================================
# 4. 実行
# ============================================

def run_data_agent(question: str, file_path: str, thread_id: str = "default"):
    """データ分析エージェントを実行する。"""
    config = {"configurable": {"thread_id": thread_id}}

    initial_message = HumanMessage(
        content=f"ファイルパス: {file_path}\n\n質問: {question}"
    )

    result = app.invoke(
        {"messages": [initial_message]},
        config=config
    )

    # 最終応答の抽出
    final_message = result["messages"][-1]
    return final_message.content


# 使用例
if __name__ == "__main__":
    answer = run_data_agent(
        question="月別の平均売上高はいくらで、最も売上が高かった月はどこですか？",
        file_path="./data/sales.csv",
        thread_id="analysis-001"
    )
    print(answer)