### Manual Backend and Frontend Setup

Source: https://github.com/open-jarvis/openjarvis/blob/main/docs/downloads.md

Step-by-step commands to manually install dependencies, start the Ollama service, and launch the backend and frontend servers.

```bash
# Step 1: Clone and install
git clone https://github.com/open-jarvis/OpenJarvis.git
cd OpenJarvis
uv sync --extra server
cd frontend && npm install && cd ..

# Step 2: Start Ollama
ollama serve &
ollama pull qwen3:0.6b

# Step 3: Start backend
uv run jarvis serve --port 8000

# Step 4: Start frontend
cd frontend
npm run dev
```

--------------------------------

### OpenJarvis CLI: Serve Command Examples (Bash)

Source: https://context7.com/open-jarvis/openjarvis/llms.txt

Shows how to start an OpenAI-compatible API server using the `jarvis serve` command. Examples cover starting with default settings, customizing host, port, and model, and using an agent for agentic completions.

```bash
# Start server with defaults
jarvis serve

# Custom host, port, and model
jarvis serve --host 0.0.0.0 --port 8000 -m qwen3:8b

# With agent for agentic completions
jarvis serve --agent orchestrator -e ollama
```

--------------------------------

### Quickstart Installation Script

Source: https://github.com/open-jarvis/openjarvis/blob/main/docs/getting-started/installation.md

Automated shell script to clone the repository and initialize the environment, including dependency checks and server startup.

```bash
git clone https://github.com/open-jarvis/OpenJarvis.git
cd OpenJarvis
./scripts/quickstart.sh
```

--------------------------------

### Install and Start OpenJarvis Server

Source: https://github.com/open-jarvis/openjarvis/blob/main/docs/getting-started/quickstart.md

Instructions for installing the server dependencies and launching the API server with custom configurations.

```bash
uv sync --extra server
jarvis serve --port 8000
jarvis serve --host 0.0.0.0 --port 8000 --engine ollama --model qwen3:8b --agent orchestrator
```

--------------------------------

### Manual Environment Setup

Source: https://github.com/open-jarvis/openjarvis/blob/main/docs/getting-started/installation.md

Step-by-step manual configuration for cloning, installing Python and Rust dependencies, and building the local backend.

```bash
git clone https://github.com/open-jarvis/OpenJarvis.git
cd OpenJarvis
uv sync --extra server
uv run maturin develop -m rust/crates/openjarvis-python/Cargo.toml
cd frontend && npm install && cd ..
```

--------------------------------

### Setup Development Environment

Source: https://github.com/open-jarvis/openjarvis/blob/main/docs/development/contributing.md

Commands to clone the repository and install dependencies using uv. This includes standard development dependencies and optional extras for specific backends.

```bash
git clone https://github.com/open-jarvis/OpenJarvis.git
cd OpenJarvis
uv sync --extra dev

# Optional extras
uv sync --extra dev --extra memory-faiss --extra memory-colbert --extra memory-bm25
uv sync --extra dev --extra inference-cloud --extra inference-google
uv sync --extra dev --extra server
uv sync --extra dev --extra docs
```

--------------------------------

### Install and Start OpenJarvis API Server

Source: https://github.com/open-jarvis/openjarvis/blob/main/docs/deployment/api-server.md

Commands to clone the repository, install server dependencies, and launch the API server with custom configurations.

```bash
git clone https://github.com/open-jarvis/OpenJarvis.git
cd OpenJarvis
uv sync --extra server
jarvis serve
jarvis serve --host 0.0.0.0 --port 8000 --engine ollama --model qwen3:8b --agent orchestrator
```

--------------------------------

### Setting Up vLLM Inference Backend

Source: https://github.com/open-jarvis/openjarvis/blob/main/docs/getting-started/installation.md

Instructions for setting up the vLLM inference backend. It involves installing vLLM following their guide and starting the server with a specified model. It's auto-detected at http://localhost:8000.

```bash
vllm serve Qwen/Qwen2.5-7B-Instruct
```

--------------------------------

### Ollama Inference Backend Setup

Source: https://github.com/open-jarvis/openjarvis/blob/main/docs/getting-started/installation.md

Commands to start the Ollama service and pull the required starter model for local inference.

