### Development Setup

Source: https://omegamax.co/docs/contributing

Clone the repository, install development dependencies, and run the initial setup command.

```bash
git clone https://github.com/omega-memory/omega.git
cd omega
pip install -e ".[dev]"
omega setup

```

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

### Setup OMEGA Environment

Source: https://omegamax.co/docs/reference/cli

Initializes the OMEGA environment by creating necessary directories, downloading embedding models, setting up the database, registering the MCP server, installing hooks, and updating CLAUDE.md. Use `--download-model` to fetch the bge-small-en-v1.5 ONNX model and `--client` to configure specific client settings.

```bash
omega setup [--download-model] [--client {claude-code}]
```

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

### Setup Mobile Access

Source: https://omegamax.co/docs/reference/cli

Prints setup instructions for mobile access using mcp-proxy and Tailscale.

```bash
omega mobile setup

```

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

### Initialize Session with Welcome Briefing

Source: https://omegamax.co/docs/api-reference

Call `omega_welcome` at the start of every session to get a briefing including recent memories and user profile. It requires the project path for scoping.

```shell
$omega_welcome(project="/Users/me/myapp")
```

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

### Configure Cloud Sync with Supabase

Source: https://omegamax.co/docs/getting-started/configuration

If `omega-memory[cloud]` is installed, use `omega cloud setup` to configure Supabase credentials. These are stored in `~/.omega/secrets.json`.

```bash
omega cloud setup
```

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

### Install OMEGA with All Dependencies

Source: https://omegamax.co/docs/troubleshooting

Install OMEGA along with all its optional dependencies, including 'onnxruntime', using a single command.

```bash
pip install "omega-memory[all]"

```

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

### Install Omega Memory from Source

Source: https://omegamax.co/docs/getting-started/installation

Clone the repository, navigate to the directory, and install Omega Memory with development dependencies.

```bash
git clone https://github.com/omega-memory/omega.git
cd omega
pip install -e ".[dev]"
omega setup
```

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

### Run Omega Memory Setup Wizard

Source: https://omegamax.co/docs/getting-started/installation

Execute the setup wizard to create the storage directory, download the embedding model, and configure MCP server and hooks.

```bash
omega setup
```

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

### Install All Omega Memory Modules

Source: https://omegamax.co/docs/getting-started/installation

Install Omega Memory with all optional modules, including router, entity, knowledge-pdf, encrypt, and cloud.

```bash
pip install omega-memory[full]
```

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

### Install Core Omega Memory

Source: https://omegamax.co/docs/getting-started/installation

Install the core package including memory and coordination tools. This is suitable for most users.

```bash
pip install omega-memory
```

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

### Install Omega Memory with Cloud Sync

Source: https://omegamax.co/docs/getting-started/installation

Install Omega Memory with Supabase cloud sync for cross-device memory sharing.

```bash
pip install omega-memory[cloud]
```

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

### Install Omega Memory with PDF Ingestion

Source: https://omegamax.co/docs/getting-started/installation

Install Omega Memory with PDF ingestion capabilities using Docling for high-quality extraction.

```bash
pip install omega-memory[knowledge-pdf]
```

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

### Install ONNX Runtime

Source: https://omegamax.co/docs/troubleshooting

Install the 'onnxruntime' package if it's missing, which is required for embedding generation.

```bash
pip install onnxruntime

```

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

### Install Omega Memory with Entity Registry

Source: https://omegamax.co/docs/getting-started/installation

Install Omega Memory with tools for managing entities and organizational structures, including encryption support.

```bash
pip install omega-memory[entity]
```

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

### Search Memories Semantically

Source: https://omegamax.co/docs/api-reference

Use `omega_query` with the default 'semantic' mode to search memories based on meaning. This example searches for memories related to 'authentication setup'. Results are ranked by relevance.

```shell
$omega_query(query="authentication setup")
```

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

### Install Omega Memory with Lite PDF Ingestion

Source: https://omegamax.co/docs/getting-started/installation

Install a lighter version of Omega Memory's PDF ingestion using pdfplumber.

```bash
pip install omega-memory[knowledge-pdf-lite]
```

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

### Install sqlite-vec for Vector Search

Source: https://omegamax.co/docs/troubleshooting

