admin/OpenJarvis
1
0
Fork 0
mirror of https://github.com/open-jarvis/OpenJarvis.git synced 2026-07-30 10:52:15 +00:00
Code Issues Packages Projects Releases Wiki Activity

feat: removing downloads and consolidating all to getting started

Browse Source
This commit is contained in:
Gabriel Bo
2026-03-05 13:45:26 -08:00
parent 8a0aee7e38
commit 0ad9fdba8a
4 changed files with 233 additions and 421 deletions
Download Patch File Download Diff File Expand all files Collapse all files
docs/downloads.md
-238
View File
@@ -1,238 +0,0 @@
---
title: Downloads
description: Download the OpenJarvis desktop app, browser app, CLI, or Python SDK
---
# Downloads
OpenJarvis runs entirely on your hardware. Choose the interface that fits your workflow.
---
## Desktop App
The native desktop app bundles Ollama (the inference engine) and the OpenJarvis Python backend
into a single installer. Download, open, and start chatting — no terminal required.
### Download
| Platform | Download | Notes |
|----------|----------|-------|
| macOS (Apple Silicon) | [:material-download: **OpenJarvis.dmg**](https://github.com/HazyResearch/OpenJarvis/releases/latest/download/OpenJarvis_aarch64.dmg) | M1/M2/M3/M4 Macs |
| macOS (Intel) | [:material-download: **OpenJarvis.dmg**](https://github.com/HazyResearch/OpenJarvis/releases/latest/download/OpenJarvis_x64.dmg) | Intel Macs (2020 and earlier) |
| Windows (64-bit) | [:material-download: **OpenJarvis-setup.exe**](https://github.com/HazyResearch/OpenJarvis/releases/latest/download/OpenJarvis_x64-setup.exe) | Windows 10+ |
| Linux (DEB) | [:material-download: **OpenJarvis.deb**](https://github.com/HazyResearch/OpenJarvis/releases/latest/download/OpenJarvis_amd64.deb) | Ubuntu, Debian |
| Linux (RPM) | [:material-download: **OpenJarvis.rpm**](https://github.com/HazyResearch/OpenJarvis/releases/latest/download/OpenJarvis_amd64.rpm) | Fedora, RHEL |
!!! tip "All releases"
Browse all versions on the [GitHub Releases](https://github.com/HazyResearch/OpenJarvis/releases) page.
### What's included
The desktop app ships with:
- **Ollama** sidecar — inference engine runs automatically in the background
- **OpenJarvis backend** — Python API server managed by the app
- **Full chat UI** — same interface as the browser app
- **Energy monitoring** — real-time power consumption tracking
- **Telemetry dashboard** — token throughput, latency, and cost comparison
### Build from source
```bash
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/`.
---
## 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
```bash
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 22+
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](http://localhost:5173).
### What you get
- **Chat interface** — markdown rendering, streaming responses, conversation history
- **Tool use** — calculator, web search, code interpreter, file I/O
- **System panel** — live telemetry, energy monitoring, cost comparison vs. cloud models
- **Dashboard** — energy graphs, trace debugging, cost breakdown
- **Settings** — model selection, agent configuration, theme toggle
---
## 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
```bash
jarvis --version
# jarvis, version 1.0.0
```
### First commands
```bash
# Ask a question
jarvis ask "What is the capital of France?"
# Use an agent with tools
jarvis ask --agent orchestrator --tools calculator "What is 137 * 42?"
# Start the API server
jarvis serve --port 8000
# Run diagnostics
jarvis doctor
# List available models
jarvis model list
# Interactive chat
jarvis chat
```
!!! info "Inference backend required"
The CLI requires a running inference backend (e.g., Ollama). See the
[Installation guide](getting-started/installation.md#setting-up-an-inference-backend)
for setup instructions.
---
## Python SDK
For programmatic access, the `Jarvis` class provides a high-level sync API.
### Install
```bash
pip install openjarvis
```
### Quick example
```python
from openjarvis import Jarvis
j = Jarvis()
print(j.ask("Explain quicksort in two sentences."))
j.close()
```
### With agents and tools
```python
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`:
```python
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](user-guide/python-sdk.md) for the full API reference.
docs/getting-started/installation.md
+225 -178
View File
@@ -1,15 +1,20 @@
---
title: Installation
description: Install OpenJarvis and set up an inference backend
description: Get OpenJarvis running — browser app, desktop app, CLI, or Python SDK
---
# Installation
This guide covers installing OpenJarvis, its optional extras, and setting up an inference backend.
OpenJarvis runs entirely on your hardware. Choose the interface that fits your workflow.
## Quickstart (Recommended)
---
The fastest way to get everything running — browser UI, backend, and inference engine — with a single command:
## 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
```bash
git clone https://github.com/HazyResearch/OpenJarvis.git
@@ -17,32 +22,101 @@ cd OpenJarvis
./scripts/quickstart.sh
```
This script checks for Python 3.10+, Node.js, and Ollama (installing what's missing), pulls a starter model, installs all dependencies, starts the backend and frontend servers, and opens the chat UI in your browser.
The script handles everything:
!!! tip "Desktop app"
Prefer a native app? Download the [Desktop App](../downloads.md#desktop-app) instead — it bundles everything into a single installer.
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
## Requirements
If you prefer to run each step yourself:
| 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 |
## Installing OpenJarvis
=== "Quickstart script"
=== "Step 1: Clone and install"
```bash
git clone https://github.com/HazyResearch/OpenJarvis.git
cd OpenJarvis
./scripts/quickstart.sh
uv sync --extra server
cd frontend && npm install && cd ..
```
Handles everything: deps, Ollama, model pull, backend, frontend, browser open.
=== "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](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):
```bash
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**](https://github.com/HazyResearch/OpenJarvis/releases/download/desktop-latest/OpenJarvis_1.0.0_aarch64.dmg) |
| Windows (64-bit) | [:material-download: **OpenJarvis-setup.exe**](https://github.com/HazyResearch/OpenJarvis/releases/download/desktop-latest/OpenJarvis_1.0.0_x64-setup.exe) |
| Linux (DEB) | [:material-download: **OpenJarvis.deb**](https://github.com/HazyResearch/OpenJarvis/releases/download/desktop-latest/OpenJarvis_1.0.0_amd64.deb) |
| Linux (RPM) | [:material-download: **OpenJarvis.rpm**](https://github.com/HazyResearch/OpenJarvis/releases/download/desktop-latest/OpenJarvis-1.0.0-1.x86_64.rpm) |
| Linux (AppImage) | [:material-download: **OpenJarvis.AppImage**](https://github.com/HazyResearch/OpenJarvis/releases/download/desktop-latest/OpenJarvis_1.0.0_amd64.AppImage) |
The app connects to `http://localhost:8000` automatically.
!!! tip "All releases"
Browse all versions on the [GitHub Releases](https://github.com/HazyResearch/OpenJarvis/releases) page.
### Build from source
```bash
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)"
@@ -64,64 +138,134 @@ This script checks for Python 3.10+, Node.js, and Ollama (installing what's miss
uv sync
```
For development with all dev tools:
### Verify
```bash
uv sync --extra dev
```
```bash
jarvis --version
# jarvis, version 1.0.0
```
### First commands
```bash
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](#setting-up-an-inference-backend) below.
---
## Python SDK
For programmatic access, the `Jarvis` class provides a high-level sync API.
### Install
```bash
pip install openjarvis
```
### Quick example
```python
from openjarvis import Jarvis
j = Jarvis()
print(j.ask("Explain quicksort in two sentences."))
j.close()
```
### With agents and tools
```python
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`:
```python
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](../user-guide/python-sdk.md) 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. Install only what you need.
OpenJarvis uses optional extras to keep the base installation lightweight.
### Inference Backends
| Extra | Install Command | Dependencies | Description |
|-------|----------------|--------------|-------------|
| `inference-ollama` | `pip install 'openjarvis[inference-ollama]'` | None (HTTP-based) | Ollama backend. Communicates via HTTP API. |
| `inference-vllm` | `pip install 'openjarvis[inference-vllm]'` | None (HTTP-based) | vLLM backend. Communicates via OpenAI-compatible API. |
| `inference-llamacpp` | `pip install 'openjarvis[inference-llamacpp]'` | None (HTTP-based) | llama.cpp server backend. |
| `inference-cloud` | `pip install 'openjarvis[inference-cloud]'` | `openai>=1.30`, `anthropic>=0.30` | Cloud inference via OpenAI and Anthropic APIs. |
| `inference-google` | `pip install 'openjarvis[inference-google]'` | `google-genai>=1.0` | Google Gemini API backend. |
| 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"
The `inference-ollama`, `inference-vllm`, and `inference-llamacpp` extras have no additional Python dependencies. OpenJarvis communicates with these engines over HTTP using the `httpx` library that is already a core dependency. You still need the actual engine software running on your machine or network.
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 | Dependencies | Description |
|-------|----------------|--------------|-------------|
| `memory-faiss` | `pip install 'openjarvis[memory-faiss]'` | `faiss-cpu>=1.7`, `sentence-transformers>=2.2`, `numpy>=1.24` | FAISS vector store with sentence-transformer embeddings. |
| `memory-colbert` | `pip install 'openjarvis[memory-colbert]'` | `colbert-ai>=0.2`, `torch>=2.0` | ColBERTv2 late-interaction retrieval. |
| `memory-bm25` | `pip install 'openjarvis[memory-bm25]'` | `rank-bm25>=0.2.2` | BM25 sparse retrieval backend. |
| `memory-pdf` | `pip install 'openjarvis[memory-pdf]'` | `pdfplumber>=0.10` | PDF document ingestion support. |
| 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. It is always available and suitable for most use cases.
The default SQLite/FTS5 memory backend requires no additional dependencies.
### Tools
### Server & Other
| Extra | Install Command | Dependencies | Description |
|-------|----------------|--------------|-------------|
| `tools-search` | `pip install 'openjarvis[tools-search]'` | `tavily-python>=0.3` | Web search tool via the Tavily API. |
### Server
| Extra | Install Command | Dependencies | Description |
|-------|----------------|--------------|-------------|
| `server` | `pip install 'openjarvis[server]'` | `fastapi>=0.110`, `uvicorn>=0.30`, `pydantic>=2.0` | OpenAI-compatible API server (`jarvis serve`). |
### Other Extras
| Extra | Install Command | Dependencies | Description |
|-------|----------------|--------------|-------------|
| `agents` | `pip install 'openjarvis[agents]'` | None | Agent infrastructure (included in base). |
| `learning` | `pip install 'openjarvis[learning]'` | None | Learning/router policy system (included in base). |
| `openclaw` | `pip install 'openjarvis[openclaw]'` | None | OpenClaw agent transport layer. Requires Node.js 22+ at runtime. |
| `docs` | `pip install 'openjarvis[docs]'` | `mkdocs>=1.6`, `mkdocs-material>=9.5`, `mkdocstrings[python]>=0.25` | Documentation build tools. |
| `dev` | `pip install 'openjarvis[dev]'` | `pytest>=8`, `pytest-asyncio>=0.24`, `pytest-cov>=5`, `respx>=0.22`, `ruff>=0.4` | Development and testing tools. |
### Installing Multiple Extras
| 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:
@@ -129,149 +273,52 @@ Combine extras with commas:
pip install 'openjarvis[server,memory-faiss,inference-cloud]'
```
Or with `uv`:
```bash
uv pip install 'openjarvis[server,memory-faiss,inference-cloud]'
```
## Verifying Installation
After installation, verify that the CLI is available:
```bash
jarvis --version
```
Expected output:
```
jarvis, version 1.0.0
```
View all available commands:
```bash
jarvis --help
```
Expected output:
```
Usage: jarvis [OPTIONS] COMMAND [ARGS]...
OpenJarvis -- modular AI assistant backend
Options:
--version Show the version and exit.
--help Show this message and exit.
Commands:
ask Ask Jarvis a question.
bench Run inference benchmarks.
init Detect hardware and generate ~/.openjarvis/config.toml.
memory Manage the memory store.
model Manage language models.
serve Start the OpenAI-compatible API server.
telemetry Query and manage inference telemetry data.
```
## Setting Up an Inference Backend
OpenJarvis requires at least one inference backend to generate responses. Choose the backend that best matches your hardware.
OpenJarvis requires at least one inference backend. Choose the one that matches your hardware.
### Ollama (Recommended for most users)
### Ollama (Recommended)
Ollama is the easiest way to get started. It handles model downloading and serving automatically.
The easiest way to get started. Handles model downloading and serving automatically.
1. Install Ollama from [ollama.com](https://ollama.com)
2. Start the server:
1. Install from [ollama.com](https://ollama.com)
2. Start the server and pull a model:
```bash
ollama serve
ollama pull qwen3:0.6b
```
3. Pull a model:
```bash
ollama pull qwen3:8b
```
Or pull directly via the Jarvis CLI:
```bash
jarvis model pull qwen3:8b
```
4. Verify the engine is detected:
```bash
jarvis model list
```
3. Verify: `jarvis model list`
!!! tip "Best for: Apple Silicon Macs, consumer NVIDIA GPUs, CPU-only systems"
### vLLM (High-throughput serving)
### vLLM
vLLM provides high-throughput serving optimized for datacenter GPUs.
High-throughput serving optimized for datacenter GPUs.
1. Install vLLM following the [official guide](https://docs.vllm.ai)
2. Start the server:
1. Install following the [official guide](https://docs.vllm.ai)
2. Start: `vllm serve Qwen/Qwen2.5-7B-Instruct`
3. Auto-detected at `http://localhost:8000`
```bash
vllm serve Qwen/Qwen2.5-7B-Instruct
```
!!! tip "Best for: NVIDIA datacenter GPUs (A100, H100), AMD GPUs"
3. OpenJarvis will auto-detect it at `http://localhost:8000`
### llama.cpp
!!! tip "Best for: NVIDIA datacenter GPUs (A100, H100, L40), AMD GPUs"
Efficient CPU and GPU inference with GGUF quantized models.
### llama.cpp (Lightweight, CPU-friendly)
1. Build from [github.com/ggerganov/llama.cpp](https://github.com/ggerganov/llama.cpp)
2. Start: `llama-server -m /path/to/model.gguf --port 8080`
3. Auto-detected at `http://localhost:8080`
llama.cpp provides efficient CPU and GPU inference with GGUF quantized models.
1. Build llama.cpp from [github.com/ggerganov/llama.cpp](https://github.com/ggerganov/llama.cpp)
2. Start the server:
```bash
llama-server -m /path/to/model.gguf --port 8080
```
3. OpenJarvis will auto-detect it at `http://localhost:8080`
!!! tip "Best for: CPU-only machines, constrained environments, GGUF models"
### SGLang
SGLang provides structured generation and high-performance serving.
1. Install SGLang following the [official guide](https://github.com/sgl-project/sglang)
2. Start the server:
```bash
python -m sglang.launch_server --model Qwen/Qwen2.5-7B-Instruct --port 30000
```
3. OpenJarvis will auto-detect it at `http://localhost:30000`
### Cloud APIs (OpenAI, Anthropic, Google)
For cloud-based inference, install the cloud extras and set your API keys:
### Cloud APIs
```bash
pip install 'openjarvis[inference-cloud,inference-google]'
```
Set environment variables:
```bash
export OPENAI_API_KEY="sk-..."
export ANTHROPIC_API_KEY="sk-ant-..."
export GOOGLE_API_KEY="..."
```
OpenJarvis will automatically detect available cloud providers.
## Next Steps
- [Quick Start](quickstart.md) — Run your first query
docs/index.md
+8 -4
View File
@@ -34,12 +34,16 @@ Everything runs on your hardware. Cloud APIs are optional.
=== "Desktop App"
Download the native desktop app — it bundles Ollama and the Python backend
so everything works out of the box.
The desktop app is a native window for the chat UI. Start the backend first,
then open the app.
[Download for macOS (Apple Silicon)](https://github.com/HazyResearch/OpenJarvis/releases/latest/download/OpenJarvis_aarch64.dmg){ .md-button .md-button--primary }
**1.** Start backend: `git clone ... && cd OpenJarvis && ./scripts/quickstart.sh`
Also available for [macOS (Intel)](https://github.com/HazyResearch/OpenJarvis/releases/latest/download/OpenJarvis_x64.dmg), [Windows](https://github.com/HazyResearch/OpenJarvis/releases/latest/download/OpenJarvis_x64-setup.exe), [Linux (DEB)](https://github.com/HazyResearch/OpenJarvis/releases/latest/download/OpenJarvis_amd64.deb), and [Linux (RPM)](https://github.com/HazyResearch/OpenJarvis/releases/latest/download/OpenJarvis_amd64.rpm). See the [Downloads](downloads.md) page for details.
**2.** Download the app:
[Download for macOS (Apple Silicon)](https://github.com/HazyResearch/OpenJarvis/releases/download/desktop-latest/OpenJarvis_1.0.0_aarch64.dmg){ .md-button .md-button--primary }
Also available for [Windows](https://github.com/HazyResearch/OpenJarvis/releases/download/desktop-latest/OpenJarvis_1.0.0_x64-setup.exe), [Linux (DEB)](https://github.com/HazyResearch/OpenJarvis/releases/download/desktop-latest/OpenJarvis_1.0.0_amd64.deb), and [Linux (RPM)](https://github.com/HazyResearch/OpenJarvis/releases/download/desktop-latest/OpenJarvis-1.0.0-1.x86_64.rpm). See [Installation](getting-started/installation.md#desktop-app) for details.
=== "Python SDK"
mkdocs.yml
-1
View File
@@ -124,7 +124,6 @@ extra:
nav:
- Home: index.md
- Downloads: downloads.md
- Getting Started:
- Installation: getting-started/installation.md
- Quick Start: getting-started/quickstart.md