Thought: 현재 상황을 분석하고 다음 행동을 계획한다.
Action: 외부 도구를 호출하거나 환경과 상호작용한다.
Observation: Action의 결과를 관찰한다.
... (반복)
Thought: 충분한 정보를 수집했으므로 최종 답변을 생성한다.

Thought: 먼저 애플의 현재 시가총액을 달러로 확인해야 한다.
Action: search("Apple current market cap USD")
Observation: Apple's market cap is approximately $3.4 trillion.
Thought: 이제 현재 USD/KRW 환율을 확인해야 한다.
Action: search("current USD KRW exchange rate")
Observation: 1 USD = 1,450 KRW
Thought: 3.4조 달러 * 1,450 = 4,930조 원이다. 최종 답변을 생성한다.
Answer: 애플의 시가총액은 약 4,930조 원입니다.

import anthropic

client = anthropic.Anthropic()

# Tool 정의
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": "서울 날씨 어때?"}
    ]
)

# 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. 실제 tool 실행 (개발자가 구현)
weather_result = call_weather_api(tool_input["location"])

# 4. tool 결과를 Claude에게 전달
follow_up = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    tools=tools,
    messages=[
        {"role": "user", "content": "서울 날씨 어때?"},
        {"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": "서울 날씨와 도쿄 날씨를 비교해줘"}],
    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  # 서울과 도쿄 동시 호출
)

[User Query]
     |
     v
[Planner LLM] --> Step 1, Step 2, Step 3, ...
     |
     v
[Executor] --> Step 1 실행 --> Step 2 실행 --> Step 3 실행
     |
     v
[Re-planner] --> 필요시 계획 수정
     |
     v
[Final Answer]

                    [문제]
                   /  |  \
              [생각1] [생각2] [생각3]    <-- 여러 경로 생성
              /  \      |      \
         [1-a] [1-b]  [2-a]   [3-a]    <-- 각 경로 확장
           |     |      |       |
        [평가] [평가]  [평가]   [평가]   <-- 자체 평가
           |            |
        [선택]        [선택]            <-- 최적 경로 선택

# 단기 기억: 대화 히스토리를 messages로 관리
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 Memory 예시 구조
entity_store = {
    "김영주": {
        "직업": "데이터 엔지니어",
        "관심사": ["LLM", "데이터 파이프라인", "Kubernetes"],
        "선호_언어": "Python",
        "최근_질문_주제": "LangGraph Agent 구축"
    },
    "프로젝트_A": {
        "상태": "진행 중",
        "기술_스택": ["LangGraph", "Claude API", "PostgreSQL"],
        "목표": "사내 데이터 분석 Agent 구축"
    }
}

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

# MessagesState는 messages 리스트를 관리하는 내장 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):
    """Tool을 실행하는 노드"""
    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):
    """tool 호출이 필요한지 판단"""
    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"}}
)

# compile 시 중단점 설정
app = graph.compile(
    checkpointer=checkpointer,
    interrupt_before=["execute_tool"],   # tool 실행 전 중단
    # interrupt_after=["execute_tool"],  # tool 실행 후 중단
)

# 실행하면 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"])
        ]}

# 중단된 상태에서 사용자가 승인
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

# 각 전문 Agent 정의
def research_agent(state: MessagesState):
    """웹 검색 전문 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):
    """코드 작성 및 실행 전문 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):
    """데이터 분석 전문 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 라우팅 함수
def supervisor(state: MessagesState):
    """어떤 Agent에게 작업을 위임할지 결정"""
    model = ChatAnthropic(model="claude-sonnet-4-20250514")
    system_prompt = """당신은 Supervisor입니다. 사용자의 요청을 분석하여
    적절한 전문 Agent에게 작업을 위임하세요.
    - 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 Application (MCP Client)]
         |
    [MCP Protocol]
         |
[MCP Server A]  [MCP Server B]  [MCP Server C]
     |               |               |
[GitHub API]   [Database]      [File System]

# 평가 메트릭 예시
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 정의
# ============================================

@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. Agent 구성
# ============================================

# Tool 리스트
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)


# Agent 노드 정의
def agent_node(state: MessagesState):
    """Agent가 추론하고 필요시 tool을 호출한다."""
    system_message = {
        "role": "system",
        "content": """당신은 데이터 분석 전문 Agent입니다.
        사용자의 질문에 답하기 위해 다음 절차를 따르세요:
        1. 먼저 load_csv로 데이터를 로드하여 구조를 파악합니다.
        2. run_analysis로 적절한 pandas 쿼리를 실행합니다.
        3. generate_summary로 결과를 요약합니다.
        항상 단계별로 생각하고, 필요한 tool을 호출하세요."""
    }
    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")  # tool 결과를 agent에게 전달

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


# ============================================
# 4. 실행
# ============================================

def run_data_agent(question: str, file_path: str, thread_id: str = "default"):
    """데이터 분석 Agent를 실행한다."""
    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)