Install the 'sqlite-vec' extension to enable efficient vector similarity search. OMEGA falls back to hash-based search if this is unavailable.

```bash
pip install sqlite-vec

```

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

### Verify API Key Setup

Source: https://omegamax.co/docs/guides/router

Run this command to check which LLM providers have valid API keys configured and available for use by the router.

```bash
omega_router_status
# Shows which providers have valid keys
```

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

### Quick Example: Storing and Querying Memories

Source: https://omegamax.co/docs/guides/memory

Demonstrates basic memory operations: storing a decision, querying for relevant information, and remembering a user-provided text.

```python
# Store a decision
omega_store(content="Use PostgreSQL for the analytics service — need window functions and JSONB", event_type="decision")

# Query later
omega_query(query="database choice for analytics")

# User says "remember this"
omega_remember(text="Deploy window is Tuesdays 2-4pm PST")

```

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

### Install Omega Memory with LLM Routing

Source: https://omegamax.co/docs/getting-started/installation

Install Omega Memory with additional tools for routing prompts to various LLM providers like OpenAI and Anthropic.

```bash
pip install omega-memory[router]
```

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

### Verify Omega Memory Installation

Source: https://omegamax.co/docs/getting-started/installation

Run the doctor command to check the installation status of Python, database, embedding model, MCP server, hooks, and CLAUDE.md.

```bash
omega doctor
```

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

### Example Output of Omega Doctor

Source: https://omegamax.co/docs/getting-started/installation

This is an example of the output you can expect when running the 'omega doctor' command, showing the status of various checks.

```text
OMEGA Doctor — v1.2.0
─────────────────────
[OK] Python 3.12.4
[OK] Database: ~/.omega/omega.db (254 memories)
[OK] Embedding model: bge-small-en-v1.5-onnx
[OK] MCP server registered in ~/.claude.json
[OK] 7 hooks installed in ~/.claude/settings.json
[OK] CLAUDE.md has OMEGA block

All checks passed.

```

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

### Querying Omega Before Tasks

Source: https://omegamax.co/docs/guides/memory

Run `omega_query` at the start of non-trivial tasks to identify prior decisions and potential issues.

```bash
omega_query
```

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

### Install Omega Memory with Encryption

Source: https://omegamax.co/docs/getting-started/installation

Install Omega Memory with AES-256 encrypted secure profile storage and macOS Keychain integration.

```bash
pip install omega-memory[encrypt]
```

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

### Retrieve Coordination Playbook

Source: https://omegamax.co/docs/api-reference

Use `omega_protocol` to get dynamically assembled operating instructions. Specify the desired section and project path for context-sensitive rules. Call this after `omega_welcome` or when protocol guidance is needed.

```shell
$omega_protocol(section="memory")
```

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

### omega_protocol

Source: https://omegamax.co/docs/api-reference

Retrieves your coordination playbook, which are dynamically assembled operating instructions. Call this at the session start (after omega_welcome) or when protocol guidance is needed.

```APIDOC
## omega_protocol

### Description
Get your coordination playbook: dynamically assembled operating instructions. Call at session start (step 2 after omega_welcome) or when you need protocol guidance.

### Parameters
#### Path Parameters
- **section** (string) - Required - Section to retrieve: 'memory', 'coordination', 'coordination_gate', 'teamwork', 'context', 'reminders', 'diagnostics', 'entity', 'heuristics', 'git', 'what_next'. Groups: 'solo', 'multi_agent', 'full', 'minimal'.
- **project** (string) - Required - Project path for context-sensitive rules.

### Request Example
```
omega_protocol(section="memory", project="/Users/me/myapp")
```

### Response
#### Success Response
[PROTOCOL]Memory section loaded
Store decisions after completing tasks
Query before non-trivial work
Checkpoint when context is filling up
```

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

### Get Session Briefing

Source: https://omegamax.co/docs/reference/python-api

Retrieve a session briefing, including recent memories and user profile information, using the `welcome` function.

```python
welcome(session_id=None, project=None) -> dict
```

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

### Print Supabase SQL Schema

Source: https://omegamax.co/docs/reference/cli

Use this command to print the Supabase SQL schema, which can be used for manual setup.

```bash
omega cloud schema

```

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

