# Self-host a Perplexica alternative, or own the open-source system behind it

> Running a Perplexica alternative yourself means standing up three parts: the app, a model runtime, and a search backend. Each has a real install path here, and the open-source system a team can own end to end is Kortix, the open-source AI Operating System.

URL: https://perplexicaalternative.com/self-hosted-perplexica-alternatives

## How the self-hosted answer engines compare

Every row comes from the project's own repository or setup docs, checked October 2026.

| | Kortix (recommended) | Vane, formerly Perplexica | Open WebUI | Khoj |
| --- | --- | --- | --- | --- |
| Open source | Yes | Yes | Yes, keeps its branding terms | Yes |
| What it is | The open-source AI Operating System | A self-hosted AI answering engine | A chat interface over any model | A personal AI over your documents |
| Runs on | Kortix Cloud, your VPC, or your own on-prem network | One Docker image with its own search engine | One server or a desktop app | One server or a laptop |
| Model choice | Any model with your own keys | Local models through Ollama, or cloud providers | Local models through Ollama, or cloud APIs | Local or online models |
| How answers are built | Agents do the work and reach your tools | SearXNG web search with cited sources | Web search plus your own documents | Your documents and the live web |
| What you own | Agents, skills, memory, and connectors as files in one git repo | The app and its search configuration | The chat interface and its settings | The app and your document index |
| Best for | Teams that want finished work they review before it lands | One person who wants private web answers | A local chat front end over open models | Personal notes and document search |

## What self-hosting a Perplexica alternative actually requires

A hosted answer engine hides three parts behind one box: the app you type into, a model runtime that writes the answer, and a search backend that fetches live pages. Self-hosting means running each part yourself, on a machine you control.

Vane, the project most people still search for as Perplexica, bundles the app and a private search engine in one image, so you supply only a model. The rename to Vane landed in March 2026, so the repository and the image now carry that name. The quickest path is one command:

```sh
docker run -d -p 3000:3000 -v vane-data:/home/vane/data --name vane itzcrazykns1337/vane:latest
```

Open `http://localhost:3000`, pick a model provider in the setup screen, and you get cited answers over the live web. The bundled search engine is SearXNG, and the project documents a slim image if you already run SearXNG yourself.

### The parts you run, and where each project fits

Each self-hosted option is a different slice of the same stack.

- **The search backend.** SearXNG is a metasearch engine; alone it returns a page of links rather than a written answer. Standalone, it runs as a Docker Compose stack:

```sh
mkdir -p ./searxng/core-config/ && cd ./searxng/
curl -fsSL -O https://raw.githubusercontent.com/searxng/searxng/master/container/docker-compose.yml -O https://raw.githubusercontent.com/searxng/searxng/master/container/.env.example
cp -i .env.example .env
docker compose up -d
```

- **The model runtime.** Ollama runs open models on your own hardware, so queries never leave your network:

```sh
curl -fsSL https://ollama.com/install.sh | sh
```

- **The chat front end.** Open WebUI is a chat interface that connects to Ollama or a cloud API:

```sh
docker run -d -p 3000:8080 --add-host=host.docker.internal:host-gateway -v open-webui:/app/backend/data -e WEBUI_SECRET_KEY=your-secret-key --name open-webui --restart always ghcr.io/open-webui/open-webui:main
```

- **The documents layer.** Khoj answers from your own files and the web. It ships a Compose file you configure and start:

```sh
mkdir ~/.khoj && cd ~/.khoj
wget https://raw.githubusercontent.com/khoj-ai/khoj/master/docker-compose.yml
docker-compose up
```

### What you take on when you self-host

Self-hosting keeps queries on your network and lets you pick the model that answers. It also moves the operations to you: images to update, a database to back up, DNS and TLS to hold, keys to rotate, and every service to keep running. For one person who wants private web answers, a single command is a fair trade.

For a team, citations are rarely the end. It also needs work that lands in a ticket, a report someone can review, and an action inside one of its tools. That is a different layer, and it is where Kortix sits.

## The self-hosted system a team can own end to end

Kortix is the open-source AI Operating System: your agents, their skills, your company memory, and every connector in one git repo you own, with the agents working on real cloud computers.

It runs on the same kind of server the answer engines need. A self-hosted instance is the full Kortix platform on a server you control, installed as one Docker Compose stack that the `kortix self-host` CLI configures and updates. It needs a Linux server with a public IP, DNS records for the domain and its API subdomain, ports 80 and 443 open, and a sandbox provider key. The install is documented at [Kortix](https://kortix.com/docs/host):

```sh
curl -fsSL https://kortix.com/install | bash
kortix self-host init --domain kortix.example.com --admin-email you@example.com
kortix self-host start
kortix self-host doctor
```

Run `kortix self-host doctor` and fix every failing check before you invite a team. Sessions run on a cloud sandbox provider rather than the server itself, so the box has to be reachable for them to call back. Then connect GitHub in the dashboard, create a project, and add a model key.

Run it on Kortix Cloud, in your VPC, or on your own on-prem network. Self-host is free. Any model provider with your own keys, so you are not tied to the model behind a search box. Each session has its own isolated machine and branch, and session work reaches `main` through a change request. Merge is default-deny for agents.

An answer engine answers one person's questions. Kortix is the open-source layer a team owns end to end, holding the agents that do the work, the memory that accumulates, and the connectors into its tools, all as files in one repo you can read, diff, and roll back.

## The Kortix self-host commands

`terminal`

```sh
curl -fsSL https://kortix.com/install | bash
kortix self-host init --domain kortix.example.com --admin-email you@example.com
kortix self-host start
kortix self-host doctor
```

Source: https://kortix.com/docs/host

Four commands from the Kortix self-hosting docs.