AI Infrastructure

Local Deep Research (2026): Open-Source Deep Research Tools You Can Self-Host, Compared

The open-source deep research agents you can run on your own hardware in November 2026, checked on GitHub and in each project's documentation: Local Deep Research, GPT Researcher, LangChain's Local Deep Researcher, Vane (formerly Perplexica), Open WebUI's agentic search, Khoj and DeerFlow. Licences, search back ends, Ollama support, what runs offline, model and hardware picks, a set-up with Ollama and SearXNG, and the limits.

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 wantPickWhy
A research app that runs on your machineLocal Deep ResearchOllama by default, SearXNG and academic engines, encrypted storage, egress controls
Long reports and a Python libraryGPT ResearcherPlanner and execution agents, PDF and Word export; needs reconfiguring for local use
Quick cited answers, Perplexity styleVane (formerly Perplexica)One Docker image with SearxNG inside, Ollama support
Research inside a chat UI you already runOpen WebUI agentic searchThe model calls search_web and fetch_url itself
The smallest codebase to learn fromLangChain’s Local Deep ResearcherOne search, summarise and reflect loop for Ollama or LM Studio
Notes plus web researchKhojA /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:

  1. Plan. Break the question into sub-questions.
  2. Search. Send several queries to one or more search engines.
  3. Read. Fetch the pages behind the results and extract the useful text.
  4. Reflect. Decide what is still unknown and search again.
  5. 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

ToolLicenceLatest releaseSearch back endLocal modelsInterface
Local Deep Research (LearningCircuit)MITv2.0.0, 7 Nov 2026SearXNG, arXiv, PubMed, Semantic Scholar, Wikipedia, GitHub; Tavily, Brave and Google by keyOllama (default), LM Studio, llama.cpp, OpenAI-compatibleWeb UI on port 5000, REST API, MCP server
GPT ResearcherApache 2.0v3.8.0, 9 Nov 2026Tavily by default; SearXNG, DuckDuckGo, Brave, Serper, arXiv and moreOllama, or any OpenAI-compatible base URLWeb UI on port 8000, pip package
Local Deep Researcher (LangChain)MITNo tagged releases; last commit 15 Oct 2026DuckDuckGo by default; SearXNG, Tavily, PerplexityOllama, LM StudioLangGraph Studio
Vane (formerly Perplexica)MITv1.12.2, 10 Apr 2026SearxNG, bundled in the Docker imageOllama, plus cloud providersWeb UI on port 3000
Open WebUI agentic searchOpen WebUI Licensev0.13.3, 8 Nov 2026SearXNG, DuckDuckGo, Brave and other providersOllama, OpenAI-compatibleChat UI
KhojAGPL-3.02.0.0-beta.28, 26 Mar 2026SearXNG in its Docker Compose file; Serper, Firecrawl, Exa by keyOllama through its OpenAI-compatible URLWeb, desktop, Obsidian, Emacs
DeerFlow 2MITv2.2.0, 4 Nov 2026DuckDuckGo, Tavily, SearXNG and othersAny OpenAI-compatible endpointWeb 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-agent strategy 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.

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 json is added to search.formats in settings.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:

ModelSimpleQAxbench-DeepSearchOllama download
Qwen3.6-27B95.7% (287 of 300)77.0% (77 of 100)18 to 19 GB
Qwen3.5-9B91.2% (182 of 200)59.0% (59 of 100)6.6 GB
gpt-oss-20b85.4% (295 of 346)Not reported14 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:

  1. Open http://localhost:5000 and create an account. The password derives your database key and is never stored, so keep it somewhere safe.
  2. In Settings, confirm the provider is Ollama and select the model you pulled.
  3. Raise the local context window from 20,480 if your GPU has room, and confirm with ollama ps that the model still runs fully on the GPU.
  4. Check that SearXNG is the search engine, then run a quick summary before a detailed report.
  5. 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.txt and 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.


Need cited answers from your organisation’s own documents rather than the public web? See VDF AI Chat or book a demo.

Frequently asked questions

What is local deep research?

Deep research is an agent pattern: a model plans sub-questions, runs many web searches, reads the pages it finds, checks what is still missing, searches again and writes a report with citations. Local deep research runs that loop with a model on your own hardware, usually through Ollama, LM Studio or llama.cpp, and often with a self-hosted SearXNG instance for search. Local Deep Research is also the name of an MIT-licensed project by LearningCircuit on GitHub, which reached version 2.0.0 on 7 November 2026.

What is the best open-source deep research tool?

For running entirely on your own machine, Local Deep Research is the most complete option checked here: a web interface, encrypted per-user storage, Ollama as the default provider, SearXNG and academic search engines, and settings that restrict where a run may send traffic. GPT Researcher is the larger project and writes longer reports, but it defaults to OpenAI and the Tavily search API until you reconfigure it. Vane, formerly Perplexica, suits quick cited answers rather than long reports.

Can deep research run with Ollama?

Yes. Local Deep Research uses Ollama as its default provider, LangChain's Local Deep Researcher is built around Ollama or LM Studio, Vane lists Ollama among its providers, Khoj reaches Ollama through its OpenAI-compatible address, and GPT Researcher accepts model names with an ollama prefix. Raise the context window first: Ollama's documentation says tasks such as web search and agents should be set to at least 64,000 tokens, while its default on a GPU with under 24 GiB of memory is 4K.

Is there an open-source Perplexity alternative I can self-host?

Vane is the closest match. The MIT-licensed project, known as Perplexica until its rename, is an answer engine with cited sources, a Docker image that bundles the SearxNG metasearch engine, support for Ollama and cloud providers, and Speed, Balanced and Quality modes. Its latest tagged release, v1.12.2, dates from 10 April 2026. Open WebUI with web search switched on and Khoj cover similar ground inside a general chat interface.

Can local deep research run fully offline?

Only when the sources are local too. Web research needs the internet by definition, and a self-hosted SearXNG still forwards each query to public search engines. What can stay offline is research over your own documents: Local Deep Research has a Private only scope that searches local collections and forces local inference, and GPT Researcher and Khoj can also work from local files. The model, the embeddings and the document index then all run on your hardware.

Which local model is best for deep research?

The only public comparison found is the community benchmark set of the Local Deep Research project. With models served by Ollama and a cloud search API, it reports about 95.7 percent on SimpleQA for Qwen3.6-27B, 91.2 percent for Qwen3.5-9B and 85.4 percent for gpt-oss-20b, on samples of 200 to 346 questions. The project itself warns about small samples, grader noise and possible contamination. In practice, pick a tool-capable model that fits your GPU with a large context window.

Filed under
deep researchlocal LLMOllamaSearXNGopen-source AIAI agents
On-Prem AI

Plan your on-prem AI deployment

Book an architecture call and we will scope a private, on-prem AI deployment for your environment — integrations, hardware, and governance included.

Keep reading