Installation
Install IntelliAsk on a fresh Linux VM with intelliask provision — prerequisites, the eight provisioning steps, a first smoke-test, and every flag.
This is the full first-time setup. Run one command on a fresh Linux VM and the provisioner chains the entire deployment for you. It is idempotent, so you can safely re-run it after fixing config or pulling repo updates.
Prerequisites
Host requirements
- A Linux VM with root/sudo access (the provisioner installs Docker and a systemd service). Ubuntu/Debian and RHEL-family hosts are supported.
- Outbound internet to pull images. Docker + Compose are installed for you if missing — you don't need them beforehand.
- x86-64 (amd64) — the binary and the stack images target amd64.
- At least 4 GiB RAM / 2 vCPU for the default resource limits (memory ceilings
total ~3.3 GiB). Raise the
<SERVICE>_CPUS/<SERVICE>_MEMORYvalues inconfig/.envfor larger hosts.
Step 1 — Get the stack onto the VM
Download the provisioning bundle and unpack it. It contains the single
intelliask binary and the config/ folder next to it. Every command below is run
from that folder (the one that holds the intelliask binary).
Copy the archive to the VM (or download it directly there with curl/wget), then
unzip it:
Download it straight onto the VM
If the VM has internet access you can skip the copy step and pull it directly:
Step 2 — Registry (nothing to do for a standard install)
config/.env ships pointed at the public IntelliAsk image registry, which serves
every image — the main app, the six codeapi-* code interpreter images, and the
supporting services (mongo, meilisearch, the RAG API, pgvector, redis,
garage) — for anonymous pull. There are no credentials to set and no login
step for a normal install:
Optional: pull from your own registry
Every image is referenced as ${REGISTRY:-}${<SERVICE>_IMAGE}, so the stack is
registry-agnostic. To pull from your own mirror, point REGISTRY at it:
If that registry needs auth, docker login registry.example.com on the host once
before provisioning and pass --skip-login to provision.
Prefer to do it per service instead? Edit the image line for just that service
in its compose file under config/ and leave the rest on the default registry —
e.g. in config/intelliask.compose.yml:
Optional: wire up a model for a first test
config/.env ships with Anthropic pre-wired as a ready-to-use example endpoint
(ENDPOINTS=agents,anthropic) with blank placeholders you can fill in:
Set ANTHROPIC_API_KEY before provisioning and IntelliAsk boots with a working
model out of the box — handy for confirming the whole stack is healthy end-to-end
(see First smoke-test). Leave it blank to add your own providers
later via Custom Endpoints.
Step 3 — Provision
That single command performs all eight steps:
Configuration — interactively prompts for your license device key
(written to LICENSE_DEVICE_KEY) and, if you enable the reverse proxy, the
public DNS name clients use (PUBLIC_HOST). You can also opt to expose the
metrics exporter through the proxy under its own DNS name.
Docker Engine + Compose — installed natively if not already present (skipped when found).
Secrets — fills any blank secret in config/.env
(SESSION_SECRET, CREDS_KEY, CREDS_IV, JWT_SECRET, JWT_REFRESH_SECRET,
MEILI_MASTER_KEY, the code-interpreter key pairs, and the Garage S3 keys).
Existing values are left untouched unless you pass --rotate-secrets.
Registry login (optional) — the default registry pulls anonymously, so this
step is normally skipped. It only runs if you configured a private mirror that needs
auth; you can also docker login by hand and pass --skip-login.
Prepare stack configuration — persists the reverse-proxy choice and pre-creates
the host bind-mount directories under STORAGE_ROOT with the right ownership so the
app (running as uid/gid 1000) can write uploads and generated files.
Bootstrap Garage S3 + start the stack — starts Garage, creates the cluster layout, bucket, and access key, then brings up the whole stack.
Install the systemd service — installs and enables intelliask.service so the
stack starts on boot, plus a login banner (MOTD) showing live status.
Wait for ready — polls IntelliAsk's /health until it serves, then prints the
URL.
When it finishes you'll see the access URL, e.g. http://localhost:3080 (or your
VM's address/port).
Provision flags
Pass these after provision:
| Flag | Effect |
|---|---|
--skip-docker | Docker + Compose are already installed; skip that step. |
--skip-login | Skip the private registry login (public images only). |
--rotate-secrets | Regenerate all secrets. Only safe on a brand-new install. |
--no-bootstrap | Start the stack but skip the Garage S3 bootstrap (run intelliask garage later). |
--no-service | Don't install the systemd boot service. |
--with-proxy | Also run the bundled Caddy reverse proxy (default TLS mode: internal). |
--no-proxy | Don't run the reverse proxy. |
--proxy-mode <mode> | Proxy TLS mode: file | internal | auto | off. Implies --with-proxy. |
--proxy-email <addr> | ACME contact email, used only with --proxy-mode auto. |
--rotate-secrets is destructive on an existing stack
On an already-initialised stack the existing data volumes keep their old
credentials, so rotating secrets breaks DB/S3 access. Only use --rotate-secrets
on a brand-new install, or wipe data afterwards with
intelliask down --volumes.
Examples:
If you pass neither --with-proxy nor --no-proxy, you're asked interactively
(non-interactive runs keep the existing PROXY_ENABLED value in
config/.env).
After provisioning
- Open IntelliAsk at the printed URL (
http://<host>:3080, orhttps://<host>behind the proxy). - It runs on boot via systemd. Control it with
sudo systemctl start|stop|restart|status intelliask, or directly withintelliask— see Daily Operations. - Code Interpreter (
codeapi) runs its sandbox from a prebuilt language-runtime package tree bind-mounted at${STORAGE_ROOT}/code-interpreter-packageson the host. Build it with the upstreambuild-packages.shand drop it there before the Run Code feature works — an empty tree yields "runtime is unknown" errors. The sandbox also needs host cgroup v2 (unified hierarchy).
First smoke-test
Confirm the deployment is healthy end-to-end:
- Check the stack is up —
intelliask statusshows every service and probes the app's/healthendpoint. - Register the first account at the printed URL. The first user you create is the owner.
- Send a message. If you set
ANTHROPIC_API_KEYinconfig/.env(see Step 2), the Anthropic endpoint is already available — pick it and send a prompt to verify chat works.
Didn't set a key yet? Add one now and apply it without a full re-provision:
Then add any other providers you need via Custom Endpoints.
Re-running provision
provision is idempotent. Re-run it any time to repair drift — Docker install is
skipped when present, secret generation only fills blanks, and the Garage bootstrap
reports "already configured" on subsequent runs:
Alternative Deployment (Advanced)
Manual Docker Compose deployment
The intelliask binary is the recommended approach for most users. However, advanced users with Docker Compose expertise can deploy manually using the compose files directly (docker compose up -d). This approach:
- Requires manual secret generation, service orchestration, and update management
- Enables full customization — substitute any bundled service (S3, Redis, PostgreSQL, reverse proxy) with your own infrastructure
- Uses
docker-compose.override.ymlto override defaults
See Configuration & Secrets > Alternative Deployment for details.
Next steps
With the stack running, continue through the rest of the guide:
Configure the stack
Tune config/.env — secrets, image registry, storage, resource limits, and
optional modules.
Add AI providers
Wire up OpenAI-, Anthropic-, and OpenAI-compatible endpoints in
config/intelliask.yaml.
Reverse proxy & TLS
Put IntelliAsk behind the bundled Caddy proxy with automatic or custom certificates.
Daily operations
Start, stop, update, back up, and monitor the stack with the intelliask
binary.
Last updated on