Analytics cookies only (Google Analytics, PostHog). No ad networks, no cross-site tracking. See our privacy policy.
Updated Sep 2026
verified on Ubuntu 26.04 · Aug 2026Self-host Jan on your own VPS — a privacy-focused, offline-capable AI assistant with a clean interface and support for local and remote models.
Jan is a privacy-focused AI assistant that runs models locally on your device. It's designed for people who want the convenience of a chat interface without sending their conversations to the cloud. Jan supports both local models (via its built-in engine) and remote APIs (Ollama, OpenAI, etc.), giving you flexibility in how you run it.
The appeal is privacy by design. Jan stores all data locally — conversations, settings, model downloads — and never phones home. The desktop app is the primary interface, but you can also run Jan's backend on a VPS and access it via the web, giving you a self-hosted AI assistant that works from any device.
Jan's approach to model management is opinionated: it downloads models directly, manages them in a local directory, and handles inference without requiring Docker or complex setup. This makes it simpler than Ollama for some use cases, though less flexible for server deployments.
Jan's server mode is relatively lightweight. The web interface is a static frontend, and the backend is a small Node.js service that proxies to either local models or external APIs.
With remote API (Ollama, OpenAI, etc.):
With local models (built-in engine):
The key insight: Jan's strength is its desktop experience. The VPS deployment is useful for team access or running models on a more powerful server, but if you're running models locally on the VPS, Ollama is often simpler. The hybrid approach — Jan on the VPS connecting to Ollama on the same box — gives you the best of both worlds.
A 2 vCPU / 4 GB VPS works well for remote-API deployments. For local models, you need the same RAM as Ollama (16 GB+ for 7B models).
Start from a fresh Ubuntu 24.04 or 26.04 server. Update and create a non-root user:
apt update && apt upgrade -y
adduser deploy
usermod -aG sudo deploy
Lock down the firewall:
ufw allow OpenSSH
ufw allow 80
ufw allow 443
ufw enable
Install Docker:
curl -fsSL https://get.docker.com | sh
usermod -aG docker deploy
Log out and back in as deploy so the docker group takes effect.
Paid link — we earn a commission if you shop through it.
Create a working directory:
mkdir ~/jan && cd ~/jan
Create a compose file:
services:
jan:
image: janhq/jan-server:latest
restart: unless-stopped
ports:
- "127.0.0.1:1337:1337"
volumes:
- jan_data:/app/data
volumes:
jan_data:
Start it:
docker compose up -d
Jan listens on port 1337. The 127.0.0.1 bind keeps it private.
Jan needs a model backend to generate responses. You have two options:
Option 1: Ollama (recommended)
If Ollama is on the same server, Jan can reach it at http://host.docker.internal:11434. This is the simplest path — Ollama handles model management, and Jan provides the interface.
Option 2: Local models Jan can download and run models directly using its built-in engine. This requires more RAM (the model weights load into Jan's process) and gives you more control over model selection.
To configure the backend:
If you're using Ollama, make sure at least one model is pulled:
docker exec -it ollama ollama pull llama3.2
Jan needs HTTPS for production use, especially if you're accessing it remotely. Point a reverse proxy at 127.0.0.1:1337 and terminate HTTPS on 443.
The simplest path is Automatic HTTPS with Caddy. Point an A record for your hostname (say ai.example.com) at the server's public IP, then have Caddy reverse-proxy that hostname to 127.0.0.1:1337.
If you're using the Caddy container approach, put Jan and Caddy in the same compose file and proxy to the Jan service name:
reverse_proxy jan:1337
Load https://ai.example.com in your browser. Jan shows a clean, minimal interface.
Set up your account:
Test the connection:
If the response fails, check the Jan logs:
docker compose logs jan | tail -20
Common issues: model provider not reachable, wrong URL, or Ollama not running.
Jan's model management depends on your backend:
With Ollama: Jan shows models from your Ollama instance. Pull models in Ollama, and they appear in Jan's model dropdown. This is the recommended approach for server deployments.
With Jan's built-in engine: Jan can download models directly. Go to Settings → Models → Download Model and select from the available options. Models are stored in the Jan data volume.
Hybrid approach: Use Ollama for the heavy models (7B+) and Jan's built-in engine for smaller, faster models (3B) for quick questions.
Jan's data lives in the data volume:
docker run --rm -v jan_data:/data -v $(pwd):/backup alpine \
tar czf /backup/jan-$(date +%F).tar.gz -C /data .
This backs up conversations, settings, and downloaded models (if using Jan's built-in engine). For Ollama, see Deploy Ollama on a VPS for separate backup instructions.
Pull the newer image and recreate:
docker compose pull
docker compose up -d
Jan updates are usually non-breaking. Check the Jan changelog for any notable changes.
Can't connect to Ollama. Verify Ollama is running (docker compose ps in the Ollama directory) and the URL is correct. If both are on the same server, http://host.docker.internal:11434 should work.
Slow responses. Expected without a GPU. Jan's built-in engine on CPU is slower than Ollama for the same models. Consider using Ollama as the backend for better performance.
Model not found. The model name must match exactly what's available in your backend. Check Ollama's model list with curl http://localhost:11434/api/tags.
Web interface won't load. Check that Jan is running (docker compose ps) and the port is correct. Look at logs for startup errors.
Conversations missing after restart. Jan stores data in the Docker volume. If the volume was removed or recreated, conversations are lost. Back up the data volume regularly.
You're done when you can: load the web interface over HTTPS, start a conversation, get responses from your configured backend, and switch between models. The interface should feel responsive and the conversations should persist.
From here, explore Jan's features like conversation templates, model fine-tuning, and keyboard shortcuts. For a more feature-rich web interface, see Open WebUI. For document-based AI workflows, see AnythingLLM. A 2 vCPU / 4 GB box handles remote-API deployments; step up to 8 vCPU / 16 GB for local models. See Best VPS for AI & ML Workloads for the ranked picks.
We estimate about 20 minutes of hands-on time for "How to Deploy Jan on a VPS"; this is an editorial estimate, not a measurement.
The "How to Deploy Jan on a VPS" guide was verified end-to-end on Ubuntu 26.04 (Aug 2026).