```bash
ollama serve &
ollama pull qwen3:0.6b
```

--------------------------------

### Setting Up Ollama Inference Backend

Source: https://github.com/open-jarvis/openjarvis/blob/main/docs/getting-started/installation.md

Provides commands to install Ollama, start the server, and pull a model. This is the recommended inference backend for ease of use.

```bash
ollama serve
ollama pull qwen3:0.6b
```

--------------------------------

### Install Optional Extras for OpenJarvis

Source: https://github.com/open-jarvis/openjarvis/blob/main/docs/getting-started/installation.md

Demonstrates how to install optional extras for OpenJarvis using 'uv sync --extra'. Examples include installing 'inference-cloud', 'memory-faiss', and combining multiple extras.

```bash
uv sync --extra inference-cloud
uv sync --extra memory-faiss
uv sync --extra server --extra memory-faiss --extra inference-cloud
```

--------------------------------

### Initialize and Run NativeOpenHandsAgent

Source: https://github.com/open-jarvis/openjarvis/blob/main/docs/architecture/agents.md

Shows the setup for the NativeOpenHandsAgent, which supports both tool invocation and direct Python code execution. This example includes configuration for token limits and turn constraints.

```python
from openjarvis.agents.native_openhands import NativeOpenHandsAgent

agent = NativeOpenHandsAgent(
    engine,
    model="qwen3:8b",
    tools=[CalculatorTool(), WebSearchTool()],
    max_turns=3,
    max_tokens=2048,
)
result = agent.run("Summarize https://example.com/article")
```

--------------------------------

### Setup Development Environment for Contributors

Source: https://github.com/open-jarvis/openjarvis/blob/main/README.md

Commands to install development dependencies, configure pre-commit hooks, and run the test suite for the OpenJarvis project.

```bash
git clone https://github.com/open-jarvis/OpenJarvis.git
cd OpenJarvis
uv sync --extra dev
uv run pre-commit install
uv run pytest tests/ -v
```

--------------------------------

### Full Jarvis Workflow Example

Source: https://github.com/open-jarvis/openjarvis/blob/main/docs/user-guide/python-sdk.md

A comprehensive example demonstrating initialization, document indexing, standard and full queries with tools, memory searching, and final resource cleanup.

```python
from openjarvis import Jarvis

j = Jarvis(model="qwen3:8b")
result = j.memory.index("./docs/")
response = j.ask("What are the main features?")
full_result = j.ask_full("Calculate the square root of 256 and add 10", agent="orchestrator", tools=["calculator"])
results = j.memory.search("configuration")
j.close()
```

--------------------------------

### Complete Working Example (Python SDK)

Source: https://github.com/open-jarvis/openjarvis/blob/main/docs/getting-started/quickstart.md

A comprehensive Python example demonstrating indexing, searching, asking questions, using agents, listing models, and cleaning up with the OpenJarvis SDK.

```APIDOC
## Complete Working Example

Here is a complete end-to-end session combining multiple features:

```python
from openjarvis import Jarvis

# Initialize with defaults (auto-detect hardware and engine)
j = Jarvis()

# 1. Index some documentation
index_result = j.memory.index("./docs/", chunk_size=512)
print(f"Indexed {index_result['chunks']} chunks from {index_result['path']}")

# 2. Search memory
results = j.memory.search("how to configure engines")
for r in results:
    print(f"  [{r['score']:.3f}] {r['source']}")

# 3. Ask a question (memory context is injected automatically)
answer = j.ask("How do I configure the Ollama engine host?")
print(f"\nAnswer: {answer}")

# 4. Use an agent with tools
calc_result = j.ask_full(
    "Calculate the compound interest on $10,000 at 5% for 10 years",
    agent="orchestrator",
    tools=["calculator", "think"],
)
print(f"\nCalculation: {calc_result['content']}")
print(f"Tools used: {[t['tool_name'] for t in calc_result['tool_results']]}")
print(f"Agent turns: {calc_result['turns']}")

# 5. List available models
models = j.list_models()
print(f"\nAvailable models: {models}")

# 6. Clean up
j.close()
```
```

--------------------------------

### Python SDK Quick Example

Source: https://github.com/open-jarvis/openjarvis/blob/main/docs/downloads.md