### Get Cross-Project Lessons

Source: https://omegamax.co/docs/reference/python-api

Retrieve lessons learned across all projects, with options to exclude specific projects or sessions. Lessons are ranked by verification count and access frequency.

```python
get_cross_project_lessons(task=None, limit=5, exclude_project=None, exclude_session=None) -> list
```

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

### Serve Mobile Data via HTTP

Source: https://omegamax.co/docs/reference/cli

Starts an mcp-proxy HTTP server for mobile access. You can specify the port and host address.

```bash
omega mobile serve [--port PORT] [--host HOST]

```

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

### OMEGA Session Start Briefing

Source: https://omegamax.co/docs/getting-started/quickstart

When a Claude Code session starts, OMEGA provides a welcome briefing with memory counts, project context, and upcoming tasks.

```text
## Welcome back! OMEGA ready — 254 memories | my-project | main
[CONTEXT] Recent: deployed v2.1, fixed auth bug, added rate limiting
[TODO] Next: implement webhook retry logic
```

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

### Warm Up Router at Session Start

Source: https://omegamax.co/docs/guides/router

Pre-loads the classifier into memory at the beginning of a session to eliminate initial routing latency. This reduces first-route latency significantly.

```python
omega_warm_router()
```

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

### Store User Preference Memory

Source: https://omegamax.co/docs/api-reference

Use `omega_store` to save memories, such as user preferences. This example stores a preference for using 'bun' over 'npm'. The `event_type` can be specified, and priority is auto-set if omitted.

```shell
$omega_store(
content="Always use bun instead of npm",
event_type="user_preference"
)
```

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

### Get Cross-Session Lessons

Source: https://omegamax.co/docs/reference/python-api

Retrieve lessons learned across different sessions, ranked by verification count and access frequency. Exclusions for specific projects or sessions can be applied.

```python
get_cross_session_lessons(task=None, limit=5, project_path=None, exclude_project=None, exclude_session=None) -> list
```

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

### Get System Status Overview

Source: https://omegamax.co/docs/reference/python-api

Retrieve a summary of system status, including memory count, database size, model status, and edge count, using the `status` function.

```python
status() -> dict
```

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

### Register Peer's Public Key for Trust

Source: https://omegamax.co/docs/guides/federation

Use `omega_federation_trust_add` to register a peer's Ed25519 public key, allowing future imports from that peer. This is a one-time setup for new peers.

```bash
# On instance B: first time accepting from A — register A's public key
omega_federation_trust_add(
    public_key_pem="<A's public key>",
    label="instance-A",
)
→ trusted peer added: fingerprint 9f1c… label instance-A

```

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

### Configure Router API Keys in secrets.json

Source: https://omegamax.co/docs/getting-started/configuration

If `omega-memory[router]` is installed, configure API keys by editing the `~/.omega/secrets.json` file. Protect this file with `chmod 600`.

```json
{
  "anthropic_api_key": "sk-ant-...",
  "openai_api_key": "sk-...",
  "google_api_key": "...",
  "groq_api_key": "gsk_...",
  "xai_api_key": "xai-..."
}
```

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

### Install OMEGA Hooks

Source: https://omegamax.co/docs/getting-started/configuration

Command to reinstall OMEGA hooks into the Claude Code configuration. This re-enables automatic memory capture, surfacing, and coordination guards.

```bash
omega setup --install-hooks

```

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

### Run OMEGA MCP Server

Source: https://omegamax.co/docs/reference/cli

Starts the MCP server in stdio mode. This command is primarily used internally by Claude Code and is not typically called directly by users.

```bash
omega serve
```

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

### Get Pre-Session Briefing with Market Type Filter

Source: https://omegamax.co/docs/guides/oracle

Obtain a pre-session briefing filtered by a specific market type. This provides relevant historical context for probability estimation tasks.

```python
omega_oracle_analyze(view="briefing", market_type="btc")
```

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

### Store, Retrieve, and List Profile Data

Source: https://omegamax.co/docs/guides/profile

Demonstrates basic operations for setting, getting, and listing profile data. Use `omega_profile_set` to store data, `omega_profile_get` to retrieve decrypted data, and `omega_profile_list` to see available categories and field counts.

