Update app.py

app.py

@@ -34,9 +34,9 @@
 
 
 import gradio as gr
-import random
+from typing import TypedDict, List, Dict, Optional, Annotated
+from langchain_core.messages import BaseMessage, HumanMessage, AIMessage
 from langgraph.graph import StateGraph, END
-from langchain_core.messages import BaseMessage, HumanMessage, AIMessage, ToolMessage
 from langchain_core.prompts import ChatPromptTemplate
 from langchain_openai import ChatOpenAI
 
@@ -47,15 +47,12 @@ from retriever import load_guest_dataset
 # 定义状态对象
 class AgentState(TypedDict):
     messages: List[BaseMessage]  # 消息历史
-    plan: Optional[str]  # 当前计划
-    tool_results: List[dict]  # 工具执行结果
-    step_count: int  # 当前步骤计数
+    plan: Annotated[Optional[str], "当前计划"]  # 当前计划
+    tool_results: Annotated[List[Dict], "工具执行结果"]  # 工具执行结果
+    step_count: Annotated[int, "步骤计数器"]  # 当前步骤计数
+    final_response: Annotated[Optional[str], "最终响应"]  # 最终响应
 
-# Initialize the model - 使用ChatOpenAI替代HfApiModel
-model = ChatOpenAI(model="gpt-3.5-turbo", temperature=0.7)
-# model = ChatOpenAI(temperature=0)
-
-# Initialize the tools
+# 初始化工具
 search_tool = DuckDuckGoSearchTool()
 weather_info_tool = WeatherInfoTool()
 hub_stats_tool = HubStatsTool()
@@ -67,9 +64,16 @@ TOOLS = {
     "weather_info": weather_info_tool,
     "hub_stats": hub_stats_tool,
     "guest_info": guest_info_tool,
-    # 可以在这里添加基础工具
+    # 基础工具（模拟smolagents的add_base_tools）
+    "search_web": search_tool,
+    "get_weather": weather_info_tool,
+    "get_hub_stats": hub_stats_tool,
+    "get_guest_info": guest_info_tool
 }
 
+# 初始化模型 - 使用ChatOpenAI替代HfApiModel
+model = ChatOpenAI(model="gpt-3.5-turbo", temperature=0.7, max_tokens=512)
+
 # ========================
 # LangGraph 节点函数
 # ========================
@@ -79,17 +83,283 @@ def plan_node(state: AgentState):
     messages = state["messages"]
     step_count = state["step_count"]
     
-    # 每3步进行规划
-    if step_count % 3 == 0:
+    # 每3步进行规划（模拟planning_interval=3）
+    if step_count % 3 == 0 or step_count == 0:
         # 创建规划提示
         prompt = ChatPromptTemplate.from_messages([
-            ("system", "你是一个智能助手Alfred。根据对话历史和当前状态，规划下一步行动。"),
-            ("human", "当前对话历史:\n{messages}\n\n请规划下一步行动。")
+            ("system", "你是一个智能助手Alfred。根据对话历史和当前状态，规划下一步行动。"
+             "提供清晰、具体的计划，包括要使用的工具（如果适用）。"),
+            ("human", "当前对话历史:\n{history}\n\n请规划下一步行动。")
         ])
         
+        # 提取对话历史
+        history = "\n".join([f"{m.type}: {m.content}" for m in messages])
+        
         chain = prompt | model
