DEV Community: Loki Bein Blodsson

Reclaiming the Digital Clearing: A Guide to Self-Hosting SearXNG

Loki Bein Blodsson — Sun, 07 Jun 2026 04:18:54 +0000

Introduction: Reclaiming the Digital Clearing

In the vast, rugged landscapes of Central Alberta, we understand that a homestead is only as secure as the perimeter we defend. In the digital realm, our search queries are the raw ore that data-mining giants exploit to track our movements and trap us in algorithmic filter bubbles. To reclaim your digital sovereignty, you must step into the digital forge and build your own tools.

SearXNG is a "metasearch engine"—it does not crawl the web itself but acts as a privacy-preserving proxy, aggregating results from dozens of services without passing your personal footprint to them. By hosting your own instance on the traditional territory of Treaty 6, you break free from biased results and ensure your intent remains your own. This is the first step in establishing a digital clearing where you decide what is surfaced and who is allowed to watch.

Your Accomplishments

Establish a stable Docker-based bedrock on Ubuntu 22.04+.
Deploy a high-performance SearXNG and Redis stack.
Configure advanced settings to prevent bot blocks.
Integrate your private search engine into your daily routine.

Prerequisites: Establishing the Bedrock

Properly sized infrastructure is the hewn stone of your foundation. A stable system requires a base that can withstand the weight of its operations; without precision here, the "chaos" of system failure is inevitable.

Hardware Requirements
CPU: 1 Core (Minimum).
RAM: 1 GB (Minimum).

The Scaling Path:

If you intend to weave this search engine into your Local AI (Week 1), you will need the strength of 16GB RAM and an NVIDIA GPU (6GB+ VRAM) to turn the AI's crawl into a sprint.Software Requirements
OS: Ubuntu 22.04 or newer.

Orchestration:

Docker and Docker-Compose installed and functional.Recommended Hosting: Claim Your Credits For those operating beyond the local homestead, a Virtual Private Server (VPS) provides the uptime your kingdom requires.

Vultr:

Claim your $100 free credit to lower the barrier to entry. Their "Give $100, Get $35" structure is built for rapid Docker deployments.

DigitalOcean:

A respected name offering generous credits for the first 60 days to help you spin up your stack.Once the bedrock is firm, the "incantation" of installation can begin.

Orchestration: Docker and Docker-Compose.

Using Docker Compose is a strategic maneuver; it allows for rapid, reproducible deployments that can be re-forged in seconds.Prepare the Environment Execute these commands to prepare the space for your engine:
mkdir searxng-stack && cd searxng-stack
nano docker-compose.yml

The Configuration (docker-compose.yml) Paste this logic into your editor:

version: '3'
services:
redis:
container_name: redis
image: redis:alpine
networks:
- searxng
restart: always

searxng:
container_name: searxng
image: searxng/searxng:latest
networks:
- searxng
ports:
- "8080:8080"
volumes:
- ./searxng-data:/etc/searxng
environment:
- SEARXNG_BASE_URL=http://localhost:8080/
depends_on:
- redis
restart: always

networks:
searxng:
external: false

Execute and Verify Strike the anvil with the following command:
docker compose up -d

First-run verification:

Navigate to http://localhost:8080. The appearance of the SearXNG search bar confirms your gateway is live. However, "up and running" is only the beginning of a truly refined system.

Detailed Configuration: Refining the Logic

Precision within the settings.yml file prevents future system failure. This is where you fine-tune the engine's soul.
Casting the Sigil: Use openssl rand -hex 32 to generate a unique cryptographic key. Paste this into the secret_key field to secure your sessions.

Naming the Kingdom:

Customize the instance_name to reflect your identity.

Enabling Formats:

Ensure both html and json formats are enabled, allowing for human use and future AI-weaving.The Strategy of Persistence By using the volume mapping ./searxng-data, you ensure configurations survive container updates. Without this, every "re-forging" of the container wipes your custom logic. Persistence is the difference between a temporary tool and a permanent homestead.

" width="800" height="447">

Common Use-Cases:

Integrating the Kingdom
A tool only provides value when it is seamlessly integrated into your daily routine. To truly break the shackles of Big Tech profiling, you must set SearXNG as your default search engine.

Step-by-Step Browser Integration:

Access browser settings and locate the "Search Engine" management section.
Add a new search engine using your server's details.
Use the following query URL format:

your-server-ip:8080/search?q=%sThis integration transforms your relationship with the web, turning a passive utility into a private gateway.

" width="800" height="447">

Critical Takeaways for Avoiding Blocks:

If Google or Bing blocks your IP, increase your engine timeouts significantly.

The Strategic Maneuver:

Rely on more permissive alternatives like Startpage or DuckDuckGo if aggressive engines remain hostile.

" width="800" height="447">

Security & Production Hardening:

The Protector’s Oath
Exposing your engine to the internet without hardening is an ethical failure. Leaving port 8080 open is an unlocked gate in a storm , inviting unwanted eyes into your sanctuary.

Reverse Proxy:

Route traffic through Nginx or Traefik to hide internal ports and act as a shield.

HTTPS/SSL Certificates:

Use Let's Encrypt to ensure your queries are encrypted in transit.
Access Restriction: Implement IP whitelisting or HTTP auth so only authorized kin can consume your resources.

" width="800" height="447">

Extending the Stack: The Weaving of Systems

SearXNG is a vital component in the larger FOSS AI ecosystem. It acts as the "eyes" for your local LLM, providing it with live web data.Connecting to Open-WebUI (Week 1):

Navigate to Open-WebUI admin settings.
Select Web Search and choose SearXNG .
Provide the internal Docker URL: http://searxng:8080.

This connection grants your local AI a view of the live web. For further automation, integrate n8n-Server to build search-based workflows that monitor the web on your behalf.

" width="800" height="447">

Conclusion & The Horizon: Next Steps

The system is live. You have forged a search engine that respects your privacy and breaks the bubbles of the old world. You have reclaimed your data.The system is live. The work continues.Supercharge Your Forge: The FOSS AI Power Pack For those who value their time and require the master ledger, the FOSS AI Power Pack ( $9–$ 19) is available.

Inside:

Optimized Compose files, environment variable cheat sheets, and troubleshooting flowcharts to ensure your forge never goes cold.Internal Lore:
Open-WebUI + Ollama: Run LLMs Locally
n8n-Server: The No-Code Automation Engine
Whisper-API: Self-Hosted Speech-to-Text

" width="800" height="447">

Keep up the good work! Thank you for checking out Loki's Studio. ALWAYS check any code before using it to insure it is trust worthy! I am starting with this series, but soon I will have a lot more to share.

"/>

PROST 🍻

Open-WebUI + Ollama Guide: Run LLMs Locally with Docker

Loki Bein Blodsson — Sat, 09 May 2026 00:07:17 +0000

1️⃣ Introduction

Welcome to the ultimate Open-WebUI guide. If you've ever wanted the power and sleek interface of ChatGPT but with the privacy of a local server, you are in the right place.

Ollama is a lightweight inference engine that makes running large language models (LLMs) dead simple, while Open-WebUI (formerly Ollama WebUI) provides a beautiful, feature-rich, and extensible front-end. By combining them, you can build your own private AI assistant.
Why a self-hosted FOSS version matters:
Absolute Privacy: Your chats, code snippets, and intellectual property never leave your machine.
Zero Subscription Costs: Run powerful open-source models for free.
Offline Access: Work seamlessly even without an internet connection.
TL;DR - What you will accomplish today:
Install Docker & Docker Compose.
Deploy a unified Ollama and Open-WebUI stack using a single file.
Prevent data loss with persistent volumes.
Download and run Llama locally.

2️⃣ Prerequisites

Before we spin up our Ollama local LLM stack, ensure your system meets these baseline requirements:
Hardware: * RAM: 8 GB minimum (16 GB highly recommended to run 7B-8B parameter models).
CPU: Modern multi-core processor.
GPU (Optional but recommended): An NVIDIA GPU with at least 6GB VRAM will drastically improve token generation speed.
Software: Docker and Docker-Compose installed on your system. (If you haven't done this yet, check out our Beginner's Guide to Docker).
Network: Ports 8080 (WebUI) and 11434 (Ollama API) available.

3️⃣ Quick-Start Installation

The biggest mistake beginners make is running Open-WebUI and Ollama in separate, disjointed Docker commands, leading to localhost connection errors. We will solve this by deploying them together in a single docker-compose.yml file.

Create a new directory and create your compose file:

mkdir open-webui-stack && cd open-webui-stack
nano docker-compose.yml

Paste the following configuration:

version: '3.8'

