Private AI web search with a local model: what to run

SearXNG, OpenSERP and Vane compared: what stays on your machine, what still leaves it, and the catch in each self-hosted search stack.

A model running on your own machine does not make an AI answer private. The search half of the stack still talks to somebody: the question goes to whichever engine finds the pages, and the pages are fetched from wherever the loader runs. Three self-hosted search stacks change that, and each one gives something up.

Two jobs behind one answer

Open WebUI’s web-search documentation splits the work in two. The search engine finds candidate pages; the web loader opens them and extracts the text. The results are then embedded into a vector store, in a collection whose default suffix is _web_search and whose documented purpose is “Storing transient results from search engine queries.” (environment reference)

Three settings decide whether any of this happens at all: ENABLE_WEB_SEARCH, off by default, WEB_SEARCH_RESULT_COUNT, default 3, and WEB_SEARCH_CONCURRENT_REQUESTS, default 0 for unlimited. The loader has its own separate knob, WEB_LOADER_CONCURRENT_REQUESTS, default 10, because the two were the same variable until the project split them.

The stacks you can run yourself

StackWhat it isLicenceWhat it needsThe catch
SearXNGMetasearch engine that queries upstream search engines from your serverAGPL-3.0Its own instance, with JSON output enabledJSON format is off by default, and Open WebUI gets a 403 without it
OpenSERPScraper that merges results from six enginesMITA reachable base URL, no API keyScraping gets you rate limited and blocked
Vane (formerly Perplexica)Answer engine with its own UI, bundles SearXNGMITDocker, plus a local model endpointThe repository was last pushed to in September 2026, so it moves slowly
Hosted search API (Brave, Tavily, Exa and the rest)The vendor does the searchingVendor termsAn account and an API keyThe query leaves for the vendor, so this is the baseline the others beat

SearXNG is the core of the stack. Its README says “Users are neither tracked nor profiled”, and its licence section reads “This project is licensed under the GNU Affero General Public License (AGPL-3.0).” The default settings.yml in the repository lists 357 engine entries, from 360search through arXiv to Yandex, which is where the breadth comes from. The defaults are conservative: server.port 8888, server.bind_address set to 127.0.0.1, server.limiter false and server.public_instance false.

OpenSERP is the small alternative. It is MIT licensed, its last push to the repository was 2026-11-19, and it needs nothing but a base URL: Open WebUI “calls its /mega/search endpoint, which queries Google, Bing, Yandex, Baidu, DuckDuckGo and Ecosia together and returns the combined results”. The price is in the documentation’s own warning: “OpenSERP works by scraping search engine result pages rather than using official APIs. Those engines may throttle, present a CAPTCHA, or block the requesting address under load, which surfaces in Open WebUI as a failed search.”

Vane is the one with a front end of its own. Its README describes it as a privacy-focused answering engine that “runs entirely on your own hardware”, with search powered by SearXNG, and the standard container bundles that engine so no second service is needed. It points at Ollama for the model, keeps a local search history (“Every search is saved locally so you can revisit your discoveries anytime”), and can also be pointed at OpenAI, Anthropic, Gemini or Groq, which is the switch that undoes the privacy case. The install steps are already written up on this site in the Vane walkthrough.

What still leaves your machine

SearXNG’s own documentation is the clearest statement of the trade. It explains that removing private data means “not sending cookies to external search engines and generating a random browser profile for every request”, and then says plainly: “The IP address used will be the IP of the instance, but SearXNG can also be configured to use proxy or Tor.”

So the query text goes to Google, Bing, DuckDuckGo and the rest, and they see the address of the machine running SearXNG. The loader then fetches each result page itself, from your network, so the site you read sees where you are. Nothing about the model changes either fact.

Public instances add two problems. SearXNG’s documentation warns that “public instances without proper protection are more vulnerable to abuse of the search service, which may cause the external service to enforce CAPTCHAs or to ban the IP address of the instance. Thus, search requests would return less results”, and concludes: “Always use an instance which is operated by people you trust.” The other problem is the operator, who may log what arrives.

Inside Open WebUI the fetched page text also goes into the vector collection, unless you turn that off. BYPASS_WEB_SEARCH_EMBEDDING_AND_RETRIEVAL and BYPASS_WEB_SEARCH_WEB_LOADER are both off by default; the second one means “only snippets from the search engine are used, and the full page content is not fetched”. The retrieval side of that is the same machinery as the RAG stack comparison.

Running SearXNG under Open WebUI

The order matters, because the second step is the one people skip. SearXNG’s default settings.yml ships formats: with - html and nothing else, so a JSON query is refused. Its search API documentation is explicit: “Requesting an unset format will return a 403 Forbidden error.” Open WebUI’s provider tutorial names the symptom: without JSON support, “SearXNG will block queries from Open WebUI and you’ll encounter 403 Client Error: Forbidden errors in your Open WebUI logs”. Add - json under search: in settings.yml and restart.

After that the wiring is short. Set WEB_SEARCH_ENGINE to searxng, point SEARXNG_QUERY_URL at the /search endpoint, and leave SEARXNG_LANGUAGE at its default of all. The Open WebUI tutorial for the provider is a community contribution that the project says “is not supported by the Open WebUI team”, so treat the settings names as the thing to check rather than the prose around them.

Two defaults deserve attention before you expose anything. A fresh SearXNG install has server.limiter set to false, which is the bot detection and rate limiting that public instances need, and server.public_instance left false, which is the flag that turns on the features designed only for public instances. A fresh Open WebUI has web search off entirely and needs ENABLE_WEB_SEARCH turned on in the admin panel, plus a per-chat toggle: the documentation describes a Use Web Search? dialog with Continue and Cancel that users see when they turn on web search in the chat input. The chat front end itself is covered in the Open WebUI guide.

Where these stacks break

Result quality is the thing nobody can promise you. Open WebUI’s own tip says SearXNG “is still useful when you want a self-hosted, privacy-preserving metasearch engine, but result quality depends heavily on its upstream engines, rate limits, and instance configuration”.

A shared instance degrades on its own. SearXNG bans an engine that fails, with ban_time_on_fail 5 seconds and max_ban_time_on_fail 120, and the suspended-times table is longer than the good behaviour: SearxEngineAccessDenied 180 seconds, SearxEngineTooManyRequests 180 seconds, and cf_SearxEngineCaptcha 1296000 seconds, which is fifteen days, for a Cloudflare CAPTCHA. That last entry is why the documentation includes a page about answering a CAPTCHA “from server’s IP” through a SOCKS tunnel, and why an instance that suddenly starts returning thin results may be sending its queries from an address the engines have blocked.

Maintenance is the other risk. Vane is the slowest of the three to move: its repository was last pushed to on 2026-09-01. Open WebUI is moving faster: its latest release is v0.13.4, published 2026-11-17. SearXNG itself was last pushed to on 2026-11-20, and its documentation carries a build stamp of 2026.11.20.

Bottom line

Run SearXNG yourself, on a machine whose address you are willing to have upstream engines see, and accept that a self-hosted metasearch engine is a private relationship with the search engines rather than a private relationship with the internet. Use OpenSERP if you want one container and no configuration, at the cost of scraping bans. Use Vane if you want a finished answer engine with citations and a browser UI, and keep its model provider pointed at your own hardware.

Whichever you pick, the question still leaves your network. Keeping the model on your own hardware is the half of the exchange you can actually control. Our other self-hosted guides are under Local AI coverage.

Other GPUs and tasks: Local AI by VRAM · RSS