-        response = chain.invoke({"messages": "\n".join([m.content for m in messages])})
+        response = chain.invoke({"history": history})
         
         return {
             "plan": response.content,
-            "messages": messages}
+            "messages": messages + [AIMessage(content=f"计划: {response.content}")],
+            "step_count": step_count + 1
+        }
+    return state
+
+def tool_selection_node(state: AgentState):
+    """工具选择节点 - 决定使用哪个工具"""
+    messages = state["messages"]
+    plan = state.get("plan", "")
+    
+    # 创建工具选择提示
+    tool_list = ", ".join(TOOLS.keys())
+    prompt = ChatPromptTemplate.from_messages([
+        ("system", "你是一个智能助手Alfred。根据用户请求和当前计划，选择最合适的工具。"),
+        ("system", f"可用工具: {tool_list}"),
+        ("system", f"当前计划: {plan}"),
+        ("human", "用户请求: {last_message}\n\n请选择要使用的工具（只返回工具名称）。")
+    ])
+    
+    # 获取最后一条用户消息
+    last_user_message = next((m.content for m in reversed(messages) if isinstance(m, HumanMessage)), "")
+    
+    chain = prompt | model
+    response = chain.invoke({"last_message": last_user_message})
+    
+    # 提取选择的工具
+    tool_name = response.content.strip().lower()
+    return {
+        "selected_tool": tool_name,
+        "messages": messages + [AIMessage(content=f"选择工具: {tool_name}")]
+    }
+
+def tool_execution_node(state: AgentState):
+    """工具执行节点 - 执行选定的工具"""
+    tool_name = state["selected_tool"]
+    messages = state["messages"]
+    
+    # 获取工具实例
+    tool = TOOLS.get(tool_name)
+    if not tool:
+        error_msg = f"未知工具: {tool_name}"
+        return {
+            "tool_results": [{"tool": tool_name, "error": error_msg}],
+            "messages": messages + [AIMessage(content=error_msg)]
+        }
+    
+    # 提取工具参数（最后一条用户消息）
+    last_user_message = next((m.content for m in reversed(messages) if isinstance(m, HumanMessage)), "")
+    
+    # 执行工具
+    try:
+        result = tool.run(last_user_message)
+        tool_result = {"tool": tool_name, "result": result}
+    except Exception as e:
+        tool_result = {"tool": tool_name, "error": str(e)}
+    
+    return {
+        "tool_results": [tool_result],
+        "messages": messages + [AIMessage(content=f"工具执行结果: {str(tool_result)[:200]}...")]
+    }
+
+def response_generation_node(state: AgentState):
+    """响应生成节点 - 基于工具结果生成最终响应"""
+    tool_results = state["tool_results"]
+    messages = state["messages"]
+    
+    # 创建响应生成提示
+    results_str = "\n".join([f"{res['tool']}: {res.get('result', res.get('error', '无结果'))}" 
+                            for res in tool_results])
+    
+    prompt = ChatPromptTemplate.from_messages([
+        ("system", "你是一个智能助手Alfred。基于工具执行结果生成对用户的响应。"),
+        ("system", f"工具执行结果:\n{results_str}"),
+        ("system", "确保响应完整、友好且直接回答用户问题。"),
+        ("human", "用户原始请求: {last_message}")
+    ])
+    
+    # 获取最后一条用户消息
+    last_user_message = next((m.content for m in reversed(messages) if isinstance(m, HumanMessage)), "")
+    
+    chain = prompt | model
+    response = chain.invoke({"last_message": last_user_message})
+    
+    return {
+        "messages": messages + [AIMessage(content=response.content)],
+        "final_response": response.content
+    }
+
+def should_continue(state: AgentState):
+    """决定是否继续的条件函数"""
+    messages = state["messages"]
+    step_count = state["step_count"]
+    
+    # 检查是否有最终响应
+    if "final_response" in state:
+        last_ai_message = state["final_response"]
+        
+        # 检查AI是否表示需要更多操作
+        if "需要更多信息" in last_ai_message or "下一步" in last_ai_message:
+            return "continue"
+        
+        # 检查是否有未完成的工具调用
+        if any("error" in res for res in state.get("tool_results", [])):
+            return "continue"
+        
+        # 默认情况下结束
+        return "end"
+    
+    # 默认情况下继续
+    return "continue"
+
+# ========================
+# 构建LangGraph工作流
+# ========================
+
+# 创建状态图
+workflow = StateGraph(AgentState)
+
+# 添加节点
+workflow.add_node("plan", plan_node)
+workflow.add_node("select_tool", tool_selection_node)
+workflow.add_node("execute_tool", tool_execution_node)
+workflow.add_node("generate_response", response_generation_node)
+
+# 设置入口点
+workflow.set_entry_point("plan")
+
+# 添加边
+workflow.add_edge("plan", "select_tool")
+workflow.add_edge("select_tool", "execute_tool")
+workflow.add_edge("execute_tool", "generate_response")
+
+# 添加条件边
+workflow.add_conditional_edges(
+    "generate_response",
+    should_continue,
+    {
+        "continue": "plan",  # 继续规划
+        "end": END  # 结束
+    }
+)
+
+# 编译工作流
+agent_workflow = workflow.compile()
+
+# ========================
+# Gradio界面 (模拟GradioUI)
+# ========================
+
+class GradioUI:
+    def __init__(self, agent_workflow):
+        self.agent_workflow = agent_workflow
+    
+    def run_agent(self, message):
+        """运行代理工作流"""
+        # 初始化状态
+        initial_state = {
+            "messages": [HumanMessage(content=message)],
+            "plan": None,
+            "tool_results": [],
+            "step_count": 0,
+            "final_response": None
+        }
+        
+        # 执行工作流
+        for step in self.agent_workflow.stream(initial_state):
+            for node_name, node_state in step.items():
+                # 当有最终响应时返回
+                if "final_response" in node_state:
+                    return self.format_history(node_state["messages"])
+        
+        # 如果未返回，则使用最终状态
+        return self.format_history(initial_state["messages"])
+    
+    def format_history(self, messages):
+        """格式化消息历史用于显示"""
+        formatted = []
+        for msg in messages:
+            if isinstance(msg, HumanMessage):
+                formatted.append(("用户", msg.content))
+            elif isinstance(msg, AIMessage):
+                # 区分不同类型的AI消息
+                if "计划:" in msg.content:
+                    formatted.append(("Alfred (计划)", msg.content))
+                elif "选择工具:" in msg.content:
+                    formatted.append(("Alfred (工具选择)", msg.content))
+                elif "工具执行结果:" in msg.content:
+                    formatted.append(("Alfred (工具结果)", msg.content))
+                else:
+                    formatted.append(("Alfred", msg.content))
+        return formatted
+    
+    def chat_interface(self, message, history):
+        """Gradio聊天界面函数"""
+        # 添加当前消息到历史
+        history = history or []
+        history.append(("用户", message))
+        
+        # 运行代理
+        agent_history = self.run_agent(message)
+        
+        # 更新Gradio历史记录
+        for role, content in agent_history:
+            # 只添加新的消息
+            if (role, content) not in history:
+                history.append((role, content))
+        
+        # 提取最终响应
+        final_response = next((content for role, content in reversed(history) if role == "Alfred"), "")
+        
+        # 转换为Gradio格式
+        gradio_history = []
+        for role, content in history:
+            if role.startswith("用户"):
+                gradio_history.append((content, None))
+            else:
+                if gradio_history and gradio_history[-1][1] is None:
+                    gradio_history[-1] = (gradio_history[-1][0], content)
+                else:
+                    gradio_history.append((None, f"[{role}]: {content}"))
+        
+        return "", gradio_history
+    
+    def launch(self):
+        """启动Gradio界面"""
+        with gr.Blocks(title="Alfred Agent with LangGraph") as demo:
+            gr.Markdown("# 🤖 Alfred 智能代理 (LangGraph 实现)")
+            gr.Markdown("使用LangGraph框架实现的智能代理系统，支持多种工具调用")
+            
+            with gr.Row():
+                with gr.Column(scale=3):
+                    chatbot = gr.Chatbot(label="对话历史", height=500)
+                    msg = gr.Textbox(label="输入消息", placeholder="在此输入您的问题...")
+                    clear_btn = gr.ClearButton([msg, chatbot])
+                    
+                    # 示例问题
+                    gr.Examples(
+                        examples=[
+                            "今天的天气怎么样？",
+                            "搜索LangGraph的最新信息",
+                            "Hugging Face上有多少模型？",
+                            "昨天的嘉宾是谁？"
+                        ],
+                        inputs=msg
+                    )
+                
+                with gr.Column(scale=1):
+                    gr.Markdown("### 可用工具")
+                    for tool_name in TOOLS.keys():
+                        gr.Markdown(f"- {tool_name}")
+            
+            # 事件处理
+            msg.submit(
+                self.chat_interface, 
+                [msg, chatbot], 
+                [msg, chatbot]
+            )
+            
+        demo.launch()
+
+if __name__ == "__main__":
+    # 创建并启动Gradio界面
+    GradioUI(agent_workflow).launch()