How to Self-Host a Free Perplexity Alternative: Vane, Morphic, and Khoj Compared

In March 2026, the most popular open-source alternative to Perplexity quietly changed its name. The maintainer of Perplexica, a project that had spent two years as the default answer to "how do I get a self-hosted Perplexity," pushed a commit titled `feat(app): rename to 'vane'` and moved the Docker image from `itzcrazykns1337/perplexica` to `itzcrazykns1337/vane`. The stated reason, per the project's own release notes and the coverage around it, was that sitting one letter away from a well-funded commercial brand had started creating real confusion and legal risk. Same maintainer, same GitHub repository, same codebase - just a new name, and since the rename it has kept shipping: a redesigned setup wizard, a deep-research mode, file uploads, domain-limited search, and a custom streaming engine that replaced LangChain entirely.

If you've been paying $20/month for Perplexity Pro, or you're building an internal tool that needs to answer questions with live citations instead of a static knowledge cutoff, this is worth fifteen minutes, because the mechanism behind these tools is simpler than it looks and entirely free to run on your own hardware.

What an "AI search engine" is actually doing

A tool like Perplexity, or its self-hosted equivalents, isn't a single model with better training data. It's a pipeline with three distinct stages, and understanding them is what separates "install it and hope" from actually being able to debug one when it gives you a bad answer.

First, your query goes to a metasearch layer, not the LLM. Vane uses SearXNG under the hood, an open-source metasearch engine that fires your query at ten-plus underlying search engines simultaneously and merges the results. This is the step that makes the answer current - the LLM never needs to "know" anything about today, because today's information gets fetched fresh on every query.

Second, the fetched pages get reranked before anything is written. Raw search-engine ranking optimizes for what's popular, not what's relevant to your specific phrasing, so Vane generates an embedding for your query and for each candidate passage, then sorts the candidates by cosine similarity and keeps the ones that actually address the question. This is the same mechanism covered in more depth in how to evaluate a RAG pipeline - it's retrieval-augmented generation, just with the web itself as the corpus instead of your own documents.

Third, the LLM synthesizes an answer strictly from the reranked passages and cites them inline, rather than answering from its own training data. That constraint is what makes the citations trustworthy - the model is instructed to work from evidence in front of it, not to recall a training-set fact that might be a year stale.

Vane (formerly Perplexica): the direct Perplexity clone

Vane is the closest thing to running Perplexity itself on your own server. It ships as three Docker containers - the Next.js frontend, the backend API, and a bundled SearXNG instance - so `docker compose up` gets you a working answer engine without touching a cloud API if you don't want to. For the LLM layer, you can point it at a fully local model through Ollama (Llama 3, Mistral, Qwen, whatever you've already pulled), or wire in OpenAI, Anthropic, Gemini, or Groq for higher-quality synthesis at the cost of an API bill.

The features added since the Vane rename are worth knowing about specifically because they close gaps that made Perplexica feel like a toy compared to the paid product: deep research mode runs multiple search-and-rerank passes before synthesizing, instead of one; domain-limited search lets you scope a query to specific sites (useful for "search only our docs site and these three vendor blogs"); and the move away from LangChain to a custom streaming engine cut a dependency that was a common source of version-conflict pain in self-hosted deploys. If your goal is "I want Perplexity's UI and behavior, self-hosted, for free," this is the project to start with.

Morphic: when you want a richer answer, not just a faster one

Morphic takes a different bet: instead of matching Perplexity's UI, it leans into the Vercel AI SDK's generative-UI capabilities so an answer can render as more than a paragraph with footnotes - inline image grids, structured comparison cards, and other components streamed live as the model reasons. It supports multiple search providers (Tavily, SearXNG, Brave, Exa) and a wide model roster including local models through Ollama, and it deploys as a one-click Vercel template if you'd rather not manage a server at all.

The tradeoff is that Morphic's best experience leans on Tavily's paid search API rather than being fully free by default, though SearXNG remains a genuinely free swap-in. If your use case is an internal tool where the answer needs to look more like a dashboard than a chat bubble, Morphic's generative UI is the differentiator; if you just want the plainest, most reliable free path, it adds a dependency Vane doesn't need.

Khoj: when the answer should also come from your own files

Khoj solves a different problem than the other two. It's AGPL-3.0 licensed, Y Combinator-backed, and built around the idea that your best answers aren't only on the public web - they're in your notes, PDFs, and internal docs too. Khoj combines the same web-search-plus-synthesis pattern with semantic search over documents you feed it (Markdown, Org-mode, PDF, Word, Notion exports), lets you build custom agents with their own persona and tool access, and reaches you through more surfaces than a browser tab: Obsidian, Emacs, WhatsApp, and a desktop app, on top of self-hosted or cloud deployment.

If your actual need is "answer questions using both the internet and our internal wiki," Khoj is purpose-built for that in a way Vane and Morphic aren't out of the box - you'd have to bolt on your own document-retrieval layer to either of them to get the same result.

Picking the right one for what you're actually trying to do

• Want the closest thing to Perplexity itself, fully self-hosted, minimal setup: start with Vane.
• Want a richer, dashboard-style answer UI and don't mind an optional paid search API: try Morphic.
• Need answers grounded in your own documents alongside the live web, with agents and multi-surface access: Khoj is the fit.
• Already running Ollama and Open WebUI for general chat: any of the three layers on top of that same local-model investment - you're not starting from zero on hardware or model choice.

None of these need a GPU to be useful. Point them at a hosted API (OpenAI, Anthropic, or a cheap open-weight provider) for the synthesis step and run only the search-and-rerank layer locally, and you get most of the privacy and cost benefit without needing to self-host a model too - the same tradeoff explored in open-source vs. OpenAI embedding models for the retrieval side of this same pipeline.

Where this fits if you're building AI products, not just using them

Running one of these tools is a good weekend project. Understanding why the pipeline is built the way it is - metasearch for freshness, embedding-based reranking for relevance, constrained synthesis for trustworthy citations - is the actual skill, and it's the same architecture pattern behind most production RAG systems, not just search clones. That's the gap AI Product Development Bootcamp is built to close: not "install this open-source tool," but how to design, evaluate, and ship a retrieval pipeline like this one for your own product, using the same reranking and evaluation concepts covered in how to learn AI product development. Vane, Morphic, and Khoj are good references to read the source of for exactly that reason - they're real, working implementations of the pattern, not toy tutorials.