```python
# Store sensitive data
omega_profile_set(category="identity", field_name="passport_number", value="X12345678",
    metadata={"issuing_country": "US", "expires": "2032-06"})

# Retrieve and decrypt
omega_profile_get(category="identity", field_name="passport_number")
# Returns: "X12345678" (decrypted on-device)

# See what's stored without decrypting
omega_profile_list()
# Returns: identity (3 fields), financial (2 fields), contacts (5 fields)

# Search metadata (not encrypted values)
omega_profile_search(query="passport")

```

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

### Compacting Similar Lessons

Source: https://omegamax.co/docs/guides/memory

Use `omega_compact` to cluster numerous similar lessons, such as repeated debugging insights, into concise summaries.

```bash
omega_compact
```

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

### omega_welcome

Source: https://omegamax.co/docs/api-reference

Retrieves a session welcome briefing, including recent relevant memories and user profile information. This function should be called at the beginning of every session.

```APIDOC
## omega_welcome

### Description
Get a session welcome briefing with recent relevant memories and user profile. Call this first at the start of every session.

### Parameters
#### Path Parameters
- **project** (string) - Required - Project path for scoping the briefing.
- **session_id** (string) - Required - Session identifier for continuity tracking.

### Request Example
```
omega_welcome(project="/Users/me/myapp", session_id="session-123")
```

### Response
#### Success Response
[WELCOME]Session briefing ready
Profile: 12 encrypted fields
Recent: 3 decisions, 2 lessons
Tasks: 2 pending checkpoints
```

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

### Get Oracle Briefing

Source: https://omegamax.co/docs/guides/oracle

Obtain a comprehensive briefing that includes all analytical views of the Oracle. This is useful for getting a complete overview before making new predictions.

```python
omega_oracle_analyze(view="briefing")
```

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

### Configure OMEGA Cloud Sync

Source: https://omegamax.co/docs/reference/cli

Sets up the Supabase connection for cloud synchronization. Requires the Supabase project URL (`--url`) and anon key (`--key`). A service role key (`--service-key`) can also be provided optionally.

```bash
omega cloud setup [--url URL] [--key KEY] [--service-key KEY]
```

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

### Basic Routing Workflow

Source: https://omegamax.co/docs/guides/router

Demonstrates setting a priority mode and then routing multiple prompts. The router selects different models based on the prompt's intent and the 'balanced' priority.

```python
omega_set_priority_mode(mode="balanced")

omega_route_prompt(prompt="Implement a rate limiter with sliding window")
# Returns: Anthropic/Claude Opus 4.6 (coding intent, quality match)

omega_route_prompt(prompt="Fix the typo in the README")
# Returns: Groq/Llama 3.1 8B (simple_edit intent, speed match)
```

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

### Verify OMEGA Installation Health

Source: https://omegamax.co/docs/reference/cli

Checks the health of the OMEGA installation, including imports, embedding model, database, MCP registration, and hooks. The `--client` option can be used to include client-specific checks.

```bash
omega doctor [--client {claude-code}]
```

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

### Record a Regime Change

Source: https://omegamax.co/docs/guides/oracle

Log a transition between market regimes. This helps in understanding how market conditions evolve and impact predictions.

```python
omega_oracle_record(
    record_type="regime_change",
    content="Market shifted from accumulation to markup phase",
    data={"from_regime": "accumulation", "to_regime": "markup", "confidence": 0.85}
)
```

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

### Get User Profile

Source: https://omegamax.co/docs/reference/python-api

Retrieve the user profile, which is constructed from patterns identified in memories, using `get_profile`.

```python
get_profile() -> dict
```

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

### Take a Session Snapshot

Source: https://omegamax.co/docs/guides/coordination

Create a snapshot of the current session state before performing risky operations like rebases or large refactors. This allows for recovery if something goes wrong.

```python
omega_session_snapshot(session_id="agent-1", reason="Before rebase onto main")

```

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

### Get Memory Type Statistics

Source: https://omegamax.co/docs/reference/python-api

Obtain memory counts grouped by their event types using `type_stats`.

```python
type_stats() -> dict
```

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

### Backup OMEGA Database

Source: https://omegamax.co/docs/reference/cli