A simple example demonstrating how to use the Jarvis class for basic queries.

```APIDOC
## OpenJarvis Python SDK Quick Example

### Description
Demonstrates the basic usage of the `Jarvis` class to ask questions.

### Method
Python

### Endpoint
N/A

### Parameters
N/A

### Request Example
```python
from openjarvis import Jarvis

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

### Response
```
Output of the question asked.
```
```

--------------------------------

### Starting the OpenJarvis API Server

Source: https://github.com/open-jarvis/openjarvis/blob/main/docs/getting-started/quickstart.md

Instructions on how to start the OpenJarvis API server, including default and custom configurations.

```APIDOC
## Starting the API Server

OpenJarvis provides an OpenAI-compatible API server for integration with existing tools and frontends.

!!! note "Requires the `server` extra"
    ```bash
    uv sync --extra server
    ```

### Start the Server

```bash
jarvis serve --port 8000
```

With custom options:

```bash
jarvis serve --host 0.0.0.0 --port 8000 --engine ollama --model qwen3:8b --agent orchestrator
```
```

--------------------------------

### OpenJarvis CLI: Chat Command Examples (Bash)

Source: https://context7.com/open-jarvis/openjarvis/llms.txt

Illustrates how to use the `jarvis chat` CLI command for interactive multi-turn conversations. Examples include starting a basic chat, specifying models and agents, using custom system prompts, and lists in-chat commands for session management.

```bash
# Start interactive chat
jarvis chat

# With specific model and agent
jarvis chat -m qwen3:8b -a orchestrator --tools calculator,web_search

# With custom system prompt
jarvis chat --system "You are a helpful coding assistant"

# In-chat commands:
#   /quit, /exit  - end session
#   /clear        - clear conversation history
#   /model        - show current model
#   /history      - show conversation
#   /help         - available commands
```

--------------------------------

### Install and Load launchd Service

Source: https://github.com/open-jarvis/openjarvis/blob/main/docs/deployment/launchd.md

Copies the OpenJarvis launchd plist file to the user's LaunchAgents directory and loads it, enabling the service to start automatically at login and upon loading. It also includes verification steps.

```bash
cp deploy/launchd/com.openjarvis.plist ~/Library/LaunchAgents/
launchctl load ~/Library/LaunchAgents/com.openjarvis.plist
launchctl list | grep openjarvis
curl http://localhost:8000/health
```

--------------------------------

### OpenJarvis Configuration Example (TOML)

Source: https://github.com/open-jarvis/openjarvis/blob/main/docs/architecture/intelligence.md

An example TOML configuration file demonstrating how to set the default engine, default model, and a preferred engine for specific models.

```toml
[engine]
default = "ollama"

[intelligence]
default_model = "llama3.2:3b"
model_path = "./models/llama-3.2-3b.Q4_K_M.gguf"
quantization = "gguf_q4"
preferred_engine = "llamacpp"
```

--------------------------------

### CLI Installation and Verification

Source: https://github.com/open-jarvis/openjarvis/blob/main/docs/getting-started/installation.md

Commands to install the CLI tool, verify the version, and execute initial diagnostic or interaction commands.

```bash
git clone https://github.com/open-jarvis/OpenJarvis.git
cd OpenJarvis
uv sync
uv run maturin develop -m rust/crates/openjarvis-python/Cargo.toml
jarvis --version
jarvis ask "What is the capital of France?"
jarvis doctor
```

--------------------------------

### OpenJarvis Configuration Example

Source: https://github.com/open-jarvis/openjarvis/blob/main/docs/user-guide/channels.md

Example TOML configuration file for OpenJarvis, showing how to enable channels and set platform-specific bot tokens for Telegram, Discord, and Slack.

```toml
[channel]
enabled = true
default_channel = ""
default_agent = "simple"

[channel.telegram]
bot_token = "YOUR_TELEGRAM_BOT_TOKEN"

[channel.discord]
bot_token = "YOUR_DISCORD_BOT_TOKEN"

