tool_calls가 찍혔다고 도구가 실행된 것은 아니다 — bind_tools·ToolNode·ReAct 루프

from langchain_core.tools import tool


@tool
def get_weather(location: str):
    """Call to get the weather"""
    if location in ["서울", "인천"]:
        return "It's 60 degrees and foggy."
    else:
        return "It's 90 degrees and sunny."


@tool
def get_coolest_cities():
    """Get a list of coolest cities"""
    return "서울, 고성"

from langchain_openai import ChatOpenAI
from langgraph.prebuilt import ToolNode

tools = [get_weather, get_coolest_cities]

tool_node = ToolNode(tools)                                  # ② 실행 담당
model_with_tools = ChatOpenAI(model="gpt-4o-mini", temperature=0).bind_tools(tools)  # ① 결정 담당

model_with_tools.invoke("서울 날씨는 어때?").tool_calls
# [{'name': 'get_weather',
#   'args': {'location': '서울'},
#   'id': 'call_HmyqZSrjgHd0p59ePE1Ll9kZ',
#   'type': 'tool_call'}]

model_with_tools.invoke("한국에서 가장 추운 도시는?").tool_calls
# [{'name': 'get_coolest_cities', 'args': {}, 'type': 'tool_call', 'id': 'call_lt9B...'}]

tool_node.invoke({"messages": [model_with_tools.invoke("서울 날씨는 어때?")]})
# {'messages': [ToolMessage(content="It's 60 degrees and foggy.",
#                           name='get_weather',
#                           tool_call_id='call_k7S04S37SUlIhe5jdyw9zJIb')]}

import json
from langchain_core.messages import ToolMessage


class BasicToolNode:
    """A node that runs the tools requested in the last AIMessage."""

    def __init__(self, tools: list) -> None:
        self.tools_by_name = {tool.name: tool for tool in tools}

    def __call__(self, inputs: dict):
        if messages := inputs.get("messages", []):
            message = messages[-1]           # 마지막 AIMessage
        else:
            raise ValueError("No message found in input")

        outputs = []
        for tool_call in message.tool_calls:  # 요청된 도구를 순회하며
            tool_result = self.tools_by_name[tool_call["name"]].invoke(
                tool_call["args"]
            )
            outputs.append(
                ToolMessage(
                    content=json.dumps(tool_result),
                    name=tool_call["name"],
                    tool_call_id=tool_call["id"],   # 요청 id를 그대로 되돌려준다
                )
            )
        return {"messages": outputs}

from typing import Literal
from langgraph.graph import END, MessagesState


def should_continue(state: MessagesState) -> Literal["tools", END]:
    messages = state["messages"]
    last_message = messages[-1]
    if last_message.tool_calls:      # 도구 요청이 있으면
        return "tools"               # tools 노드로
    return END                       # 없으면 종료

from langgraph.prebuilt import ToolNode, tools_condition

graph_builder.add_conditional_edges("chatbot", tools_condition)

from typing import Annotated
from typing_extensions import TypedDict
from langgraph.graph import StateGraph
from langgraph.graph.message import add_messages
from langgraph.prebuilt import ToolNode, tools_condition
from langchain_community.tools.tavily_search import TavilySearchResults
from langchain_openai import ChatOpenAI


class State(TypedDict):
    messages: Annotated[list, add_messages]


tool = TavilySearchResults(max_results=2)
tools = [tool]
tool_node = ToolNode(tools)

llm = ChatOpenAI(model="gpt-4o-mini")
llm_with_tools = llm.bind_tools(tools)


def chatbot(state: State):
    result = llm_with_tools.invoke(state["messages"])
    return {"messages": [result]}


graph_builder = StateGraph(State)
graph_builder.add_node("chatbot", chatbot)
graph_builder.add_node("tools", tool_node)

graph_builder.add_edge("tools", "chatbot")                      # 되돌아오는 엣지 = 사이클
graph_builder.add_conditional_edges("chatbot", tools_condition) # 분기
graph_builder.set_entry_point("chatbot")

graph = graph_builder.compile()

for chunk in app.stream(
    {"messages": [("human", "가장 추운 도시의 날씨는 어때?")]},
    stream_mode="values",
):
    chunk["messages"][-1].pretty_print()