Build a working local AI research service first, then make its browser interface available remotely
Local Deep Research is a self-hosted AI research application with a browser-based interface. In this guide, we install its Python package with pip, connect the supporting language model and search services, start the application, and verify it at http://localhost:5000. The pip installation works on Windows, macOS, and Linux, although some environment configuration differs by operating system and shell. After the local deployment works correctly, we explain how to connect it to an HTTP tunnel with Localtonet for controlled remote access.
What you are installing
Local Deep Research is an AI-powered research assistant that can search across web sources, academic services, and local documents before synthesizing the collected material into a report with citations. It is designed to run under the operator's control and can work with local or cloud-hosted language model endpoints. This tutorial focuses on the official Python package installation rather than building the project from source.
The pip route is especially relevant to developers and users who want to integrate Local Deep Research into an existing Python environment. The project's own installation guidance recommends Docker for many general deployments because containers handle more of the dependency setup automatically. Choosing pip gives you a conventional Python installation, but it also means that you remain responsible for the supporting search engine, language model service, environment variables, and platform-specific libraries.
local-deep-research package and can be installed with pip on Windows, macOS, or Linux.
http://localhost:5000.
Prerequisites for Windows, macOS, and Linux
The manual installation documentation specifies Python 3.10 or newer and pip. The documented setup also uses Docker to run SearXNG, so Docker must be installed and running if you follow that exact search setup. Ollama must be installed separately, started, and supplied with a model. Alternatively, experienced operators can configure a supported OpenAI-compatible model endpoint by following the current Local Deep Research documentation.
Hardware compatibility matters for older systems. Current project guidance says x86-64 installations require an AVX-capable processor, with Intel Sandy Bridge or AMD Bulldozer from approximately 2011 or newer given as the compatibility floor. Several scientific Python dependencies can fail with an illegal-instruction error on older CPUs. ARM64 is documented as supported.
| Platform | Core pip installation | Platform consideration |
|---|---|---|
| Windows | Python 3.10 or newer, pip, SearXNG, and a supported model endpoint | PDF export requires Pango and Cairo system libraries. Use a Windows-supported method to define the required SearXNG environment variable before starting the application. |
| macOS | Python 3.10 or newer, pip, SearXNG, and a supported model endpoint | The documented POSIX-style environment command can be used in a compatible shell. macOS includes fonts used for common CJK PDF output. |
| Linux | Python 3.10 or newer, pip, SearXNG, and a supported model endpoint | The documented shell examples apply directly to a compatible POSIX shell. Additional host fonts may be needed for CJK characters or emoji in PDF exports. |
An isolated virtual environment is a common way to prevent Python dependency conflicts. The supplied project evidence does not prescribe one specific environment command, so use the environment-management procedure appropriate for your Python distribution and operating system before running the documented pip command.
Install Local Deep Research with pip
The following five-step sequence follows the project's current pip quick-install workflow. Complete it in order so that the package, search service, model service, and Local Deep Research web interface are available together.
Install the Python package
Open a terminal in the Python environment where you want Local Deep Research installed, then install the published package with pip.
pip install local-deep-researchAllow pip to complete before continuing. If the command invokes a different Python installation from the one you intended to use, correct your Python environment selection rather than installing repeatedly into multiple environments.
Start SearXNG for search results
The official pip guide uses the SearXNG container image and publishes its service on local port 8080. Docker must already be installed and running.
docker pull searxng/searxng
docker run -d -p 8080:8080 --name searxng searxng/searxng
This creates a container named searxng. Do not launch another container with the same name unless you have removed or renamed the existing one.
Install and run Ollama
Install Ollama using its official operating-system procedure and make sure its service is running. Local Deep Research also supports other compatible model endpoints, but the quick-install sequence uses Ollama, so this guide keeps that documented path.
Download the documented example model
Pull the model used in the official pip setup example. Model downloads can be large, so the required time and disk usage depend on the selected model and your connection.
ollama pull gemma3:12bWait for the download to finish before starting a research session. A package installation alone does not provide a language model.
Approve the local SearXNG origin and start the web interface
Local Deep Research blocks private, loopback, and link-local search-engine URLs by default unless the server operator approves them. On macOS or Linux with a compatible shell, use the documented environment assignment and then start the interface.
export LDR_SEARCH_ENGINE_WEB_SEARXNG_DEFAULT_PARAMS_INSTANCE_URL=http://localhost:8080
ldr-web
On Windows, define the same variable and value through the supported environment-variable mechanism for your Windows version and terminal, then run ldr-web in that configured environment. The supplied project instructions do not establish one universal Windows shell syntax, so we do not substitute an unverified command.
If Local Deep Research reports that the SearXNG engine is disabled because its instance URL is private, loopback, or link-local, the required environment variable is missing from the environment that launched ldr-web. Stop the application, define the operator-approved SearXNG URL in the correct process environment, and restart it. Avoid using the broader setting that permits all private search-engine URLs unless you have reviewed and accepted the wider access scope.
Verify the local installation before exposing it
After a few seconds, open http://localhost:5000 in a browser on the same computer. The Local Deep Research interface should load. This local check is essential because a tunnel cannot repair an application that failed to start, a missing model, or an unavailable SearXNG container.
Confirm more than the appearance of the first page. Check that Ollama is running and that the downloaded model is available to the application. Start a small test research request and review the application output for model connection or search-engine errors. If the interface loads but SearXNG returns no results, inspect the Local Deep Research process output for the private-URL warning described above.
Keep the terminal running while using ldr-web, unless you deliberately place the application under a service manager. The evidence supplied for this tutorial does not define a production service configuration for Windows, macOS, or Linux, so service-manager commands and automatic-start instructions are intentionally omitted.
Database encryption and the unencrypted fallback
Local Deep Research uses SQLCipher for AES-256 encrypted databases. Pre-built sqlcipher3 wheels are documented for Windows, macOS, and Linux, which means most users should not need to compile SQLCipher. Verify that the application starts without encryption-related errors before entering API keys or importing private documents.
The project provides LDR_BOOTSTRAP_ALLOW_UNENCRYPTED=true as a fallback that uses standard SQLite. This is not an equivalent security configuration. The project explicitly warns that API keys and data will then be stored unencrypted. Use that fallback only after evaluating the consequences for the machine, its users, its backups, and the information processed by the application.
A service that was reachable only through localhost becomes reachable through its assigned public tunnel address once exposed. Review Local Deep Research authentication and authorization, protect any configured API keys, apply least privilege, and avoid placing sensitive research data on a remotely reachable deployment without appropriate controls. A tunnel provides connectivity, but it does not replace application-level access policy.
Expose the working interface with Localtonet
Once http://localhost:5000 works from the host computer, an HTTP tunnel is the appropriate Localtonet tunnel family for the browser interface. Our client establishes an outbound connection to a Localtonet relay server, so you do not need inbound router port forwarding, a public IP address, firewall changes, or a VPN setup for this workflow.
The local target remains the Local Deep Research service on port 5000. The tunnel provides a public HTTPS address for the web application. Creating a configuration does not start it automatically, and the public address remains available only while the selected Localtonet client is connected and the tunnel is running.
How to configure the Localtonet HTTP tunnel
Install and run our client
Install the Localtonet client on the Windows, macOS, or Linux device that is running Local Deep Research, or on a device that can reach that service locally. Start the client before configuring the tunnel.
Authenticate and select the device
Use the device-specific authentication token associated with the client that will run the tunnel. Treat the token as a secret and never place it in an article, screenshot, script, or shared configuration.
Select an available relay server
Choose a currently available relay server or region from our dashboard. Available server values can vary, so retrieve the selection from the current product rather than copying a hardcoded server code from another deployment.
Create an HTTP configuration for the local service
Select an HTTP tunnel and point its local target to the Local Deep Research host and port. When our client runs on the same machine as the application, the evidenced local service is available through localhost on port 5000. If the client runs elsewhere, use an address that the client device can actually reach and confirm that network path locally first.
Start the tunnel
Use the Start button after reviewing the target. Saving or creating a tunnel does not mean it is running. Starting it connects the local service to the assigned public address.
Test the assigned public URL
Open the public URL from a separate browser or network and confirm that the expected Local Deep Research interface appears. Stop or delete the tunnel when remote access is no longer required.
For the current dashboard workflow and available options, review our Localtonet HTTP tunnel documentation. HTTP process types can provide a generated subdomain, a selected subdomain where supported, or a custom domain. Exact custom-domain DNS requirements should always be checked against the current documentation before changing DNS records.
Troubleshooting the complete setup
| Symptom | Likely area | What to verify |
|---|---|---|
localhost:5000 does not load |
Local Deep Research process | Confirm ldr-web is still running and inspect its terminal output before configuring Localtonet. |
| No language models are available | Ollama or model setup | Confirm Ollama is running and that the documented model download completed successfully. |
| SearXNG returns no results | Private URL approval | Confirm the SearXNG environment variable is present in the same environment that launched Local Deep Research. |
| Local page works but public URL does not | Localtonet tunnel lifecycle | Confirm our client is connected, the correct device is selected, the HTTP target uses port 5000, and the tunnel has been started. |
| Public URL opens the wrong application | Local target selection | Recheck the target host and port, especially when several development services are running on the same computer. |
| PDF export fails on Windows | Platform dependency | Install the Pango and Cairo libraries required by the project's PDF export stack. |
Frequently asked questions
Does Local Deep Research support pip installation on Windows, macOS, and Linux?
Yes. The project documents pip installation across all three operating-system families and provides pre-built SQLCipher wheels for them. Shell syntax and optional system libraries can differ, particularly for Windows environment variables and PDF export.
What local port does the web interface use?
The documented web interface is available at http://localhost:5000. Verify that address locally before creating an HTTP tunnel.
Is SearXNG mandatory?
The pip installation guide recommends SearXNG for the best search results and includes it in the quick-install workflow. If you use a localhost SearXNG service, its exact origin must be approved by the Local Deep Research server operator.
Can I use a model provider other than Ollama?
Local Deep Research documents support for Ollama and OpenAI-compatible language model endpoints. This guide uses Ollama because it is the model service in the official pip quick-install sequence. Follow the project's current provider documentation for any alternative endpoint rather than guessing its URL, credentials, or configuration fields.
Does creating a Localtonet tunnel immediately make the application public?
No. Creating the tunnel configuration does not start it. The selected Localtonet client must be connected, and you must start the tunnel before its assigned public address becomes available.
Do I need router port forwarding or a public IP address?
No. Our client establishes an outbound connection to a Localtonet relay server, so this workflow does not require inbound router port forwarding, firewall changes, VPN setup, or a public IP address.
Will the public URL remain online if I close Local Deep Research or Localtonet?
No. Local Deep Research must remain running and reachable by our client. The selected Localtonet client must also stay connected, and the tunnel must remain started. If any part of that chain stops, the public service will no longer work.
Access your Local Deep Research interface with Localtonet
Finish the pip installation, verify the application at http://localhost:5000, and then create an HTTP tunnel from the device that can reach it. Review access controls before sharing the assigned public URL, and stop the tunnel when remote access is no longer needed.