[channel.slack]
bot_token = "YOUR_SLACK_BOT_TOKEN"
app_token = "YOUR_SLACK_APP_TOKEN"
```

--------------------------------

### Implement ReadyScreen Component

Source: https://github.com/open-jarvis/openjarvis/blob/main/docs/superpowers/plans/2026-03-26-deep-research-phase2b-frontend.md

The ReadyScreen component serves as the final confirmation view once data indexing is complete. It provides a welcoming interface and suggests example queries to help the user get started.

```tsx
import { Sparkles } from "lucide-react";

interface Props {
  connectedSources: string[];
  onStart: (query?: string) => void;
}

const SUGGESTIONS = [
  "What were the key decisions from last week's team threads?",
  "Find the proposal doc shared about the roadmap",
  "Summarize my unread emails from today",
  "What meetings do I have this week?",
  "What topics came up in recent meetings?",
];

export function ReadyScreen({ connectedSources, onStart }: Props) {
  return (
    <div className="flex flex-col items-center gap-8 px-8 py-16 max-w-2xl mx-auto text-center">
      <div className="w-16 h-16 rounded-2xl bg-green-500/10 flex items-center justify-center">
        <Sparkles size={32} className="text-green-400" />
      </div>

      <div>
        <h2 className="text-2xl font-semibold" style={{ color: "var(--color-text)" }}>
          You're All Set!
        </h2>
        <p className="mt-2 text-sm opacity-60">
          {connectedSources.length} source{connectedSources.length !== 1 ? "s" : ""} connected and indexed. Ask anything across your data.
        </p>
      </div>
    </div>
  );
}
```

--------------------------------

### Initialize and Run OpenJarvis Quick Start

Source: https://github.com/open-jarvis/openjarvis/blob/main/README.md

Steps to initialize the environment, set up the Ollama inference backend, and execute a query using the Jarvis CLI.

```bash
git clone https://github.com/open-jarvis/OpenJarvis.git
cd OpenJarvis
uv sync
uv run jarvis init
curl -fsSL https://ollama.com/install.sh | sh
ollama serve &
ollama pull qwen3:8b
uv run jarvis ask "What is the capital of France?"
```

--------------------------------

### Build and Serve Documentation

Source: https://github.com/open-jarvis/openjarvis/blob/main/docs/development/contributing.md

Commands to install documentation dependencies, serve the site locally with hot-reloading, or build the static site.

```bash
uv sync --extra docs
uv run mkdocs serve --dev-addr 127.0.0.1:8001
uv run mkdocs build
```

--------------------------------

### Initialize OpenJarvis Environment

Source: https://github.com/open-jarvis/openjarvis/blob/main/docs/downloads.md

Clones the repository and executes the quickstart script to set up the local backend and dependencies.

```bash
git clone https://github.com/open-jarvis/OpenJarvis.git && cd OpenJarvis
./scripts/quickstart.sh
```

--------------------------------

### System Health Check

Source: https://github.com/open-jarvis/openjarvis/blob/main/docs/deployment/api-server.md

Examples of healthy and unhealthy responses for the GET /health endpoint.

```json
{"status": "ok"}
```

```json
{"detail": "Engine unhealthy"}
```

--------------------------------

### Retrieve Available Models

Source: https://github.com/open-jarvis/openjarvis/blob/main/docs/deployment/api-server.md

Example response for the GET /v1/models endpoint, listing all models available on the inference engine.

```json
{
  "object": "list",
  "data": [
    {
      "id": "qwen3:8b",
      "object": "model",
      "created": 1740100800,
      "owned_by": "openjarvis"
    },
    {
      "id": "llama3.1:8b",
      "object": "model",
      "created": 1740100800,
      "owned_by": "openjarvis"
    }
  ]
}
```

--------------------------------

### Project Setup with uv

Source: https://github.com/open-jarvis/openjarvis/blob/main/CONTRIBUTING.md

Clones the OpenJarvis repository and sets up the development environment using uv, including development dependencies.

```bash
git clone https://github.com/open-jarvis/OpenJarvis.git
cd OpenJarvis
uv sync --extra dev
```

--------------------------------

### Initialize BM25 Retrieval Backend

Source: https://github.com/open-jarvis/openjarvis/blob/main/docs/user-guide/memory.md

Demonstrates how to install the necessary dependencies and initialize the BM25 memory-based retrieval backend for keyword-based search.

```bash
uv sync --extra memory-bm25
```

```python
backend = MemoryRegistry.create("bm25")
backend.store("Python is a programming language", source="intro.txt")
results = backend.retrieve("programming language")
```

--------------------------------

### OpenJarvis CLI: Ask Command Examples (Bash)

Source: https://context7.com/open-jarvis/openjarvis/llms.txt

Provides examples of using the `jarvis ask` CLI command to send queries to the assistant. It covers basic questions, specifying models and engines, using agents with tools, controlling generation parameters like temperature and max tokens, outputting as JSON, disabling context, and viewing telemetry profiles.

```bash
# Basic question
jarvis ask "What is the capital of France?"