Creates a backup of the `omega.db` file to the `~/.omega/backups/` directory, keeping the last 5 backups.

```bash
omega backup
```

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

### Retrieve Session Context

Source: https://omegamax.co/docs/reference/python-api

Get the current session context for handoff or resuming a session using `get_session_context`.

```python
get_session_context(session_id, project=None) -> dict
```

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

### Create Entities and Relationships

Source: https://omegamax.co/docs/guides/entity

Create a holding company and a subsidiary, then define their relationship and view the organizational tree. This is useful for establishing corporate structures.

```python
# Create a holding company and subsidiary
omega_entity_create(entity_id="holdco", name="Holding Company Inc", entity_type="c_corp", jurisdiction="US-DE")
omega_entity_create(entity_id="acme", name="Acme LLC", entity_type="llc", jurisdiction="US-WY")

# Define the relationship
omega_entity_add_relationship(source_entity_id="holdco", target_entity_id="acme", relationship_type="parent_of",
    metadata={"ownership_pct": 100, "year": 2024})

# View the hierarchy
omega_entity_tree(entity_id="holdco")

# Store entity-scoped data
omega_store(content="Acme uses Stripe for payment processing", event_type="decision", entity_id="acme")

```

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

### Get Recent Activity Summary

Source: https://omegamax.co/docs/reference/python-api

Retrieve an overview of recent session activity over a specified number of days using `get_activity_summary`.

```python
get_activity_summary(days=7) -> dict
```

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

### Get Session Statistics

Source: https://omegamax.co/docs/reference/python-api

View memory counts grouped by session, showing the top 20 sessions with the most memories, using `session_stats`.

```python
session_stats() -> dict
```

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

### Get Deduplication Statistics

Source: https://omegamax.co/docs/reference/python-api

View statistics related to memory deduplication, such as the number of duplicates found, evolved, or blocked, using `get_dedup_stats`.

```python
get_dedup_stats() -> dict
```

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

### Perform Context-Aware Search for Memories

Source: https://omegamax.co/docs/guides/memory

Boost search results by providing context files or tags that are relevant to your current work. This helps prioritize memories related to your active project.

```python
omega_query(
    query="error handling patterns",
    context_file="src/api/handler.py",
    context_tags=["python", "fastapi"]
)

```

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

### Get Router Context Information

Source: https://omegamax.co/docs/guides/router

Retrieves information about the current model, provider, token count, and conversation depth for a given session.

```python
omega_router_context(session_id="agent-1")
# Returns: current model, provider, token count, conversation depth
```

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

### Sync OMEGA Data to Cloud

Source: https://omegamax.co/docs/reference/cli

Synchronizes local OMEGA data to the Supabase cloud.

```bash
omega cloud sync
```

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

### Import Verified and Trusted Memory Subset

Source: https://omegamax.co/docs/guides/federation

Use `omega_federation_import` to perform a trust check and merge a signed manifest into the local store. It records `federation_origin` lineage and handles de-duplication.

```bash
# Import: trust-check + merge
omega_federation_import(path="manifest-2026-Q1.json")
→ 148 imported, 4 already_local (idempotent dedup)
  each row carries federation_origin: A, manifest-2026-Q1.json

```

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

### Store and Query Entity- and Project-Scoped Memories

Source: https://omegamax.co/docs/guides/entity

Organize memories by scoping them to both an entity and a specific project using omega_store and omega_query.

```python
# Store a memory scoped to both entity and project
omega_store(content="Decided to use Next.js 16 for the redesign", event_type="decision",
    entity_id="acme", project="website-redesign")

# Query memories for a specific project
omega_query(query="tech stack decisions", entity_id="acme", project="website-redesign")
```

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

### Performing Manual Backups

Source: https://omegamax.co/docs/guides/memory

Execute `omega_backup` to export all data. Manual backups are recommended before critical operations, supplementing the weekly auto-maintenance backups.

```bash
omega_backup(filepath="~/omega-backup.json")
```

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

### Verify Supabase Connection

Source: https://omegamax.co/docs/reference/cli

Use this command to verify that the Supabase connection is working correctly.

```bash
omega cloud verify

```

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

### Set and Get Entity-Scoped Profiles

Source: https://omegamax.co/docs/guides/entity

