Upload folder using huggingface_hub

README.md

@@ -1,12 +1,159 @@
 ---
-title: SearchOps Assistant
-emoji: 🌍
-colorFrom: gray
-colorTo: indigo
+title: SearchOps_Assistant
+app_file: app.py
 sdk: gradio
 sdk_version: 5.29.1
-app_file: app.py
-pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Search Personal Co-Worker
+
+An intelligent search assistant built on LangGraph that can answer questions, perform web searches, record query history, and support personalized interactions.
+
+## Project Overview
+
+This project creates a smart search agent capable of finding information, answering questions, and maintaining search history records. Built using the LangGraph framework, it combines various tools to provide a rich search experience.
+
+## Key Features
+
+- **Intelligent Search**: Answer complex questions like "Where to find the best Chinese food in New York" or "What are the strongest AI technologies in 2025"
+- **Search History Management**: Automatically saves all search records, allowing users to query their history using natural language (e.g., "give me all the search history")
+- **Multi-Tool Integration**: Combines web search, Wikipedia, Python computation and other tools to provide comprehensive answers
+- **Personalized Experience**: Recognizes users by username and saves individual search histories
+- **Evaluation Mechanism**: Supports custom success criteria to evaluate search result quality
+- **Automated Execution**: Uses Docker for automated program running and web scraping capabilities
+- **Mobile Notifications**: Integrates with Pushover API to send real-time notifications to mobile devices
+- **Web Scraping**: Employs Pydantic for structured data extraction from websites
+
+## Project Structure
+
+The project consists of three main files:
+
+- **app.py**: Frontend interface responsible for user interaction
+- **search.py**: LangGraph core backend that manages the search process and graph nodes
+- **search_tools.py**: Defines all tools and agent functionalities
+
+## LangGraph Architecture
+
+The search flow consists of the following nodes:
+
+- **StartNode**: Initializes the search process
+- **WorkerNode**: Handles the main search logic
+- **ToolsNode**: Manages and executes various external tools
+- **EvaluatorNode**: Evaluates whether search results meet success criteria
+- **SQLFormatterNode**: Processes database-related queries
+- **EndNode**: Completes the search process and returns results
+
+## Integrated Tools
+
+This project integrates several powerful tools:
+
+1. **Search Tool**: Online web search functionality
+2. **History Query Tool**: Retrieves user's past search history
+3. **Wikipedia Tool**: Directly queries Wikipedia content
+4. **Python REPL**: Executes Python code for calculations or data processing
+5. **Push Notification Tool**: Sends push notifications to mobile devices via Pushover API
+6. **File Tools**: File read/write operations
+7. **Docker Execution**: Securely runs code in isolated containers
+8. **Web Scraping**: Uses Pydantic models for structured web data extraction
+
+## Installation & Setup
+
+### Requirements
+
+- Python 3.8+
+- Docker (for automated program execution)
+- Required dependencies (see requirements.txt)
+- Pushover account and API key (for mobile notifications)
+
+### Installation Steps
+
+1. Clone the repository:
+   ```bash
+   git clone [repository-url]
+   cd [project-folder]
+   ```
+
+2. Install dependencies:
+   ```bash
+   pip install -r requirements.txt
+   playwright install chromium
+   ```
+
+3. Set up environment variables:
+   ```bash
+   # Required for Pushover notifications
+   export PUSHOVER_USER_KEY=your_user_key
+   export PUSHOVER_API_TOKEN=your_api_token
+   ```
+
+4. Install Docker (if not already installed):
+   ```bash
+   # For Ubuntu
+   sudo apt-get update
+   sudo apt-get install docker-ce docker-ce-cli containerd.io
+   
+   # For macOS and Windows, download and install Docker Desktop
+   ```
+
+### Running the Application
+
+```bash
+python app.py
+```
+
+The application will start locally. Access the URL displayed in the terminal (typically http://localhost:7860) to use the search assistant.
+
+## Usage Guide
+
+1. Enter your username (used to record search history)
+2. Type your question in the search box
+3. Specify success criteria (optional, used to evaluate result quality)
+4. Click the "Search" button
+5. View your search results
+6. Query your history by entering commands like "give me all the search history"
+7. Receive push notifications on your mobile device for important alerts
+
+## Deploying to Hugging Face
+
+To deploy this project to Hugging Face Spaces:
+
+1. Create a setup.sh file with the following content:
+   ```bash
+   #!/bin/bash
+   pip install -r requirements.txt
+   playwright install chromium
+   ```
+
+2. Create a .hf directory with a requirements.txt file containing:
+   ```
+   execute_setup_sh==True
+   ```
+
+3. Set up repository secrets in Hugging Face for sensitive API keys:
+   - PUSHOVER_USER_KEY
+   - PUSHOVER_API_TOKEN
+
+4. Ensure your code runs in headless mode for Playwright:
+   ```python
+   browser = playwright.chromium.launch(headless=True)
+   ```
+
+5. Note: Docker execution features may have limited functionality in the Hugging Face environment
+
+## Troubleshooting
+
+If you encounter issues during deployment, check:
+- Browser binary installation (Playwright requires additional setup)
+- Environment differences between local and deployment
+- Path configurations and dependencies
+- API key configuration for Pushover notifications
+- Docker availability and permissions in your deployment environment
+
+## Contributing
+
+Contributions to improve the project are welcome. Please feel free to submit a pull request or open an issue.
+
+## License
+
+Benny
+

SearchOps_Assistant/.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

SearchOps_Assistant/.hf/requirements.txt

@@ -0,0 +1,14 @@
+gradio==5.29.1
+langchain==0.3.25
+langchain_community==0.3.24
+langchain_core==0.3.60
+langchain_experimental==0.3.4
+langchain_openai==0.3.17
+langgraph==0.4.5
+playwright==1.52.0
+pydantic==2.11.4
+python-dotenv==1.1.0
+Requests==2.32.3
+typing_extensions==4.13.2
+
+execute_setup_sh==True

SearchOps_Assistant/README.md

@@ -0,0 +1,158 @@
+# Search Personal Co-Worker
+
+An intelligent search assistant built on LangGraph that can answer questions, perform web searches, record query history, and support personalized interactions.
+
+## Project Overview
+
+This project creates a smart search agent capable of finding information, answering questions, and maintaining search history records. Built using the LangGraph framework, it combines various tools to provide a rich search experience.
+
+## Key Features
+
+- **Intelligent Search**: Answer complex questions like "Where to find the best Chinese food in New York" or "What are the strongest AI technologies in 2025"
+- **Search History Management**: Automatically saves all search records, allowing users to query their history using natural language (e.g., "give me all the search history")
+- **Multi-Tool Integration**: Combines web search, Wikipedia, Python computation and other tools to provide comprehensive answers
+- **Personalized Experience**: Recognizes users by username and saves individual search histories
+- **Evaluation Mechanism**: Supports custom success criteria to evaluate search result quality
+- **Automated Execution**: Uses Docker for automated program running and web scraping capabilities
+- **Mobile Notifications**: Integrates with Pushover API to send real-time notifications to mobile devices
+- **Web Scraping**: Employs Pydantic for structured data extraction from websites
+
+## Project Structure
+
+The project consists of three main files:
+
+- **app.py**: Frontend interface responsible for user interaction
+- **search.py**: LangGraph core backend that manages the search process and graph nodes
+- **search_tools.py**: Defines all tools and agent functionalities
+
+## LangGraph Architecture
+
+The search flow consists of the following nodes:
+
+- **StartNode**: Initializes the search process
+- **WorkerNode**: Handles the main search logic
+- **ToolsNode**: Manages and executes various external tools
+- **EvaluatorNode**: Evaluates whether search results meet success criteria
+- **SQLFormatterNode**: Processes database-related queries
+- **EndNode**: Completes the search process and returns results
+
+## Integrated Tools
+
+This project integrates several powerful tools:
+
+1. **Search Tool**: Online web search functionality
+2. **History Query Tool**: Retrieves user's past search history
+3. **Wikipedia Tool**: Directly queries Wikipedia content
+4. **Python REPL**: Executes Python code for calculations or data processing
+5. **Push Notification Tool**: Sends push notifications to mobile devices via Pushover API
+6. **File Tools**: File read/write operations
+7. **Docker Execution**: Securely runs code in isolated containers
+8. **Web Scraping**: Uses Pydantic models for structured web data extraction
+
+## Installation & Setup
+
+### Requirements
+
+- Python 3.8+
+- Docker (for automated program execution)
+- Required dependencies (see requirements.txt)
+- Pushover account and API key (for mobile notifications)
+
+### Installation Steps
+
+1. Clone the repository:
+   ```bash
+   git clone [repository-url]
+   cd [project-folder]
+   ```
+
+2. Install dependencies:
+   ```bash
+   pip install -r requirements.txt
+   playwright install chromium
+   ```
+
+3. Set up environment variables:
+   ```bash
+   # Required for Pushover notifications
+   export PUSHOVER_USER_KEY=your_user_key
+   export PUSHOVER_API_TOKEN=your_api_token
+   ```
+
+4. Install Docker (if not already installed):
+   ```bash
+   # For Ubuntu
+   sudo apt-get update
+   sudo apt-get install docker-ce docker-ce-cli containerd.io
+   
+   # For macOS and Windows, download and install Docker Desktop
+   ```
+
+### Running the Application
+
+```bash
+python app.py
+```
+
+The application will start locally. Access the URL displayed in the terminal (typically http://localhost:7860) to use the search assistant.
+
+## Usage Guide
+
+1. Enter your username (used to record search history)
+2. Type your question in the search box
+3. Specify success criteria (optional, used to evaluate result quality)
+4. Click the "Search" button
+5. View your search results
+6. Query your history by entering commands like "give me all the search history"
+7. Receive push notifications on your mobile device for important alerts
+
+## Deploying to Hugging Face
+
+To deploy this project to Hugging Face Spaces:
+
+1. Create a setup.sh file with the following content:
+   ```bash
+   #!/bin/bash
+   pip install -r requirements.txt
+   playwright install chromium
+   ```
+
+2. Create a .hf directory with a requirements.txt file containing:
+   ```
+   execute_setup_sh==True
+   ```
+
+3. Set up repository secrets in Hugging Face for sensitive API keys:
+   - PUSHOVER_USER_KEY
+   - PUSHOVER_API_TOKEN
+
+4. Ensure your code runs in headless mode for Playwright:
+   ```python
+   browser = playwright.chromium.launch(headless=True)
+   ```
+
+5. Note: Docker execution features may have limited functionality in the Hugging Face environment
+
+## Troubleshooting
+
+If you encounter issues during deployment, check:
+- Browser binary installation (Playwright requires additional setup)
+- Environment differences between local and deployment
+- Path configurations and dependencies
+- API key configuration for Pushover notifications
+- Docker availability and permissions in your deployment environment
+
+## Contributing
+
+Contributions to improve the project are welcome. Please feel free to submit a pull request or open an issue.
+
+## License
+
+[Add your license information here]
+
+---
+title: SearchOps_Assistant
+app_file: app.py
+sdk: gradio
+sdk_version: 5.29.1
+---

SearchOps_Assistant/app.py

@@ -0,0 +1,52 @@
+import gradio as gr
+from search import Search
+
+
+async def setup():
+    search = Search()
+    await search.setup()
+    return search
+
+async def process_message(search, username, message, success_criteria, history):
+    results = await search.run_superstep(message, username, success_criteria, history)
+    return results, search
+    
+async def reset():
+    new_search = Search()
+    await new_search.setup()
+    return "", "","", None, new_search
+
+def free_resources(search):
+    print("Cleaning up")
+    try:
+        if search:
+            search.free_resources()
+    except Exception as e:
+        print(f"Exception during cleanup: {e}")
+
+
+with gr.Blocks(title="Search", theme=gr.themes.Default(primary_hue="emerald")) as ui:
+    gr.Markdown("## Search Personal Co-Worker")
+    search = gr.State(delete_callback=free_resources)
+    
+    with gr.Row():
+        chatbot = gr.Chatbot(label="Search", height=300, type="messages")
+    with gr.Group():
+        with gr.Row():
+            username = gr.Textbox(show_label=False, placeholder="Enter your username")
+        with gr.Row():
+            message = gr.Textbox(show_label=False, placeholder="Your request to the Search")
+        with gr.Row():
+            success_criteria = gr.Textbox(show_label=False, placeholder="What are your success critiera?")
+    with gr.Row():
+        reset_button = gr.Button("Reset", variant="stop")
+        go_button = gr.Button("Go!", variant="primary")
+        
+    ui.load(setup, [], [search])
+    message.submit(process_message, [search,username, message, success_criteria, chatbot], [chatbot, search])
+    success_criteria.submit(process_message, [search, username, message, success_criteria, chatbot], [chatbot, search])
+    go_button.click(process_message, [search, username, message, success_criteria, chatbot], [chatbot, search])
+    reset_button.click(reset, [], [username, message, success_criteria, chatbot, search])
+
+    
+ui.launch(inbrowser=True)

SearchOps_Assistant/db.ipynb

@@ -0,0 +1,122 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.agents.agent_toolkits import SQLDatabaseToolkit\n",
+    "from langchain.sql_database import SQLDatabase\n",
+    "from langchain.agents import Tool"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "AttributeError",
+     "evalue": "'SQLDatabase' object has no attribute 'close'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
+      "\u001b[31mAttributeError\u001b[39m                            Traceback (most recent call last)",
+      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[4]\u001b[39m\u001b[32m, line 5\u001b[39m\n\u001b[32m      1\u001b[39m \u001b[38;5;66;03m# 初始化数据库连接\u001b[39;00m\n\u001b[32m      2\u001b[39m db = SQLDatabase.from_uri(\u001b[33m\"\u001b[39m\u001b[33msqlite:///example.db\u001b[39m\u001b[33m\"\u001b[39m)\n\u001b[32m----> \u001b[39m\u001b[32m5\u001b[39m \u001b[43mdb\u001b[49m\u001b[43m.\u001b[49m\u001b[43mclose\u001b[49m()\n",
+      "\u001b[31mAttributeError\u001b[39m: 'SQLDatabase' object has no attribute 'close'"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "# 初始化数据库连接\n",
+    "db = SQLDatabase.from_uri(\"sqlite:///example.db\")\n",
+    "\n",
+    "\n",
+    "db.close()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sqlite3\n",
+    "\n",
+    "conn = sqlite3.connect(\"query_log.db\")\n",
+    "cursor = conn.cursor()\n",
+    "\n",
+    "cursor.execute('''\n",
+    "CREATE TABLE IF NOT EXISTS search_history (\n",
+    "    id TEXT PRIMARY KEY,\n",
+    "    username TEXT,\n",
+    "    feedback TEXT,\n",
+    "    reply TEXT,\n",
+    "    timestamp DATETIME DEFAULT CURRENT_TIMESTAMP\n",
+    ")\n",
+    "''')\n",
+    "\n",
+    "conn.commit()\n",
+    "conn.close()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "('benny', 'b43cb216-d36d-4ba3-87f7-75fdf5790487', \"The assistant has indicated an inability to retrieve the search history, which means it did not fulfill the user's request to provide a table of the search history. Additionally, while the assistant asked the user if they have specific search queries, this does not meet the requirement for providing the requested information. Therefore, the response does not meet the success criteria.\", \"It seems that I'm unable to retrieve the search history at this moment. If you have any specific search queries or topics you're interested in, please let me know!\", '2025-05-16 08:53:20')\n"
+     ]
+    }
+   ],
+   "source": [
+    "conn = sqlite3.connect(\"query_log.db\")\n",
+    "cursor = conn.cursor()\n",
+    "\n",
+    "cursor.execute('''\n",
+    "select * from search_history\n",
+    "''')\n",
+    "results = cursor.fetchall()\n",
+    "\n",
+    "for row in results:\n",
+    "    print(row) \n",
+    "conn.commit()\n",
+    "conn.close()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".venv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

SearchOps_Assistant/requirements.txt

@@ -0,0 +1,12 @@
+gradio==5.29.1
+langchain==0.3.25
+langchain_community==0.3.24
+langchain_core==0.3.60
+langchain_experimental==0.3.4
+langchain_openai==0.3.17
+langgraph==0.4.5
+playwright==1.52.0
+pydantic==2.11.4
+python-dotenv==1.1.0
+Requests==2.32.3
+typing_extensions==4.13.2

SearchOps_Assistant/search.py

@@ -0,0 +1,378 @@
+from typing import Annotated
+from typing_extensions import TypedDict
+from langgraph.graph import StateGraph, START, END
+from langgraph.graph.message import add_messages
+from dotenv import load_dotenv
+from langgraph.prebuilt import ToolNode
+from langchain_openai import ChatOpenAI
+from langgraph.checkpoint.memory import MemorySaver
+from langchain_core.messages import AIMessage, HumanMessage, SystemMessage
+from typing import List, Any, Optional, Dict
+from pydantic import BaseModel, Field
+from searcher_tools import playwright_tools, other_tools
+import uuid
+import asyncio
+from datetime import datetime
+import sqlite3
+import json
+load_dotenv(override=True)
+
+class State(TypedDict):
+    messages: Annotated[List[Any], add_messages]
+    username: str
+    success_criteria: str
+    feedback_on_work: Optional[str]
+    success_criteria_met: bool
+    user_input_needed: bool
+    tool_name: Optional[str] 
+
+class EvaluatorOutput(BaseModel):
+    feedback: str = Field(description="Feedback on the assistant's response")
+    success_criteria_met: bool = Field(description="Whether the success criteria have been met")
+    user_input_needed: bool = Field(description="True if more input is needed from the user, or clarifications, or the assistant is stuck")
+
+
+class Search:
+    def __init__(self):
+        self.worker_llm_with_tools = None
+        self.evaluator_llm_with_output = None
+        self.tools = None
+        self.llm_with_tools = None
+        self.graph = None
+        self.search_id = str(uuid.uuid4())
+        self.memory = MemorySaver()
+        self.browser = None
+        self.playwright = None
+        self.formatting_llm = None
+    async def setup(self):
+        self.tools, self.browser, self.playwright = await playwright_tools()
+        self.tools += await other_tools()
+        worker_llm = ChatOpenAI(model="gpt-4o-mini")
+        self.worker_llm_with_tools = worker_llm.bind_tools(self.tools)
+        evaluator_llm = ChatOpenAI(model="gpt-4o-mini")
+        self.evaluator_llm_with_output = evaluator_llm.with_structured_output(EvaluatorOutput)
+        self.formatting_llm = ChatOpenAI(model="gpt-4o-mini")
+        await self.build_graph()
+
+    def worker(self, state: State) -> Dict[str, Any]:
+
+        if not state.get("username") or state["username"].strip() == "":
+            # Username not provided, return response asking for username
+            response = AIMessage(content="Please provide a username before search or accessing search history.")
+            new_state = dict(state)
+            new_state["messages"] = [response]
+            new_state["tool_name"] = None
+            new_state["user_input_needed"] = True  # Signal that we need user input
+            return new_state
+
+        system_message = f"""You are a helpful assistant that can use tools to complete tasks.
+    You keep working on a task until either you have a question or clarification for the user, or the success criteria is met.
+    You have many tools to help you, including tools to browse the internet, navigating and retrieving web pages.
+    You have a tool to run python code, but note that you would need to include a print() statement if you wanted to receive output.
+    The username is {state['username']}The current date and time is {datetime.now().strftime("%Y-%m-%d %H:%M:%S")}
+
+    This is the success criteria:
+    {state['success_criteria']}
+    You should reply either with a question for the user about this assignment, or with your final response.
+    If you have a question for the user, you need to reply by clearly stating your question. An example might be:
+
+    Question: please clarify whether you want a summary or a detailed answer
+
+    If you've finished, reply with the final answer, and don't ask a question; simply reply with the answer.
+    """
+        
+        if state.get("feedback_on_work"):
+            system_message += f"""
+    Previously you thought you completed the assignment, but your reply was rejected because the success criteria was not met.
+    Here is the feedback on why this was rejected:
+    {state['feedback_on_work']}
+    With this feedback, please continue the assignment, ensuring that you meet the success criteria or have a question for the user."""
+        
+        # Add in the system message
+
+        found_system_message = False
+        messages = state["messages"]
+        for message in messages:
+            if isinstance(message, SystemMessage):
+                message.content = system_message
+                found_system_message = True
+        
+        if not found_system_message:
+            messages = [SystemMessage(content=system_message)] + messages
+        
+        # Invoke the LLM with tools
+        response = self.worker_llm_with_tools.invoke(messages)
+        tool_name = None
+        if hasattr(response, "tool_calls") and response.tool_calls:
+            tool_name = response.tool_calls[0]["name"]
+            print(f"Next tool to run: {tool_name}")
+        # Return updated state
+        new_state = dict(state)  
+        new_state["messages"] = [response]  
+        new_state["tool_name"] = tool_name  
+        
+        return new_state
+
+
+    def worker_router(self, state: State) -> str:
+        last_message = state["messages"][-1]
+        
+        if hasattr(last_message, "tool_calls") and last_message.tool_calls:
+            return "tools"
+        else:
+            return "evaluator"
+        
+        
+    def format_conversation(self, messages: List[Any]) -> str:
+        conversation = "Conversation history:\n\n"
+        for message in messages:
+            if isinstance(message, HumanMessage):
+                conversation += f"User: {message.content}\n"
+            elif isinstance(message, AIMessage):
+                text = message.content or "[Tools use]"
+                conversation += f"Assistant: {text}\n"
+        return conversation
+        
+    def evaluator(self, state: State) -> State:
+        last_response = state["messages"][-1].content
+
+        system_message = f"""You are an evaluator that determines if a task has been completed successfully by an Assistant.
+            Assess the Assistant's last response based on the given criteria. Respond with your feedback, and with your decision on whether the success criteria has been met,
+            and whether more input is needed from the user."""
+
+        user_message = f"""You are evaluating a conversation between the User and Assistant. You decide what action to take based on the last response from the Assistant.
+
+            The entire conversation with the assistant, with the user's original request and all replies, is:
+            {self.format_conversation(state['messages'])}
+
+            The success criteria for this assignment is:
+            {state['success_criteria']}
+
+            And the final response from the Assistant that you are evaluating is:
+            {last_response}
+
+            Respond with your feedback, and decide if the success criteria is met by this response.
+            Also, decide if more user input is required, either because the assistant has a question, needs clarification, or seems to be stuck and unable to answer without help.
+
+            The Assistant has access to tools, including a tool to retrieve search history. If the Assistant correctly uses this tool, regardless of the result (which depends on permissions),
+            then consider the success criteria met if the Assistant did its job correctly and communicated results or limitations properly.
+            """
+        if state["feedback_on_work"]:
+            user_message += f"Also, note that in a prior attempt from the Assistant, you provided this feedback: {state['feedback_on_work']}\n"
+            user_message += "If you're seeing the Assistant repeating the same mistakes, then consider responding that user input is required."
+        
+        evaluator_messages = [SystemMessage(content=system_message), HumanMessage(content=user_message)]
+
+        eval_result = self.evaluator_llm_with_output.invoke(evaluator_messages)
+        new_state = {
+            "messages": [{"role": "assistant", "content": f"Evaluator Feedback on this answer: {eval_result.feedback}"}],
+            "feedback_on_work": eval_result.feedback,
+            "success_criteria_met": eval_result.success_criteria_met,
+            "user_input_needed": eval_result.user_input_needed
+        }
+        return new_state
+
+    def route_based_on_evaluation(self, state: State) -> str:
+        is_admin = state['username'] == 'admin'
+
+        if state["success_criteria_met"] or state["user_input_needed"]:
+            # Log search for non-admin users immediately
+            if not is_admin:
+                self.log_search(
+                    state['username'],
+                    self.search_id,
+                    state['feedback_on_work'],
+                    state["messages"][-1].content
+                )
+            return "END"
+        else:
+            return "worker"
+
+    def sqlformator(self, state: State) -> Dict[str, Any]:
+        """
+        A node that completely replaces the state with just the formatted table
+        """
+        print("SQL Formatter activated, completely replacing history with formatted table")
+        
+        # Get the last message which should contain the JSON data
+        last_message = state["messages"][-1]
+        original_message = None
+        
+        # Find the original user request for search history
+        for msg in state["messages"]:
+            if isinstance(msg, HumanMessage) and "search history" in msg.content.lower():
+                original_message = msg
+                break
+        
+        # If no request found, use a generic one
+        if not original_message:
+            original_message = HumanMessage(content="give me the search history")
+        
+        # Format the JSON data
+        try:
+            # Parse JSON to ensure we have valid data
+            import json
+            json_data = json.loads(last_message.content)
+            
+            # Create system message for the formatting LLM
+            system_message = """You are a data formatting specialist. Format the provided JSON data as a clean ASCII table.
+            ONLY return the formatted table, nothing else. Do not reference or include the original JSON."""
+            
+            # Create formatting prompt
+            user_message = f"""Format this JSON data as a readable ASCII table:
+
+            {last_message.content}
+            
+            Create a table with these columns: ID, Thread ID, Username, Timestamp
+            Truncate long values for readability.
+            ONLY return the formatted table, nothing else."""
+            
+            # Create a new LLM instance for formatting
+            formatting_llm = ChatOpenAI(model="gpt-4o-mini")
+            
+            # Get formatted response
+            formatting_response = formatting_llm.invoke([
+                SystemMessage(content=system_message),
+                HumanMessage(content=user_message)
+            ])
+            
+            # Create an enhanced formatted response
+            formatted_table = "# Search History Results\n\n" + formatting_response.content
+            
+        except Exception as e:
+            print(f"Error formatting table: {e}")
+            formatted_table = f"Error formatting search history: {str(e)}"
+        
+        # Create completely new state with minimal message history
+        # This is the key part - we're replacing the entire message history
+        new_state = {
+            "messages": [
+                SystemMessage(content="SQL assistant."),
+                original_message,  # Original user request
+                AIMessage(content=formatted_table)  # Only the formatted table
+            ],
+            "username": state["username"],
+            "success_criteria": state["success_criteria"],
+            "feedback_on_work": None,  # Reset feedback
+            "success_criteria_met": True,  # Mark as completed
+            "user_input_needed": False,
+            "tool_name": None  # Reset tool name
+        }
+        
+        return new_state
+    
+    def route_based_on_tools(self, state: State) -> str:
+        last_message = state["messages"][-1]
+        print("Tool output:", last_message.content)
+        
+        print("State keys:", list(state.keys()))
+        
+        tool_name = state.get("tool_name")
+        print("Tool name detected:", tool_name)
+        
+        if tool_name == "get_user_history":
+            if not state.get("username") or state["username"].strip() == "":
+                print("Username not provided, search history access denied")
+                # Add a message to state explaining why access is denied
+                state["messages"].append(AIMessage(content="Error: Username is required to access search history. Please provide a username."))
+                return "END"  # End the flow with error message
+            print("Detected get_user_history tool, routing to SQL formatter")
+            return "sqlformator"
+        else:
+            print("Routing to worker")
+            return "worker"
+    
+
+
+    def log_search(self,username:str,thread_id: str, feedback: str, reply: str):
+        conn = sqlite3.connect("query_log.db")
+        cursor = conn.cursor()
+        cursor.execute('''
+            INSERT INTO search_history (thread_id, username,  feedback, reply)
+            VALUES (?, ?, ?, ?)
+        ''', (thread_id,username, feedback, reply))
+        conn.commit()
+        conn.close()
+
+    async def build_graph(self):
+        # Set up Graph Builder with State
+        graph_builder = StateGraph(State)
+
+        # Add nodes
+        graph_builder.add_node("worker", self.worker)
+        graph_builder.add_node("tools", ToolNode(tools=self.tools))
+        graph_builder.add_node("evaluator", self.evaluator)
+        graph_builder.add_node("sqlformator", self.sqlformator)
+
+        # Add edges
+        graph_builder.add_conditional_edges("worker", self.worker_router, {"tools": "tools", "evaluator": "evaluator"})
+        graph_builder.add_conditional_edges("tools", self.route_based_on_tools, {"worker": "worker", "sqlformator": 'sqlformator'})
+        graph_builder.add_edge("sqlformator", END)
+        graph_builder.add_conditional_edges("evaluator", self.route_based_on_evaluation, {"worker": "worker", "END": END})
+        
+        graph_builder.add_edge(START, "worker")
+
+        # Compile the graph
+        self.graph = graph_builder.compile(checkpointer=self.memory)
+
+    async def run_superstep(self, message, username, success_criteria, history):
+        config = {"configurable": {"thread_id": self.search_id}}
+
+        state = {
+            "messages": message,
+            "username": username,
+            "success_criteria": success_criteria or "The answer should be clear and accurate",
+            "feedback_on_work": None,
+            "success_criteria_met": False,
+            "user_input_needed": False,
+            "tool_name": None
+        }
+        result = await self.graph.ainvoke(state, config=config)
+
+
+
+        user = {"role": "user", "content": message}
+
+        # For search history requests, find the formatted table response
+        if "search history" in message.lower():
+            formatted_table = None
+            for msg in reversed(result["messages"]):
+                content = msg.content if hasattr(msg, "content") else msg.get("content", "")
+                
+                # Look for a message that contains table formatting indicators
+                if any(marker in content for marker in ["|", "+-", "ID", "Thread ID", "Username", "Timestamp"]):
+                    formatted_table = content
+                    break
+            
+            if formatted_table:
+                reply = {"role": "assistant", "content": formatted_table}
+            else:
+                # Fallback to last message if no table found
+                reply = {"role": "assistant", "content": result["messages"][-1].content}
+        else:
+            # For non-search history requests, use normal processing
+            reply = {"role": "assistant", "content": result["messages"][-2].content}
+
+        reply = {"role": "assistant", "content": result["messages"][-2].content}
+        feedback = {"role": "assistant", "content": result["messages"][-1].content}
+        
+
+        return history + [user, reply, feedback]
+    
+
+
+
+
+
+    def cleanup(self):
+        if self.browser:
+            try:
+                loop = asyncio.get_running_loop()
+                loop.create_task(self.browser.close())
+                if self.playwright:
+                    loop.create_task(self.playwright.stop())
+            except RuntimeError:
+                # If no loop is running, do a direct run
+                asyncio.run(self.browser.close())
+                if self.playwright:
+                    asyncio.run(self.playwright.stop())

SearchOps_Assistant/searcher_tools.py

@@ -0,0 +1,102 @@
+from playwright.async_api import async_playwright
+from langchain_community.agent_toolkits import PlayWrightBrowserToolkit
+from dotenv import load_dotenv
+import os
+import requests
+from langchain.agents import Tool
+from langchain_community.agent_toolkits import FileManagementToolkit
+from langchain_community.tools.wikipedia.tool import WikipediaQueryRun
+from langchain_experimental.tools import PythonREPLTool
+from langchain_community.utilities import GoogleSerperAPIWrapper
+from langchain_community.utilities.wikipedia import WikipediaAPIWrapper
+from langchain.agents.agent_toolkits import SQLDatabaseToolkit
+from langchain.sql_database import SQLDatabase
+import uuid
+import sqlite3
+load_dotenv(override=True)
+pushover_token = os.getenv("PUSHOVER_TOKEN")
+pushover_user = os.getenv("PUSHOVER_USER")
+pushover_url = "https://api.pushover.net/1/messages.json"
+serper = GoogleSerperAPIWrapper()
+
+async def playwright_tools():
+    playwright = await async_playwright().start()
+    browser = await playwright.chromium.launch(headless=False)
+    toolkit = PlayWrightBrowserToolkit.from_browser(async_browser=browser)
+    return toolkit.get_tools(), browser, playwright
+
+
+def push(text: str):
+    """Send a push notification to the user"""
+    requests.post(pushover_url, data = {"token": pushover_token, "user": pushover_user, "message": text})
+    return "success"
+
+
+def get_file_tools():
+    toolkit = FileManagementToolkit(root_dir="sandbox")
+    return toolkit.get_tools()
+
+
+
+
+def get_user_history(username: str):
+    """
+    Retrieves search history from the database for the given username only.
+    Users can only view their own search records.
+    """
+    try:
+        conn = sqlite3.connect("query_log.db")
+        cursor = conn.cursor()
+
+        # Ensure table exists
+        cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='search_history'")
+        if not cursor.fetchone():
+            print("[ERROR] search_history table does not exist")
+            return []
+
+        # Query the user's own records
+        query = '''
+        SELECT * FROM search_history
+        WHERE username = ?
+        ORDER BY timestamp DESC 
+        '''
+        cursor.execute(query, (username,))
+        results = cursor.fetchall()
+
+        # Format the results into dictionaries
+        formatted_results = []
+        for row in results:
+            record = {}
+            for i, col in enumerate(cursor.description):
+                record[col[0]] = row[i]
+            formatted_results.append(record)
+
+        conn.close()
+        return formatted_results
+
+    except Exception as e:
+        print(f"[ERROR] Database error: {str(e)}")
+        return []
+
+async def other_tools():
+    push_tool = Tool(name="send_push_notification", func=push, description="Use this tool when you want to send a push notification")
+    file_tools = get_file_tools()
+
+    tool_search =Tool(
+        name="search",
+        func=serper.run,
+        description="Use this tool when you want to get the results of an online web search"
+    )
+    
+    get_history_tool = Tool(
+                            name="get_user_history",
+                            func=get_user_history,
+                            description="Use this tool when user wants to view their own search history"
+                        )
+    wikipedia = WikipediaAPIWrapper()
+    wiki_tool = WikipediaQueryRun(api_wrapper=wikipedia)
+
+    python_repl = PythonREPLTool()
+    
+    return file_tools + [push_tool, tool_search, python_repl,  wiki_tool, get_history_tool]
+

app.py

@@ -0,0 +1,52 @@
+import gradio as gr
+from search import Search
+
+
+async def setup():
+    search = Search()
+    await search.setup()
+    return search
+
+async def process_message(search, username, message, success_criteria, history):
+    results = await search.run_superstep(message, username, success_criteria, history)
+    return results, search
+    
+async def reset():
+    new_search = Search()
+    await new_search.setup()
+    return "", "","", None, new_search
+
+def free_resources(search):
+    print("Cleaning up")
+    try:
+        if search:
+            search.free_resources()
+    except Exception as e:
+        print(f"Exception during cleanup: {e}")
+
+
+with gr.Blocks(title="Search", theme=gr.themes.Default(primary_hue="emerald")) as ui:
+    gr.Markdown("## Search Personal Co-Worker")
+    search = gr.State(delete_callback=free_resources)
+    
+    with gr.Row():
+        chatbot = gr.Chatbot(label="Search", height=300, type="messages")
+    with gr.Group():
+        with gr.Row():
+            username = gr.Textbox(show_label=False, placeholder="Enter your username")
+        with gr.Row():
+            message = gr.Textbox(show_label=False, placeholder="Your request to the Search")
+        with gr.Row():
+            success_criteria = gr.Textbox(show_label=False, placeholder="What are your success critiera?")
+    with gr.Row():
+        reset_button = gr.Button("Reset", variant="stop")
+        go_button = gr.Button("Go!", variant="primary")
+        
+    ui.load(setup, [], [search])
+    message.submit(process_message, [search,username, message, success_criteria, chatbot], [chatbot, search])
+    success_criteria.submit(process_message, [search, username, message, success_criteria, chatbot], [chatbot, search])
+    go_button.click(process_message, [search, username, message, success_criteria, chatbot], [chatbot, search])
+    reset_button.click(reset, [], [username, message, success_criteria, chatbot, search])
+
+    
+ui.launch(inbrowser=True)

db.ipynb

@@ -0,0 +1,69 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.agents.agent_toolkits import SQLDatabaseToolkit\n",
+    "from langchain.sql_database import SQLDatabase\n",
+    "from langchain.agents import Tool"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sqlite3\n",
+    "\n",
+    "conn = sqlite3.connect(\"query_log.db\")\n",
+    "cursor = conn.cursor()\n",
+    "\n",
+    "cursor.execute('''\n",
+    "CREATE TABLE IF NOT EXISTS search_history (\n",
+    "    id INTEGER PRIMARY KEY AUTOINCREMENT,\n",
+    "    thread_id TEXT,\n",
+    "    username TEXT,\n",
+    "    feedback TEXT,\n",
+    "    reply TEXT,\n",
+    "    timestamp DATETIME DEFAULT CURRENT_TIMESTAMP\n",
+    ")\n",
+    "''')\n",
+    "\n",
+    "conn.commit()\n",
+    "conn.close()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".venv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

requirements.txt

@@ -0,0 +1,13 @@
+gradio==5.29.1
+langchain==0.3.25
+langchain_community==0.3.24
+langchain_core==0.3.60
+langchain_experimental==0.3.4
+langchain_openai==0.3.17
+langgraph==0.4.5
+playwright==1.52.0
+pydantic==2.11.4
+python-dotenv==1.1.0
+Requests==2.32.3
+typing_extensions==4.13.2
+

search.py

@@ -0,0 +1,378 @@
+from typing import Annotated
+from typing_extensions import TypedDict
+from langgraph.graph import StateGraph, START, END
+from langgraph.graph.message import add_messages
+from dotenv import load_dotenv
+from langgraph.prebuilt import ToolNode
+from langchain_openai import ChatOpenAI
+from langgraph.checkpoint.memory import MemorySaver
+from langchain_core.messages import AIMessage, HumanMessage, SystemMessage
+from typing import List, Any, Optional, Dict
+from pydantic import BaseModel, Field
+from searcher_tools import playwright_tools, other_tools
+import uuid
+import asyncio
+from datetime import datetime
+import sqlite3
+import json
+load_dotenv(override=True)
+
+class State(TypedDict):
+    messages: Annotated[List[Any], add_messages]
+    username: str
+    success_criteria: str
+    feedback_on_work: Optional[str]
+    success_criteria_met: bool
+    user_input_needed: bool
+    tool_name: Optional[str] 
+
+class EvaluatorOutput(BaseModel):
+    feedback: str = Field(description="Feedback on the assistant's response")
+    success_criteria_met: bool = Field(description="Whether the success criteria have been met")
+    user_input_needed: bool = Field(description="True if more input is needed from the user, or clarifications, or the assistant is stuck")
+
+
+class Search:
+    def __init__(self):
+        self.worker_llm_with_tools = None
+        self.evaluator_llm_with_output = None
+        self.tools = None
+        self.llm_with_tools = None
+        self.graph = None
+        self.search_id = str(uuid.uuid4())
+        self.memory = MemorySaver()
+        self.browser = None
+        self.playwright = None
+        self.formatting_llm = None
+    async def setup(self):
+        self.tools, self.browser, self.playwright = await playwright_tools()
+        self.tools += await other_tools()
+        worker_llm = ChatOpenAI(model="gpt-4o-mini")
+        self.worker_llm_with_tools = worker_llm.bind_tools(self.tools)
+        evaluator_llm = ChatOpenAI(model="gpt-4o-mini")
+        self.evaluator_llm_with_output = evaluator_llm.with_structured_output(EvaluatorOutput)
+        self.formatting_llm = ChatOpenAI(model="gpt-4o-mini")
+        await self.build_graph()
+
+    def worker(self, state: State) -> Dict[str, Any]:
+
+        if not state.get("username") or state["username"].strip() == "":
+            # Username not provided, return response asking for username
+            response = AIMessage(content="Please provide a username before search or accessing search history.")
+            new_state = dict(state)
+            new_state["messages"] = [response]
+            new_state["tool_name"] = None
+            new_state["user_input_needed"] = True  # Signal that we need user input
+            return new_state
+
+        system_message = f"""You are a helpful assistant that can use tools to complete tasks.
+    You keep working on a task until either you have a question or clarification for the user, or the success criteria is met.
+    You have many tools to help you, including tools to browse the internet, navigating and retrieving web pages.
+    You have a tool to run python code, but note that you would need to include a print() statement if you wanted to receive output.
+    The username is {state['username']}The current date and time is {datetime.now().strftime("%Y-%m-%d %H:%M:%S")}
+
+    This is the success criteria:
+    {state['success_criteria']}
+    You should reply either with a question for the user about this assignment, or with your final response.
+    If you have a question for the user, you need to reply by clearly stating your question. An example might be:
+
+    Question: please clarify whether you want a summary or a detailed answer
+
+    If you've finished, reply with the final answer, and don't ask a question; simply reply with the answer.
+    """
+        
+        if state.get("feedback_on_work"):
+            system_message += f"""
+    Previously you thought you completed the assignment, but your reply was rejected because the success criteria was not met.
+    Here is the feedback on why this was rejected:
+    {state['feedback_on_work']}
+    With this feedback, please continue the assignment, ensuring that you meet the success criteria or have a question for the user."""
+        
+        # Add in the system message
+
+        found_system_message = False
+        messages = state["messages"]
+        for message in messages:
+            if isinstance(message, SystemMessage):
+                message.content = system_message
+                found_system_message = True
+        
+        if not found_system_message:
+            messages = [SystemMessage(content=system_message)] + messages
+        
+        # Invoke the LLM with tools
+        response = self.worker_llm_with_tools.invoke(messages)
+        tool_name = None
+        if hasattr(response, "tool_calls") and response.tool_calls:
+            tool_name = response.tool_calls[0]["name"]
+            print(f"Next tool to run: {tool_name}")
+        # Return updated state
+        new_state = dict(state)  
+        new_state["messages"] = [response]  
+        new_state["tool_name"] = tool_name  
+        
+        return new_state
+
+
+    def worker_router(self, state: State) -> str:
+        last_message = state["messages"][-1]
+        
+        if hasattr(last_message, "tool_calls") and last_message.tool_calls:
+            return "tools"
+        else:
+            return "evaluator"
+        
+        
+    def format_conversation(self, messages: List[Any]) -> str:
+        conversation = "Conversation history:\n\n"
+        for message in messages:
+            if isinstance(message, HumanMessage):
+                conversation += f"User: {message.content}\n"
+            elif isinstance(message, AIMessage):
+                text = message.content or "[Tools use]"
+                conversation += f"Assistant: {text}\n"
+        return conversation
+        
+    def evaluator(self, state: State) -> State:
+        last_response = state["messages"][-1].content
+
+        system_message = f"""You are an evaluator that determines if a task has been completed successfully by an Assistant.
+            Assess the Assistant's last response based on the given criteria. Respond with your feedback, and with your decision on whether the success criteria has been met,
+            and whether more input is needed from the user."""
+
+        user_message = f"""You are evaluating a conversation between the User and Assistant. You decide what action to take based on the last response from the Assistant.
+
+            The entire conversation with the assistant, with the user's original request and all replies, is:
+            {self.format_conversation(state['messages'])}
+
+            The success criteria for this assignment is:
+            {state['success_criteria']}
+
+            And the final response from the Assistant that you are evaluating is:
+            {last_response}
+
+            Respond with your feedback, and decide if the success criteria is met by this response.
+            Also, decide if more user input is required, either because the assistant has a question, needs clarification, or seems to be stuck and unable to answer without help.
+
+            The Assistant has access to tools, including a tool to retrieve search history. If the Assistant correctly uses this tool, regardless of the result (which depends on permissions),
+            then consider the success criteria met if the Assistant did its job correctly and communicated results or limitations properly.
+            """
+        if state["feedback_on_work"]:
+            user_message += f"Also, note that in a prior attempt from the Assistant, you provided this feedback: {state['feedback_on_work']}\n"
+            user_message += "If you're seeing the Assistant repeating the same mistakes, then consider responding that user input is required."
+        
+        evaluator_messages = [SystemMessage(content=system_message), HumanMessage(content=user_message)]
+
+        eval_result = self.evaluator_llm_with_output.invoke(evaluator_messages)
+        new_state = {
+            "messages": [{"role": "assistant", "content": f"Evaluator Feedback on this answer: {eval_result.feedback}"}],
+            "feedback_on_work": eval_result.feedback,
+            "success_criteria_met": eval_result.success_criteria_met,
+            "user_input_needed": eval_result.user_input_needed
+        }
+        return new_state
+
+    def route_based_on_evaluation(self, state: State) -> str:
+        is_admin = state['username'] == 'admin'
+
+        if state["success_criteria_met"] or state["user_input_needed"]:
+            # Log search for non-admin users immediately
+            if not is_admin:
+                self.log_search(
+                    state['username'],
+                    self.search_id,
+                    state['feedback_on_work'],
+                    state["messages"][-1].content
+                )
+            return "END"
+        else:
+            return "worker"
+
+    def sqlformator(self, state: State) -> Dict[str, Any]:
+        """
+        A node that completely replaces the state with just the formatted table
+        """
+        print("SQL Formatter activated, completely replacing history with formatted table")
+        
+        # Get the last message which should contain the JSON data
+        last_message = state["messages"][-1]
+        original_message = None
+        
+        # Find the original user request for search history
+        for msg in state["messages"]:
+            if isinstance(msg, HumanMessage) and "search history" in msg.content.lower():
+                original_message = msg
+                break
+        
+        # If no request found, use a generic one
+        if not original_message:
+            original_message = HumanMessage(content="give me the search history")
+        
+        # Format the JSON data
+        try:
+            # Parse JSON to ensure we have valid data
+            import json
+            json_data = json.loads(last_message.content)
+            
+            # Create system message for the formatting LLM
+            system_message = """You are a data formatting specialist. Format the provided JSON data as a clean ASCII table.
+            ONLY return the formatted table, nothing else. Do not reference or include the original JSON."""
+            
+            # Create formatting prompt
+            user_message = f"""Format this JSON data as a readable ASCII table:
+
+            {last_message.content}
+            
+            Create a table with these columns: ID, Thread ID, Username, Timestamp
+            Truncate long values for readability.
+            ONLY return the formatted table, nothing else."""
+            
+            # Create a new LLM instance for formatting
+            formatting_llm = ChatOpenAI(model="gpt-4o-mini")
+            
+            # Get formatted response
+            formatting_response = formatting_llm.invoke([
+                SystemMessage(content=system_message),
+                HumanMessage(content=user_message)
+            ])
+            
+            # Create an enhanced formatted response
+            formatted_table = "# Search History Results\n\n" + formatting_response.content
+            
+        except Exception as e:
+            print(f"Error formatting table: {e}")
+            formatted_table = f"Error formatting search history: {str(e)}"
+        
+        # Create completely new state with minimal message history
+        # This is the key part - we're replacing the entire message history
+        new_state = {
+            "messages": [
+                SystemMessage(content="SQL assistant."),
+                original_message,  # Original user request
+                AIMessage(content=formatted_table)  # Only the formatted table
+            ],
+            "username": state["username"],
+            "success_criteria": state["success_criteria"],
+            "feedback_on_work": None,  # Reset feedback
+            "success_criteria_met": True,  # Mark as completed
+            "user_input_needed": False,
+            "tool_name": None  # Reset tool name
+        }
+        
+        return new_state
+    
+    def route_based_on_tools(self, state: State) -> str:
+        last_message = state["messages"][-1]
+        print("Tool output:", last_message.content)
+        
+        print("State keys:", list(state.keys()))
+        
+        tool_name = state.get("tool_name")
+        print("Tool name detected:", tool_name)
+        
+        if tool_name == "get_user_history":
+            if not state.get("username") or state["username"].strip() == "":
+                print("Username not provided, search history access denied")
+                # Add a message to state explaining why access is denied
+                state["messages"].append(AIMessage(content="Error: Username is required to access search history. Please provide a username."))
+                return "END"  # End the flow with error message
+            print("Detected get_user_history tool, routing to SQL formatter")
+            return "sqlformator"
+        else:
+            print("Routing to worker")
+            return "worker"
+    
+
+
+    def log_search(self,username:str,thread_id: str, feedback: str, reply: str):
+        conn = sqlite3.connect("query_log.db")
+        cursor = conn.cursor()
+        cursor.execute('''
+            INSERT INTO search_history (thread_id, username,  feedback, reply)
+            VALUES (?, ?, ?, ?)
+        ''', (thread_id,username, feedback, reply))
+        conn.commit()
+        conn.close()
+
+    async def build_graph(self):
+        # Set up Graph Builder with State
+        graph_builder = StateGraph(State)
+
+        # Add nodes
+        graph_builder.add_node("worker", self.worker)
+        graph_builder.add_node("tools", ToolNode(tools=self.tools))
+        graph_builder.add_node("evaluator", self.evaluator)
+        graph_builder.add_node("sqlformator", self.sqlformator)
+
+        # Add edges
+        graph_builder.add_conditional_edges("worker", self.worker_router, {"tools": "tools", "evaluator": "evaluator"})
+        graph_builder.add_conditional_edges("tools", self.route_based_on_tools, {"worker": "worker", "sqlformator": 'sqlformator'})
+        graph_builder.add_edge("sqlformator", END)
+        graph_builder.add_conditional_edges("evaluator", self.route_based_on_evaluation, {"worker": "worker", "END": END})
+        
+        graph_builder.add_edge(START, "worker")
+
+        # Compile the graph
+        self.graph = graph_builder.compile(checkpointer=self.memory)
+
+    async def run_superstep(self, message, username, success_criteria, history):
+        config = {"configurable": {"thread_id": self.search_id}}
+
+        state = {
+            "messages": message,
+            "username": username,
+            "success_criteria": success_criteria or "The answer should be clear and accurate",
+            "feedback_on_work": None,
+            "success_criteria_met": False,
+            "user_input_needed": False,
+            "tool_name": None
+        }
+        result = await self.graph.ainvoke(state, config=config)
+
+
+
+        user = {"role": "user", "content": message}
+
+        # For search history requests, find the formatted table response
+        if "search history" in message.lower():
+            formatted_table = None
+            for msg in reversed(result["messages"]):
+                content = msg.content if hasattr(msg, "content") else msg.get("content", "")
+                
+                # Look for a message that contains table formatting indicators
+                if any(marker in content for marker in ["|", "+-", "ID", "Thread ID", "Username", "Timestamp"]):
+                    formatted_table = content
+                    break
+            
+            if formatted_table:
+                reply = {"role": "assistant", "content": formatted_table}
+            else:
+                # Fallback to last message if no table found
+                reply = {"role": "assistant", "content": result["messages"][-1].content}
+        else:
+            # For non-search history requests, use normal processing
+            reply = {"role": "assistant", "content": result["messages"][-2].content}
+
+        reply = {"role": "assistant", "content": result["messages"][-2].content}
+        feedback = {"role": "assistant", "content": result["messages"][-1].content}
+        
+
+        return history + [user, reply, feedback]
+    
+
+
+
+
+
+    def cleanup(self):
+        if self.browser:
+            try:
+                loop = asyncio.get_running_loop()
+                loop.create_task(self.browser.close())
+                if self.playwright:
+                    loop.create_task(self.playwright.stop())
+            except RuntimeError:
+                # If no loop is running, do a direct run
+                asyncio.run(self.browser.close())
+                if self.playwright:
+                    asyncio.run(self.playwright.stop())

searcher_tools.py

@@ -0,0 +1,102 @@
+from playwright.async_api import async_playwright
+from langchain_community.agent_toolkits import PlayWrightBrowserToolkit
+from dotenv import load_dotenv
+import os
+import requests
+from langchain.agents import Tool
+from langchain_community.agent_toolkits import FileManagementToolkit
+from langchain_community.tools.wikipedia.tool import WikipediaQueryRun
+from langchain_experimental.tools import PythonREPLTool
+from langchain_community.utilities import GoogleSerperAPIWrapper
+from langchain_community.utilities.wikipedia import WikipediaAPIWrapper
+from langchain.agents.agent_toolkits import SQLDatabaseToolkit
+from langchain.sql_database import SQLDatabase
+import uuid
+import sqlite3
+load_dotenv(override=True)
+pushover_token = os.getenv("PUSHOVER_TOKEN")
+pushover_user = os.getenv("PUSHOVER_USER")
+pushover_url = "https://api.pushover.net/1/messages.json"
+serper = GoogleSerperAPIWrapper()
+
+async def playwright_tools():
+    playwright = await async_playwright().start()
+    browser = await playwright.chromium.launch(headless=False)
+    toolkit = PlayWrightBrowserToolkit.from_browser(async_browser=browser)
+    return toolkit.get_tools(), browser, playwright
+
+
+def push(text: str):
+    """Send a push notification to the user"""
+    requests.post(pushover_url, data = {"token": pushover_token, "user": pushover_user, "message": text})
+    return "success"
+
+
+def get_file_tools():
+    toolkit = FileManagementToolkit(root_dir="sandbox")
+    return toolkit.get_tools()
+
+
+
+
+def get_user_history(username: str):
+    """
+    Retrieves search history from the database for the given username only.
+    Users can only view their own search records.
+    """
+    try:
+        conn = sqlite3.connect("query_log.db")
+        cursor = conn.cursor()
+
+        # Ensure table exists
+        cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='search_history'")
+        if not cursor.fetchone():
+            print("[ERROR] search_history table does not exist")
+            return []
+
+        # Query the user's own records
+        query = '''
+        SELECT * FROM search_history
+        WHERE username = ?
+        ORDER BY timestamp DESC 
+        '''
+        cursor.execute(query, (username,))
+        results = cursor.fetchall()
+
+        # Format the results into dictionaries
+        formatted_results = []
+        for row in results:
+            record = {}
+            for i, col in enumerate(cursor.description):
+                record[col[0]] = row[i]
+            formatted_results.append(record)
+
+        conn.close()
+        return formatted_results
+
+    except Exception as e:
+        print(f"[ERROR] Database error: {str(e)}")
+        return []
+
+async def other_tools():
+    push_tool = Tool(name="send_push_notification", func=push, description="Use this tool when you want to send a push notification")
+    file_tools = get_file_tools()
+
+    tool_search =Tool(
+        name="search",
+        func=serper.run,
+        description="Use this tool when you want to get the results of an online web search"
+    )
+    
+    get_history_tool = Tool(
+                            name="get_user_history",
+                            func=get_user_history,
+                            description="Use this tool when user wants to view their own search history"
+                        )
+    wikipedia = WikipediaAPIWrapper()
+    wiki_tool = WikipediaQueryRun(api_wrapper=wikipedia)
+
+    python_repl = PythonREPLTool()
+    
+    return file_tools + [push_tool, tool_search, python_repl,  wiki_tool, get_history_tool]
+