Update app.py

app.py

@@ -13,8 +13,7 @@ from langchain_core.tools import tool
 from langchain_core.messages import AIMessage, ToolMessage, HumanMessage, BaseMessage, SystemMessage
 from random import randint
 
-from tkinter import messagebox
-#messagebox.showinfo("Test", "Script run successfully")
+import wikipedia
 
 import gradio as gr
 import logging
@@ -26,12 +25,15 @@ class OrderState(TypedDict):
     finished: bool
 
 # System instruction for the BaristaBot
-BARISTABOT_SYSINT = (
+SYSINT = (
     "system",
-    "You are a BaristaBot, an interactive cafe ordering system. A human will talk to you about the "
-    "available products. Answer questions about menu items, help customers place orders, and "
-    "confirm details before finalizing. Use the provided tools to manage the order."
-)
+    "You are a general AI assistant. I will ask you a question. Report your thoughts, and finish your answer with the following template: "
+    "FINAL ANSWER: [YOUR FINAL ANSWER]. YOUR FINAL ANSWER should be a number OR as few words as possible OR a comma separated list of numbers and/or strings."
+    "If you are asked for a number, don't use comma to write your number neither use units such as $ or percent sign unless specified otherwise."
+    "If you are asked for a string, don't use articles, neither abbreviations (e.g. for cities), and write the digits in plain text unless specified otherwise."
+    "If you are asked for a comma separated list, apply the above rules depending of whether the element to be put in the list is a number or a string."
+    "If a tool required for task completion is unavailable after multiple tries, return 0."
+    )
 
 WELCOME_MSG = "Welcome to the BaristaBot cafe. Type `q` to quit. How may I serve you today?"
 
@@ -39,52 +41,24 @@ WELCOME_MSG = "Welcome to the BaristaBot cafe. Type `q` to quit. How may I serve
 llm = ChatGoogleGenerativeAI(model="gemini-1.5-flash-latest")
 
 @tool
-def get_menu() -> str:
-    """Provide the cafe menu."""
-    #messagebox.showinfo("Test", "Script run successfully")
-    with open("menu.txt", 'r', encoding = "UTF-8") as f:
-        return f.read()
-
-@tool
-def add_to_order(drink: str, modifiers: Iterable[str] = []) -> str:
-    """Adds the specified drink to the customer's order."""
-    return f"{drink} ({', '.join(modifiers) if modifiers else 'no modifiers'})"
-
-@tool
-def confirm_order() -> str:
-    """Asks the customer to confirm the order."""
-    return "Order confirmation requested"
-
-@tool
-def get_order() -> str:
-    """Returns the current order."""
-    return "Current order details requested"
-
-@tool
-def clear_order() -> str:
-    """Clears the current order."""
-    return "Order cleared"
-
-@tool
-def place_order() -> int:
-    """Sends the order to the kitchen."""
-    #messagebox.showinfo("Test", "Order successful!")
-    return randint(2, 10)  # Estimated wait time
-
-def chatbot_with_tools(state: OrderState) -> OrderState:
-    """Chatbot with tool handling."""
-    logging.info(f"Messagelist sent to chatbot node: {[msg.content for msg in state.get('messages', [])]}")
+def wikipedia_search(title: str) -> str:
+    """Provides a short snippet from a Wikipedia article with the given itle"""
+    page = wikipedia.page(title)
+        return page.content[:100]
+
+def agent_node(state: OrderState) -> OrderState:
+    """agent with tool handling."""
+    print(f"Messagelist sent to agent node: {[msg.content for msg in state.get('messages', [])]}")
     defaults = {"order": [], "finished": False}
 
     # Ensure we always have at least a system message
     if not state.get("messages", []):
-        new_output = AIMessage(content=WELCOME_MSG)
-        return defaults | state | {"messages": [SystemMessage(content=BARISTABOT_SYSINT), new_output]}
+        return defaults | state | {"messages": []}
 
     try:
         # Prepend system instruction if not already present
         messages_with_system = [
-            SystemMessage(content=BARISTABOT_SYSINT)
+            SystemMessage(content=SYSINT)
         ] + state.get("messages", [])
 
         # Process messages through the LLM
@@ -95,52 +69,6 @@ def chatbot_with_tools(state: OrderState) -> OrderState:
         # Fallback if LLM processing fails
         return defaults | state | {"messages": [AIMessage(content=f"I'm having trouble processing that. {str(e)}")]}
 
