Skip to main content

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>_MEMORY values in config/.env for 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:

# from your machine, copy the downloaded zip to the VM
scp intelliask-setup.zip user@your-vm:~
 
# on the VM
unzip intelliask-setup.zip
cd intelliask && chmod +x intelliask

Download it straight onto the VM

If the VM has internet access you can skip the copy step and pull it directly:

curl -LO https://intelliask.mt/api/downloads/intelliask-setup/latest/intelliask-setup.zip
unzip intelliask-setup.zip
cd intelliask && chmod +x intelliask

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:

# config/.env (pre-set — leave as-is)
REGISTRY=registry.intelliask.mt/

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:

# config/.env
REGISTRY=registry.example.com/intelliask/

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:

services:
  intelliask:
    # was: image: ${REGISTRY:-}${INTELLIASK_IMAGE:-}
    image: registry.example.com/intelliask/intelliask:v0.8.7

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:

# config/.env
ANTHROPIC_API_KEY=        # paste a key to enable the Anthropic endpoint
ANTHROPIC_MODELS=         # optional allow-list (blank = provider defaults)
ANTHROPIC_REVERSE_PROXY=  # optional Anthropic-compatible gateway URL

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

./intelliask 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:

FlagEffect
--skip-dockerDocker + Compose are already installed; skip that step.
--skip-loginSkip the private registry login (public images only).
--rotate-secretsRegenerate all secrets. Only safe on a brand-new install.
--no-bootstrapStart the stack but skip the Garage S3 bootstrap (run intelliask garage later).
--no-serviceDon't install the systemd boot service.
--with-proxyAlso run the bundled Caddy reverse proxy (default TLS mode: internal).
--no-proxyDon'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:

# Fresh VM, behind HTTPS via the bundled proxy with an internal CA cert
./intelliask provision --with-proxy --proxy-mode internal
 
# Public DNS with automatic Let's Encrypt certificates
./intelliask provision --proxy-mode auto --proxy-email ops@example.com
 
# Docker already installed, no boot service (e.g. a throwaway test host)
./intelliask provision --skip-docker --no-service

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, or https://<host> behind the proxy).
  • It runs on boot via systemd. Control it with sudo systemctl start|stop|restart|status intelliask, or directly with intelliask — see Daily Operations.
  • Code Interpreter (codeapi) runs its sandbox from a prebuilt language-runtime package tree bind-mounted at ${STORAGE_ROOT}/code-interpreter-packages on the host. Build it with the upstream build-packages.sh and 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:

  1. Check the stack is up — intelliask status shows every service and probes the app's /health endpoint.
  2. Register the first account at the printed URL. The first user you create is the owner.
  3. Send a message. If you set ANTHROPIC_API_KEY in config/.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:

# edit config/.env → set ANTHROPIC_API_KEY=...
intelliask up intelliask

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:

./intelliask provision --skip-docker

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.yml to override defaults

See Configuration & Secrets > Alternative Deployment for details.

Next steps

With the stack running, continue through the rest of the guide:

Last updated on