# Specify model and engine
jarvis ask -m qwen3:8b -e ollama "Explain quantum entanglement"

# Use agent with tools
jarvis ask --agent orchestrator --tools calculator,think "What is 2^10?"

# Control generation parameters
jarvis ask -t 0.2 --max-tokens 2048 "Write a poem about AI"

# Output as JSON
jarvis ask --json "Hello world"

# Disable memory context injection
jarvis ask --no-context "Hello"

# Show inference telemetry profile
jarvis ask --profile "What is machine learning?"
# Output includes: latency, tokens, throughput, energy consumption, GPU metrics
```

--------------------------------

### Setup System User and Environment

Source: https://github.com/open-jarvis/openjarvis/blob/main/docs/deployment/systemd.md

Commands to create a dedicated system user, set up a virtual environment, and clone the OpenJarvis repository for deployment.

```bash
sudo useradd --system --create-home --home-dir /opt/openjarvis openjarvis
sudo -u openjarvis python3 -m venv /opt/openjarvis/.venv
sudo -u openjarvis git clone https://github.com/open-jarvis/OpenJarvis.git /opt/openjarvis/OpenJarvis
cd /opt/openjarvis/OpenJarvis && sudo -u openjarvis uv sync --extra server
```

--------------------------------

### OpenJarvis Scheduler Python API Example

Source: https://github.com/open-jarvis/openjarvis/blob/main/docs/user-guide/scheduler.md

Example demonstrating the usage of the OpenJarvis Python API for the task scheduler. It covers setting up storage, initializing the scheduler with a Jarvis system, creating tasks, listing active tasks, managing task states (pause, resume, cancel), and starting the background execution thread.

```python
from openjarvis.scheduler.store import SchedulerStore
from openjarvis.scheduler.scheduler import TaskScheduler

# Set up storage
store = SchedulerStore(db_path="~/.openjarvis/scheduler.db")  # (1)!

# Wire in a JarvisSystem for task execution
from openjarvis import Jarvis
jarvis = Jarvis()

scheduler = TaskScheduler(
    store=store,
    system=jarvis,         # (2)!
    poll_interval=60,      # (3)!
)

# Create tasks
daily_summary = scheduler.create_task(
    prompt="Summarize the latest news headlines",
    schedule_type="cron",
    schedule_value="0 8 * * *",
    agent="simple",
)
print(f"Created task {daily_summary.id}, next run: {daily_summary.next_run}")

# List active tasks
for task in scheduler.list_tasks(status="active"):
    print(f"  {task.id}: {task.prompt} @ {task.next_run}")

# Manage task state
scheduler.pause_task(daily_summary.id)
scheduler.resume_task(daily_summary.id)   # next_run recomputed from now
scheduler.cancel_task(daily_summary.id)  # permanent

# Start the background thread
scheduler.start()   # (4)!
```

--------------------------------

### Setting Up llama.cpp Inference Backend

Source: https://github.com/open-jarvis/openjarvis/blob/main/docs/getting-started/installation.md

Details on setting up the llama.cpp inference backend. This includes building the project from source and starting the llama server with a model file and port. It's auto-detected at http://localhost:8080.

```bash
llama-server -m /path/to/model.gguf --port 8080
```

--------------------------------

### Configure Ngrok Tunnel for Webhooks

Source: https://github.com/open-jarvis/openjarvis/blob/main/docs/user-guide/channels.md

Provides the shell commands required to install and start an ngrok tunnel, which is necessary for exposing the local OpenJarvis webhook endpoint to external services like SendBlue.

```bash
brew install ngrok
ngrok config add-authtoken YOUR_TOKEN
ngrok http 8222
```

--------------------------------

### Tauri Development Setup and Build Commands

Source: https://github.com/open-jarvis/openjarvis/blob/main/desktop/README.md

Commands to set up the development environment for the OpenJarvis desktop application using Node.js and Cargo. Includes installation, running in development mode with hot-reloading, and building for production.

```bash
# Prerequisites: Node.js 22+, Rust stable, system deps (see below)