Manage profile data for an entity using omega_profile_set and omega_profile_get. omega_profile_search allows for querying profile fields.

```python
omega_profile_set(category="financial", field_name="ein", value="98-7654321", entity_id="acme-llc")
omega_profile_get(category="financial", entity_id="acme-llc")
omega_profile_search(query="ein", entity_id="acme-llc")
```

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

### Agent 1: Register and Claim Files

Source: https://omegamax.co/docs/guides/coordination

Agent 1 registers its session, specifies capabilities and task, and then claims exclusive access to a specific file for a given task.

```python
# Agent 1: Register and claim files
omega_session_register(session_id="agent-1", capabilities=["code", "test"], task="Implement auth module")
omega_file_claim(session_id="agent-1", file_path="/src/auth.py", task="Adding OAuth flow")
```

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

### Configuring Tool Profile for OMEGA HTTP Daemon (launchd)

Source: https://omegamax.co/docs/guides/tool-profiles

Add the OMEGA_MODE environment variable to the `EnvironmentVariables` section of the launchd plist file for the OMEGA HTTP daemon. Remember to reload the service.

```xml
launchctl unload ~/Library/LaunchAgents/com.omega.mcp-daemon.plist
launchctl load ~/Library/LaunchAgents/com.omega.mcp-daemon.plist
```

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

### Temporarily Set OMEGA_HOME Environment Variable

Source: https://omegamax.co/docs/getting-started/configuration

Demonstrates how to set the OMEGA_HOME environment variable for a single command execution. This is useful for testing or temporary configuration changes.

```bash
OMEGA_HOME=/path/to/storage omega doctor

```

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

### Running Tests

Source: https://omegamax.co/docs/contributing

Execute tests using pytest, with options for coverage and specific files. Includes linting with ruff.

```bash
pytest tests/                          # All tests
pytest tests/ --cov=omega              # With coverage
pytest tests/test_bridge.py -v         # Single file
ruff check src/ tests/                 # Lint

```

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

### Configure Router API Keys via Environment Variables

Source: https://omegamax.co/docs/getting-started/configuration

Alternatively, API keys for router integration can be set as environment variables. Ensure these are kept secure.

```bash
export ANTHROPIC_API_KEY="sk-ant-..."
export OPENAI_API_KEY="sk-..."
export GOOGLE_API_KEY="..."
export GROQ_API_KEY="gsk_..."
export XAI_API_KEY="xai-..."
```

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

### Inventory Check with Entity Scoping

Source: https://omegamax.co/docs/guides/profile

Use `omega_profile_list` to get an inventory of stored data. It can be used globally or scoped to a specific `entity_id` to see counts of fields per category.

```python
omega_profile_list()
# identity: 4 fields
# financial: 2 fields
# contacts: 7 fields

omega_profile_list(entity_id="acme")
# financial: 1 field
# professional: 1 field

```

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

### Retrieve Cross-Session Lessons

Source: https://omegamax.co/docs/guides/memory

Rank and retrieve lessons learned across different projects, ordered by how often they have been verified. Useful for finding robust solutions.

```python
omega_lessons(task="setting up CI pipeline", limit=5, cross_project=True)

```

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

### Get Memory Type Breakdown

Source: https://omegamax.co/docs/api-reference

Use the 'types' action with omega_stats to retrieve a breakdown of memory types currently stored in the system. This helps in understanding the distribution of different memory categories.

```bash
omega_stats(action="types")
```

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

### OMEGA Knowledge CLI Commands

Source: https://omegamax.co/docs/guides/knowledge

Command-line interface for managing the OMEGA knowledge base, including scanning, listing, and searching documents.

```bash
omega knowledge scan                          # Scan default directory
omega knowledge scan --directory /path/to/docs  # Scan custom directory
omega knowledge list                          # List all documents
omega knowledge search "authentication flow"  # Search documents
```

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

### Benchmark Router Performance

Source: https://omegamax.co/docs/guides/router

Verifies the correct functioning of the router by running sample prompts and reporting accuracy and routing decisions.

```python
omega_router_benchmark()
# Runs 6 sample prompts, reports intent classification accuracy and routing decisions
```

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

### Check Oracle Status Dashboard

