RAG Frameworks · RUC-NLPIR

Search-o1

Search-o1 is a Python framework that augments large reasoning models (like OpenAI's o1) with real-time web search capabilities through an agentic RAG system. It addresses knowledge gaps during complex reasoning tasks by dynamically retrieving and integrating external information into the reasoning chain.

Talk to DEV.co Discuss Implementation

Source: GitHub — github.com/RUC-NLPIR/Search-o1

1.2k

GitHub stars

106

Forks

Python

Primary language

MIT

License (OSI-approved)

Key facts

Objective fields from the source. Values we can't verify are shown as “Unknown” rather than guessed.

Field	Value
Repository	RUC-NLPIR/Search-o1
Owner	RUC-NLPIR
Primary language	Python
License	MIT — OSI-approved
Stars	1.2k
Forks	106
Open issues	2
Latest release	Unknown
Last updated	2025-11-17
Source	https://github.com/RUC-NLPIR/Search-o1

What Search-o1 is

Search-o1 implements an interleaved agentic retrieval workflow that detects search queries during token generation, batches document retrieval via Jina and Bing APIs, and integrates results via a Reason-in-Documents module. Supports multiple benchmarks (GPQA, AIME, AMC, LiveCodeBench, HotpotQA) with configurable search limits, document length, and retrieval parameters.

Quickstart

Get the Search-o1 source

Clone the repository and explore it locally.

terminalbash

1git clone https://github.com/RUC-NLPIR/Search-o1.git2cd Search-o13# follow the project's README for install & configuration

Need it deployed, integrated, or customized instead? DEV.co ships production installs.

Best use cases

PhD-Level Science and Math Reasoning

Deploy for GPQA, AMC, AIME, and similar high-complexity reasoning tasks where reasoning models struggle with specialized knowledge gaps; Search-o1 retrieves domain-specific information during inference.

Multi-hop Open-Domain QA

Apply to HotpotQA, 2WikiMultihopQA, and MuSiQue datasets where answers require reasoning over multiple retrieved documents; agentic search dynamically gathers evidence chains.

Live Code and Complex Problem Solving

Use for LiveCodeBench and custom code-generation tasks where reasoning models need real-time access to libraries, APIs, or reference documentation during generation.

Implementation considerations

Install Python 3.9+, set up conda environment, and pin dependencies via requirements.txt; verify compatibility with target LRM backbone (tested with o1-like models, roadmap includes Sky-T1 and DeepSeek-R1).
Obtain and validate Bing Search API keys and Jina API credentials before deployment; implement key rotation and rate-limit handling for production use.
Preprocess datasets into unified JSON format using provided `data_pre_process.ipynb` notebook; for custom tasks, extend `scripts/prompts.py` and `scripts/evaluate.py` to match your evaluation criteria.
Configure hyperparameters carefully: `max_search_limit` (search queries per session), `max_turn` (reasoning iterations), `top_k` (retrieved documents), and `max_doc_len` (token budget per document) affect quality and latency trade-offs.
No official release versions published; code updated last on 2025-11-17; pin to specific commit hash for reproducibility in production environments.

When to avoid it — and what to weigh

Deterministic or Latency-Critical Systems — Search-o1 introduces external API calls (Bing Search, Jina) with unpredictable network latency. Not suitable for sub-second inference requirements or systems requiring guaranteed response times.
Fully Offline or Air-Gapped Deployments — Requires external APIs (Bing Search, Jina) and internet connectivity. Cannot function in closed networks without proxy infrastructure and custom search/document services.
Low-Latency Edge or Mobile Inference — HTTP-based search and document retrieval overhead incompatible with edge devices. Use local reasoning models without search augmentation instead.
Tasks Where Context Pollution Is Unacceptable — Relies on retrieval quality from public APIs; noisy or irrelevant documents may degrade reasoning. Requires careful prompt engineering and filtering to minimize interference.

License & commercial use

MIT License (OSI-approved permissive license). Permits commercial use, modification, and distribution with attribution; no warranty or liability protection provided.

MIT License clearly allows commercial use. No commercial disclaimers or restrictions stated in repository. However, requires Bing Search and Jina API subscriptions (third-party costs). Ensure compliance with Bing and Jina terms of service for your use case. Requires review if integrating with proprietary models or restricted datasets.

DEV.co evaluation signals

Editorial assessment — not user reviews. Directional, with an explicit confidence level.

Signal	Assessment
Maintenance	Active
Documentation	Adequate
License clarity	Clear
Deployment complexity	Moderate
DEV.co fit	Good
Assessment confidence	High

Security considerations

API keys (Bing, Jina) passed via command-line arguments—avoid in production logs; use environment variables and secrets management. No input sanitization documented for user queries or retrieved documents; implement validation to prevent prompt injection or malicious URLs. Third-party API calls (Bing, Jina) expose queries and may log data—review privacy policies. No authentication or access control in codebase; assume single-user or trusted-environment operation.

Alternatives to consider

WebThinker (RUC-NLPIR)

Same authors; newer framework (May 2025) with deeper research capabilities; consider if Search-o1 roadmap goals (multi-model support) not urgent for your timeline.

LangChain + ReAct Agents

More mature, widely-adopted framework for agentic RAG and search integration; better documentation, community support, and production tooling; choose if vendor lock-in to academic code is a concern.

OpenAI o1 + Custom Retrieval

Use OpenAI's native reasoning model with proprietary or fine-tuned search pipelines; avoids open-source maintenance burden; requires higher API costs but provides SLA and support.

Software development agency

Build on Search-o1 with DEV.co software developers

Explore Search-o1 on GitHub to integrate agentic retrieval into your LRM inference pipeline. Ideal for research, prototyping, and custom reasoning applications. Get started with quick-start scripts and benchmark datasets.

Talk to DEV.co

Related open-source tools

Surfaced by semantic similarity across the DEV.co open-source index.

SearChat Controllable-RAG-Agent haystack

Related on DEV.co

Explore the category and the services that help you build with it.

RAG Frameworks AI Application Development API Development Cloud Deployment Talk to DEV.co

Search-o1 FAQ

Can I use Search-o1 without Bing Search or Jina?

Requires modification. Scripts hardcode Bing and Jina APIs. You must fork and replace API calls with custom search/document services. No pluggable interface provided.

What reasoning models are supported?

Tested with o1-like models. Roadmap mentions Sky-T1 and DeepSeek-R1 support (not yet implemented). Must pass model path to scripts; compatibility with other LRMs requires prompt engineering review.

Is there a pre-trained model I can download?

No. Search-o1 is a framework for augmenting existing reasoning models. You must provide your own LRM checkpoint (e.g., fine-tuned o1, QwQ, R1).

How does Search-o1 handle irrelevant or noisy retrieved documents?

Reason-in-Documents module integrates results back into reasoning chain. Quality depends on Bing/Jina retrieval quality and document filtering (max_doc_len parameter). No explicit noise filtering documented.

Custom software development services

Adopting Search-o1 is usually one piece of a larger software development effort. As a software development agency, DEV.co provides software development services and web development expertise — pairing senior software developers and web developers with your team to design, build, and operate rag frameworks software in production.

Augment Your Reasoning Model with Live Search

Talk to DEV.co Schedule a Consultation