cd desktop
npm install
cargo tauri dev    # Hot-reload development mode
cargo tauri build  # Production build
```

--------------------------------

### Build and Execute System with OpenJarvis (Python)

Source: https://context7.com/open-jarvis/openjarvis/llms.txt

Demonstrates how to build a custom OpenJarvis system by specifying the engine, model, agent, and tools. It also shows how to execute queries through the system, retrieve results, and handle tool outputs. Finally, it includes closing the system connection.

```python
system = (
    SystemBuilder()
    .engine("ollama")
    .model("qwen3:8b")
    .agent("orchestrator")
    .tools(["calculator", "web_search", "think", "file_read"])
    .telemetry(True)
    .sessions(True)
    .build()
)

result = system.ask(
    "Search the web for recent AI news and summarize",
    agent="orchestrator",
    tools=["web_search", "think"],
    temperature=0.7
)
print(result["content"])
print(result["tool_results"])

system.close()
```

--------------------------------

### Get Max ROWID from Chat Database (Python)

Source: https://github.com/open-jarvis/openjarvis/blob/main/docs/superpowers/plans/2026-03-27-channel-gateway-deep-research.md

Retrieves the maximum ROWID from the 'message' table in the SQLite chat database. This is used to determine the starting point for polling new messages. Handles operational errors by returning 0.

```Python
def _get_max_rowid(db_path: str) -> int:
    """Get the current max ROWID from chat.db."""
    try:
        conn = sqlite3.connect(f"file:{db_path}?mode=ro", uri=True)
        row = conn.execute("SELECT MAX(ROWID) FROM message").fetchone()
        conn.close()
        return row[0] or 0
    except sqlite3.OperationalError:
        return 0
```

--------------------------------

### Initialize Test Environment and Run Tests

Source: https://github.com/open-jarvis/openjarvis/blob/main/docs/superpowers/plans/2026-03-26-deep-research-agent-v2.md

Commands to prepare the test directory and execute the test suite for the newly implemented SQL tool.

```bash
touch tests/tools/__init__.py
uv run pytest tests/tools/test_knowledge_sql.py -v --tb=short
```

--------------------------------

### Verify OpenJarvis CLI Installation

Source: https://github.com/open-jarvis/openjarvis/blob/main/docs/downloads.md

Checks the installed version of the OpenJarvis CLI.

```bash
jarvis --version
```

--------------------------------

### Python SDK Installation

Source: https://github.com/open-jarvis/openjarvis/blob/main/docs/downloads.md

Instructions to clone the repository and install the OpenJarvis Python SDK.

```APIDOC
## Install OpenJarvis Python SDK

### Description
Clone the repository and install the OpenJarvis package for programmatic access.

### Method
Shell commands

### Endpoint
N/A

### Parameters
N/A

### Request Example
```bash
git clone https://github.com/open-jarvis/OpenJarvis.git
cd OpenJarvis
pip install .
```

### Response
N/A
```

--------------------------------

### OpenJarvis CLI Verification

Source: https://github.com/open-jarvis/openjarvis/blob/main/docs/downloads.md

Verify the installation by checking the installed version of the jarvis CLI.

```APIDOC
## Verify OpenJarvis CLI Installation

### Description
Check the installed version of the jarvis CLI to confirm successful installation.

### Method
Shell command

### Endpoint
N/A

### Parameters
N/A

### Request Example
```bash
jarvis --version
```

### Response
```
jarvis, version 0.1.0
```
```

--------------------------------

### OpenJarvis CLI Installation

Source: https://github.com/open-jarvis/openjarvis/blob/main/docs/downloads.md

Instructions to clone the repository and install OpenJarvis using pip.

```APIDOC
## Install OpenJarvis CLI

### Description
Clone the repository and install the OpenJarvis package.

