Omega Memory

SSE

by omega-memory

2.9k downloads Not rated yet

GitHub Website

About

Persistent memory for AI coding agents with semantic search, contradiction detection, memory decay, and cross-session learning. 25 MCP tools, local-first, #1 on LongMemEval (95.4%).

Details

Transport: SSE

Explore

Setting up with Highlight

This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:

Download and install Highlight from highlightai.com/download
Navigate to the plugins tab and select "Add Custom Plugin"
Configure the plugin with the settings below

Plugin Name Omega Memory

Command (node, npx, python, etc.)

Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.
Enable "Start Automatically" if you want the plugin to start when Highlight launches

Setting up with Cursor

Open Cursor's settings
Navigate to the MCP section
Click "Add new Global MCP server"
Copy and paste the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "omega memory": {
            "server": {
                "command": "uvx",
                "args": [
                    "omega-memory"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "omega memory": {
            "server": {
                "command": "uvx",
                "args": [
                    "omega-memory"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "omega memory": {
            "server": {
                "command": "uvx",
                "args": [
                    "omega-memory"
                ]
            }
        }
    }
}

Setting up with Claude Desktop

Open Claude Desktop's settings
Go to the Integrations tab
Click "Add MCP Server"
Use the configuration below based on your operating system

Note: Make sure Claude Desktop is running before attempting to connect.

JSON

{
    "mcpServers": {
        "omega memory": {
            "server": {
                "command": "uvx",
                "args": [
                    "omega-memory"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "omega memory": {
            "server": {
                "command": "uvx",
                "args": [
                    "omega-memory"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "omega memory": {
            "server": {
                "command": "uvx",
                "args": [
                    "omega-memory"
                ]
            }
        }
    }
}

Setting up with Windsurf

Open Windsurf's preferences
Go to the Integrations section
Click "Add MCP Integration"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "omega memory": {
            "server": {
                "command": "uvx",
                "args": [
                    "omega-memory"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "omega memory": {
            "server": {
                "command": "uvx",
                "args": [
                    "omega-memory"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "omega memory": {
            "server": {
                "command": "uvx",
                "args": [
                    "omega-memory"
                ]
            }
        }
    }
}

Setting up with Cline

Open Cline's settings
Navigate to the Integrations section
Click "Add MCP Server"
Copy and paste the configuration below based on your operating system

Note: Make sure to restart Cline after adding the configuration.

JSON

{
    "mcpServers": {
        "omega memory": {
            "server": {
                "command": "uvx",
                "args": [
                    "omega-memory"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "omega memory": {
            "server": {
                "command": "uvx",
                "args": [
                    "omega-memory"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "omega memory": {
            "server": {
                "command": "uvx",
                "args": [
                    "omega-memory"
                ]
            }
        }
    }
}

Setting up with Goose

Open Goose's preferences
Go to the Integrations tab
Select "MCP Servers"
Click "Add New Server"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "omega memory": {
            "server": {
                "command": "uvx",
                "args": [
                    "omega-memory"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "omega memory": {
            "server": {
                "command": "uvx",
                "args": [
                    "omega-memory"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "omega memory": {
            "server": {
                "command": "uvx",
                "args": [
                    "omega-memory"
                ]
            }
        }
    }
}

`omega_store`

Store a memory with optional type and metadata. Use when the user says 'remember this' or for programmatic capture (decisions, lessons, errors). Defaults to type 'memory' if event_type is omitted.

`omega_query`

Search memories — semantic (default) or exact phrase match. Use mode='phrase' for literal substring search (error messages, specific strings).

`omega_welcome`

Get a session welcome briefing with recent relevant memories and user profile.

`omega_profile`

Read or update the user profile. Returns the profile by default. If 'update' dict is provided, merges those fields into the profile and saves.

`omega_delete_memory`

Delete a specific memory by its ID.

`omega_edit_memory`

Edit the content of a specific memory.

`omega_list_preferences`

List all stored user preferences.

`omega_health`

Detailed health check with memory usage, node counts, cache stats, warnings, and recommendations.

`omega_backup`

Export or import memories for backup/restore. Default mode is export.

`omega_lessons`

Retrieve cross-session or cross-project lessons learned, ranked by verification count and access frequency.

`omega_feedback`

Record feedback on a surfaced memory (helpful, unhelpful, outdated). Improves future surfacing quality.

`omega_clear_session`

Clear all memories for a specific session. Use for cleanup after test sessions.

`omega_similar`

Find memories similar to a given memory. Use for discovering related context.

`omega_timeline`

Show memory timeline grouped by day. Use to see what was captured recently.

`omega_consolidate`

Run memory consolidation: prune stale low-value memories, cap session summaries, clean orphaned edges. Returns a report.

`omega_traverse`

Traverse the memory relationship graph from a starting memory. Shows all connected memories within N hops, useful for understanding context chains and discovering related knowledge clusters.

`omega_compact`

Compact related memories into consolidated knowledge nodes. Finds clusters of similar memories (same event type, high overlap) and creates summary nodes, marking originals as superseded. Reduces noise while preserving knowledge.

`omega_checkpoint`

Save a task checkpoint — captures current plan, progress, files touched, decisions, and key context. Use when: (1) context window is getting full, (2) completing a major milestone, (3) before starting a new session for an ongoing task. Checkpoints enable seamless session continuity.

`omega_resume_task`

Resume a previously checkpointed task. Retrieves the latest checkpoint with full plan, progress, files, decisions, and next steps. Use at the start of a new session to continue where you left off.

`omega_remind`

Set a time-based reminder. OMEGA will surface it when the time arrives (at session start or during active sessions). Use for 'remind me in 1 hour to...' requests.

`omega_remind_list`

List active reminders with their status and due times.

`omega_remind_dismiss`

Dismiss a reminder by its ID. Use after acknowledging a reminder.

`omega_type_stats`

Get memory counts grouped by event type. Shows the composition of the memory store (how many decisions, lessons, errors, etc.).

`omega_session_stats`

Get memory counts grouped by session. Shows which sessions have contributed the most memories (top 20).

`omega_weekly_digest`

Get a weekly knowledge digest with stats, trends, and highlights. Shows new memories, session count, growth trends, type breakdown, and top topics.

`omega_protocol`

Get your coordination playbook — dynamically assembled operating instructions. Call at session start (step 2 after omega_welcome) or when you need protocol guidance. Returns context-sensitive rules based on project, peer activity, and learned lessons.

Claude Desktop / Cursor

Paste into your MCP client config file to install this server.

{
    "mcpServers": {
        "omega memory": {
            "server": {
                "command": "uvx",
                "args": [
                    "omega-memory"
                ]
            }
        }
    }
}

McpServers

{
    "server": {
        "command": "uvx",
        "args": [
            "omega-memory"
        ]
    }
}

Transport

"stdio"

Package

"omega-memory"

Registry

"pypi"

Cross-model memory for AI agents. Local-first. Works with Claude, GPT, Gemini, Cursor, Claw Code, and any MCP client.Your agent's brain shouldn't live on someone else's server, or be locked to one provider.

AI coding agents are stateless. Every new session starts from zero. The "solutions" either lock you into one model provider or send your codebase context to their cloud.

- Context loss.Agents forget every decision, preference, and architectural choice between sessions. Developers spend 10-30 minutes per session re-explaining context that was already established.
- Repeated mistakes.Without learning from past sessions, agents make the same errors over and over. They don't remember what worked, what failed, or why a particular approach was chosen.
- Cloud memory = someone else's database.Services like Mem0 require API keys and send your data to their servers. When they change pricing, get acquired, or go down, your agent's accumulated intelligence disappears.
- Vendor lock-in.Anthropic's Memory Tool only works with Claude. OpenAI's memory only works with GPT. Switch models, lose your memory.

OMEGA solves this. Memory, coordination, and learning that runs entirely on your machine. Works with every major LLM and coding agent. No cloud. No API keys. No vendor lock-in.

pip install omega-memory[server] # Full install (memory + MCP server) omega setup # Downloads model, registers MCP, installs hooks omega doctor # Verify everything works

pip install omega-memory[server] omega setup --client claude-desktop

This registers OMEGA as an MCP server in Claude Desktop's config. Restart Claude Desktop to activate.

Cursor, Claw Code, Windsurf, Cline, Codex

pip install omega-memory[server] omega setup --client cursor # or: claw-code, windsurf, cline, codex

If you only need OMEGA as a Python library for scripts, CI/CD, or automation:

pip install omega-memory # Core only, no MCP server process

from omega import store, query, remember store("Always use TypeScript strict mode", "user_preference") results = query("TypeScript preferences")

This gives you the full storage and retrieval API without running an MCP server (~50 MB lighter, no background process). Hooks still work:

omega setup --hooks-only # Auto-capture + memory surfacing, no MCP server (~600MB RAM saved)

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

- Create~/.omega/directory
- Download the ONNX embedding model (~90 MB) to~/.cache/omega/models/
- Registeromega-memoryas an MCP server (Claude Code auto-detected, or specify --client)
- Install session hooks into~/.claude/settings.json
- Add an OMEGA block to~/.claude/CLAUDE.md

OMEGA works through natural language — no API calls, no configuration. Just talk to Claude.

Claude stores this as a permanent memory with semantic embeddings.

"What did I decide about authentication?"

OMEGA surfaces the relevant memory automatically:

That's it. Memories persist across sessions, accumulate over time, and are surfaced automatically when relevant — even if you don't explicitly ask.

Memory & Learning— Stores decisions, lessons, error patterns, and preferences with semantic search. Claude recalls what matters without you re-explaining everything each session. 25 memory tools including compaction, consolidation, timeline, graph traversal, and context virtualization (checkpoint/resume).

Multi-Agent Coordination(omega-pro)— File and branch locking, session management, task queues with dependencies, intent broadcasting, and agent-to-agent messaging. 29 coordination tools that prevent agents from overwriting each other's work.

Intelligent LLM Routing(omega-pro)— Classifies tasks and routes to the optimal model. Coding → Claude Sonnet. Quick edit → Llama 8b at 1/60th the cost. 1M token context → Gemini Flash. 5 providers, 4 priority modes, sub-2ms intent classification.

Knowledge Base(omega-pro)— Ingest PDFs, markdown, web pages, and text files into a searchable knowledge base with semantic chunking.

Entity Registry(omega-pro)— Multi-entity corporate memory with relationships, hierarchies, and entity-scoped memories/profiles/documents.

Secure Profile(omega-pro)— AES-256 encrypted personal data storage with macOS Keychain integration.

Anthropic's Memory Tool stores data client-side but requires Claude API calls for all memory operations. OMEGA runs entirely on-device, including embeddings (ONNX).

Anthropic Memory is for Anthropic. OMEGA is for everyone.

Claude Code · Cursor · Claw Code · Any MCP Client │ │ │ │ └─────────┴─────┬───┴──────────────┘ │ stdio/MCP ┌───────────────▼─────────────┐ │ OMEGA MCP Server │ │ 25 core tools │ └──┬──────────────────┘ │ ┌────────▼──────────────┐ │ Core Memory Engine │ │ (semantic search, │ │ embeddings, graphs) │ └─────┬─────────────────┘ │ ▼ ┌──────────────────────────────────────┐ │ omega.db (SQLite) │ │ memories | edges | embeddings │ └──────────────────────────────────────┘

Single database, modular handlers. Optional modules (coordination, router, entity, knowledge, profile) are available viaomega-proand register into the same server process. No separate daemons, no microservices.

OMEGA runs as an MCP server inside Claude Code. The core package provides 25 memory tools.omega-proadds coordination, routing, entity, knowledge, and profile tools.

All hooks dispatch viafast_hook.py→ daemon UDS socket, with fail-open semantics.

With omega-pro, additional coordination handlers register automatically: session lifecycle, file/branch claim guards, heartbeat, and git push guards.
- Vector similarityvia sqlite-vec (cosine distance, 384-dim bge-small-en-v1.5)
- Full-text searchvia FTS5 (fast keyword matching)
- Type-weighted scoring(decisions/lessons weighted 2x)
- Contextual re-ranking(boosts by tag, project, and content match)
- Deduplicationat query time

- Dedup: SHA256 hash (exact) + embedding similarity 0.85+ (semantic) + Jaccard per-type
- Evolution: Similar content (55-95%) appends new insights to existing memories
- TTL: Session summaries expire after 1 day, lessons/preferences are permanent
- Auto-relate: Createsrelatededges (similarity >= 0.45) to top-3 similar memories
- Compaction: Clusters and summarizes related memories

- Startup: ~31 MB RSS
- After first query (ONNX model loaded): ~337 MB RSS
- Database: ~10.5 MB for ~242 memories

omega setupmodifies these files outside~/.omega/:

- ~/.claude.json— Addsomega-memoryMCP server entry
- ~/.claude/settings.json— Adds hook entries
- ~/.claude/CLAUDE.md— Adds a managedblock

- Ensurepip install -e ".[server]"from the repo root
- Checkpython3 -c "import omega"works

- Runpip install omega-memory[server](the[server]extra includes the MCP package)

claude mcp add omega-memory -- python3 -m omega.server.mcp_server

- Check~/.claude/settings.jsonhas OMEGA hook entries
- Check~/.omega/hooks.logfor errors

pip install -e ".[server,dev]" pytest tests/ # 2198+ tests ruff check src/ # Lint

claude mcp remove omega-memory rm -rf ~/.omega ~/.cache/omega pip uninstall omega-memory

Manually remove OMEGA entries from~/.claude/settings.jsonand theblock from~/.claude/CLAUDE.md.

- Contributing Guide
- Security Policy
- Changelog
- Report a Bug

This is a web browser that enables your coding agent, such as Claude Code, to visit websites on your behalf and assist you in identifying bugs or creating UI test cases.

Local code analysis MCP server with 25+ tools: semantic search, call graph tracing, dependency analysis, and symbol navigation. Built with Tree-sitter and CozoDB. Supports Go, Python, JS, TS.

A local-first code indexer that enhances LLMs with deep code understanding. It integrates with AI assistants via the Model Context Protocol (MCP) and supports AI-powered semantic search.

A server for managing structured project context using SQLite, with support for vector embeddings for semantic search and Retrieval Augmented Generation (RAG).

MCP of MCPs is a meta-server that merges all your MCP servers into a single smart endpoint. It gives AI agents instant tool discovery, selective schema loading, and massively cheaper execution, so you stop wasting tokens and time. With persistent tool metadata, semantic search, and direct code execution between tools, it turns chaotic multi-server setups into a fast, efficient, hallucination-free workflow. It also automatically analyzes the tools output schemas if not exist and preserves them across sessions for consistent behavior.

An MCP server for intelligent semantic search and automatic learning within codebases, allowing AI agents to efficiently query and index project artifacts.

Stdio MCP server that exposes zkShare tools to AI clients: store encrypted context, proofs, semantic search, sharing, and sandbox calls via POST /api/v1/context with ZKSHARE_API_KEY.

Embeddings, vector search, document storage, and full-text search with the open-source AI application database

Semantic search through Dickens' classic tale. Find passages by meaning, theme, or concept - not just keywords.

An MCP server providing semantic search capabilities for APLCart data.

MCP server for Christian scholarship and research — scripture, Greek/Hebrew word data, cross-references, patristic texts, and semantic search,

No reviews yet — be the first

Use Google, GitHub, or an email account so ratings stay tied to real people.

Email sign in

No reviews posted yet.

About

Details

Explore

Setting up with Highlight

omega_store

omega_query

omega_welcome

omega_profile

omega_delete_memory

omega_edit_memory

omega_list_preferences

omega_health

omega_backup

omega_lessons

omega_feedback

omega_clear_session

omega_similar

omega_timeline

omega_consolidate

omega_traverse

omega_compact

omega_checkpoint

omega_resume_task

omega_remind

omega_remind_list

omega_remind_dismiss

omega_type_stats

omega_session_stats

omega_weekly_digest

omega_protocol

Claude Desktop / Cursor

McpServers

Transport

Package

Registry

Cursor, Claw Code, Windsurf, Cline, Codex

More like this

Sequential Thinking

Aws Kb Retrieval Server

Memory

Sentry

`omega_store`

`omega_query`

`omega_welcome`

`omega_profile`

`omega_delete_memory`

`omega_edit_memory`

`omega_list_preferences`

`omega_health`

`omega_backup`

`omega_lessons`

`omega_feedback`

`omega_clear_session`

`omega_similar`

`omega_timeline`

`omega_consolidate`

`omega_traverse`

`omega_compact`

`omega_checkpoint`

`omega_resume_task`

`omega_remind`

`omega_remind_list`

`omega_remind_dismiss`

`omega_type_stats`

`omega_session_stats`

`omega_weekly_digest`

`omega_protocol`