Update app.py

app.py

@@ -33,333 +33,56 @@
 #     GradioUI(alfred).launch()
 
 
-import gradio as gr
-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.prompts import ChatPromptTemplate
-from langchain_openai import ChatOpenAI
+from typing import TypedDict, Annotated
+from langgraph.graph.message import add_messages
+from langchain_core.messages import AnyMessage, HumanMessage, AIMessage
+from langgraph.prebuilt import ToolNode
+from langgraph.graph import START, StateGraph
+from langgraph.prebuilt import tools_condition
+from langchain_huggingface import HuggingFaceEndpoint, ChatHuggingFace
+
+from tools import DuckDuckGoSearchRun, weather_info_tool, hub_stats_tool
+from retriever import guest_info_tool
+
+# Initialize the web search tool
+search_tool = DuckDuckGoSearchRun()
+
+# Generate the chat interface, including the tools
+llm = HuggingFaceEndpoint(
+    repo_id="Qwen/Qwen2.5-Coder-32B-Instruct",
+    huggingfacehub_api_token=HUGGINGFACEHUB_API_TOKEN,
+)
 
-# Import our custom tools from their modules
-from tools import DuckDuckGoSearchTool, WeatherInfoTool, HubStatsTool
-from retriever import load_guest_dataset
+chat = ChatHuggingFace(llm=llm, verbose=True)
+tools = [guest_info_tool, search_tool, weather_info_tool, hub_stats_tool]
+chat_with_tools = chat.bind_tools(tools)
 
-# 定义状态对象
+# Generate the AgentState and Agent graph
 class AgentState(TypedDict):
-    messages: List[BaseMessage]  # 消息历史
-    plan: Annotated[Optional[str], "当前计划"]  # 当前计划
-    tool_results: Annotated[List[Dict], "工具执行结果"]  # 工具执行结果
-    step_count: Annotated[int, "步骤计数器"]  # 当前步骤计数
-    final_response: Annotated[Optional[str], "最终响应"]  # 最终响应
-
-# 初始化工具
-search_tool = DuckDuckGoSearchTool()
-weather_info_tool = WeatherInfoTool()
-hub_stats_tool = HubStatsTool()
-guest_info_tool = load_guest_dataset()
-
-# 所有可用工具
-TOOLS = {
-    "duckduckgo_search": search_tool,
-    "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 节点函数
-# ========================
-
-def plan_node(state: AgentState):
-    """规划节点 - 决定下一步行动"""
-    messages = state["messages"]
-    step_count = state["step_count"]
-    
-    # 每3步进行规划（模拟planning_interval=3）
-    if step_count % 3 == 0 or step_count == 0:
-        # 创建规划提示
-        prompt = ChatPromptTemplate.from_messages([
-            ("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({"history": history})
-        
-        return {
-            "plan": response.content,
-            "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]}...")]
-    }
+    messages: Annotated[list[AnyMessage], add_messages]
 
-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})
-    
+def assistant(state: AgentState):
     return {
-        "messages": messages + [AIMessage(content=response.content)],
-        "final_response": response.content
+        "messages": [chat_with_tools.invoke(state["messages"])],
     }
 
-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)
+## The graph
+builder = StateGraph(AgentState)
 
-# 设置入口点
-workflow.set_entry_point("plan")
+# Define nodes: these do the work
+builder.add_node("assistant", assistant)
+builder.add_node("tools", ToolNode(tools))
 
-# 添加边
-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  # 结束
-    }
+# Define edges: these determine how the control flow moves
+builder.add_edge(START, "assistant")
+builder.add_conditional_edges(
+    "assistant",
+    # If the latest message requires a tool, route to tools
+    # Otherwise, provide a direct response
+    tools_condition,
 )
-
-# 编译工作流
-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()
+builder.add_edge("tools", "assistant")
+alfred = builder.compile()
 
 if __name__ == "__main__":
-    # 创建并启动Gradio界面
-    GradioUI(agent_workflow).launch()
+    GradioUI(alfred).launch()