Source: https://omegamax.co/docs/guides/oracle

Get a quick status update on the Oracle's performance, including prediction counts, Brier score, and active regime. This provides a high-level overview of the system's state.

```python
omega_oracle_status()
```

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

### Export Memory Subset and Ship Manifest

Source: https://omegamax.co/docs/guides/federation

Use `omega_federation_export` to create a signed manifest of a memory subset. Ship the generated JSON file to the peer instance.

```bash
# On instance A: export the subset and ship the manifest file to B
omega_federation_export(
    entity_id="incident-response",
    since="2026-02-01",
)
→ wrote manifest-2026-Q1.json
  152 memories, signed by key fingerprint A's-pubkey

```

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

### AI Memory Persistence Comparison

Source: https://omegamax.co/docs/benchmark-report

Illustrates the difference between AI sessions with and without persistent memory. OMEGA ensures context is retained across sessions, unlike systems that reset.

```mermaid
flowchart LR
    subgraph without["Without Persistent Memory"]
        direction LR
        D1["Session 1\n✅ Context built\n✅ Decisions made\n✅ Bugs solved"] -->|"Session ends"| L1["❌ Context lost"]
        L1 --> D2["Session 2\n⚠️ Start from zero\n⚠️ Re-explain everything\n⚠️ Repeat mistakes"]
        D2 -->|"Session ends"| L2["❌ Context lost"]
        L2 --> D3["Session 3\n⚠️ Start from zero\n..."]
    end

    subgraph with["With OMEGA"]
        direction LR
        O1["Session 1\n✅ Context built\n✅ Auto-captured"] -->|"OMEGA persists"| O2["Session 2\n✅ Full context\n✅ Decisions recalled\n✅ Preferences loaded"]
        O2 -->|"OMEGA persists"| O3["Session 3\n✅ Accumulated\n    knowledge"]
    end

    style without fill:#1a1a2e,stroke:#e74c3c,color:#fff
    style with fill:#1a1a2e,stroke:#2ecc71,color:#fff

```

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

### Checkpoint Current Work for Context Virtualization

Source: https://omegamax.co/docs/guides/memory

Save your current work state, including task details, progress, decisions, and key context, when the context window is nearing capacity. This enables resuming work later.

```python
omega_checkpoint(
    task_title="API redesign Phase 2",
    plan="Migrate all endpoints to v2 schema",
    progress="Completed users and orders endpoints. Auth endpoints remain.",
    files_touched={"src/api/users.py": "Migrated to v2 schema", "src/api/orders.py": "Migrated to v2 schema"},
    decisions=["Keep backward compat for v1 until March", "Use Pydantic v2 model_validator"],
    key_context="V2 schema uses camelCase keys. Auth endpoints depend on the new JWT middleware in src/middleware/auth.py.",
    next_steps="Migrate src/api/auth.py and src/api/billing.py, then update integration tests."
)

```

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

### Route Prompt to Optimal LLM

Source: https://omegamax.co/docs/guides/router

This function routes a prompt to the most suitable LLM based on intent, priority, and other factors. It returns the recommended model, provider, and the reasoning behind the choice.

```python
omega_route_prompt(prompt="Write a recursive tree traversal in Python", priority="quality")
# Returns: recommended model, provider, and reasoning
```

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

### Store and Query Entity-Scoped Memories

Source: https://omegamax.co/docs/guides/entity

Use omega_store to save memories and omega_query to retrieve them, both scoped to a specific entity_id.

```python
omega_store(content="Acme uses us-east-1 for all AWS services", event_type="decision", entity_id="acme-llc")
omega_query(query="AWS region", entity_id="acme-llc")
```

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

### Import Core Omega Bridge Functions

Source: https://omegamax.co/docs/reference/python-api

Import essential functions from the omega.bridge module for memory operations and querying.

```python
from omega.bridge import store, query, remember, auto_capture
```

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

### Build Signed Inclusion Proof

Source: https://omegamax.co/docs/guides/audit

Builds a signed inclusion proof for a specific memory version (memver_id). This proves membership without revealing other rows and indicates the proof depth.

```bash
# Build an inclusion proof for one specific decision
omega_audit_inclusion_proof(memver_id="memver_a14f…")
→ wrote inclusion-memver_a14f.json (proof depth 8)
```

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

