Thought: Analyze the current situation and plan the next action.
Action: Call an external tool or interact with the environment.
Observation: Observe the result of the Action.
... (repeat)
Thought: Sufficient information has been gathered, so generate the final answer.

Thought: First, I need to check Apple's current market cap in USD.
Action: search("Apple current market cap USD")
Observation: Apple's market cap is approximately $3.4 trillion.
Thought: Now I need to check the current USD/KRW exchange rate.
Action: search("current USD KRW exchange rate")
Observation: 1 USD = 1,450 KRW
Thought: 3.4 trillion * 1,450 = 4,930 trillion KRW. Generate the final answer.
Answer: Apple's market cap is approximately 4,930 trillion KRW.

import anthropic

client = anthropic.Anthropic()

# Tool definition
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 call
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. Extract tool_use block from Claude's response
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        # unique identifier

# 3. Actually execute the tool (implemented by the developer)
weather_result = call_weather_api(tool_input["location"])

# 4. Send tool result to 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  # Simultaneous call for Seoul and Tokyo
)

[User Query]
     |
     v
[Planner LLM] --> Step 1, Step 2, Step 3, ...
     |
     v
[Executor] --> Execute Step 1 --> Execute Step 2 --> Execute Step 3
     |
     v
[Re-planner] --> Modify plan if needed
     |
     v
[Final Answer]

                    [Problem]
                   /  |  \
              [Thought1] [Thought2] [Thought3]    <-- Generate multiple paths
              /  \      |      \
         [1-a] [1-b]  [2-a]   [3-a]    <-- Expand each path
           |     |      |       |
        [Eval] [Eval]  [Eval]   [Eval]   <-- Self-evaluation
           |            |
        [Select]      [Select]            <-- Select optimal path

# Short-term memory: managing conversation history as messages
messages = [
    {"role": "user", "content": "My name is Youngju Kim"},
    {"role": "assistant", "content": "Hello, Youngju Kim!"},
    {"role": "user", "content": "What did I say my name was?"},
    # Can reference previous conversation within the context window
]

from langchain_community.vectorstores import Chroma
from langchain_openai import OpenAIEmbeddings

# Long-term memory: store in Vector DB
vectorstore = Chroma(
    collection_name="agent_memory",
    embedding_function=OpenAIEmbeddings()
)

# Store past interactions
vectorstore.add_texts([
    "The user is interested in Python and data analysis.",
    "The user lives in Seoul and prefers Korean.",
    "In a previous session, the user asked about pandas DataFrames."
])

# Search relevant memories
relevant_memories = vectorstore.similarity_search(
    "user's programming interests", k=3
)

# Entity Memory example structure
entity_store = {
    "Youngju Kim": {
        "occupation": "Data Engineer",
        "interests": ["LLM", "Data Pipeline", "Kubernetes"],
        "preferred_language": "Python",
        "recent_question_topic": "LangGraph Agent Construction"
    },
    "Project_A": {
        "status": "In Progress",
        "tech_stack": ["LangGraph", "Claude API", "PostgreSQL"],
        "goal": "Building an internal data analysis Agent"
    }
}

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

# MessagesState is a built-in State that manages a messages list
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):
    """Node that calls the LLM"""
    response = model_with_tools.invoke(state["messages"])
    return {"messages": [response]}

def execute_tool(state: AgentState):
    """Node that executes tools"""
    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}

# Add nodes
graph.add_node("agent", call_model)
graph.add_node("tools", execute_tool)

graph.add_edge(START, "agent")     # Start -> agent node
graph.add_edge("tools", "agent")   # tools -> agent node (deliver results)

def should_continue(state: AgentState):
    """Determine if tool calls are needed"""
    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)

# Execute
result = app.invoke(
    {"messages": [("user", "Tell me the current weather in Seoul")]},
    config={"configurable": {"thread_id": "session-001"}}
)

# Set breakpoints at compile time
app = graph.compile(
    checkpointer=checkpointer,
    interrupt_before=["execute_tool"],   # Interrupt before tool execution
    # interrupt_after=["execute_tool"],  # Interrupt after tool execution
)

# Execution stops just before the execute_tool node
result = app.invoke(
    {"messages": [("user", "Please delete this data")]},
    config={"configurable": {"thread_id": "session-002"}}
)

# Resume after user approval
app.invoke(None, config={"configurable": {"thread_id": "session-002"}})

from langgraph.types import interrupt, Command