### Method
Shell commands

### Endpoint
N/A

### Parameters
N/A

### Request Example
```bash
git clone https://github.com/open-jarvis/OpenJarvis.git
cd OpenJarvis
pip install .
```

### Response
N/A
```

--------------------------------

### Initialize and Use FAISS Memory Backend

Source: https://github.com/open-jarvis/openjarvis/blob/main/docs/user-guide/memory.md

Shows how to install dependencies and initialize the FAISS backend for semantic vector-based retrieval.

```bash
uv sync --extra memory-faiss
```

```python
backend = MemoryRegistry.create("faiss")
doc_id = backend.store("Neural networks are computational models")
results = backend.retrieve("deep learning architectures")
```

--------------------------------

### Enable and Disable OpenJarvis Service on Boot

Source: https://github.com/open-jarvis/openjarvis/blob/main/docs/deployment/systemd.md

Configure whether the OpenJarvis service should automatically start when the system boots up. Use `systemctl enable` to ensure it starts on boot and `systemctl disable` to prevent it from starting automatically.

```bash
# Enable automatic start on boot
sudo systemctl enable openjarvis

# Disable automatic start on boot
sudo systemctl disable openjarvis
```

--------------------------------

### Verify Installation

Source: https://github.com/open-jarvis/openjarvis/blob/main/docs/development/contributing.md

Commands to verify the OpenJarvis installation by checking the version and displaying help documentation.

```bash
uv run jarvis --version
uv run jarvis --help
```

--------------------------------

### Example OpenJarvis Configuration

Source: https://github.com/open-jarvis/openjarvis/blob/main/docs/getting-started/configuration.md

Sample TOML configuration files for Apple Silicon and NVIDIA Datacenter environments.

```toml
[engine]
default = "ollama"

[engine.ollama]
host = "http://localhost:11434"

[intelligence]
default_model = "qwen3:8b"
fallback_model = "llama3.2:3b"
temperature = 0.7
max_tokens = 1024
```

--------------------------------

### Install OpenJarvis CLI

Source: https://github.com/open-jarvis/openjarvis/blob/main/docs/downloads.md

Installs the OpenJarvis CLI by cloning the repository and synchronizing dependencies using uv.

```bash
git clone https://github.com/open-jarvis/OpenJarvis.git
cd OpenJarvis
uv sync
```

--------------------------------

### Discover and List Models with OpenJarvis Engines

Source: https://github.com/open-jarvis/openjarvis/blob/main/docs/architecture/engine.md

Demonstrates how to initialize the engine discovery process and retrieve a mapping of available models across all healthy engines. This requires a loaded configuration object.

```python
from openjarvis.engine import discover_engines, discover_models
from openjarvis.core.config import load_config

config = load_config()
engines = discover_engines(config)
models = discover_models(engines)
# Output: {"ollama": ["qwen3:8b", "llama3.2:3b"], "vllm": ["mistral:7b"]}
```

--------------------------------

### Initialize and Use SQLite Memory Backend

Source: https://github.com/open-jarvis/openjarvis/blob/main/docs/user-guide/memory.md

Demonstrates how to initialize the default SQLite FTS5 backend and perform basic storage and retrieval operations.

```python
from openjarvis.core.registry import MemoryRegistry

backend = MemoryRegistry.create("sqlite", db_path="./memory.db")
doc_id = backend.store("Hello world", source="test.txt")
results = backend.retrieve("hello")
backend.close()
```

--------------------------------

### Configure OpenJarvis to Start After Ollama

Source: https://github.com/open-jarvis/openjarvis/blob/main/docs/deployment/systemd.md

Ensure the OpenJarvis service starts only after the Ollama service is running by adding `After=ollama.service` and `Requires=ollama.service` to the `[Unit]` section of the systemd service file. `Requires` ensures OpenJarvis won't start if Ollama fails.

```ini
[Unit]
Description=OpenJarvis API Server
After=network.target ollama.service
Requires=ollama.service
```

--------------------------------

### Single-Run Configuration with Full Options

Source: https://github.com/open-jarvis/openjarvis/blob/main/docs/user-guide/evaluations.md

An advanced configuration example showing all available options for meta-information, default parameters, judge configuration, run settings, and detailed model and benchmark specifications.

```APIDOC
## Single-Run Configuration with Full Options