services:
ollama:
image: ollama/ollama:latest
container_name: ollama
volumes:
- ollama_data:/root/.ollama
ports:
- "11434:11434"
restart: unless-stopped
# Uncomment the following lines if you have an NVIDIA GPU and nvidia-docker2 installed
# deploy:
# resources:
# reservations:
# devices:
# - driver: nvidia
# count: 1
# capabilities: [gpu]

open-webui:
image: ghcr.io/open-webui/open-webui:main
container_name: open-webui
volumes:
- open-webui_data:/app/backend/data
ports:
- "8080:8080"
environment:
- OLLAMA_BASE_URL=http://ollama:11434
- WEBUI_AUTH=True
depends_on:
- ollama
restart: unless-stopped

volumes:
ollama_data:
open-webui_data:

Save the file and run:
docker compose up -d

First-run verification: Wait about 60 seconds for the containers to initialize, then open your browser and navigate to http://localhost:8080. You should be greeted by the Open-WebUI login screen!

4️⃣ Detailed Configuration

Let's break down why this configuration solves the most common self-hosting headaches:
Persistent Storage (Volumes): Notice the ollama_data and open-webui_data volumes? Without these, every time you update or restart your container, you would lose your downloaded models and chat history. This setup ensures your data is permanently safe.
Internal Network Routing: By setting OLLAMA_BASE_URL=http://ollama:11434, we tell the WebUI to talk directly to the Ollama container via Docker's internal DNS. This completely bypasses annoying localhost or 127.0.0.1 routing conflicts.
Authentication (WEBUI_AUTH=True): This forces users to create an account before accessing the AI, securing your server from unauthorized use.

Pro-Tip: If you want to access this outside your home network, we highly recommend putting Open-WebUI behind Nginx Proxy Manager or Traefik with an SSL certificate.

5️⃣ Common Use-Cases & Mini-Projects

Downloading Your First Model
Once logged into Open-WebUI, click on the Settings gear, navigate to Models, and type llama3 or llama3.1 into the pull model field. Click download.
Alternatively, you can pull a model directly via your terminal:
docker exec -it ollama ollama run llama3.1

API Access for Developers
Because we exposed port 11434, you can use your new local LLM server just like the OpenAI API. Test it with this simple curl request:
curl -X POST http://localhost:11434/api/generate -d '{
"model": "llama3.1",
"prompt": "Why is the sky blue? Explain in one sentence.",
"stream": false
}'

6️⃣ Troubleshooting & FAQ

Q: My GPU isn't being detected by Ollama. Tokens are generating very slowly!

A: If you are on Linux with an NVIDIA card, you must install the NVIDIA Container Toolkit (nvidia-docker2). Once installed, uncomment the deploy block in the docker-compose.yml file and restart the stack (docker compose up -d --force-recreate).

Q: I keep getting "Out of Memory" errors on my 8GB RAM machine.

A: Standard 7B or 8B models might be too heavy for your system. Switch to a smaller, highly efficient model. Try pulling gemma:2b or Microsoft's phi3 inside the Open-WebUI interface.

Q: Open-WebUI says "Ollama connection failed."

A: Double-check that your OLLAMA_BASE_URL is set to http://ollama:11434 (not localhost) and that the ollama container is running without restart loops (docker ps).

7️⃣ Security & Production Hardening

If you plan to expose this setup to the internet, you must harden it:
Disable Open Signups: Once you have created your admin account, go to the WebUI Admin Panel -> Settings -> General, and turn off "Enable New User Signups".
Backup Strategy: Regularly back up your Docker volumes. You can easily tarball your volumes located in /var/lib/docker/volumes/ to keep your chat history safe.
Reverse Proxy: Never expose port 8080 directly to the web. Route it through a proxy manager with Let's Encrypt SSL.

8️⃣ Extending the Stack

Your private AI assistant doesn't have to exist in a vacuum. You can seamlessly integrate this setup with other FOSS homelab tools:
Give it internet access: Connect Open-WebUI to SearXNG (Self-Hosted Search Engine) to allow your LLM to scrape the live web.
Safe Code Execution: Integrate Open-Terminal to give your AI agents a sandboxed browser-based shell to write and test code safely.

9️⃣ Conclusion & Next Steps

You now have a fully functional, highly secure, and persistent Ollama local LLM server with a gorgeous user interface. You've eliminated third-party privacy risks and unlocked the world of open-weight AI models.