Local Deep Research: agentic research on your own hardware

The problem: research runs that leave your machine

Most agentic research tools are thin clients over someone else's inference and someone else's index. You type a question, it fans out to a hosted search API, the retrieved pages and your query go through a vendor's model, and the synthesis comes back. That is fine for public questions and awkward for anything under an NDA, a patient record, or an unpublished draft.

Local Deep Research targets that gap. The README frames it as an "AI research assistant you control" that can "run locally for privacy, use any LLM and build your own searchable knowledge base." The intended user is someone with a GPU who wants iterative, cited research output without shipping the query to a third party, or someone who needs to search sources that are not on the public web, such as private documents or PubMed and arXiv.

The project is Python, MIT licensed, and has no homepage; the repository is the distribution point. It is not a library you import into an existing pipeline so much as an application you run, with a web UI on port 5000 and an examples directory containing API usage samples.

How the research loop is assembled

The architecture is a LangChain stack. The pyproject.toml declares `langchain~=1.2`, `langchain-community~=0.4`, `langchain-core~=1.2`, plus provider adapters: `langchain-ollama`, `langchain-openai`, and `langchain-anthropic`. That is the whole reason the same research loop can drive a local Ollama model, an OpenAI-compatible endpoint such as LM Studio, or a hosted API. The LLM is a swappable component, not a hardcoded backend.

Retrieval is similarly pluggable. The dependency list includes `duckduckgo-search`, and the topics and README mention arXiv, PubMed, Brave, SearXNG, and private documents. Page extraction is handled by a stack of parsers rather than one: `trafilatura`, `readabilipy`, `justext`, `extruct`, and `beautifulsoup4` are all listed, with `playwright` for pages that need a real browser engine. That combination suggests the pipeline fetches a URL, tries structured extraction first, and falls back to readability-style scraping when the markup is hostile.

Storage is SQLite with SQLCipher. The README links a dedicated `docs/SQLCIPHER_INSTALL.md` and states that the database is encrypted; the pip path ships pre-built wheels so SQLCipher does not need compilation. The Dockerfile installs `libsqlcipher-dev`, `sqlcipher`, and `libsqlcipher1` via apt, which confirms the encryption is at the database layer rather than a wrapper around exported files.

Installing Local Deep Research with pip or Docker

The README gives three install routes. The pip route is the shortest if you already have an LLM endpoint and a search backend running. Install the package and start the web app:

pip install local-deep-research
python -m local_deep_research.web.app

The README states this starts the web UI on http://localhost:5000. It also warns that you still need Ollama (or any OpenAI-compatible endpoint) and SearXNG running separately, so this command alone does not give you a working research loop. The pip guide is `docs/install-pip.md`.

The Docker Compose route is the one the README recommends for anything other than native Linux, because the single-container `docker run` example uses `--network host`, which the README says silently fails on Docker Desktop and leaves `localhost` pointing at the LDR container itself. The Compose path is two commands on CPU:

curl -O https://raw.githubusercontent.com/LearningCircuit/local-deep-research/main/docker-compose.yml && docker compose up -d

For NVIDIA acceleration on Linux, the README adds an override file:

curl -O https://raw.githubusercontent.com/LearningCircuit/local-deep-research/main/docker-compose.yml && \
curl -O https://raw.githubusercontent.com/LearningCircuit/local-deep-research/main/docker-compose.gpu.override.yml && \
 docker compose -f docker-compose.yml -f docker-compose.gpu.override.yml up -d

The README says to open http://localhost:5000 after about 30 seconds. The Compose file publishes `5000:5000` and adds `host.docker.internal:host-gateway` so the container can reach services on the host, which is how it talks to LM Studio or an Ollama instance running outside Docker.

One configuration detail matters more than it looks. The README notes that since v1.10.3, private or localhost search engine URLs are blocked by default, and the single-container example pins SearXNG by setting `LDR_SEARCH_ENGINE_WEB_SEARXNG_DEFAULT_PARAMS_INSTANCE_URL=http://localhost:8080`. Setting that variable also marks the engine operator-approved and makes the URL read-only in the web UI. If you prefer not to lock it, `docs/SearXNG-Setup.md` describes an origin allowlist instead.

Where the deployment story breaks down

