Local deep research means running a research agent, one that plans, searches the web, reads pages and writes a cited report, with a model on your own hardware. The most complete open-source option is Local Deep Research (MIT), which pairs Ollama with a self-hosted SearXNG. GPT Researcher, Vane (formerly Perplexica), Open WebUI's agentic search and Khoj are the main alternatives.
Quick picks
Repositories, licences, release pages and documentation for every tool below were read on 14 November 2026. Benchmark figures are the projects’ own.
| You want | Pick | Why |
|---|---|---|
| A research app that runs on your machine | Local Deep Research | Ollama by default, SearXNG and academic engines, encrypted storage, egress controls |
| Long reports and a Python library | GPT Researcher | Planner and execution agents, PDF and Word export; needs reconfiguring for local use |
| Quick cited answers, Perplexity style | Vane (formerly Perplexica) | One Docker image with SearxNG inside, Ollama support |
| Research inside a chat UI you already run | Open WebUI agentic search | The model calls search_web and fetch_url itself |
| The smallest codebase to learn from | LangChain’s Local Deep Researcher | One search, summarise and reflect loop for Ollama or LM Studio |
| Notes plus web research | Khoj | A /research command over your documents and the web; AGPL-3.0 |
What a deep research agent does
A chat model answers from memory. A search-enabled chat model runs one search and summarises the top results. A deep research agent runs a loop:
- Plan. Break the question into sub-questions.
- Search. Send several queries to one or more search engines.
- Read. Fetch the pages behind the results and extract the useful text.
- Reflect. Decide what is still unknown and search again.
- Write. Produce a structured report that cites the pages used.
The loop is what separates it from retrieval over a fixed document set. If your sources are your own files rather than the web, the problem is retrieval, and our guide to local models for RAG is the better starting point. If you want a notebook that answers from uploaded documents, see the NotebookLM alternatives page.
Running the loop locally changes two things. The model sees your question, your follow-ups and every page it reads without sending them to a model provider. And the weak point moves to search: the queries still leave your network, so the search back end deserves as much attention as the model.
Open-source deep research tools compared, November 2026
| Tool | Licence | Latest release | Search back end | Local models | Interface |
|---|---|---|---|---|---|
| Local Deep Research (LearningCircuit) | MIT | v2.0.0, 7 Nov 2026 | SearXNG, arXiv, PubMed, Semantic Scholar, Wikipedia, GitHub; Tavily, Brave and Google by key | Ollama (default), LM Studio, llama.cpp, OpenAI-compatible | Web UI on port 5000, REST API, MCP server |
| GPT Researcher | Apache 2.0 | v3.8.0, 9 Nov 2026 | Tavily by default; SearXNG, DuckDuckGo, Brave, Serper, arXiv and more | Ollama, or any OpenAI-compatible base URL | Web UI on port 8000, pip package |
| Local Deep Researcher (LangChain) | MIT | No tagged releases; last commit 15 Oct 2026 | DuckDuckGo by default; SearXNG, Tavily, Perplexity | Ollama, LM Studio | LangGraph Studio |
| Vane (formerly Perplexica) | MIT | v1.12.2, 10 Apr 2026 | SearxNG, bundled in the Docker image | Ollama, plus cloud providers | Web UI on port 3000 |
| Open WebUI agentic search | Open WebUI License | v0.13.3, 8 Nov 2026 | SearXNG, DuckDuckGo, Brave and other providers | Ollama, OpenAI-compatible | Chat UI |
| Khoj | AGPL-3.0 | 2.0.0-beta.28, 26 Mar 2026 | SearXNG in its Docker Compose file; Serper, Firecrawl, Exa by key | Ollama through its OpenAI-compatible URL | Web, desktop, Obsidian, Emacs |
| DeerFlow 2 | MIT | v2.2.0, 4 Nov 2026 | DuckDuckGo, Tavily, SearXNG and others | Any OpenAI-compatible endpoint | Web UI on port 2026 |
One well-known name is missing on purpose. LangChain’s Open Deep Research repository is archived on GitHub, with its last push on 10 August 2026. Its code remains readable as a reference, but an archived repository takes no fixes. The related Local Deep Researcher repository remains active.
Local Deep Research on GitHub: what the LearningCircuit project does
The project that owns the name is LearningCircuit/local-deep-research. Version 2.0.0, released on 7 November 2026, rebuilt its web layer on FastAPI; the release notes list breaking changes for reverse proxies and API clients, so read them before upgrading an older install.
What stands out for local use:
- Local by default. The default provider is Ollama, and the quick-start pulls
gpt-oss:20b. LM Studio, llama.cpp and other OpenAI-compatible servers are supported. - Search choice. Free engines include SearXNG, arXiv, PubMed, Semantic Scholar, Wikipedia and GitHub. Tavily, Brave Search and Google need keys. The default
langgraph-agentstrategy lets the model choose engines per query. - Your own documents. Sources found during research can be saved to a library, indexed and searched together with the web later.
- Storage. Each user gets a separate SQLCipher database encrypted with AES-256, with the key derived from the password. The README states there is no telemetry.
- Egress scopes. Every run has a scope: Adaptive (the default), Public only, Private only, Strict or Unprotected. Private only searches local sources and forces local inference. The project describes this as a guard rail against misconfiguration, not an air gap, and recommends firewall rules for a hard boundary.
- Other entry points. A REST API, a Python client and an MCP server over stdio that exposes its research tools to MCP clients, such as the local hosts in our MCP set-up guide.
One detail trips up new installs. Since v1.10.3, a SearXNG address on localhost or a private network is blocked unless the server operator approves it, because any signed-in user could otherwise point the setting at an internal service. The Docker commands below approve it by pinning the URL in the environment.
GPT Researcher, Vane, Open WebUI and the other options
GPT Researcher
GPT Researcher (Apache 2.0) is the largest project in this group. A planner agent generates research questions, execution agents gather and summarise sources, and a publisher writes the report, which can be exported to PDF or Word. It works on web sources and local documents and installs as a web app or with pip install gpt-researcher.
Out of the box it expects an OpenAI key and a Tavily key. A local set-up replaces both in .env. This follows the project’s Ollama guide, with the model swapped for a current one, plus its SearXNG retriever:
OPENAI_API_KEY="123"
OPENAI_API_BASE="http://127.0.0.1:11434/v1"
OLLAMA_BASE_URL="http://127.0.0.1:11434/"
FAST_LLM="ollama:qwen3.5:9b"
SMART_LLM="ollama:qwen3.5:9b"
STRATEGIC_LLM="ollama:qwen3.5:9b"
EMBEDDING_PROVIDER="ollama"
OLLAMA_EMBEDDING_MODEL="nomic-embed-text"
RETRIEVER="searx"
SEARX_URL="http://localhost:8080"
Retrievers can be combined with commas, for example RETRIEVER=searx,arxiv.
LangChain’s Local Deep Researcher
This MIT-licensed repository is a compact example rather than a product. It generates a query, searches, summarises, reflects on gaps and repeats for a set number of loops, three by default, then returns a Markdown summary with sources. It uses DuckDuckGo without a key, or SearXNG, Tavily or Perplexity, and it runs in LangGraph Studio. Read it to understand the pattern; use something else for daily work.
Vane, formerly Perplexica
Vane is the answer for people looking for an open-source Perplexity alternative. One command starts the app together with SearxNG:
docker run -d -p 3000:3000 -v vane-data:/home/vane/data --name vane itzcrazykns1337/vane:latest
It offers Speed, Balanced and Quality modes, searches the web, discussions or academic papers, accepts file uploads and keeps history locally. A slim image points at your own SearxNG, which must have JSON output and the Wolfram Alpha engine enabled. Releases have slowed: the latest tag is from April 2026 and the last commit seen was on 1 September 2026.
Open WebUI agentic search
If you already run Open WebUI, you may not need another tool. With web search configured and Function Calling set to Native, the model receives two tools, search_web and fetch_url, and decides for itself when to search, which pages to open and when to search again. The docs call this agentic search; there is no separate deep research mode and no report generator. By default a fetched page enters the context whole, so set the Fetch URL Content Length Limit when the model is local. Our comparison of self-hosted chat interfaces covers Open WebUI’s licence and administration.
Khoj and DeerFlow
Khoj (AGPL-3.0) combines chat over your notes with web search and has a /research command that its docs describe as going deeper for more accurate answers. SearXNG works out of the box in its Docker Compose file. Its last tagged release is a beta from March 2026 and the last commit seen was on 2 August 2026, so check activity before you depend on it.
DeerFlow (MIT) began as ByteDance’s deep research framework. Version 2 is a ground-up rewrite into a general agent harness with sandboxes, memory and sub-agents; the original framework lives on a 1.x branch. It is capable but far more than a research tool, and its README recommends models with context windows of 100,000 tokens or more.
SearXNG as the search back end
Almost every tool above can use SearXNG, a metasearch engine under AGPL-3.0 that queries other search engines and merges the results without tracking users. It is the usual choice because it needs no API key and runs in one container.
Two facts decide whether it works:
- JSON output is off by default. SearXNG serves only HTML unless
jsonis added tosearch.formatsinsettings.yml. Open WebUI’s SearXNG guide lists “403 Client Error: Forbidden” as the symptom of the missing format, and GPT Researcher and Vane need the same change. - It is a relay, not an index. A self-hosted SearXNG forwards each query to public engines. Your prompts stay local; your search terms do not. Local Deep Research treats a local SearXNG as a public engine for exactly this reason.
Result quality depends on which upstream engines are enabled and whether they throttle your address. Open WebUI’s docs warn that results from self-hosted engines can vary.
Can deep research run fully offline?
Web research cannot, because the pages live on the internet. Research over your own material can, and the tools differ in how far they help.
Local Deep Research goes furthest. Its Private only scope limits a run to local collections, the library and local document stores, forces local inference and normally refuses cloud providers. Under that scope and under Strict, the project also arms a socket-level guard that refuses connections to public addresses, which it describes as a backstop with known gaps. GPT Researcher can write reports from local documents with embeddings served by Ollama, and Khoj answers from indexed notes and files.
One caveat from the Local Deep Research README applies to every tool here. A “local” endpoint is judged by its address, not by where the model runs. An Ollama cloud model, or a local proxy in front of a hosted API, looks local and still sends prompts off the machine. If offline matters, check the model list as well as the URL, and block outbound traffic at the firewall.
Which local model and hardware for deep research
A research loop stresses three things: tool or structured-output reliability, the ability to hold many page extracts in context, and stamina over dozens of calls.
The Local Deep Research project publishes community benchmarks run with its langgraph-agent strategy, models served by Ollama and the Serper cloud search API:
| Model | SimpleQA | xbench-DeepSearch | Ollama download |
|---|---|---|---|
| Qwen3.6-27B | 95.7% (287 of 300) | 77.0% (77 of 100) | 18 to 19 GB |
| Qwen3.5-9B | 91.2% (182 of 200) | 59.0% (59 of 100) | 6.6 GB |
| gpt-oss-20b | 85.4% (295 of 346) | Not reported | 14 GB |
The project attaches caveats: small samples, noise from the grading model and the risk that newer models saw SimpleQA in training. The harder multi-step benchmark separates the 27B model from the 9B model far more than the simple one does.
Hardware follows from the download size plus context. The project’s FAQ gives a rough guide of 8 GB of VRAM for 13B models and 16 GB for 30B models, with 8 GB of system RAM as a minimum. Context is the setting people miss:
- Ollama defaults to 4K tokens under 24 GiB of VRAM and recommends at least 64,000 for web search and agents.
- Local Deep Research sets local models to 20,480 tokens by default and says to raise it if synthesis prompts are truncated.
- Qwen’s model cards advise keeping at least 128K tokens when thinking mode is on.
More context means more memory, so check the fit with the VRAM calculator. For models by GPU size, see our picks by VRAM tier; for agent-specific evidence, the guide to local models for tool calling.
Set-up: Local Deep Research with Ollama and SearXNG
These are the project’s own quick-start commands for native Linux, where --network host works:
# 1. Ollama and a model
docker run -d -p 11434:11434 --name ollama ollama/ollama
docker exec ollama ollama pull gpt-oss:20b
# 2. SearXNG
docker run -d -p 8080:8080 --name searxng searxng/searxng
# 3. Local Deep Research, with the local SearXNG URL approved
docker run -d --network host \
--name local-deep-research \
--volume "deep-research:/data" \
-e LDR_DATA_DIR=/data \
-e LDR_SEARCH_ENGINE_WEB_SEARXNG_DEFAULT_PARAMS_INSTANCE_URL=http://localhost:8080 \
localdeepresearch/local-deep-research
On macOS, Windows and WSL2, host networking does not behave this way under Docker Desktop, and the README says to use Docker Compose instead:
curl -O https://raw.githubusercontent.com/LearningCircuit/local-deep-research/main/docker-compose.yml && docker compose up -d
Then:
- Open
http://localhost:5000and create an account. The password derives your database key and is never stored, so keep it somewhere safe. - In Settings, confirm the provider is Ollama and select the model you pulled.
- Raise the local context window from 20,480 if your GPU has room, and confirm with
ollama psthat the model still runs fully on the GPU. - Check that SearXNG is the search engine, then run a quick summary before a detailed report.
- Choose the egress scope for each run. Use Private only when the question should not reach a search engine at all.
A pip install is also documented (pip install local-deep-research), and the project requires a CPU with AVX support.
Limits: search keys, hallucinated citations and context size
- Search is the dependency. The best-scoring benchmark runs above used a paid cloud search API. Free SearXNG results are good enough for many questions but vary, and public engines rate-limit automated traffic.
- Citations need checking. A cited link proves a page was found, not that it says what the report claims. Models can attach a real URL to a sentence the page does not support. Open the sources behind any figure you intend to reuse.
- Context limits what gets read. When pages exceed the window, tools truncate or summarise them, and details vanish silently. Small windows are the most common cause of shallow reports from local models.
- Some pages are never fetched. Local Deep Research respects
robots.txtand identifies itself honestly, so sites that block automated access are skipped. - Web pages are untrusted input. Text on a fetched page can try to steer the model. Keep research agents away from tools that write or send anything; our prompt injection prevention guide covers the controls.
- It is slow. A report takes many model calls. No project publishes timings for local hardware that we could verify, so measure on your own machine.
- Licences differ. MIT and Apache 2.0 tools are simple to adopt at work. Khoj and SearXNG are AGPL-3.0, and Open WebUI uses its own licence with branding conditions.
How VDF AI fits
The tools above answer one person’s question from the public web. VDF AI does not run, host, resell or integrate with Local Deep Research, GPT Researcher, Vane, Khoj, DeerFlow or SearXNG. The honest bridge is what changes when research moves inside an organisation: the valuable sources are internal, not everyone may read every document, and someone has to be able to show which sources and which model produced an answer.
VDF AI Chat is built for that case. Per its product page, retrieval is filtered by each user’s own permissions, answers carry citations back to the source document and section, and each turn writes an audit record, on-premises, in a sovereign region or air-gapped. To discuss a research workflow over your own sources, contact the team.
Sources
GitHub repositories, release pages and project documentation as they stood on 14 November 2026.
- Local Deep Research repository, v2.0.0 release notes, SearXNG set-up, configuration reference, FAQ, search engines guide and MCP server guide
- GPT Researcher repository, running with Ollama, search engines and its SearXNG retriever source
- LangChain: Local Deep Researcher and Open Deep Research (archived)
- Vane repository and releases
- Open WebUI: agentic search, SearXNG provider and releases
- Khoj: repository, chat commands, online search and Ollama set-up
- DeerFlow repository and its configuration guide
- SearXNG repository and search settings
- Ollama: context length, web search, and library pages for qwen3.6, qwen3.5 and gpt-oss
- Qwen’s Qwen3.5-9B model card, for its advice on context length with thinking mode
Need cited answers from your organisation’s own documents rather than the public web? See VDF AI Chat or book a demo.