def sensitive_tool_node(state: AgentState):
    """Node that requests user approval before performing sensitive operations"""
    last_message = state["messages"][-1]

    for tool_call in last_message.tool_calls:
        if tool_call["name"] in ["delete_data", "send_email", "execute_query"]:
            # Interrupt execution and request user approval
            user_response = interrupt(
                f"Attempting to execute '{tool_call['name']}' tool. "
                f"Input: {tool_call['args']}. Do you approve?"
            )

            if user_response != "approved":
                return {"messages": [
                    ToolMessage(
                        content="User rejected the execution.",
                        tool_call_id=tool_call["id"]
                    )
                ]}

        # Execute if approved
        result = tool_map[tool_call["name"]].invoke(tool_call["args"])
        return {"messages": [
            ToolMessage(content=str(result), tool_call_id=tool_call["id"])
        ]}

# User approves from the interrupted state
app.invoke(
    Command(resume="approved"),
    config={"configurable": {"thread_id": "session-002"}}
)

                    [User Query]
                         |
                         v
                   [Supervisor Agent]
                   /       |        \
                  v        v         v
          [Research    [Code       [Data
           Agent]      Agent]      Agent]
              |           |           |
              v           v           v
         [Web Search] [Code Exec] [SQL Query]

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

# Define each specialized Agent
def research_agent(state: MessagesState):
    """Web search specialist Agent"""
    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):
    """Code writing and execution specialist Agent"""
    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):
    """Data analysis specialist Agent"""
    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 routing function
def supervisor(state: MessagesState):
    """Decide which Agent to delegate the task to"""
    model = ChatAnthropic(model="claude-sonnet-4-20250514")
    system_prompt = """You are a Supervisor. Analyze the user's request
    and delegate it to the appropriate specialist Agent.
    - research: when information retrieval is needed
    - code: when code writing/execution is needed
    - data: when data analysis/visualization is needed
    - FINISH: when the task is complete"""

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

def route_supervisor(state: MessagesState):
    """Route based on the Supervisor's decision"""
    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

# Compose graph
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 Application (MCP Client)]
         |
    [MCP Protocol]
         |
[MCP Server A]  [MCP Server B]  [MCP Server C]
     |               |               |
[GitHub API]   [Database]      [File System]

# Evaluation metrics example
evaluation = {
    "correct_tool_selected": True,      # Was the correct tool selected?
    "correct_parameters": True,         # Are the parameters accurate?
    "unnecessary_tool_calls": 0,        # Number of unnecessary calls
    "total_tool_calls": 3,             # Total call count
    "optimal_tool_calls": 2,           # Optimal call count
    "efficiency": 2/3                  # Efficiency
}

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 Definitions
# ============================================

@tool
def load_csv(file_path: str) -> str:
    """Loads a CSV file and returns basic information."""
    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:
    """Runs an analysis query on CSV data using pandas.

    Args:
        file_path: Path to the CSV file
        query: pandas query to execute (e.g., '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"Query execution error: {str(e)}"


@tool
def generate_summary(analysis_results: str, user_question: str) -> str:
    """Converts analysis results into a user-friendly summary.

    Args:
        analysis_results: Analysis result text
        user_question: Original user question
    """
    summary = f"""
    ## Analysis Summary

    **Question**: {user_question}

    **Results**:
    {analysis_results}
    """
    return summary


# ============================================
# 2. Agent Configuration
# ============================================

# Tool list
tools = [load_csv, run_analysis, generate_summary]

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


# Agent node definition
def agent_node(state: MessagesState):
    """Agent reasons and calls tools as needed."""
    system_message = {
        "role": "system",
        "content": """You are a data analysis specialist Agent.
        To answer the user's question, follow these steps:
        1. First load the data with load_csv to understand its structure.
        2. Execute appropriate pandas queries with run_analysis.
        3. Summarize the results with generate_summary.
        Always think step by step and call the necessary tools."""
    }
    messages = [system_message] + state["messages"]
    response = model_with_tools.invoke(messages)
    return {"messages": [response]}


# ============================================
# 3. Graph Construction
# ============================================

# Create StateGraph
workflow = StateGraph(MessagesState)

# Add nodes
workflow.add_node("agent", agent_node)
workflow.add_node("tools", ToolNode(tools))

# Add edges
workflow.add_edge(START, "agent")
workflow.add_conditional_edges(
    "agent",
    tools_condition,  # "tools" if tool_calls exist, END otherwise
)
workflow.add_edge("tools", "agent")  # Deliver tool results to agent

# Compile
checkpointer = MemorySaver()
app = workflow.compile(checkpointer=checkpointer)


# ============================================
# 4. Execution
# ============================================

def run_data_agent(question: str, file_path: str, thread_id: str = "default"):
    """Run the data analysis Agent."""
    config = {"configurable": {"thread_id": thread_id}}

    initial_message = HumanMessage(
        content=f"File path: {file_path}\n\nQuestion: {question}"
    )

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

    # Extract final response
    final_message = result["messages"][-1]
    return final_message.content


# Usage example
if __name__ == "__main__":
    answer = run_data_agent(
        question="What is the monthly average sales and which month had the highest sales?",
        file_path="./data/sales.csv",
        thread_id="analysis-001"
    )
    print(answer)