Local Deep Research

AI-powered research assistant for deep, iterative research

Performs deep, iterative research using multiple LLMs and search engines with proper citations

▶️ Watch Review by The Art Of The Terminal

🚀 What is Local Deep Research?

AI research assistant you control. Run locally for privacy, use any LLM and build your own searchable knowledge base. You own your data and see exactly how it works.

⚡ Quick Start

Docker Run (Linux):

# Step 1: Pull and run Ollama
docker run -d -p 11434:11434 --name ollama ollama/ollama
docker exec ollama ollama pull gpt-oss:20b

# Step 2: Pull and run SearXNG for optimal search results
docker run -d -p 8080:8080 --name searxng searxng/searxng

# Step 3: Pull and run Local Deep Research
docker run -d -p 5000:5000 --network host \
  --name local-deep-research \
  --volume 'deep-research:/data' \
  -e LDR_DATA_DIR=/data \
  localdeepresearch/local-deep-research

Exemplary Docker Compose:

Mac and no Nvidia-GPU: Docker Compose File

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

With NVIDIA GPU (Linux):

# download and up -d
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

Open http://localhost:5000 after ~30 seconds.

pip install (for programmatic/API usage):

pip install local-deep-research

⚠️ Docker is preferred for most users. pip installation requires manual setup of SQLCipher for database encryption—see SQLCipher Guide. Best suited for programmatic integration into existing Python projects.

More install options →

🏗️ How It Works

Research

You ask a complex question. LDR:

Does the research for you automatically
Searches across web, academic papers, and your own documents
Synthesizes everything into a report with proper citations

Choose from 20+ research strategies for quick facts, deep analysis, or academic research.

Build Your Knowledge Base

flowchart LR
    R[Research] --> D[Download Sources]
    D --> L[(Library)]
    L --> I[Index & Embed]
    I --> S[Search Your Docs]
    S -.-> R

Every research session finds valuable sources. Download them directly into your encrypted library—academic papers from ArXiv, PubMed articles, web pages. LDR extracts text, indexes everything, and makes it searchable. Next time you research, ask questions across your own documents and the live web together. Your knowledge compounds over time.

🛡️ Security

flowchart LR
    U1[User A] --> D1[(Encrypted DB)]
    U2[User B] --> D2[(Encrypted DB)]

Your data stays yours. Each user gets their own isolated SQLCipher database encrypted with AES-256 (Signal-level security). No password recovery means true zero-knowledge—even server admins can't read your data. Run fully local with Ollama + SearXNG and nothing ever leaves your machine.

Supply Chain Security: Docker images are signed with Cosign, include SLSA provenance attestations, and attach SBOMs. Verify with:

cosign verify localdeepresearch/local-deep-research:latest

Detailed Architecture → | Security Policy →

📊 Performance

~95% accuracy on SimpleQA benchmark (preliminary results)

Tested with GPT-4.1-mini + SearXNG + focused-iteration strategy
Comparable to state-of-the-art AI research systems
Local models can achieve similar performance with proper configuration
Join our community benchmarking effort →

✨ Key Features

🔍 Research Modes

Quick Summary - Get answers in 30 seconds to 3 minutes with citations
Detailed Research - Comprehensive analysis with structured findings
Report Generation - Professional reports with sections and table of contents
Document Analysis - Search your private documents with AI

🛠️ Advanced Capabilities

LangChain Integration - Use any vector store as a search engine
REST API - Authenticated HTTP access with per-user databases
Benchmarking - Test and optimize your configuration
Analytics Dashboard - Track costs, performance, and usage metrics
Real-time Updates - WebSocket support for live research progress
Export Options - Download results as PDF or Markdown
Research History - Save, search, and revisit past research
Adaptive Rate Limiting - Intelligent retry system that learns optimal wait times
Keyboard Shortcuts - Navigate efficiently (ESC, Ctrl+Shift+1-5)
Per-User Encrypted Databases - Secure, isolated data storage for each user

📰 News & Research Subscriptions