### Description
This configuration showcases a comprehensive setup for a single evaluation run, including metadata, default generation parameters, judge configuration, execution settings, and detailed specifications for the model and benchmark.

### Method
N/A (Configuration File)

### Endpoint
N/A (Configuration File)

### Parameters
#### Meta
- **name** (str) - Optional - Suite name shown in CLI output.
- **description** (str) - Optional - Human-readable description of the evaluation.

#### Defaults
- **temperature** (float) - Optional - Default sampling temperature (0.0).
- **max_tokens** (int) - Optional - Default maximum output tokens (2048).

#### Judge
- **model** (str) - Optional - Judge model identifier (default: `"gpt-4o"`).
- **provider** (str) - Optional - Provider override for the judge model (e.g., `"openai"`).
- **temperature** (float) - Optional - Judge sampling temperature (0.0).
- **max_tokens** (int) - Optional - Maximum judge output tokens (1024).

#### Run
- **max_workers** (int) - Optional - Number of parallel evaluation threads (4).
- **output_dir** (str) - Optional - Directory for output files (default: `"results/"`).
- **seed** (int) - Optional - Random seed for dataset shuffling (42).
- **telemetry** (bool) - Optional - Enable GPU telemetry capture (false).
- **gpu_metrics** (bool) - Optional - Enable GPU metric polling (false).

#### Models (per model)
- **name** (str) - Required - Model identifier (e.g., `"qwen3:8b"`).
- **engine** (str) - Optional - Engine key (e.g., `"ollama"`).
- **provider** (str) - Optional - Provider override for cloud models.
- **temperature** (float) - Optional - Override default temperature for this model.
- **max_tokens** (int) - Optional - Override default max tokens for this model.
- **param_count_b** (float) - Optional - Model parameter count in billions (0.0).
- **active_params_b** (float) - Optional - Active parameters per token in billions (defaults to `param_count_b`).
- **gpu_peak_tflops** (float) - Optional - GPU peak FP16 TFLOPS (0.0).
- **gpu_peak_bandwidth_gb_s** (float) - Optional - GPU peak memory bandwidth in GB/s (0.0).
- **num_gpus** (int) - Optional - Number of GPUs used (1).

#### Benchmarks (per benchmark)
- **name** (str) - Required - Benchmark key (e.g., `"supergpqa"`).
- **backend** (str) - Optional - Inference backend (`"jarvis-direct"` or `"jarvis-agent"`).
- **max_samples** (int) - Optional - Limit number of samples (None evaluates full dataset).
- **split** (str) - Optional - Override default dataset split.
- **agent** (str) - Optional - Agent name for `jarvis-agent` backend.
- **tools** (list[str]) - Optional - Tool names for `jarvis-agent` backend ([]).
- **judge_model** (str) - Optional - Override `[judge].model` for this benchmark.
- **temperature** (float) - Optional - Override temperature for this benchmark.
- **max_tokens** (int) - Optional - Override max tokens for this benchmark.

### Request Example
```toml
[meta]
name = "single-run-example"
description = "Evaluate SuperGPQA with a single model and full configuration"

[defaults]
temperature = 0.0
max_tokens = 2048

[judge]
model = "gpt-4o"
temperature = 0.0
max_tokens = 1024

[run]
max_workers = 4
output_dir = "results/"
seed = 42

[[models]]
name = "qwen3:8b"
engine = "ollama"
temperature = 0.3
max_tokens = 4096

[[benchmarks]]
name = "supergpqa"
backend = "jarvis-direct"
max_samples = 100
split = "train"
```

### Response
N/A (This is a configuration file, not an API endpoint.)
```

--------------------------------

### Start API Server

Source: https://github.com/open-jarvis/openjarvis/blob/main/docs/user-guide/cli.md

Launches an OpenAI-compatible API server. Requires the 'server' extra dependencies and supports custom host, port, model, and agent configurations.

```bash
uv sync --extra server
jarvis serve
jarvis serve --port 8000
jarvis serve --host 0.0.0.0 --port 9000
jarvis serve --model qwen3:8b
jarvis serve --agent orchestrator
```