-def order_node(state: OrderState) -> OrderState:
-    """Handles order-related tool calls."""
-    logging.info("order node")
-    tool_msg = state.get("messages", [])[-1]
-    order = state.get("order", [])
-    outbound_msgs = []
-    order_placed = False
-
-    for tool_call in tool_msg.tool_calls:
-        tool_name = tool_call["name"]
-        tool_args = tool_call["args"]
-
-        if tool_name == "add_to_order":
-            modifiers = tool_args.get("modifiers", [])
-            modifier_str = ", ".join(modifiers) if modifiers else "no modifiers"
-            order.append(f'{tool_args["drink"]} ({modifier_str})')
-            response = "\n".join(order)
-
-        elif tool_name == "confirm_order":
-            response = "Your current order:\n" + "\n".join(order) + "\nIs this correct?"
-
-        elif tool_name == "get_order":
-            response = "\n".join(order) if order else "(no order)"
-
-        elif tool_name == "clear_order":
-            order.clear()
-            response = "Order cleared"
-
-        elif tool_name == "place_order":
-            order_text = "\n".join(order)
-            order_placed = True
-            response = f"Order placed successfully!\nYour order:\n{order_text}\nEstimated wait: {randint(2, 10)} minutes"
-
-        else:
-            raise NotImplementedError(f'Unknown tool call: {tool_name}')
-
-        outbound_msgs.append(
-            ToolMessage(
-                content=response,
-                name=tool_name,
-                tool_call_id=tool_call["id"],
-            )
-        )
-
-    return {"messages": outbound_msgs, "order": order, "finished": order_placed}
-
 def maybe_route_to_tools(state: OrderState) -> str:
     """Route between chat and tool nodes."""
     if not (msgs := state.get("messages", [])):
@@ -149,20 +77,16 @@ def maybe_route_to_tools(state: OrderState) -> str:
     msg = msgs[-1]
 
     if state.get("finished", False):
-        logging.info("from chatbot GOTO End node")
+        print("from agent GOTO End node")
         return END
 
     elif hasattr(msg, "tool_calls") and len(msg.tool_calls) > 0:
         if any(tool["name"] in tool_node.tools_by_name.keys() for tool in msg.tool_calls):
-            logging.info("from chatbot GOTO tools node")
+            print("from agent GOTO tools node")
             return "tools"
-        else:
-            logging.info("from chatbot GOTO order node")
-            return "ordering"
 
-    else:
-        logging.info("from chatbot GOTO human node")
-        return "human"
+    print("tool call failed, letting agent try again")
+    return "human"
 
 def human_node(state: OrderState) -> OrderState:
     """Handle user input."""
@@ -174,7 +98,7 @@ def human_node(state: OrderState) -> OrderState:
 
     return state
 
-def maybe_exit_human_node(state: OrderState) -> Literal["chatbot", "__end__"]:
+def maybe_exit_human_node(state: OrderState) -> Literal["agent", "__end__"]:
     """Determine if conversation should continue."""
     if state.get("finished", False):
         logging.info("from human GOTO End node")
@@ -184,32 +108,31 @@ def maybe_exit_human_node(state: OrderState) -> Literal["chatbot", "__end__"]:
         logging.info("Chatbot response obtained, ending conversation")
         return END
     else:
-        logging.info("from human GOTO chatbot node")
-        return "chatbot"
+        logging.info("from human GOTO agent node")
+        return "agent"
 
 # Prepare tools
-auto_tools = [get_menu]
+auto_tools = []
 tool_node = ToolNode(auto_tools)
 
-order_tools = [add_to_order, confirm_order, get_order, clear_order, place_order]
+interactive_tools = [wikipedia_search]
 
 # Bind all tools to the LLM
-llm_with_tools = llm.bind_tools(auto_tools + order_tools)
+llm_with_tools = llm.bind_tools(auto_tools + interactive_tools)
 
 # Build the graph
 graph_builder = StateGraph(OrderState)
 
 # Add nodes
-graph_builder.add_node("chatbot", chatbot_with_tools)
+graph_builder.add_node("chatbot", agent_node)
 graph_builder.add_node("human", human_node)
 graph_builder.add_node("tools", tool_node)
-graph_builder.add_node("ordering", order_node)
 
 # Add edges and routing
-graph_builder.add_conditional_edges("chatbot", maybe_route_to_tools)
+graph_builder.add_conditional_edges("agent", maybe_route_to_tools)
 graph_builder.add_conditional_edges("human", maybe_exit_human_node)
-graph_builder.add_edge("tools", "chatbot")
-graph_builder.add_edge("ordering", "chatbot")
+graph_builder.add_edge("tools", "agent")
+graph_builder.add_edge("ordering", "agent")
 graph_builder.add_edge(START, "human")
 
 # Compile the graph