You pick which model runs where: the server first, then the model on it. Every answer keeps the model, the server and the speed behind it — and the chat is yours to rewind, fork or lift out whole.
One docker compose up · SQLite, no external services · nine languages
Two dropdowns pick the server and model. Streaming answers with reasoning, tool calls, and per-message attribution — visible, not hidden.
Here's a script that archives everything in the current directory and excludes its own output:
#!/usr/bin/env bash set -euo pipefail # timestamped archive of the current folder stamp=$(date +"%Y-%m-%d_%H-%M-%S") zip -r "backup_${stamp}.zip" . -x "backup_*.zip"
Run it inside the folder you want to archive; the new .zip lands right there.
// mockup with placeholder data — not a real conversation
A search or documentation tool returns what matched one query, never the whole reference — and a model can confidently call what it did not receive nonexistent. A prompt could not fix that; we measured it making things worse. So every tool call opens the raw output the model actually got, stored with the message.
### model_validator with mode='after' for cross-field validation Source: https://github.com/pydantic/pydantic/blob/main/pydantic/functional_validators.py @model_validator(mode='after') def verify_square(self) -> Self: if self.width != self.height: raise ValueError('width and height do not match') return self
wrap// the panel is real; the excerpt is trimmed for the page
Pick the server and model for every message. Servers that are asleep or unreachable are hidden, so they cannot be picked by mistake.
Native Ollama and any OpenAI-compatible API — OpenRouter, LM Studio, vLLM, llama.cpp — side by side.
Answers stream as they generate; reasoning shows in its own pane. Esc stops any response.
Paste images to vision models; attach PDFs, docx or code as lossless text on any model.
Bundled web search plus any MCP server. Read-only tools run freely; anything that changes state asks you first.
Roles, private chats, registration you can close. API keys and MCP tokens are encrypted in the database.
Give Calivi a VM of its own and the model gets a shell there — bash and file edits, as the owner's account, like a terminal coding agent. The UI stays the chat window.
agent mode · every step opens to its output ✓bash df -h /home && free -h ✓bash du -sh ~/models/* | sort -h ✓read_file ~/models/README ?bash rm -rf ~/models/old-q4 waiting for your approval — Approve · Deny
// mockup with placeholder data — not a real session
Each command is a row you can open to its output. The steps are kept with the reply and handed back to the model next turn, so it knows what it already ran.
Harmless commands just run. rm, stopping services, writing under /etc wait for your approval; a few things are refused outright. 🛡 makes every call ask.
New versions arrive with apt upgrade from a signed repository, and never cut a reply that is still running. Each package is tested in a VM of its distribution first.
Paste one prompt into Claude Code, Codex or any coding agent on the machine that should host Calivi. It checks the machine, installs what is missing, starts Calivi, verifies it and hands you the URL.
Needs only Docker with Compose.
$ git clone https://github.com/orkun-soylu/calivi.git $ cd calivi $ docker compose up -d --build
A Proxmox image, or the calivi package for Debian 13, Ubuntu 24.04 LTS or 26.04 LTS —
on a machine meant for it: its owner's model gets a root-capable shell there. Calivi serves on
port 80; the first account claims the machine with the setup code shown on its console.
# the package, downloaded from the latest release $ sudo apt install ./calivi_X.Y.Z-1+deb13_amd64.deb # or +ubuntu24.04 / +ubuntu26.04
Then, with Docker, open http://localhost:8090 and sign up right away — the first
account becomes the admin. Add a model server under Settings → Servers, pick it from the top bar,
and chat. Settings, backups and HTTPS are in the README.