Automated Research Digests - Subscribe to topics and receive AI-powered research summaries
Customizable Frequency - Daily, weekly, or custom schedules for research updates
Smart Filtering - AI filters and summarizes only the most relevant developments
Multi-format Delivery - Get updates as markdown reports or structured summaries
Topic & Query Support - Track specific searches or broad research areas

🌐 Search Sources

Free Search Engines

Academic: arXiv, PubMed, Semantic Scholar
General: Wikipedia, SearXNG
Technical: GitHub, Elasticsearch
Historical: Wayback Machine
News: The Guardian, Wikinews

Premium Search Engines

Tavily - AI-powered search
Google - Via SerpAPI or Programmable Search Engine
Brave Search - Privacy-focused web search

Custom Sources

Local Documents - Search your files with AI
LangChain Retrievers - Any vector store or database
Meta Search - Combine multiple engines intelligently

Full Search Engines Guide →

📦 Installation Options

Option 1: Docker

# Step 1: Pull and run SearXNG for optimal search results
docker run -d -p 8080:8080 --name searxng searxng/searxng

# Step 2: Pull and run Local Deep Research
docker run -d -p 5000:5000 --network host \
  --name local-deep-research \
  --volume 'deep-research:/data' \
  -e LDR_DATA_DIR=/data \
  localdeepresearch/local-deep-research

Option 2: Docker Compose (Recommended)

LDR uses Docker compose to bundle the web app and all its dependencies so you can get up and running quickly.

Option 2a: Quick Start (One Command)

Default: CPU-only base (works on all platforms)

The base configuration works on macOS (M1/M2/M3/M4 and Intel), Windows, and Linux without requiring any GPU hardware.

Quick Start Command:

Note: curl -O will overwrite existing docker-compose.yml files in the current directory.

Linux/macOS:

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

Windows (PowerShell required):

curl.exe -O https://raw.githubusercontent.com/LearningCircuit/local-deep-research/main/docker-compose.yml
if ($?) { docker compose up -d }

Use with a different model:

curl -O https://raw.githubusercontent.com/LearningCircuit/local-deep-research/main/docker-compose.yml && MODEL=gpt-oss:20b docker compose up -d

Option 2a-GPU: Add NVIDIA GPU Acceleration (Linux only)

For users with NVIDIA GPUs who want hardware acceleration.

Prerequisites:

Install the NVIDIA Container Toolkit first (Ubuntu/Debian):

# Install NVIDIA Container Toolkit (for GPU support)
curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg \
  && curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | \
    sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
    sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list

sudo apt-get update
sudo apt-get install nvidia-container-toolkit -y
sudo systemctl restart docker

# Verify installation
nvidia-smi

Verify: The nvidia-smi command should display your GPU information. If it fails, check your NVIDIA driver installation.

Note: For RHEL/CentOS/Fedora, Arch, or other Linux distributions, see the NVIDIA Container Toolkit installation guide.

Quick Start Commands:

Note: curl -O will overwrite existing files in the current directory.

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

Optional: Create an alias for convenience

alias docker-compose-gpu='docker compose -f docker-compose.yml -f docker-compose.gpu.override.yml'
# Then simply use: docker-compose-gpu up -d

Open http://localhost:5000 after ~30 seconds. This starts LDR with SearXNG and all dependencies.

Option 2b: DIY docker-compose

See docker-compose.yml for a docker-compose file with reasonable defaults to get up and running with ollama, searxng, and local deep research all running locally.

Things you may want/need to configure:

Ollama GPU driver
Ollama context length (depends on available VRAM)
Ollama keep alive (duration model will stay loaded into VRAM and idle before getting unloaded automatically)
Deep Research model (depends on available VRAM and preference)

Prerequisites

Docker
Docker Compose
cookiecutter: Run pip install --user cookiecutter

Clone the repository:

git clone https://github.com/LearningCircuit/local-deep-research.git
cd local-deep-research

Configuring with Docker Compose

Cookiecutter will interactively guide you through the process of creating a docker-compose configuration that meets your specific needs. This is the recommended approach if you are not very familiar with Docker.

In the LDR repository, run the following command to generate the compose file:

cookiecutter cookiecutter-docker/
docker compose -f docker-compose.default.yml up

Docker Compose Guide →

Option 3: Python Package (pip)

Note: This option is recommended primarily for programmatic/API usage or advanced users who want to integrate LDR into existing Python projects. For most users, Docker is preferred as it handles all dependencies automatically, including SQLCipher encryption which requires additional system libraries when installed via pip outside of Docker.

# Step 1: Install the package
pip install local-deep-research

# Step 2: Setup SearXNG for best results
docker pull searxng/searxng
docker run -d -p 8080:8080 --name searxng searxng/searxng

# Step 3: Install Ollama from https://ollama.ai

# Step 4: Download a model
ollama pull gemma3:12b

# Step 5: Start the web interface
python -m local_deep_research.web.app

⚠️ SQLCipher Note: The pip installation uses standard SQLite by default. For full SQLCipher encryption support (AES-256 encrypted databases), you'll need to install system-level SQLCipher libraries. See SQLCipher Installation Guide for platform-specific instructions. Docker images include SQLCipher pre-configured.

Note: For development from source, see the Development Guide.

Optional Dependencies

VLLM support (for running transformer models directly):

pip install "local-deep-research[vllm]"

This installs torch, transformers, and vllm for advanced local model hosting. Most users running Ollama or LlamaCpp don't need this.

Full Installation Guide →

Option 4: Unraid

For Unraid users:

Local Deep Research is fully compatible with Unraid servers!

Quick Install (Template Method)

Navigate to Docker tab → Docker Repositories

Add template repository:

https://github.com/LearningCircuit/local-deep-research

Click Add Container → Select LocalDeepResearch from template
Configure paths (default: /mnt/user/appdata/local-deep-research/)
Click Apply

Docker Compose Manager Plugin

If you prefer using Docker Compose on Unraid:

Install "Docker Compose Manager" from Community Applications
Create a new stack with the compose file from this repo
Update volume paths to Unraid format (/mnt/user/appdata/...)

Features on Unraid:

✅ Pre-configured template with sensible defaults
✅ Automatic SearXNG and Ollama integration
✅ NVIDIA GPU passthrough support (optional)
✅ Integration with Unraid shares for document search
✅ Backup integration with CA Appdata Backup plugin

Complete Unraid Setup Guide →

💻 Usage Examples

Python API

from local_deep_research.api import LDRClient, quick_query

# Option 1: Simplest - one line research
summary = quick_query("username", "password", "What is quantum computing?")
print(summary)

# Option 2: Client for multiple operations
client = LDRClient()
client.login("username", "password")
result = client.quick_research("What are the latest advances in quantum computing?")
print(result["summary"])

HTTP API

The code example below shows the basic API structure - for working examples, see the link below

import requests
from bs4 import BeautifulSoup

# Create session and authenticate
session = requests.Session()
login_page = session.get("http://localhost:5000/auth/login")
soup = BeautifulSoup(login_page.text, "html.parser")
login_csrf = soup.find("input", {"name": "csrf_token"}).get("value")

# Login and get API CSRF token
session.post("http://localhost:5000/auth/login",
            data={"username": "user", "password": "pass", "csrf_token": login_csrf})
csrf = session.get("http://localhost:5000/auth/csrf-token").json()["csrf_token"]

# Make API request
response = session.post("http://localhost:5000/api/start_research",
                       json={"query": "Your research question"},
                       headers={"X-CSRF-Token": csrf})

🚀 Ready-to-use HTTP API Examples → examples/api_usage/http/

✅ Automatic user creation - works out of the box
✅ Complete authentication with CSRF handling
✅ Result retry logic - waits until research completes
✅ Progress monitoring and error handling

Command Line Tools

# Run benchmarks from CLI
python -m local_deep_research.benchmarks --dataset simpleqa --examples 50

# Manage rate limiting
python -m local_deep_research.web_search_engines.rate_limiting status
python -m local_deep_research.web_search_engines.rate_limiting reset

🔗 Enterprise Integration

Connect LDR to your existing knowledge base:

from local_deep_research.api import quick_summary

# Use your existing LangChain retriever
result = quick_summary(
    query="What are our deployment procedures?",
    retrievers={"company_kb": your_retriever},
    search_tool="company_kb"
)

Works with: FAISS, Chroma, Pinecone, Weaviate, Elasticsearch, and any LangChain-compatible retriever.

Integration Guide →

📊 Performance & Analytics

Benchmark Results

Early experiments on small SimpleQA dataset samples:

Configuration	Accuracy	Notes
gpt-4.1-mini + SearXNG + focused_iteration	90-95%	Limited sample size
gpt-4.1-mini + Tavily + focused_iteration	90-95%	Limited sample size
gemini-2.0-flash-001 + SearXNG	82%	Single test run

Note: These are preliminary results from initial testing. Performance varies significantly based on query types, model versions, and configurations. Run your own benchmarks →

Built-in Analytics Dashboard

Track costs, performance, and usage with detailed metrics. Learn more →

🤖 Supported LLMs

Local Models (via Ollama)

Llama 3, Mistral, Gemma, DeepSeek
LLM processing stays local (search queries still go to web)
No API costs

Cloud Models

OpenAI (GPT-4, GPT-3.5)
Anthropic (Claude 3)
Google (Gemini)
100+ models via OpenRouter

Model Setup →

📚 Documentation

Getting Started

Core Features

Advanced Features

Development

Examples & Tutorials

📰 Featured In

"Local Deep Research deserves special mention for those who prioritize privacy... tuned to use open-source LLMs that can run on consumer GPUs or even CPUs. Journalists, researchers, or companies with sensitive topics can investigate information without queries ever hitting an external server."

— Medium: Open-Source Deep Research AI Assistants

News & Articles

Korben.info - French tech blog ("Sherlock Holmes numérique")
Roboto.fr - "L'alternative open-source gratuite à Deep Research d'OpenAI"
KDJingPai AI Tools - AI productivity tools coverage
AI Sharing Circle - AI resources coverage

Community Discussions

Hacker News - 190+ points, community discussion
LangChain Twitter/X - Official LangChain promotion
LangChain LinkedIn - 400+ likes

International Coverage

🇨🇳 Chinese

Juejin (掘金) - Developer community
Cnblogs (博客园) - Developer blogs
GitHubDaily (Twitter/X) - Influential tech account
Zhihu (知乎) - Tech community
A姐分享 - AI resources
CSDN - Installation guide
NetEase (网易) - Tech news portal

🇯🇵 Japanese

note.com: 調査革命：Local Deep Research徹底活用法 - Comprehensive tutorial
Qiita: Local Deep Researchを試す - Docker setup guide
LangChainJP (Twitter/X) - Japanese LangChain community

🇰🇷 Korean

PyTorch Korea Forum - Korean ML community
GeekNews (Hada.io) - Korean tech news

Reviews & Analysis

BSAIL Lab: How useful is Deep Research in Academia? - Academic review by contributor @djpetti
The Art Of The Terminal: Use Local LLMs Already! - Comprehensive review of local AI tools, featuring LDR's research capabilities (embeddings now work!)

SearXNG LDR-Academic - Academic-focused SearXNG fork with 12 research engines (arXiv, Google Scholar, PubMed, etc.) designed for LDR
DeepWiki Documentation - Third-party documentation and guides

Note: Third-party projects and articles are independently maintained. We link to them as useful resources but cannot guarantee their code quality or security.

🤝 Community & Support

Discord - Get help and share research techniques
Reddit - Updates and showcases
GitHub Issues - Bug reports

🚀 Contributing

We welcome contributions! See our Contributing Guide to get started.

📄 License

MIT License - see LICENSE file.

Dependencies: All third-party packages use permissive licenses (MIT, Apache-2.0, BSD, etc.) - see allowlist

Built with: LangChain, Ollama, SearXNG, FAISS

Support Free Knowledge: Consider donating to Wikipedia, arXiv, or PubMed.

LearningCircuit/local-deep-research

Use Cases & Benefits

About local-deep-research