The most concrete limitation is already in the README, which is unusual and worth crediting: the `--network host` example is Linux-only. On macOS, Windows, and WSL2 with Docker Desktop, the README says it fails to publish port 5000 and, worse, leaves `localhost` resolving to the LDR container, so the container cannot reach Ollama or SearXNG either. A user who copies the first code block and does not read the callout below it will get a container that appears to start and then cannot complete a single search. The README points to a Windows/WSL2 FAQ entry for a working recipe.

The second constraint is CPU support. The README states LDR needs an AVX-capable CPU, Intel Sandy Bridge or AMD Bulldozer (2011) or newer, because several scientific Python dependencies require it. That rules out older home servers and some budget VPS instances, and the failure mode is an import error rather than a graceful message.

The third is encryption. SQLCipher is on by default, but the README offers an escape hatch: `export LDR_BOOTSTRAP_ALLOW_UNENCRYPTED=true` falls back to standard SQLite if encryption causes trouble. That setting is a real trade-off, not a convenience flag, and the README does not document a rollback path from an unencrypted database back to an encrypted one.

Finally, environment variables are not defaults. The Compose file comments state that env vars force settings and prevent any change through the UI, so a variable set once in a compose file becomes a permanent override that users cannot adjust in the web interface.

Compared with Open Deep Research and hosted deep research

The related searches surface two natural comparisons: Open Deep Research and LangChain's local deep researcher. The difference is where the loop lives. Open Deep Research is a framework you configure and run yourself, typically with a cloud model and a hosted search API; you get the loop and you own the wiring. Local Deep Research is an application with a web UI, a settings layer, and a database, so the loop is already assembled and the configuration happens in a browser rather than in a script.

That is a real difference in approach, not just packaging. If your goal is to embed iterative research into an existing Python service, a framework is the better fit, because LDR's surface is a running server on port 5000 with an API you call from outside. If your goal is to sit down and run cited research without writing the orchestration, LDR is closer to what you want. The examples directory contains `examples/api_usage/`, so the API path exists, but the README's framing is the web UI.

Against hosted deep research products, the trade-off is capability against control. A hosted product will have a larger model and a managed index. LDR will run on a 3090 with a 27B model and whatever search engines you connect. The README's benchmark claim, roughly 95% on SimpleQA with Qwen3.6-27B on a single RTX 3090, is the project's own reported number with a linked dataset, and it is worth reading the dataset before treating it as representative of your queries.

Maintenance, licence, and upgrade cost

The last push to the default branch was on 2026-09-10, and the most recent release is v1.10.7 from 2026-08-28, with v1.10.6 the same day and v1.10.5 on 2026-08-16. That is an actively moving project with frequent patch releases, and the release cadence matters for operators: a version-pinned deployment will fall behind quickly.

The codebase carries visible security engineering. The Dockerfile applies a backported CPython fix for CVE-2026-15310 because no patched 3.14 image existed at build time, and it runs `apt-get upgrade -y` on every build deliberately, trading bit-for-bit reproducibility for fresh Debian patches. The comments state that a build-once-promote pipeline mitigates the reproducibility loss by building once per release and retagging the tested digest. Repository entries include `.gitleaks.toml`, `.grype.yaml`, `.semgrep/`, `.trivyignore`, and `.zap/`, and the README shows OpenSSF Scorecard, CodeQL, and Semgrep badges.

The licence is MIT, declared both in the repository LICENSE file and as a classifier in pyproject.toml. MIT is permissive: you can use, modify, and redistribute it, including commercially, provided the copyright notice and licence text are retained. That is a summary of what the licence identifier means, not legal advice; if you are redistributing LDR inside a product, read the LICENSE file and check the licences of the LangChain and parsing dependencies separately, since those are not covered by LDR's MIT grant.

Editorial conclusion

Adopt Local Deep Research if you already run Ollama or an OpenAI-compatible endpoint and you want your research queries and retrieved documents to stay on hardware you control; the Docker Compose path plus SearXNG is the shortest route to a working instance. Do not adopt it if you are on Docker Desktop for macOS or Windows and expect the documented `--network host` command to work, or if you are unwilling to operate a second service (SearXNG) alongside it. Before committing, verify three things: that your CPU supports AVX, that your chosen LLM endpoint answers on the host the container can reach, and whether you want SQLCipher encryption or will set `LDR_BOOTSTRAP_ALLOW_UNENCRYPTED=true`.

Frequently asked questions

Official sources

1. Issues
2. LearningCircuit/local-deep-research on GitHub
3. License: MIT
4. README
5. Releases