ShopBot: агент падтрымкі на LangGraph з памяццю, інструментамі і пацвярджэннем вяртанняў
Будуем агента падтрымкі кліентаў у LangGraph модуль за модулем: стан, інструменты, вузлы, маршрутызацыя, слізгальныя зводкі і перапыненне, якое чакае пацвярджэння вяртання.
Крыніцы: Your First Real LangGraph Project: Building a Customer Support Agent.
Эты праект адаптавае тры ідэі LangGraph у аднага агента: архітэктуру графа, памяць для размов і практыку затверджэння дзеянняў чалавекам. Агентам являецца бот для падтрымкі кліянта пад назвай ShopBot, прызначаны для вымышленага інтэрнэт-магазіна. Кліянты можаць запытаць пра замовленні, прагучы вярнення грошаў і падняць прыгожданні. Бот запамячае размову, шукае даныя пра замовленні за дапамою рэальных інструментаў і чакае затверджэння чалавека, прычыму якое-лібо вярнення грошаў не будзе адбыцца. Код ствараецца модуль за модулем, прычыму кожны элемент адгукваецца, і для гэтага не трэба поперадньяго досвяду работы з LangGraph.
Спачатку спланаваце граф
Звычныя памылкі пачатківаўцяў — адкрыванне порожньяго файла і пачатак пісання. LangGraph спадкарае тое, калі спачатку накрэсліце граф на паперы або ў свайму разуме. На паперы ShopBot ўяўляецца простым: крок агента, запуск інструмента, перагляд вярнення грошаў і сумарызатор складаюць вузлы, два галужэння вялі за тым, як працюе працэс, адна функцыя interrupt() зупіняе ўсё на час затверджэння, а ўсё інша запускае процэс сумарызаціі. Код проста перакладае гэтыя зображэння у тэкст.
Настройка
Створыце файл пад назвай shopbot.py або адкройце нотбук Colab. Установіце неабходныя залежнасці:
pip install langgraph langchain langchain-openai langgraph-checkpoint-sqlite python-dotenv
Потым створыце файл .env у той жа папцы, каб зберагчы ключ:
OPENAI_API_KEY=your-key-here
Модуль 1: імпорты і налаштаванні
Усе, што трэба імпортуваць у всім файле, стоіць у верхней частцы, а нічога не імпортуецца пасерэдзінам. Налаштаванні таксама знаходзяцца тут.
# ============================================================
# MODULE 1: IMPORTS & CONFIGURATION
# ============================================================
import os
import sqlite3
from typing import Annotated, Literal
from datetime import datetime
from dotenv import load_dotenv
# LangChain - the AI layer
from langchain_openai import ChatOpenAI
from langchain_core.messages import (
HumanMessage,
AIMessage,
SystemMessage,
BaseMessage,
RemoveMessage,
)
from langchain_core.tools import tool
# LangGraph - the graph layer
from langgraph.graph import StateGraph, MessagesState, START, END
from langgraph.prebuilt import ToolNode
from langgraph.checkpoint.memory import MemorySaver
from langgraph.types import interrupt, Command
load_dotenv()
# ── The LLM ─────────────────────────────────────────────────
# temperature=0 means deterministic - the agent behaves
# consistently, which is what you want for a support bot.
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
Выбраны мадэль gpt-4o-mini. Яна достаточна для выпання завад, досыта дэшавае, ўсё час можна яе выкорыстоўваць, і яна настолькі шырока, што корыстувачы не будуць звертаць увагі на затрымкі. У прымэтных сістэмах можна будзе перайсці на gpt-4o для складнейшых задач, але пачаць з простага — розумна падходжэнне.
Модуль 2: стан
Стан — гэта рабочая памяць агента, таму все, што праходзіць праз граф, павінна знаходзіцца ў яй. Неабходна выбраць, што агент павінен ведаць на кожным этапе.
# ============================================================
# MODULE 2: STATE
# ============================================================
class SupportState(MessagesState):
# MessagesState already gives us:
# messages: Annotated[list[BaseMessage], add_messages]
# We add three more fields for our specific needs:
# The running summary of the conversation (Part 2 pattern).
# Starts empty. Gets written by summarize_node when conversation gets long.
summary: str
# The name of the customer, extracted early in the conversation.
# Used to personalise every response. Starts empty.
customer_name: str
# Tracks the current ticket category, set by the agent.
# Helps the human reviewer understand context during escalation.
# Values: "order_inquiry" | "refund_request" | "complaint" | "general"
ticket_category: str
Існуе тры цяперашнія палаты паляглыя на історыі паведамленняў. summary зберагае стыснутыя даны пра пакульшыя крокі ў размове: калі колькасць паведамленняў перасягне шасць, агент сконцентруе історыю ў гэтай палаце і адмахне старыя необработаныя паведамлення, ў рэзультаты чаго вартасць токенав застаецца стабільной. customer_name — гэта практычная палата для практычна кожнага агента падтрымкі. Калі імя зберагаецца ў стане, агент можа персональна прывітваць людзей, не вымушаны перачытаць усю чат-розмову, каб яго знайсці. ticket_category дазволяе рэалізаваць умовнае направлення, адколі агент яго задае, а функцыя направлення яго чытае, каб выявіць, чы рэгулярвацыя з адзначэнням людзкага апраўлення ўжо трэба актывацыяць.
Модуль 3: інструменты
Інструменты — гэта «раны» агента. Без іх ён можа толькі размовляць, а з імі ён можа шукаць інфармацыю і выконваць дзеянні. ShopBot распаўляецца тры такія інструменты, якія падтрымваюцца фальшывай базай дадзенаў у памяці:
# ============================================================
# MODULE 3: TOOLS
# ============================================================
# ── Fake Database ────────────────────────────────────────────
# In a real project, these would be database queries or API calls.
# For learning purposes, we use a simple Python dictionary.
ORDERS_DB = {
"ORD-001": {
"customer": "Alex",
"product": "Wireless Headphones",
"status": "Delivered",
"amount": 89.99,
"delivery_date": "2025-06-10",
},
"ORD-002": {
"customer": "Sam",
"product": "Phone Case",
"status": "In Transit",
"amount": 14.99,
"delivery_date": "Expected 2025-06-18",
},
"ORD-003": {
"customer": "Jordan",
"product": "Laptop Stand",
"status": "Processing",
"amount": 45.00,
"delivery_date": "Expected 2025-06-20",
},
}
@tool
def lookup_order(order_id: str) -> str:
"""Look up the details of a customer's order by order ID.
Use this when the customer provides an order number and wants
to know the status, product name, or delivery date of their order.
Args:
order_id: The order ID string, e.g. 'ORD-001'
Returns:
A formatted string with full order details, or an error message
if the order is not found.
"""
order = ORDERS_DB.get(order_id.upper())
if not order:
return f"No order found with ID '{order_id}'. Please double-check the order number."
return (
f"Order {order_id.upper()}: {order['product']} | "
f"Status: {order['status']} | "
f"Amount: ${order['amount']:.2f} | "
f"Delivery: {order['delivery_date']}"
)
@tool
def check_refund_eligibility(order_id: str) -> str:
"""Check whether an order is eligible for a refund.
Use this BEFORE processing any refund request. An order is eligible
for a refund only if its status is 'Delivered'. Orders Fthat are
'In Transit' or 'Processing' cannot be refunded yet.
Args:
order_id: The order ID string, e.g. 'ORD-001'
Returns:
A string stating whether the order is eligible and why.
"""
order = ORDERS_DB.get(order_id.upper())
if not order:
return f"Cannot check refund: order '{order_id}' not found."
if order["status"] == "Delivered":
return (
f"Order {order_id.upper()} IS eligible for a refund. "
f"Product: {order['product']}, Amount: ${order['amount']:.2f}. "
f"Proceed to refund processing."
)
else:
return (
f"Order {order_id.upper()} is NOT eligible for a refund yet. "
f"Current status: {order['status']}. Refunds are only available "
f"for delivered orders."
)
@tool
def process_refund(order_id: str, reason: str) -> str:
"""Process a refund for a delivered order.
IMPORTANT: This tool actually issues the refund. It should only be
called AFTER human approval has been obtained. Never call this tool
without prior confirmation.
Args:
order_id: The order ID to refund
reason: The customer's stated reason for the refund
Returns:
A confirmation string with the refund reference number.
"""
order = ORDERS_DB.get(order_id.upper())
if not order:
return f"Refund failed: order '{order_id}' not found."
# In a real system, this would hit your payments API.
refund_ref = f"REF-{order_id.upper()}-{datetime.now().strftime('%H%M%S')}"
return (
f"Refund APPROVED and PROCESSED. Reference: {refund_ref}. "
f"${order['amount']:.2f} will be returned to the original payment method "
f"within 3–5 business days. Reason logged: '{reason}'."
)
# ── Collect tools and bind to LLM ───────────────────────────
# All three tools in one list.
tools = [lookup_order, check_refund_eligibility, process_refund]
# llm_with_tools = the LLM that KNOWS about the tools and can decide to call them.
# This is what we use inside agent_node.
llm_with_tools = llm.bind_tools(tools)
# tool_node = the pre-built node that EXECUTES whatever tool the LLM chose.
# This is what we register in Module 6.
tool_node = ToolNode(tools)
Акружна прыгляніце да докстрынгу process_refund — у яму напісана, што гэты інструмент дзеўальна выдае вярненне грошаў і яго трэба вызываць толькі пасля падтверджэння чалавекам. Мадэль чытае докстрынгі і выкарыстоўвае іх пад час прыняцьбы рашэння, што робіць. Пішыце іх так, як бы вы інструктавалі розумнага стажыста, які яшчэ не знае вашых правіл бізнесу, бо фактычна так і адбываецца.
Модуль 4: вузлы
Вузлы выкананяюць работу. Кожны з іх прыме стан, здзейсніць якісь заход і вернуе словнік з апдэйтамі, больш нічога. У ShopBot ёсць тры вузлы, якія вы пішыце, плюс ужо створаны tool_node з паказванага ранейя модуля. Яны включаюць прапанованне сістэмы, галоўны крок агента, крок перагляду вярнення грошаў з interrupt() і сумарызатор:
# ============================================================
# MODULE 4: NODES
# ============================================================
# ── The System Prompt ────────────────────────────────────────
# Written once, used in every call to the LLM from agent_node.
# This is the personality and rulebook of your agent.
SYSTEM_PROMPT = """You are ShopBot, a friendly and professional customer support \
agent for an e-commerce store.
Your capabilities:
- Look up order details using the lookup_order tool
- Check if an order qualifies for a refund using check_refund_eligibility
- Process approved refunds using the process_refund tool
Your rules:
- Always greet the customer by name once you know it
- Always check refund eligibility BEFORE attempting to process a refund
- For refund requests, set ticket_category to "refund_request" in your reasoning
- Be empathetic, clear, and concise
- If you cannot help, offer to escalate to a human agent
Important: The process_refund tool requires prior human approval. Do not call it \
unless the conversation shows that a human has already approved the refund."""
# ── Node 1: agent_node ──────────────────────────────────────
def agent_node(state: SupportState) -> dict:
"""The brain of the operation. Reads state, calls the LLM, and decides
whether to use a tool, give a final answer, or do something else.
This node handles two cases:
1. Normal conversation - just call the LLM and respond
2. Long conversation - if a summary exists, prepend it so the LLM
has context without seeing all the raw messages
"""
# Part 2 pattern: check for an existing summary
summary = state.get("summary", "")
if summary:
# Build context: system prompt + compressed history + recent messages
system_with_summary = SystemMessage(
content=f"{SYSTEM_PROMPT}\n\nSummary of conversation so far:\n{summary}"
)
messages_to_send = [system_with_summary] + state["messages"]
else:
# No summary yet - full history is short enough to send as-is
system_msg = SystemMessage(content=SYSTEM_PROMPT)
messages_to_send = [system_msg] + state["messages"]
# Call the LLM. It sees tools and can choose to call one.
response = llm_with_tools.invoke(messages_to_send)
# Detect ticket category from the response for routing purposes.
# A smarter version would have the LLM explicitly set this -
# for now, we scan for keywords.
content_lower = response.content.lower() if response.content else ""
updates: dict = {"messages": [response]}
if "refund" in content_lower or (
hasattr(response, "tool_calls")
and any("refund" in str(tc).lower() for tc in (response.tool_calls or []))
):
updates["ticket_category"] = "refund_request"
return updates
# ── Node 2: review_refund ───────────────────────────────────
def review_refund(state: SupportState) -> dict:
"""The human approval gate. Pauses execution, shows the pending refund
details to a human agent, and waits for their decision.
This implements the Part 3 interrupt() pattern. Execution stops here
until someone calls graph.invoke(Command(resume=...), config).
Three outcomes the human can choose:
- "approve" → let the refund tool call proceed unchanged
- "reject" → cancel the refund, send a message to the customer
- "escalate" → hand the entire ticket to a human support agent
"""
last_message = state["messages"][-1]
# Find the refund-related tool call in the last AI message.
# We look for process_refund specifically - the "real action" tool.
refund_tool_call = None
if hasattr(last_message, "tool_calls"):
for tc in last_message.tool_calls:
if "refund" in tc["name"].lower():
refund_tool_call = tc
break
# Surface the context to the human reviewer via interrupt().
# Everything in this dict is what the human sees before deciding.
human_decision = interrupt({
"message": "⚠️ Refund approval required",
"customer_name": state.get("customer_name", "Unknown"),
"tool_being_called": refund_tool_call["name"] if refund_tool_call else "refund tool",
"arguments": refund_tool_call["args"] if refund_tool_call else {},
"conversation_summary": state.get("summary", "No summary yet"),
"options": ["approve", "reject", "escalate"],
})
# ── Handle the human's decision ─────────────────────────
if human_decision == "approve":
# Do nothing to state - let tool_node execute the tool call as-is
return {}
elif human_decision == "reject":
# Cancel the tool call. The LLM will see a ToolMessage explaining why,
# and generate a polite response to the customer.
from langchain_core.messages import ToolMessage
return {
"messages": [
ToolMessage(
content=(
"Refund request was reviewed and declined by our support team. "
"Please inform the customer politely and offer alternatives."
),
tool_call_id=refund_tool_call["id"] if refund_tool_call else "unknown",
)
]
}
elif human_decision == "escalate":
# Signal escalation - in a real system you'd open a ticket,
# ping Slack, or transfer to a live agent queue.
from langchain_core.messages import ToolMessage
return {
"messages": [
ToolMessage(
content=(
"This ticket has been escalated to a senior support agent. "
"Inform the customer that a human agent will contact them "
"within 2 business hours."
),
tool_call_id=refund_tool_call["id"] if refund_tool_call else "unknown",
)
]
}
# Fallback - treat as approve
return {}
# ── Node 3: summarize_node ──────────────────────────────────
def summarize_node(state: SupportState) -> dict:
"""Triggered when the conversation exceeds 6 messages. Compresses the
full message history into a short summary, then deletes old raw messages.
This is the rolling summary pattern from Part 2. The summary grows
richer turn by turn. Token costs stay nearly flat no matter how long
the conversation runs.
"""
existing_summary = state.get("summary", "")
if existing_summary:
# Extend the existing summary with new messages
summary_instruction = (
f"Current summary:\n{existing_summary}\n\n"
"Extend this summary with the new messages above. "
"Keep it under 5 sentences. Focus on: the customer's name, "
"their issue, any orders mentioned, and what actions were taken."
)
else:
# First time summarising
summary_instruction = (
"Summarise this customer support conversation in under 5 sentences. "
"Include: the customer's name (if mentioned), their issue, "
"any order numbers discussed, and what actions were taken so far."
)
messages = state["messages"] + [HumanMessage(content=summary_instruction)]
response = llm.invoke(messages) # Plain llm, no tools needed here
# Delete all but the 2 most recent messages.
# The summary now holds everything that was in the deleted messages.
messages_to_delete = [
RemoveMessage(id=m.id) for m in state["messages"][:-2]
]
return {
"summary": response.content,
"messages": messages_to_delete,
}
Модуль 5: канты і маршрутызацыя
Функцыі маршрутызацыі выбіраюць, куда далей ісці. Яны аналізуюць стан і вяртаюць строку, і ніколі не мяняюць стан, адколькі гэта завада вузлаў. Патрэбны две такія функцыі:
# ============================================================
# MODULE 5: EDGES & ROUTING
# ============================================================
def route_after_agent(state: SupportState) -> Literal[
"review_refund", "tools", "summarize_node", "__end__"
]:
"""Called after agent_node runs. Decides what happens next.
Four possible routes:
1. The LLM wants to call process_refund → must go through human review first
2. The LLM wants to call any other tool → go directly to tool_node
3. The LLM gave a plain text answer AND the conversation is long → summarise
4. The LLM gave a plain text answer and conversation is short → we're done
"""
last_message = state["messages"][-1]
has_tool_calls = hasattr(last_message, "tool_calls") and bool(last_message.tool_calls)
if has_tool_calls:
# Check if ANY of the tool calls is the sensitive process_refund tool
tool_names = [tc["name"] for tc in last_message.tool_calls]
if "process_refund" in tool_names:
return "review_refund" # → Pause for human approval first
return "tools" # → Safe tool, run it directly
# No tool call - the LLM gave a plain response.
# Check if the conversation is long enough to need summarisation.
if len(state["messages"]) > 6:
return "summarize_node"
return "__end__" # → Conversation turn is complete
def route_after_review(state: SupportState) -> Literal["tools", "agent_node"]:
"""Called after review_refund runs (i.e., after the human has decided).
Two routes:
1. Human approved or escalated → run the tool (tool_node handles the call)
2. Human rejected → the review node already added a ToolMessage cancelling
the tool call, so skip tool_node and go back to agent_node to respond
"""
last_message = state["messages"][-1]
# If the last message is a ToolMessage, the review node cancelled the call.
# Go back to agent_node so it can generate a customer-facing response.
from langchain_core.messages import ToolMessage
if isinstance(last_message, ToolMessage):
return "agent_node"
# Otherwise, the review node returned {} (approved) - proceed to tools.
return "tools"
Модуль 6: складанне графа
Усі элементы ужо ў наявнасці, і працэс складання завжды складаецца з пяці крокаў: ініцыялізацыя, рэўістрацыя вузлаў, заданне точкі входу, дадаць рэшткі і компіляцыя.
# ============================================================
# MODULE 6: GRAPH ASSEMBLY
# ============================================================
# ── Step 1: Initialize ──────────────────────────────────────
graph_builder = StateGraph(SupportState)
# ── Step 2: Register All Nodes ──────────────────────────────
# Format: add_node("string_name", function)
# The string name is what you use in every edge definition below.
graph_builder.add_node("agent_node", agent_node)
graph_builder.add_node("tools", tool_node) # Pre-built from Module 3
graph_builder.add_node("review_refund", review_refund)
graph_builder.add_node("summarize_node", summarize_node)
# ── Step 3: Set Entry Point ─────────────────────────────────
# The first node that runs when a user sends a message.
graph_builder.add_edge(START, "agent_node")
# ── Step 4: Wire the Edges ──────────────────────────────────
# After agent_node: conditional - depends on what the LLM decided
graph_builder.add_conditional_edges(
"agent_node", # Source
route_after_agent, # Router function from Module 5
{
"review_refund": "review_refund", # Refund tool → human review first
"tools": "tools", # Other tools → run directly
"summarize_node": "summarize_node", # Long conversation → summarise
"__end__": END, # Plain answer → done
}
)
# After review_refund: conditional - depends on human's decision
graph_builder.add_conditional_edges(
"review_refund",
route_after_review,
{
"tools": "tools", # Approved → execute the tool
"agent_node": "agent_node", # Rejected → back to agent to respond
}
)
# After tools run: always go back to agent_node
# (the ReAct loop - agent sees tool result, decides what to do next)
graph_builder.add_edge("tools", "agent_node")
# After summarization: conversation turn is done
graph_builder.add_edge("summarize_node", END)
# ── Step 5: Compile ─────────────────────────────────────────
# Using MemorySaver for development.
# For production, swap this one line to SqliteSaver or PostgresSaver.
memory = MemorySaver()
shopbot = graph_builder.compile(checkpointer=memory)
У Colab чыраў Jupyter можна адобразіць графак як дыяграму:
from IPython.display import display, Image
from langchain_core.runnables.graph import MermaidDrawMethod
display(Image(
shopbot.get_graph().draw_mermaid_png(
draw_method=MermaidDrawMethod.API
)
))
Магчымае побачыць рэальную схему прабегу дзеянняў, якія вы створылі, ўзята з Лянграф і ўважаецца адной з яе найлепшых функцыяў для учняў. Калі дыяграма выглядае некорэктна, значыць і рэшткі ў яй некарэктныя.
Модуль 7: вхідная точка
Хто саме запускае агента — гэта тут. У скрыпце гэта блок if __name__ == "__main__", а ў серверэ API — апрацоўшчык маршрута, прычаму патэрн у обох случаях аднаковы.
# ============================================================
# MODULE 7: ENTRYPOINT
# ============================================================
def run_shopbot():
"""
Interactive command-line session with ShopBot.
Demonstrates: multi-turn conversation, tool use, and human-in-the-loop.
"""
print("=" * 55)
print(" ShopBot - Customer Support Agent")
print(" Powered by LangGraph")
print("=" * 55)
print("Type your message below. Type 'exit' to quit.")
print("Type 'state' to inspect what ShopBot currently remembers.\n")
# One config per session.
# thread_id is the session key - same ID = same memory thread.
# Change the ID to start a completely fresh conversation.
config = {"configurable": {"thread_id": "customer-session-001"}}
while True:
user_input = input("You: ").strip()
if not user_input:
continue
if user_input.lower() == "exit":
print("ShopBot: Thank you for contacting support. Have a great day!")
break
# ── Debug: inspect current state ────────────────────
if user_input.lower() == "state":
snapshot = shopbot.get_state(config)
print("\n[DEBUG] Current State:")
print(f" Messages in state : {len(snapshot.values.get('messages', []))}")
print(f" Customer name : {snapshot.values.get('customer_name', '(not set)')}")
print(f" Ticket category : {snapshot.values.get('ticket_category', '(not set)')}")
print(f" Summary : {snapshot.values.get('summary', '(none yet)')}")
print(f" Next node(s) : {snapshot.next}\n")
continue
# ── Normal message: invoke the graph ─────────────────
result = shopbot.invoke(
{"messages": [HumanMessage(content=user_input)]},
config=config,
)
# ── Check if graph paused for human approval ─────────
# This is how you detect that interrupt() was called inside review_refund.
while "__interrupt__" in result:
interrupt_data = result["__interrupt__"][0].value
print("\n" + "=" * 55)
print(" HUMAN APPROVAL REQUIRED")
print("=" * 55)
print(f" Customer : {interrupt_data.get('customer_name', 'Unknown')}")
print(f" Action : {interrupt_data.get('tool_being_called', 'refund')}")
print(f" Arguments : {interrupt_data.get('arguments', {})}")
print(f" Context : {interrupt_data.get('conversation_summary', 'N/A')}")
print("=" * 55)
print("Options: [a] Approve [r] Reject [e] Escalate")
human_choice = input("Your decision: ").strip().lower()
if human_choice == "a":
resume_value = "approve"
elif human_choice == "r":
resume_value = "reject"
elif human_choice == "e":
resume_value = "escalate"
else:
print("Invalid choice. Defaulting to reject.")
resume_value = "reject"
# Resume the graph with the human's decision.
# Command(resume=...) answers the pending interrupt() call.
result = shopbot.invoke(
Command(resume=resume_value),
config=config,
)
# ── Print the agent's final response ─────────────────
last_message = result["messages"][-1]
print(f"\nShopBot: {last_message.content}\n")
if __name__ == "__main__":
run_shopbot()
Рэальная сесія
Прыклад размовы паказвае, чаго можна спакаваць, калі яе запускаце:
=======================================================
ShopBot — Customer Support Agent
Powered by LangGraph
=======================================================
Type your message below. Type 'exit' to quit.
Type 'state' to inspect what ShopBot currently remembers.
You: Hi, my name is Alex and I need help with order ORD-001
ShopBot: Hi Alex! I'd be happy to help you with order ORD-001.
I can see your order:
- Product: Wireless Headphones
- Status: Delivered on 2025-06-10
- Amount: $89.99
What can I help you with regarding this order?
You: I want to return it and get a refund
ShopBot: I've checked your order ORD-001 and it's eligible for a refund
since it's been delivered. Let me process that for you right away.
=======================================================
HUMAN APPROVAL REQUIRED
=======================================================
Customer : Alex
Action : process_refund
Arguments : {'order_id': 'ORD-001', 'reason': 'Customer requested return'}
Context : No summary yet
=======================================================
Options: [a] Approve [r] Reject [e] Escalate
Your decision: a
ShopBot: Great news, Alex! Your refund has been successfully processed.
Refund Reference: REF-ORD-001-143022
Amount: $89.99 will be returned to your original payment method within
3–5 business days.
Is there anything else I can help you with?
You: state
[DEBUG] Current State:
Messages in state : 6
Customer name : (not set)
Ticket category : refund_request
Summary : (none yet)
Next node(s) : ()
You: exit
ShopBot: Thank you for contacting support. Have a great day!
Што паказва праект
Расклад з семі модуляў паказвае архітэктуру з початку да канца: StateGraph, add_node, add_conditional_edges і compile — усе ў правым парадку. Частка памяці выканана за дапамогою поля summary, функцыі summarize_node і шаблона руліючага падсумку, у яком новыя запісы стыскаюцца, а старыя вычырваныя; таксама існуе контрольны пункт MemorySaver, які падтрымлівае історыю парадоў. Для удзеле чалавека працэс зупіняецца за дапамогою interrupt() у вузле review_refund, а продовжуецца за дапамогою Command(resume=...); цыкл while "__interrupt__" in result дазволяе адмацаваць калькіляваннія ў аднам парадзе, пры чым можна затвердзіць, адхіліць або перадаць на вышэйшую інстанцію.
Калькілярныя элементы выклікаюцца з інструментаў. Асалівыя інструменты адзначаюцца з @tool, яны запускаюцца за дапамогою заздалега створанага ToolNode, а bind_tools прыўязвае іх да модэля. Цыкл ReAct праходзіць праз інструменты, вузел агента, знову інструменты і так далей. Рутаванне ставіцца да інструментаў адмінша: безпечныя інструменты прайшлі працэс без перашкод да tool_node, тады як чулківыя інструменты спачатку праходзяць праз review_refund.
Куды працаваць далей
Праект спецыяльна створаны як завершаны, але мінімалістычны. Ёсць тры расшырэнні, пачнім з самых простых:
- Крашчая адгукаванне катагорыяў. Часоўна
ticket_categoryвылучаецца праз сканаванне ключоўых слоў уagent_node. Аднойчы простыяй метада — папросіць модэль явна класіфікацыяваць тыкет з структураваным выходам, таму варта рассмотрзецьwith_structured_output(). - Стойкасць SQLite. Заменіце
MemorySaver()наSqliteSaver— гэта адна-лінейная змяна ў Модуле 6, і дадзіце запіт пад час запуску, чы гэта тая ж сесія чы новая. Тады размовы застаюцца пасля перзапуску. - Шлях для падняцья жалобы. Дадзіце чэрвоны вузол
escalate_node, які запускаецца, каліticket_category == "complaint"і адчування кліента ў стане"FRUSTRATED". Ён вызываеinterrupt(), ўбачываючы пра гэта адпаведнага агента, і пераходзіць наroute_after_agentяк новы галачок.
Короткая інструкцыя
У гэтым праекце з’явілася калькі патэранаў. ToolNode(tools) — гэта заранее створэны ўзел, які выкананяе запыты да інструментаў, якія знаходзяцца ў пасляпэльнай паведамленні модэля. llm.bind_tools(tools) паў’язуе спіс інструментаў з модэлем, пасля чаго той можа запрашаць інструмент, вяртаючы поле tool_calls заместо звычайнага тэксту. @tool ператварае функцыю на Python у тое, што модэль можа вызваць, пры чым докстрынг служыць інформацыяй, якая выкарыстоўваецца для адліквідаціі, калі яе вжываць. Перакананне hasattr(message, "tool_calls") and message.tool_calls — гэта стандартны спосаб абавесці, чы розглядванае паведамленне містыць запыт да інструмента, пры чым hasattr павінен выкананы першы, прычым перад тым, як запускаць атрыбут. Цыкл while "__interrupt__" in result обрабоўвае адна або больш застойных перарываў, адколі кожны Command(resume=...) адпавядае на адны перарыв і можа запусціць наступны. У падзеце shopbot.get_state(config) можна вымовіць паведамленне пра тэкушчы стан у будзь-ям момант: .values вяртае слоўнік стану, а .next паказвае, што будзе выканана далей, што ўзніклае вельмі корыстна для адлучэння бягаў.
Існуе рэальны разлік межа разумеўнем канцэпцыі і напісаннем коду для яе, і самэ тут маленькі праект, які помішчаецца ў галаве, але задае працу всім наявным інструментам, дапамагае падыходзіць да гэтага разліку. У гэтым прыкладзе чэкпойнтар, рэальныя інструменты, бар’ер затверджэння і трыгер для падсумавання працуюць разам у аднам агенце. Створыце яго, навмысна зламайце, вылечыце, а потым расшырыце.
Супаўзвязаная літэратура
- Шлюзы адміністрацыі і мнагаагентны маршрутызацыя для бота падтрымкі LangGraph — Дае можлівасць дадаць дэтэрміністычныя шлюзы бізнес-логікі, самакорэктуючыцы цыкл адміністрацыі і керуючы элемент з трыма спецыялістскімі сабграфамі для агента LangGraph у сферэ е-камерцыі.
- Разлікаванне заявак на падтрымку з вядома мнагаагентамі за дапамою LangGraph і Ollama — Дае можлівасць стварыць граф разлікавання заявак з трыма агентамі за дапамою LangGraph: класыфікатор, адпаведальны за адпаведны адказ і людзкі шлюз, які працюе на локальным Ollama або праз API, з адной змененай лінійкай коду.