### Verifying Active Profile with omega_mode Tool

Source: https://omegamax.co/docs/guides/tool-profiles

Call the `omega_mode` tool within an agent session to display the current profile, environment variable settings, loaded modules, and skipped modules. It also suggests commands to restart with different profiles.

```bash
omega_mode()
→ Active profile: solo
  OMEGA_MODE=solo OMEGA_TOOLS_INCLUDE=- OMEGA_TOOLS_EXCLUDE=-
  Loaded modules (11 tools): audit, dreaming, typed
  Skipped modules (106 tools): coordination, entity, federation, ingest,
    knowledge, oracle, profile, router, stores

  To expand, restart the MCP server with one of:
    OMEGA_MODE=team        # solo + coordination + federation
    OMEGA_MODE=enterprise  # everything (alias: all)
    OMEGA_MODE=solo,federation  # additive — pick specific modules
```

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

### OMEGA MCP Server Architecture

Source: https://omegamax.co/docs/architecture

Diagram illustrating the OMEGA MCP server, its core components (memory, coordinator, router), and its interaction with the SQLite database.

```text
               +---------------------+
               |    Claude Code       |
               |  (or any MCP host)   |
               +----------+----------+          
                          | stdio/MCP          
               +----------v----------+          
               |   OMEGA MCP Server   |
               |   70 tools total     |
               +--+---------------+---+
                  |               |
         +--------v--+      +----v---+
         | Core       |      | Router |
         | (memory +  |      | (opt)  |
         |  coord)    |      |        |
         +-----+------+      +---+----+
               |                 |
               v                 v
         +--------------------------------------+
         |         omega.db (SQLite)             |
         |  memories | edges | coord_* tables    |
         +--------------------------------------+

```

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

### Resume Task from Checkpoint

Source: https://omegamax.co/docs/guides/memory

Resume your work in a new session from a previously saved checkpoint. Specify the verbosity level to control the amount of detail restored.

```python
omega_resume_task(task_title="API redesign", verbosity="full")

```

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

### Set API Keys via Environment Variables

Source: https://omegamax.co/docs/guides/router

Alternative method to set API keys using environment variables in your shell configuration file (e.g., `~/.zshrc`).

```bash
export ANTHROPIC_API_KEY="sk-ant-..."
export OPENAI_API_KEY="sk-..."
```

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

### Embedding System Configuration

Source: https://omegamax.co/docs/architecture

Details on the embedding models, runtime, and storage location used by the OMEGA system.

```text
Property| Value  
---|---
Primary model| bge-small-en-v1.5 (384 dimensions)  
Fallback model| all-MiniLM-L6-v2 (384 dimensions)  
Runtime| ONNX Runtime, CPU-only  
CoreML| Disabled (memory leak in Apple's ANE runtime)  
Model location| `~/.cache/omega/models/{model}-onnx/`  
RAM after first query| ~337 MB  
Circuit breaker| Fails open after transient ONNX errors  

```

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

### omega_resume_task

Source: https://omegamax.co/docs/api-reference

Resumes a previously checkpointed task by retrieving the latest checkpoint with full plan, progress, files, decisions, and next steps.

```APIDOC
## omega_resume_task

### Description
Resumes a previously checkpointed task by retrieving the latest checkpoint with full plan, progress, files, decisions, and next steps.

### Parameters
#### Query Parameters
- **task_title** (string) - Optional - Title of the task to resume (semantic search).
- **project** (string) - Optional - Project path to filter checkpoints.
- **limit** (integer) - Optional - Number of checkpoints to retrieve.
- **verbosity** (string) - Optional - 'full' = everything, 'summary' = plan + progress + next, 'minimal' = next steps only.

### Request Example
```
omega_resume_task(task_title="Auth migration")
```

### Response
#### Success Response
- **checkpoint_data** (object) - Contains task title, progress, next steps, and decisions.
```

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

### Set HTTPS Proxy for Model Downloads

Source: https://omegamax.co/docs/troubleshooting

Configure the HTTPS_PROXY environment variable if you are behind a corporate proxy to enable model downloads.

```bash
export HTTPS_PROXY=http://proxy.example.com:8080

```