OpenProbe - Advanced Agent-Based Search System

OpenProbe is an opensource agent-based search system that performs deep web searches to answer complex questions. You can use any form of LLM model inference to use this system. It uses a LangGraph-based agent orchestrator, web UI made with Next.js, and a comprehensive evaluation framework.

🎬 Here's how it looks like

openprobe-demo.mp4

🏗️ Architecture

✨ Features

• Deep Web Search: Multi-step search process with automated planning and execution.
• Adaptive Replanning: Revises search strategies when initial plans fall short.
• Reflection: Explains why previous plans failed and how they were improved.
• Intelligent Reranking: Jina-powered result reranking with optional local reranker support.
• Query Rewriting: Rephrases tool inputs into better search queries.
• Code Execution Tool: Executes Python code in a local REPL to compute answers.
• Multi-Model Support: Natively supports Google Gemini and any OpenAI-compatible models via providers like Lambda.
• Evaluation Framework: Built-in system for testing search quality.

Core Components

• Frontend: A Next.js-based web interface in frontend/.
• Backend: A FastAPI server providing a REST API and WebSocket connection in backend/.
• Search Engine: The main agent orchestration system in src/deepsearch/graph.py.
• Web Search: Search functionality in src/deepsearch/web_search/.
• State Management: Agent state management in src/deepsearch/state.py.
• Evaluation System: Testing framework in evals/.

LangGraph Workflow

The system uses LangGraph to orchestrate the search process:

1. Master Node: Routes to other nodes based on the current state.
2. Plan Node: Generates a structured research plan.
3. Search Node: Executes web searches and summarizes findings.
4. Code Node: Generates and executes Python code for computation.
5. Solve Node: Synthesizes intermediate results into a final answer.
6. Replan Node: Reflects on failures and generates a new plan.

🛠️ Installation

Prerequisites

• Python 3.8+
• Node.js and npm
• API keys for:
  • Google Gemini API or an OpenAI-compatible API key (e.g., for Lambda).
  • Serper.dev API (for web search)
  • Jina API (for reranking, if not using a local reranker)

Setup Steps

1. Clone Repository

   git clone https://github.com/Open-Probe/Open-Probe.git
   cd Open-Probe

2. Install Dependencies

   # This single command installs all Python dependencies
   pip install -e .

   Note: This project uses uv for faster dependency management, but pip is fully supported.

3. Set Up API Keys

   Create a .env file in the project root with your API keys:

   # Google Gemini API key (default provider)
   GOOGLE_API_KEY=your_api_key
   
   # Serper.dev API key for web search
   WEB_SEARCH_API_KEY=your_api_key
   
   # Jina API key for reranking
   JINA_API_KEY=your_api_key
   
   # Optional: Use Lambda/OpenAI-compatible models
   LAMBDA_API_KEY=your_api_key

🚀 Running OpenProbe

To run the services manually:

1. Start the Backend

   python backend/start_server.py

2. Start the Frontend

   cd frontend
   # Install dependencies (only on first run)
   npm install
   # Run the UI
   npm run dev

Access the UI at http://localhost:3000.

Using the CLI

The CLI provides direct access to the DeepSearch agent.

# The package should already be installed from the setup steps

# Run a search
python -m src.deepsearch.cli search "How many meters taller is the Burj Khalifa compared to the Empire State Building?"

# Run with more replanning attempts
python -m src.deepsearch.cli search --max-replan 2 "What year was the first Uber employee born?"

# Run in interactive mode
python -m src.deepsearch.cli search --interactive

📁 Project Structure

openprobe_dev/
├── backend/                # FastAPI backend for the UI
├── frontend/               # Next.js frontend for the UI
├── src/deepsearch/         # Core DeepSearch module
│   ├── graph.py            # LangGraph workflow definition
│   ├── state.py            # State management
│   ├── prompt.py           # System prompts
│   ├── cli.py              # Command-line interface
│   └── web_search/         # Web search components
├── evals/                  # Evaluation framework
├── pyproject.toml          # Python project configuration and dependencies
└── requirements.txt        # Python dependencies

🔑 Key Dependencies

• FastAPI: Backend server.
• Next.js: Frontend UI.
• Google Gemini API: Default LLM provider.
• Lambda: Supported provider for OpenAI-compatible models.
• Serper.dev: Web search functionality.
• Jina: Search result reranking.
• LangGraph: Workflow orchestration.

📄 License

This project is licensed under the Apache License Version 2.0. You are free to use, modify, and distribute this code, subject to the terms of the license.

---

🧩 References and Acknowledgements

This project builds upon and integrates ideas and code from various open-source projects, including:

• LangChain
• LangGraph
• LlamaIndex — For data connectors and query engines.
• Serper API — For web search capabilities.
• Jina AI — For computing text embeddings.
• Mistral — For LLM-based grading and evaluation.
• LangGraph ReWOO implementation - Reference implemenation of ReWOO.
• OpenDeepSearch - For implementing the web search tool and FRAMES evaluation.

Many thanks to these projects and their communities for making this work possible!

---

👥 Contributors

We'd like to thank the following people for their contributions to this project:

• Suryansh Singh Rawat — Developer, Researcher
• Kuo-Hsin Tu — Developer, Researcher
• Jean Yu — Developer
• Ankit Basu — Researcher