OpenJarvis/docs/getting-started/installation.md

title, description

title	description
Installation	Get OpenJarvis running — browser app, desktop app, CLI, or Python SDK

Installation

OpenJarvis runs entirely on your hardware. Choose the interface that fits your workflow.

---

Browser App

Run the full chat UI in your browser. Everything stays local — the backend runs on your machine and the frontend connects via localhost.

One-command setup

git clone https://github.com/HazyResearch/OpenJarvis.git
cd OpenJarvis
./scripts/quickstart.sh

The script handles everything:

1. Checks for Python 3.10+ and Node.js 18+
2. Installs Ollama if not present and pulls a starter model
3. Installs Python and frontend dependencies
4. Starts the backend API server and frontend dev server
5. Opens http://localhost:5173 in your browser

Manual setup

If you prefer to run each step yourself:

=== "Step 1: Clone and install"

```bash
git clone https://github.com/HazyResearch/OpenJarvis.git
cd OpenJarvis
uv sync --extra server
cd frontend && npm install && cd ..
```

=== "Step 2: Start Ollama"

```bash
# Install from https://ollama.com if not already installed
ollama serve &
ollama pull qwen3:0.6b
```

=== "Step 3: Start backend"

```bash
uv run jarvis serve --port 8000
```

=== "Step 4: Start frontend"

```bash
cd frontend
npm run dev
```

Then open http://localhost:5173.

---

Desktop App

The desktop app is a native window for the OpenJarvis chat UI. All inference and backend processing happens on your local machine — the app connects to the backend you start locally.

Setup

Step 1. Start the backend (same as Browser App):

git clone https://github.com/HazyResearch/OpenJarvis.git
cd OpenJarvis
./scripts/quickstart.sh

Step 2. Download and open the desktop app:

Platform	Download
macOS (Apple Silicon)	:material-download: OpenJarvis.dmg
Windows (64-bit)	:material-download: OpenJarvis-setup.exe
Linux (DEB)	:material-download: OpenJarvis.deb
Linux (RPM)	:material-download: OpenJarvis.rpm
Linux (AppImage)	:material-download: OpenJarvis.AppImage

The app connects to http://localhost:8000 automatically.

!!! tip "All releases" Browse all versions on the GitHub Releases page.

Build from source

git clone https://github.com/HazyResearch/OpenJarvis.git
cd OpenJarvis/desktop
npm install
npm run tauri build

The built installer will be in desktop/src-tauri/target/release/bundle/.

---

CLI

The command-line interface is the fastest way to interact with OpenJarvis programmatically. Every feature is accessible from the terminal.

Install

=== "uv (recommended)"

```bash
uv pip install openjarvis
```

=== "pip"

```bash
pip install openjarvis
```

=== "From source"

```bash
git clone https://github.com/HazyResearch/OpenJarvis.git
cd OpenJarvis
uv sync
```

Verify

jarvis --version
# jarvis, version 1.0.0

First commands

jarvis ask "What is the capital of France?"

jarvis ask --agent orchestrator --tools calculator "What is 137 * 42?"

jarvis serve --port 8000

jarvis doctor

jarvis model list

jarvis chat

!!! info "Inference backend required" The CLI requires a running inference backend (e.g., Ollama). See Setting up an inference backend below.

---

Python SDK

For programmatic access, the Jarvis class provides a high-level sync API.

Install

pip install openjarvis

Quick example

from openjarvis import Jarvis

j = Jarvis()
print(j.ask("Explain quicksort in two sentences."))
j.close()

With agents and tools

result = j.ask_full(
    "What is the square root of 144?",
    agent="orchestrator",
    tools=["calculator", "think"],
)
print(result["content"])       # "12"
print(result["tool_results"])  # tool invocations
print(result["turns"])         # number of agent turns

Composition layer

For full control, use the SystemBuilder:

from openjarvis import SystemBuilder

system = (
    SystemBuilder()
    .engine("ollama")
    .model("qwen3:8b")
    .agent("orchestrator")
    .tools(["calculator", "web_search", "file_read"])
    .enable_telemetry()
    .enable_traces()
    .build()
)

result = system.ask("Summarize the latest AI news.")
system.close()

See the Python SDK guide for the full API reference.

---

Requirements

Requirement	Version	Notes
Python	3.10+	Required
Inference backend	Any	At least one of Ollama, vLLM, llama.cpp, SGLang, or a cloud API
Node.js	18+	Required for the browser UI; 22+ for OpenClaw agent

Optional Extras

OpenJarvis uses optional extras to keep the base installation lightweight.

Inference Backends

Extra	Install Command	Description
inference-cloud	pip install 'openjarvis[inference-cloud]'	OpenAI and Anthropic APIs
inference-google	pip install 'openjarvis[inference-google]'	Google Gemini API

!!! note "Ollama, vLLM, and llama.cpp are HTTP-based" These engines have no additional Python dependencies — OpenJarvis communicates over HTTP. You still need the engine software running on your machine.

Memory Backends

Extra	Install Command	Description
memory-faiss	pip install 'openjarvis[memory-faiss]'	FAISS vector store
memory-colbert	pip install 'openjarvis[memory-colbert]'	ColBERTv2 late-interaction retrieval
memory-bm25	pip install 'openjarvis[memory-bm25]'	BM25 sparse retrieval

!!! tip "SQLite memory is always available" The default SQLite/FTS5 memory backend requires no additional dependencies.

Server & Other

Extra	Install Command	Description
server	pip install 'openjarvis[server]'	OpenAI-compatible API server (jarvis serve)
dev	pip install 'openjarvis[dev]'	Development and testing tools
docs	pip install 'openjarvis[docs]'	Documentation build tools

Combine extras with commas:

pip install 'openjarvis[server,memory-faiss,inference-cloud]'

Setting Up an Inference Backend

OpenJarvis requires at least one inference backend. Choose the one that matches your hardware.

Ollama (Recommended)

The easiest way to get started. Handles model downloading and serving automatically.

1. Install from ollama.com

2. Start the server and pull a model:

   ollama serve
   ollama pull qwen3:0.6b
   

3. Verify: jarvis model list

!!! tip "Best for: Apple Silicon Macs, consumer NVIDIA GPUs, CPU-only systems"

vLLM

High-throughput serving optimized for datacenter GPUs.

1. Install following the official guide
2. Start: vllm serve Qwen/Qwen2.5-7B-Instruct
3. Auto-detected at http://localhost:8000

!!! tip "Best for: NVIDIA datacenter GPUs (A100, H100), AMD GPUs"

llama.cpp

Efficient CPU and GPU inference with GGUF quantized models.

1. Build from github.com/ggerganov/llama.cpp
2. Start: llama-server -m /path/to/model.gguf --port 8080
3. Auto-detected at http://localhost:8080

Cloud APIs

pip install 'openjarvis[inference-cloud,inference-google]'
export OPENAI_API_KEY="sk-..."
export ANTHROPIC_API_KEY="sk-ant-..."

Next Steps

• Quick Start — Run your first query
• Configuration — Customize engine hosts, model routing, memory, and more