Installation

Rust

Add Jammi to your Cargo.toml:

[dependencies]
jammi-db = "0.25"
jammi-ai = "0.25"
tokio = { version = "1", features = ["full"] }

CLI

The jammi CLI registers sources, runs SQL, and starts the server. There are three ways to get it.

Prebuilt binary (CPU)

Download a stripped, ready-to-run binary from the GitHub releases. No build toolchain required. Assets are published per release:

jammi-<version>-x86_64-unknown-linux-gnu.tar.gz — Linux x86-64 (built on a glibc 2.28 floor, so it runs on any newer Linux)
jammi-<version>-aarch64-apple-darwin.tar.gz — macOS on Apple silicon

tar -xzf jammi-0.25.0-x86_64-unknown-linux-gnu.tar.gz
./jammi --help

GPU (CUDA 12)

GPU inference ships as a container image, not a bare binary. The jammi-ai-server-cu12 image runs jammi-server as its entrypoint and also carries the jammi admin CLI; it is turnkey:

docker run --gpus all \
  -p 127.0.0.1:8080:8080 -p 127.0.0.1:8081:8081 \
  ghcr.io/f-inverse/jammi-ai-server-cu12:latest

Both ports bind to 127.0.0.1: the server performs no authentication of its own (see The identity seam), so a loopback bind keeps the unauthenticated admin surface off the host’s public network until a terminator or reverse proxy is put in front of it.

Both :latest tags are re-pointed by every v* release tag (never by a prerelease); the CPU :latest can additionally be re-pointed to the current main by a manual build-and-push-main dispatch. Pin an exact :vX.Y.Z tag for a reproducible pull.

That runs jammi-server with zero config. See Deploy as a Server for GPU configuration and persistence.

Alternatively, install the CUDA server as a pip wheel — it ships the same jammi-server binary and pulls the CUDA runtime from nvidia-*-cu12 wheels, so no system CUDA install is required (only an NVIDIA driver on the host):

pip install jammi-server-cu12
jammi-server

The jammi-ai embed wheel is CPU-only; GPU inference runs in the server, reached from Python via jammi.connect("grpc://…").

Build dependencies (Linux)

If building from source, you need a C compiler and protoc:

# Debian/Ubuntu
apt-get install protobuf-compiler gcc g++ pkg-config

# RHEL/AlmaLinux
yum install protobuf-compiler gcc gcc-c++ pkg-config

All other native libraries (lzma, zstd, zlib, sqlite) are vendored and compiled from source automatically. These tools are pre-installed in the devcontainer and CI images.

Building jammi-db with the postgres or mysql source feature additionally requires OpenSSL’s development headers: these features link a native TLS stack (native-tls -> OpenSSL) rather than rustls, and jammi-db does not vendor OpenSSL.

# Debian/Ubuntu
apt-get install libssl-dev

# RHEL/AlmaLinux
yum install openssl-devel

# macOS (Homebrew)
brew install openssl pkg-config

See Connect to PostgreSQL / MySQL.

Python

pip install jammi-ai

Requires Python 3.8+. Pre-built wheels are available for Linux, macOS, and Windows.

From source

git clone https://github.com/f-inverse/jammi-ai.git
cd jammi-ai
cargo build --release

The CLI binary is at target/release/jammi (a strict gRPC client) and the server binary at target/release/jammi-server.

For the Python package from source:

pip install maturin
maturin develop --release

Runtime requirements

Jammi has no mandatory runtime dependencies beyond the binary itself.

Optional:

CUDA toolkit + cuDNN for GPU inference (CPU works out of the box)
HuggingFace Hub access for downloading models (first run downloads ~90MB for MiniLM, cached thereafter)
PostgreSQL / MySQL client libraries if using federated database sources

Set HF_TOKEN for gated models, or HF_HOME to control the cache location — both are read as fallbacks when the config’s own [models] section (see Configuration) leaves hub_token/hub_cache_dir unset; a config value always wins over the environment variable.

Jammi AI Guide