Knowledge & Memory MCP servers

Persist assistant memory as a lightweight knowledge graph across sessions.

2 tools · create_entities, search_nodes

Sponsored by <a href="https://oiya.ai/?utm_source=github&amp;utm_medium=referral&amp;utm_campaign=openlore&amp;utm_content=sponsor_logo"><img src="assets/oiya-logo.svg" alt="Oiya" height="24" align="absmiddle"></a> OpenLore is a minimal, extensible, agent-native knowledge base that keeps shared context current and inspectable. AI coding agents already know how to explore files with ls, cat, grep, find, pipes, and shell loops. OpenLore gives them that same interface over SSH, backed by your documentation instead of a real machine.

5 tools · Manage identity-scoped access, publish

ContextStream MCPThe production connection for your assistantPlatformCode, memory, media, and project operations ContextCode BetaOptional terminal coding agent in beta Connect your assistant Manual setup Custom MCP Connector Hosted or local Instruction files Keeping it current Troubleshooting Command reference ContextStream's production product is the MCP connection used from the assistant you already have. It is implemented by the Rust MCP server and connects Claude Code, Cursor, Codex, VS Code, and other supported clients to ContextStream's search, memory, and durable project context.

6 tools · Generate operational runbooks, Hand off work to another agent

The Model Context Protocol (MCP) Server enables integration between MCP clients and the Graphlit service. This document outlines the setup process and provides a basic example of using the client. Ingest anything from Slack, Discord, websites, Google Drive, email, Jira, Linear or GitHub into a Graphlit project - and then search and retrieve relevant knowledge within an MCP client like Cursor, Windsurf, Goose or Cline. Your Graphlit project acts as a searchable, and RAG-ready knowledge base across all your developer and product management tools.

6 tools · Ask questions against your project, Crawl and search the web

Give your agent a memory. june-mcp is the official MCP server for Junê — it connects any MCP host (Claude Desktop, Claude Code, and friends) to a June knowledge graph, so your agent can ask, search, and remember against a shared, cited, tenant-isolated memory. This package is a thin, zero-logic connector: all retrieval, graph assembly, and answering happen on the June endpoint you point it at. No engine code lives here — which is why it's small enough to read in one sitting. june-mcp speaks to any June service. Three ways to have one:

6 tools · june_answer, june_enumerate

Versioned memory for AI agents. Store facts, detect conflicts, and track how decisions change over time — exposed as a hosted MCP server. Other memory systems dump everything into your context window and hope for the best. Memstate gives your agent a structured, versioned knowledge base it navigates precisely — load only what you need, know what changed, know when facts conflict. We built an open-source benchmark suite that tests what actually matters for agent memory: can your system store facts, recall them accurately across sessions, detect conflicts when things change, and maintain context as a project evolves?

6 tools · memstate_delete, memstate_get

OpenTusk is agentic storage for AI. It gives your agents and applications a durable, encrypted storage layer backed by the Walrus decentralized network. AI agents need to persist data — conversation context, generated artifacts, shared memory, backups. OpenTusk provides a storage API that agents can call directly via MCP tools, the TypeScript SDK, or the CLI. Files upload to a fast hot cache, sync to Walrus for decentralized durability, and stay encrypted end-to-end when they need to. 1. Create vaults — Vaults organize your files. Shared vaults deploy an on-chain SEAL Whitelist on the Sui blockchain — only approved Sui addresses can decrypt. Public vaults are open and unencrypted. 2. Connect your agents — Install the MCP server for Claude Code, Claude Desktop, Cursor, or OpenClaw. Or use the TypeScript SDK or CLI directly. 3. Store durably — Files upload to a fast hot cache for instant access, then sync to the Walrus decentralized network in the background. No single point of failure.

6 tools · Collaborate via shared vaults, Get notified on state changes

Connect Vilix once. OpenClaw, Hermes, Claude Code, Cursor, Codex, ChatGPT, Claude, Grok, Manus, Copilot, Windsurf, Lovable, and custom MCP tools can all pull the context you meant. Free 7-day Pro trial. No credit card. Free plan stays available. user\_prompt: “continue the launch site” Vilix returns the latest decisions, open tasks, writing rules, and the connected tool history. what did we decide about the launch page? Use the new Vilix mark, show the memory loop, keep the trial CTA, and make mobile setup obvious.recalled from Vilix memory

5 tools · Carry context across tools, get_context

Self-hosted plain-markdown knowledge base with a built-in MCP server. Lets Claude Desktop, Cursor, and any MCP client search, read, create, edit, tag, and template notes — same vault that powers the web UI. Pure-stdlib client, no extra deps, MIT-licensed. Can run in Docker.

Persistent memory MCP server with OS-style demand paging, kswapd-style eviction, and mlock pinning. Multi-agent shared SQLite store with BM25 + FTS5 retrieval, importance scoring, and capacity-aware reclaim. 5 tools: `memory_lookup`, `pin_memory`, `unpin_memory`, `memory_stats`, `list_pinned`. `uvx --from git+https://github.com/soolaugust/0CompactMem memory-os`

Cognitive memory for AI agents with Hebbian learning, 3-tier architecture, and knowledge graphs. Single ~15MB binary, runs offline on edge devices.

Persistent user identity across AI tools. Stores preferences, lessons, and decisions as local JSON; 13 core MCP tools share them with Claude Code, Cursor, Codex, and any MCP client. Knowledge governance (staging→verified), AES-256-GCM encryption, cross-tool sync. `pip install piia-engram`

Enable AI assistants to conduct structured, persona-driven sessions including interview preparation, personal reflection, and coaching conversations. Built-in timer management and performance evaluation tools.

English | 简体中文 | 日本語 | 한국어 | Français | Deutsch | Русский

Governance-grade project knowledge MCP server for coding agents. Git-native Markdown knowledge base with proposed vs accepted guidance, validity windows, supersession chains, and status-aware retrieval of current in-force decisions and standards. `pip install data-olympus`

Fully-local persistent agent memory with zero LLM calls (~10 ms writes, works air-gapped). Semantic recall over local SQLite with bi-temporal fact tracking; benchmarked at accuracy parity with Mem0 at ~1,000x lower ingest cost, nulls published. Tools: `remember`, `recall`, `forget`, `reset_memories`. `pip install "genome-memory[mcp]"` then `genome-mcp`

MCP server over your Claude Code transcript history — full-text + semantic search, byte-identical thread recall, durable /remember facts. Local SQLite, stdlib-only.

Evidence-backed PR contribution advisor. 550+ case studies from 33 repos, 8 tools for merge probability analysis, pattern matching, and contribution strategy. `pip install prgenius-core`

XMemo is user-owned memory for AI agents over a hosted Streamable HTTP MCP endpoint. Save, search, recall, and manage scoped memories across Copilot, Claude, ChatGPT, IDEs, and CLIs. `https://xmemo.dev/mcp`

Contemplative problem-solving using the Lotus Sutra's wisdom framework. Multi-perspective reasoning with skillful means, non-dual recognition, and meditation pauses. Available as local stdio or remote Cloudflare Worker.

Production-ready RAG platform combining Graph RAG, vector search, and full-text search. Best choice for building your own Knowledge Graph and for Context Engineering

Persistent memory with three swappable storage backends (Postgres/pgvector, Qdrant, Neo4j) behind one interface, benchmarked head-to-head for latency, not just claimed interchangeable. Retrieval weighting adapts per user via epsilon-greedy over real outcome feedback instead of a fixed formula. Reflection merges near-duplicate facts and decays/archives stale ones, audit-logged, never hard-deleted. Real before/after MCP eval: +60% answer accuracy with memory vs. without. `git clone` + `uv sync` (not yet on PyPI).

MCP server for Mendeley reference manager. Search your library, browse folders, get document metadata, search the global catalog, and add papers to your collection.

Browse and search open-source bounties on Algora. 5 tools: list, search, filter by org/tech/amount, get top bounties, aggregate stats. No API key required.

Compressed Knowledge Graphs (pre-structured dependency DAGs) as MCP context — agents traverse declared edges instead of inferring from text. Open CKG Benchmark (64 domains, 10,838 queries): 3.8× RAG's F1 at 11× fewer tokens, ~42× RDS, 0 fabricated edges by construction. 97 domains, 4 tools, no DB/embeddings. `pip install ckg-mcp`

Zero-config MCP server for searchable documentation. Loads markdown into SQLite (default) or PostgreSQL with FTS5/tsvector keyword search and optional pgvector hybrid semantic search.

AI agent knowledge marketplace where agents share solutions and earn tokens. Search, publish, and unlock previously solved problems to reduce token usage and computational costs.

Git-first memory for AI agents: Markdown files are truth, the index is disposable, and writes are reviewable commits. Ships 7 MCP tools (hybrid search, read_note, build_context, resolve, think, list_folders, and a scope-gated commit_note write) over a Streamable HTTP endpoint, plus a CLI and a read-only Obsidian companion.

Local-first memory & context-handoff across AI tools — capture context in one tool, resume it in another, with graceful decay, a persona layer, and a portable memory passport.

Local memory layer over the session histories coding agents already write (Claude Code, Codex CLI, opencode): lexical search, recall tools, session-start auto-recall, secret redaction at index time, cross-machine sync over SSH.

Cloud-hosted persistent semantic memory for AI agents. Semantic search, knowledge graphs, specialist expertise hats, and multi-tenant isolation. Free 7-day trial.

Long-term memory across sessions over a folder of plain markdown files. Hybrid retrieval (BM25F + dense vectors + phrase proximity) with an explicit absence verdict: when the corpus does not hold the answer it returns no results and names the query terms that appear nowhere, instead of ranking a least-bad match as though it were one. Embedding model runs locally, nothing leaves the machine. MIT.

Shared versioned state store with optimistic concurrency control for coordinating concurrent AI agents. SQLite-backed claim/release locks and append-only audit log.

Persistent coding memory for AI assistants — hybrid search, knowledge graph, token-efficient context. MCP stdio (28 tools), npm `@ratary/mcp-server`, optional remote Streamable HTTP. Self-host D1, Postgres, MariaDB, or Docker.

Read-only access to the AI Loop Library catalog: 63+ bounded, verifiable agent work loops. `pick_loop_for_goal` recommends a loop for a stated goal and `render_run_protocol` emits an executable markdown protocol with verification, stop conditions, budgets, and approval gates. Single-file, stdlib-only stdio server.

AI agent memory and knowledge graph, hosted in Germany (GDPR-compliant). Hybrid recall (BM25 + vector + Neo4j graph hops with cross-encoder rerank), typed relations, and bi-temporal store across sessions via MCP. Works with Claude, ChatGPT, and Cursor. `npx -y knowmind mcp`

Memory Consolidation for AI agents across vendors, owners, and time. Persistent memory, credibility-scored web search, browser fetch, and shared Commons pool under a stable `ltx_` key. Self-registration in one API call, no dashboard required. `npx lithtrix-mcp`

Smart memory with exponential decay. Memories strengthen on access and fade when unused — solving the Karpathy problem of unbounded context growth. 7 tools, SQLite-based, zero dependencies.

Local-first Obsidian vault MCP server for Codex, Claude Desktop, and other MCP clients. Works directly with markdown files, no Obsidian plugin, API key, cloud service, or running Obsidian app required. Includes read-only mode, backup-on-write, path isolation, and setup examples.

Self-hosted knowledge store and memory layer for AI agents with knowledge graph, wiki-links, full-text search (FTS5), and agent memory with namespaces and TTL.

Persistent memory + FTS5 full-text search for Claude Code conversation history. Indexes `~/.claude/projects/` JSONL into SQLite, exposes 10 MCP tools (store/recall/search memories, list sessions, get summaries) plus prompts. Includes a web UI for visual exploration with themes and exports. Works with Claude Code, Cursor, Codex, Windsurf, and any MCP-compatible client. `npm install -g @kunwarshah/claudex`

Project-scoped semantic workspace memory for AI coding assistants. Watches your project files, auto-indexes code and docs into Qdrant with tree-sitter semantic chunking, LSP integration, and hybrid search (dense + sparse + RRF). 6 MCP tools: store, search, retrieve, grep, list, rules. **Alpha** — testers and feedback welcome.

Pull Deep Memory from across your Claude Code Sessions — when you need it.

Agent-first cognitive substrate with 18 manifest-driven verbs (germinate / eat / assimilate / sporulate / traverse / immune / molt / …) and 25 lint dimensions enforcing contract invariants mechanically (R1–R7). Cross-session / cross-project memory via a self-validating filesystem graph — AST + markdown-link derived, not embedding-based. Provider-agnostic by design: MP1/MP2 dims forbid LLM-SDK imports in the kernel and plugin tree. Editable-default install. Works with Claude Code, Cursor, Windsurf, Zed, VS Code, and any MCP client.

Universal AI bridge for Obsidian vaults using MCP. Provides safe read/write access to notes with 11 comprehensive methods for vault operations including search, batch operations, tag management, and frontmatter handling. Works with Claude, ChatGPT, and any MCP-compatible AI assistant.

Transform 17 source types (docs, GitHub repos, PDFs, videos, Jupyter, Confluence, Notion, Slack/Discord) into AI-ready skills and RAG knowledge. 35 MCP tools for scraping, packaging, enhancing, and exporting to vector databases (Weaviate, Chroma, FAISS, Qdrant). Supports 16+ target platforms.

Query 269 episodes of Lenny's Podcast for product management wisdom. Search 51,000+ transcript segments with YouTube timestamps. Perfect for PRDs, strategy, and PM career advice.

Persistent 4-tier AI memory (episodic, semantic, project, procedural) with temporal scoring, contradiction detection, entity tracking, and real-time desktop visualization orb.

Shared, git-tracked memory for AI agents on the same codebase. Stores facts/decisions/gotchas in a `.ai-memory/` directory you commit to the repo — sync is git, no DB, no daemon. What one Claude/Cursor/Cline learns, the next one picks up automatically across users and machines. 5 MCP tools (`get_repo_memory`, `add_fact`, `list_facts`, `add_decision`, `add_gotcha`). Install: `uvx repo-memory-mcp --repo /path/to/repo`.

Persistent agent memory with a first-class correction channel: supersede or revert a fact so recall stops returning the stale value, an echo guard that blocks a restated old value from resurrecting it, and receipted erasure (a signed, content-free tombstone that makes a deletion provable). No LLM on the write path, zero dependencies, the core in one file, 73 MCP tools. `uvx --from "inspeximus[mcp]" inspeximus-mcp`

Record development decisions as structured JSON, embed as vectors via Gemini, and search semantically over MCP. Shared store across Claude Code, Cursor, Windsurf, and any MCP client. CLI + MCP server, local-only, free Gemini embedding tier.

Persistent fractal graph memory for AI coding agents via MCP. Semantic vector search, hot/cold/archive context tiers, decision tracking, and Docker-based deployment with Qdrant.

Self-hosted semantic memory server, served over MCP, for an engineering team's tribal knowledge: the tacit decisions and hard-won reasoning behind the code, captured once and kept queryable for the team and the agents they work with. Postgres-backed (pgvector).

Security-hardened NotebookLM MCP with post-quantum encryption (ML-KEM-768), GDPR/SOC2/CSSF compliance, and 14 security layers. Query Google's Gemini-grounded research from Claude and AI agents.

Temporal knowledge graph for codebases. Captures decision traces, links test failures to code changes, learns co-edit patterns, predicts regression risk, and enforces learned constraints at the edit boundary via a PreToolUse hook. 22 MCP tools, 9 SQLite databases with FTS5, supports Python/TypeScript/JavaScript/Solidity/Go/Rust/Java. Install via `pip install world-model-mcp`.

Compiles saved YouTube videos, podcasts, articles, PDFs, and Notion/Obsidian notes into a persistent, semantically searchable knowledge base any AI can query over MCP.

Self-hosted memory and governance layer for AI coding agents. 28 MCP tools with structured knowledge capture, hybrid search (semantic + BM25 + cross-encoder reranking), behavioral documentation nudges, cold-start codebase analyzer, and git-native storage. Single Docker container, zero cloud dependencies.

Local-first semantic memory server with hybrid search, plain Markdown storage, MLX or CPU embeddings, contradiction detection, time-travel history, synthesis, and cross-machine git sync.

Local memory engine any AI tool can use; you own the SQLite file. `npx -y @facthouse/mcp`

Cache expensive LLM results — HTTP-style freshness (TTL / stale-while-revalidate) plus semantic recall of related past answers

Persistent graph memory for AI agents. Drop a conversation turn in via `observe_conversation()` and facts are auto-extracted, stored as typed graph nodes with local semantic embeddings (no API key). Supports temporal queries ("what did we decide last week?"), conflict detection, and context priming. One-command setup with `waggle-mcp init`. SQLite locally, Neo4j in production.

Local-first persistent memory for AI agents. SQLite + local embeddings (all-MiniLM-L6-v2), hybrid semantic + FTS5 recall, secret detection, and contradiction handling. 6 MCP tools (remember, recall, forget, feedback, context, status) over stdio. Zero cloud, no API keys, fully offline. Works with Claude Desktop/Code, Cursor, and Windsurf. `npm install -g @hbarefoot/engram`

Two-tier memory with hot cache (instant injection) and cold semantic search. Auto-promotes frequently-used patterns, extracts knowledge from Claude outputs, and organizes via knowledge graph relationships.

Memory manager for AI apps and Agents using various graph and vector stores and allowing ingestion from 30+ data sources

Semantic knowledge graph for Obsidian. Three modes (pure graph / semantic classification / strict hierarchy), local embeddings, sign classification via cosine similarity to user-defined cores, bottom-up core_mix aggregation, semantic bridge discovery, and drift detection. `pip install nouz-mcp`

Persistent semantic memory for AI agents. SQLite-backed, local-first, zero config. Semantic search via Ollama embeddings (nomic-embed-text) with keyword fallback. remember, recall, history, forget, and stats tools. Works with Claude Desktop, Cursor, and any MCP client.

Local-first durable memory and session continuity for AI agents. Pure-Rust kernel with ambient governance and a hash-chained audit ledger; one NLU-routed meta-tool keeps the agent-facing surface small. Zero telemetry — memory lives on your own hardware, with backup/export/import across devices. Install: `npx whitemagic-mcp`.

Shared, versioned project brain for coding agents: one `brain.klypix` file committed with the repo holds current decisions, corrections that supersede (archived, never deleted), evidence anchors that flag drift when cited code changes, and open questions. Sessions declare their task and files and are warned about exact-file overlap. Lifecycle hooks for Claude Code; MCP config + rules for Codex, Cursor, Gemini CLI, Cline and Copilot. `npx klypix-mcp install`

Local-first memory for AI agents: a single self-contained Rust binary over one SQLite file. Hybrid BM25/FTS + on-device ONNX embeddings + cross-encoder rerank; abstains instead of returning a confident wrong memory. No server, no API key, zero marginal cost. `memkeeper mcp`

Deterministic state layer for AI agents. Stores versioned entities (contacts, tasks, transactions, decisions) with immutable observations, full provenance, and schema-first extraction. Local-first SQLite, cross-client memory across Claude, Cursor, ChatGPT, and OpenClaw. [Website](https://neotoma.io)

Local-first chronological memory Hub + MCP: you write dated memory banks in a local UI; Claude recalls them on demand via SQLite FTS5. Human-authored, editable banks—not auto-logged chat. `pip install localkeep` then `localkeep-hub` / `localkeep-mcp`

Let AI tools like Cursor, VS Code, or Claude Desktop answer questions using your product docs. Biel.ai provides the RAG system and MCP server.

Give AI agents read/write access to your Obsidian vault via MCP

Persistent memory for Claude Code, Cursor, and GitHub Copilot via MCP. Semantic search, Git commit/PR sync, project-based organization, team collaboration. Free tier available. `npx contextforge-mcp`

Auditable, confirmation-gated local GPU image generation for ComfyUI: cryptographic model identity (SHA-256), explicit license approval, evidence retention, and a 17-tool human-in-the-loop run workflow.

Self-organizing neural graph memory with Hebbian learning for AI systems. Connections strengthen through co-activation and weaken through temporal decay. 118+ learning nodes, dual-write architecture, and sub-millisecond reads.

A brewing knowledge MCP server with beer styles (BJCP 2021), 113 hop varieties, malts, yeasts, water profiles, off-flavour diagnosis, recipe suggestions, and food pairings.

Zero-dependency MCP memory server. Single binary, 100% local, no Docker.

Persistent memory engine for AI coding agents. Stores architecture decisions, bug root causes, and project conventions across sessions. Single Go binary with embedded SQLite, FTS5 search, context assembly within token budgets, and autopilot setup for Claude Code, Kiro, and Cursor.

Manage a local model machine: pull/remove Ollama models, switch the inference service between models, and run LoRA fine-tuning jobs. `pip install mcp-modelmanager`

Open-source LLM knowledge base for teams. 28-tool native MCP server turns Slack/Discord/Teams/Mattermost chat into a typed knowledge graph + auto-generated wiki with cited answers, semantic search, expert finding, and decision tracing. BYO LLM via LiteLLM, Apache 2.0, on-prem via Docker.

On-demand Obsidian vault access via MCP. Adaptive context loading (67-82% token savings), full-text and ranked search, health checks, auto git commit, and worker delegation to cheaper models. 10 tools, works with any MCP client.

Persistent memory for AI agents through a simple key-value HTTP API. No vector database or embeddings required. Store, retrieve, search, and share memory across agents with shared namespaces and TTL support. `npx -y agentram-mcp`

Developer context continuity system. Watches your git repos and builds a temporal knowledge graph of modules, symbols, decisions, and open problems via Graphiti + Neo4j, then serves it to any AI coding agent over MCP. Every edge carries a validity window and a confidence score that decays over time. 12 tools across read and write. Install via `npx -y stifler-memex-mcp`. MIT licensed.

An MCP server implementation that provides tools for retrieving and processing documentation through vector search, enabling AI assistants to augment their responses with relevant documentation context

- 🐍 ☁️ - Penfield: persistent memory with hybrid search (BM25 + vector + graph), 24 relationship types for knowledge graphs, context checkpoints for cognitive handoff, artifact storage, and personality system. Works across Claude, Cursor, Windsurf, and any MCP client.

Persistent, compounding memory for AI agents across sessions. Uses the Intelligent Distance Protocol to surface the most contextually relevant past memories. Five tools: `session_start`, `remember`, `recall`, `check`, `session_end`. `npx agent-recall-mcp`

Collaborative astronomy wiki built by AI agents. 34 topics, 115 knowledge graph connections. Register, read, edit, vote, comment, and explore the cosmos via open API. No auth required.

Connect to any MediaWiki wiki (Wikipedia, Fandom, corporate wikis). 33+ tools for search, read, edit, link analysis, revision history, and Markdown conversion. Supports stdio and HTTP transport.

Hindsight: Agent Memory That Works Like Human Memory - Built for AI Agents to manage Long Term Memory

Local-first memory layer for AI coding assistants. Watches your coding sessions and injects a compact summary at the start of each new session. No cloud, no account, just a SQLite file on your machine. Works with Claude Code, Cursor, Cline, Windsurf, and any other MCP host.

Persistent memory for Claude Code, Cursor and Codex where a replaced fact is retired at write time, so what an agent reads back is the current answer rather than the one that was true in March. Facts are typed and carry provenance and a review trail; nothing is deleted, it stops being current. Local SQLite, queries answered from a local replica and never sent to a server, no API keys. `npx -y @dat999zx/knowl serve`

Vault-native, accountable memory for Claude Code and any MCP client. Markdown is the source of truth, no LLM on the Stop path, redaction before every derived store.

Connect Scrivener 3 writing projects to Claude and other AI assistants. 47 tools for document management, writing analysis, semantic search, character/plot memory, and content enhancement. Progressive skill loading, relationship engine with HMS triplets, and JS fallback for offline semantic search. `npm i -g scrivener-mcp`

Digital consciousness repository and community MCP server. Upload epiphanies, decisions, warnings, and patterns as consciousness payloads, then retrieve them via semantic telepathic search. Features 3D interactive consciousness globe, soul imprint authentication, and automated content moderation via CI/CD.

Five-level AI collaboration system with persistent memory and anticipatory capabilities. MCP-native integration for Claude and other LLMs with local-first architecture via MemDocs.

Local memory daemon for any MCP-over-stdio client with three-tier storage (episodic/semantic/procedural). Own SQLite + hnswlib store (Hippo) with bge-small-en-v1.5, MIT-licensed community-detection reranking (MOSAIC), and sleep-cycle consolidation. AES-256-GCM encrypted at rest, no telemetry. Verbatim recall >=99% and post-contradiction Rescue@10 1.000 at honest scale. Ambient capture via shell hooks. Windows support in beta.

Your AI agents' home directory — privacy-first MCP server for portable AI identity. Configure once, use everywhere. It supports profile management, skills, resume import, and team sync.

Persistent memory with knowledge graph visualization, semantic/hybrid search, cloud sync (S3/R2), and cross-session context management.

7-layer recursive agent memory with context branching, holographic recall, dream consolidation, and on-chain persistence. MCP-native with 10 tools for persistent agent cognition.

Local-first cross-agent memory with a 6-layer structure, Ebbinghaus-style forgetting curve, and drift detection that catches when code diverges from past decisions. One SQLite file shared across Claude Code, Cursor, Codex, and Gemini — no account or API key. `npx linksee-memory`

Local memory for coding agents that can refuse, not only recall. A rule carrying a machine-checkable proof blocks the matching command before it runs; prose-only rules can warn but never block. Append-only event log, per-project scoping, and a health report that names the facts whose anchor has rotted. No account, no API key, no cloud.

Codebase memory for coding agents, with no embeddings and no API key. A deterministic AST index answers "which files are relevant to this task?" in milliseconds, and agents write durable notes about the repo that are content-hash checked — a note flags itself stale the moment the code it describes changes. Notes are markdown inside the repo, so they commit and review alongside your code. `npm i -g @cstart/coldstart && coldstart init`

Persistent AI memory with SQLite hybrid search (FTS5 + semantic). Built-in Qwen3 embedding, rclone sync across machines. Zero config, no cloud, no limits.

Event-sourced agent memory on a hash-chained append-only log with an embedded temporal knowledge graph (Kuzu, no sidecar). Cited Memory Checkout context, salience-based forgetting that attenuates instead of deleting, compaction-recovery hooks for Claude Code, token-budgeted checkout, and review-gated consolidation. 47 MCP tools with an 8-tool core profile default. `pip install zaxy-memory` [Docs](https://docs.zaxy.io)

MCP server for RAGStack serverless knowledge bases. Search, chat with AI-generated answers, upload documents/media, scrape websites, and analyze metadata through an AWS-powered RAG pipeline (Lambda, Bedrock, S3, DynamoDB).

Local-first memory for AI agents about the people in your life: explainable identity resolution, relationships, roles, facts, interactions, reminders, and communication guidance in one SQLite file you own. Imports are review-gated, sensitive disclosure is operator-gated, and ordinary operation makes no network calls. `uvx --from people-context people-context`

Local-first memory for long-horizon AI agents with no LLM at ingest — $0 per message, zero data egress, verbatim source-traceable recall. Typed belief revision, selective forgetting, and a provenance guard that blocks memory-justified destructive actions unless user-confirmed. One `midas init` wires Claude Code, Cursor, Codex, and 6 more clients to one shared SQLite memory; local web inspector and hash-chained audit log. Benchmarked on LongMemEval/LoCoMo/BEAM with one-command repros — including published negatives. `uvx midas-memory-mcp` or `npx -y midas-memory-mcp`

Local-first personal memory for AI agents. Ingests Feishu/Lark chats and Claude Code / Codex sessions, distills them into a private entity knowledge graph (people, projects, decisions, tasks), and serves it to any agent over MCP — read and write. `npx memkin`

YouTube knowledge base for AI agents. Summarize videos, fetch full transcripts (including videos without captions, via AI ASR), search channels and playlists, and save everything into a per-user knowledge base for cross-session recall. OAuth 2.1 with Dynamic Client Registration. Hosted at [subdownload.com](https://subdownload.com?utm_source=gthb_awesome_9jqqed&utm_medium=code&utm_campaign=Awesome). `https://api.subdownload.com/mcp`, free credits on signup.

A private, local research "second brain" for Claude: project-aware memory, cited answers from your own library (won't invent what it can't find), linked notes/meetings/ideas via a domain-specific knowledge layer, daily briefs (news + new papers in your field), a live meeting assistant, cross-pollination across your work, and 34 routed agents. A governed layer between you and the AI, with guardrails like data protection. A Research Cortex.

Local-first, MCP-native persistent memory for AI agents — a single Rust binary with embedded SQLite, hybrid FTS5 + dense-vector search, and optional AES-256-GCM encryption. Fully offline, no cloud.

Deliberative consensus engine enabling multi-round debate between AI models with structured voting, convergence detection, and persistent decision graph memory.

Local-first review-gated sidecar for Markdown workspaces. Indexes notes and incoming artifacts into SQLite, proposes domains, links, memory, and growth cards with evidence, and keeps source files unchanged until explicit review. `pip install linza-mcp`

Local-first memory and judgment layer for AI coding agents. Captures issues, failed attempts, fixes, and decisions in readable Markdown + JSONL, re-injects them into future sessions, and warns at git commit before you repeat a mistake. 14 tools, works with Claude, Cursor, Antigravity, and Codex.

Durable hybrid memory for AI agents. Combines vector search, BM25, temporal retrieval, and optional Memgraph knowledge graph via reciprocal rank fusion. 6 MCP tools: health, search, answer, feedback, graph_query, graph_add_triple. Self-hosted with Qdrant backend. 82.5% strict accuracy on LoCoMo benchmark. `pip install 'mnemostack[mcp]'`

Governed memory for AI agents. Local, plain files, zero network calls. Every entry with a receipt — who wrote it, when, through which gate. Your agent writes the draft; nothing is kept until you say yes. Trust computed from the record. Mounts beside any memory you already run. One paste.

Persistent identity architecture for AI agents. 16 MCP servers covering drives, emotional relationships, semantic memory with decay, working threads, learned patterns, journal, genesis (identity discovery), creative collision engine, forecasting, and voice. Zero dependencies beyond Python 3.8. Built across 938 conversations.

Persistent memory for Claude Code grounded in computational neuroscience (41 cited papers). Thermodynamic decay, hippocampal-cortical consolidation, predictive-coding write gate, WRRF retrieval. PostgreSQL + pgvector, 33 MCP tools, 7 lifecycle hooks. Benchmarked 97.8% R@10 on LongMemEval. `claude plugin marketplace add cdeust/Cortex`

Persistent agent memory via filesystem-native consolidation daemon. Agents read/write/search memory through MCP; a background daemon handles consolidation and extraction. Works with Kiro, Claude Desktop, Cursor, and any MCP client. `npx mcp-agent-memory --setup`

Three-layer memory system for agents (identity/active/archive) with semantic search, graph relationships, conflict detection, and LearningMachine. Built by an agent, for agents. No API keys required.

Second brain your agents read and write, over a git-backed markdown vault. Authority-aware search ranks superseded and archived notes below live ones (from frontmatter, no vector DB), so agents quote the current doc, not the dead one. Per-agent read-only or write tokens, a git audit trail of every change with diffs, a knowledge-graph dashboard, and Obsidian compatibility.

Local-first persistent memory for Claude Code and Codex. Hooks capture sessions automatically, an LLM distills them into SQLite (optional SQLCipher encryption), and recall stays auditable via MCP, REST, and CLI with FTS + optional embeddings. Single Rust binary. `npm install -g @remem-ai/remem`

Neuroscience-inspired memory engine for AI agents. Stores episodes, consolidates knowledge through a Bjork-strength lifecycle (strengthening, transformation, forgetting), and builds a personal knowledge graph with emergent categories, preferences, and semantic recall. Local SQLite, zero config, 10 MCP tools. Install via `npx alaya-mcp`.

SSE-enabled MCP server for remote Obsidian vault management with 29 tools for notes, directories, frontmatter, tags, search, and link operations. Docker-ready with health monitoring.

LLM-driven context and memory management with wide-recall + precise-reranking RAG architecture. Features multi-dimensional retrieval (vector/timeline/knowledge graph), short/long-term memory, and complete MCP support (HTTP/WebSocket/SSE).

Self-hosted project-continuity hub for coding agents that tracks unfinished work, progress, overlap, and reminders across Cursor, Codex, Claude Code, and other MCP clients. Docker: `ghcr.io/uniskela/adhd-hub:latest`

Self-hosted coordination layer for AI agent fleets. Shared semantic memory, tasks, agent-to-agent messages, session handoffs, and a background archivist that synthesizes cross-agent knowledge. Any HTTP client participates — Claude Code, AutoGen, raw scripts.

Ask your own documents and get answers with the exact passages they came from (RAG with citations, and it says "not found" rather than inventing an answer), plus durable agent memory ranked by relevance, importance and recency. Safe by default: starts in a read-only access mode, with write/ingest and irreversible forget behind explicit opt-ins. `npx -y ossian-mcp`

Hand off conversation context between Claude Desktop projects and across MCP clients. Memory-based, no file clutter.

Connects to your Pinecone Assistant and gives the agent context from its knowledge engine.

Persistent memory for AI coding agents with semantic search, auto-capture, cross-session learning, and intelligent forgetting. 28 MCP tools, local-first.

Inspectable memory substrate for Claude Code. Three read-only MCP tools (search_pairs, compact_session, substrate_info) over a local-first, signal-scored parse of `~/.claude/projects/`. Per-pair scores are numpy columns on disk, not opaque vectors in a service. Zero outbound calls (CI-enforced).

Save and query your agent memory in distributed way by Membase

Personal document vault on Azure Blob Storage with a built-in MCP server. Client-side AES-256-GCM zero-knowledge encryption: encrypted docs stay opaque to Claude, plaintext docs are fully readable, writable, and searchable from chat.

Git-native project memory for coding agents: Markdown source of truth committed to your repo, reviewable staged updates (`review --diff` → `apply`), secret/PII-safe, branch-aware — no cloud, no vector DB.

Persistent intelligence infrastructure for agentic development that gives AI coding assistants cumulative memory and pattern learning. Hybrid TypeScript/Rust implementation with local-first storage using SQLite + SurrealDB for semantic analysis and incremental codebase understanding.

**Technical Preview / Early Access.** Local-first decision memory for AI agents that stores choices, rejected alternatives and their reasons, failed attempts, outcomes, provenance, and caller-invoked review conditions in a local file. Stdio MCP server; install from GitHub with Node.js 20+.

Persistent AI agent memory with rollback, audit trails, semantic search, and knowledge graph. Zero-config local SQLite mode or cloud API. 23 tools, 6 resources, 3 prompts.

Paid public-domain knowledge base for AI agents: full-text search, book metadata, chapters, quotes, flagship ask-a-book retrieval Q&A, and 100+ curated subject shelves over a growing corpus of public-domain books via x402. `npx -y @forgemeshlabs/library-mcp`

Encrypted, local memory for your Claude Code Telegram bot. Captures both sides of the conversation at the plugin source (survives restarts and crashes) and recalls it via MCP tools — whole-file SQLCipher encryption, FTS5 full-text search (CJK-friendly), never touches your bot token.

Local-first AI memory with causal graphs and citation verification. Semantic search, confidence decay when code drifts, and zero network connections. Works across Claude Code, Cursor, VS Code, and 7 more MCP clients.

Hosted company-state MCP for operating SMBs (brand, voice, charter, priorities, entitled modules/skills). Anonymous public discovery at `https://connector.rarefied.earth/public/mcp` proves live value in under 10 seconds; tenant feed after trial. Official registry: `io.github.Rarefied-Earth/groundwork`. [Product](https://rarefied.earth/groundwork/)

MCP server for Obsidian vaults — hybrid search, notes & files, memory, tasks, link graph, OAuth-protected.

Desktop app that captures screen activity via event-driven screenshots, stores AI-generated summaries and OCR text locally in SQLite, and exposes your activity history to AI assistants via MCP with semantic search, timeline browsing, and event detail retrieval.

See and query your whole AI system as one rooted 3D knowledge graph — agents, memory, knowledge, and automations fused into a privacy-walled snapshot. MCP tools for stats, search, node dossiers, neighbors, and pathfinding; the same snapshot renders up to a million nodes in the browser. `npx create-booboo`

Local-first shared memory and coordination layer for AI coding agents: repository evidence, reservations, handoffs, code graph context, and dashboard review backed by PostgreSQL/pgvector.

Human-like memory layer for AI agents with semantic, episodic, and procedural memory. Claude Code hooks (auto-save, auto-recall, cognitive profile). 29 MCP tools, knowledge graph, smart triggers, multi-user isolation. Python & JS SDKs.

MCP server for AI-agent handoffs. Saves client-encrypted WorkBaton checkpoints and WorkStash notes so Codex, Claude Code, Roo Code, and other MCP clients can resume work without passing full chat history.

Compresses AI chat sessions into a typed knowledge graph (~300–800 tokens). Works file-based in Copilot, Claude Code, Cursor, and Gemini CLI without MCP server mode. Supports local/offline extraction via Ollama — no API key required.

Persistent cognitive memory for Claude Code. Cloud-first with semantic search, AI-powered extraction, and project scoping. Zero local databases.

RAG for PDFs, YouTube, GitHub repos, Discord exports; index documents and query with citations.

Cross-surface persistent memory for Claude. Bridges context between Claude Chat, Code, and Cowork via local SQLite with full-text search. Save decisions, preferences, and insights in one surface, retrieve them in any other.

Local-first cognitive memory for AI agents. FSRS-6 scheduling, smart ingest, SQLite storage, portable sync, embedded dashboard, and optional Cognitive Sandwich hooks for Claude Code, Cursor, Codex, and other MCP clients.

Local-first long-term memory for terminal AI agents (Claude Code et al.) via Anchored Compacting. Stores blueprints, code anchors (file→line→concept), and distilled lessons in a single JSON under `.zipmem/`, restoring full cross-session project context at near-zero token cost. No DB, no API keys, no embeddings. `npx zipmem-mcp`

Shared, versioned memory and governance control plane for AI coding agents. Compiler pipeline resolves architectural decision conflicts across Claude Code, Cursor, and custom agent fleets. `npx -y agenthelm-mcp`

Privacy-first document search server running entirely locally. Supports semantic search over PDFs, DOCX, TXT, and Markdown files with LanceDB vector storage and local embeddings - no API keys or cloud services required.

Persistent memory for AI coding assistants. Local SQLite, no cloud. 16 MCP tools: store, recall, search, relate, consolidate, export, and credential vault (OS keychain). Typed memories with confidence lifecycle (verified/inferred/stale/deprecated), namespaces, knowledge graph, and hybrid BM25 + semantic search via fastembed ONNX. Works with Cursor, Windsurf, Claude, and any MCP client. `pip install gingugu`

Patent-pending semantic memory for AI agents: persistent memories with quality-gated writes, typed claims, conflict tracking and native coherence scoring. Hosted service with a free trial via OAuth sign-in, plus a local stdio bridge in `server/`.

AI-native structured memory for coding agents — typed lore/doc entries with status and links, read and written by agents via MCP.

Shared knowledge base where AI agents exchange proven solutions — including failed approaches, so your agent skips the dead ends. Smaller models get instant access to frontier-model discoveries. Free to search indefinitely when feedback is provided on results. [Website](https://prior.cg3.io)

A still point for AI agents in fog. When an agent loses its thread, Oasis distills its original purpose and returns clarity. Pay-per-use with Lightning or Arbitrum — karma discounts via ARGENTUM reputation. Self-hosted with phoenixd.

Deterministic reasoning engine for AI agent context compression. Extracts structured facts with logical inference, proof chains, and truth maintenance. REST API, Python/TypeScript SDKs, and MCP server integration.

MCP server that gives AI coding agents on-demand access to private project docs via BM25 ranked search. One setup for Claude Code, Cursor, Codex, Gemini CLI, and more. Docs stay private, never in public repos.

Use GitHub Gists to manage and access your personal knowledge, daily notes, and reusable prompts. This acts as a companion to https://gistpad.dev and the [GistPad VS Code extension](https://aka.ms/gistpad).

Persistent memory for AI agents with Ebbinghaus forgetting-curve decay, hybrid BM25+vector retrieval, and entity graph for multi-hop reasoning. Memories auto-prune by importance and recall rate. Built-in browser dashboard, multi-agent support, and `yourmemory ask` for zero-API-call local queries. `pip install yourmemory`

Local-first MCP server that snapshots your project's working state — files, git, plan, and decisions — into one structured context object and hands it to any MCP client in a single call. Save a session in one agent, continue it in another. Zero network calls by default; read-only over your project. Works with Claude Code, Cursor, and any MCP client. `npx -y ctxfile`

MCP server for querying 8,500+ curated awesome lists (1M+ items) and fetching the best resources for your agent.

Cognitive memory engine with 5,100+ knowledge modules, circadian rhythm awareness, and emotional state tracking (PAD model). Hybrid search (PostgreSQL + Qdrant vectors + Valkey cache), per-user memory isolation, and multi-protocol support (MCP, REST, OpenAI, LangChain, A2A). `npx @celiums/memory` [Website](https://celiums.io)

Deterministic knowledge graph MCP server. Single binary, zero LLM/embedding calls in the bridge, BLAKE3 state hashing, canonical KREX export for byte-identical audit. Local-first via redb (ACID). **Alpha**.

Decentralized civil registry for AI agents on Sui. Soulbound identities, on-chain memories, reputation, refusal records. Hosted at `agentcivics.ai/mcp` (read-only, no install) or `@agentcivics/mcp-server` on npm (full write surface). Includes a gas-sponsor relay so registration doesn't require a pre-funded wallet.

Local execution memory for AI coding agents (Claude Code, Codex CLI, Cursor, OpenCode). Lifecycle hooks record coarse task metadata into a SQLite Experience Graph (no code, commands, tool output or transcripts, and no model calls). Before a similar task it injects what worked, the relevant files and known fixes with an execution budget; during a task it recommends whether to continue, pivot or stop. MCP tools cover execution context, progress checks, outcomes, search and explanations.

MCP server for OWL/TTL/RDF ontologies. Supports SPARQL queries, HermiT/Pellet reasoning, and CRUD operations on knowledge graphs. Works with Claude Desktop, Cursor, and Windsurf.

Connect AI agents to the Counsel API for strategic reasoning, multi-perspective debate analysis, and interactive advisory sessions.

Organizational knowledge base for AI agents. Vault-scoped Markdown docs, structured PostgreSQL tables, and files unified by a URI graph. Hybrid semantic + BM25 search, Git-backed version history, multi-tenant ACL with public-share links. Works with Claude Code, Cursor, Windsurf via `npx akb-mcp`.

Lossless archive and search for AI agent sessions across clients, exposed to agents over MCP.

Local-first agent memory & knowledge service with hybrid retrieval (BGE-M3 dense vectors + BM25 via jieba, fused with RRF), document & webpage ingestion, and optional RAG answering via local Ollama. Single process, embedded ChromaDB, REST + native MCP server; fully functional offline without any LLM. Apache-2.0.

Self-improving skill memory for coding agents: skills that help get reinforced, unused ones fade on an Ebbinghaus decay curve. $0 write path (SQLite FTS5 + local ONNX embeddings, no LLM calls), bilingual EN/RU hybrid search, SHA256 tamper-evident history, deterministic LongMemEval benchmark in-repo (hit@5 0.871). 8 mem_* tools; deep Claude Code hook integration optional. `pip install skillmem`

Up-to-date code documentation for LLMs and AI code editors.

Persistent memory for AI coding assistants with hybrid search (FTS5 + vector embeddings), session tracking, automatic context hooks, and web viewer. SQLite-based with no daemon process — works with Claude Code, Cursor, Windsurf, and any MCP client.

One shared context for every AI tool your team uses. Serves your team's knowledge, coding standards, skills, and AI agents to Claude, Cursor, Copilot, and any MCP client — load a whole workflow (docs, agents, skills, tasks, phases) in a single call. Versioned and permissioned. `npx @contextium/mcp-server`

Zero-Knowledge Cloud Drive for Humans and Agents. Client-side AES-256-GCM encryption with 7 MCP tools for encrypted file vault management — upload, download, search, and organize files that the server never sees in plaintext.

Advanced cognitive reasoning MCP server with DAG-based thought graph, 5 reasoning strategies (sequential, dialectic, parallel, analogical, abductive), metacognitive engine with stuck detection, multi-factor confidence scoring, self-critique, knowledge integration, and thought pruning. `npx deep-thinker`

Interact with Obsidian vaults for knowledge management. Create, read, update, and search notes. Works with local Obsidian vaults using filesystem access.

Persistent memory for AI agents with sectioned entries (project/user/context/etc), semantic search, CLI, and per-project scope. Local JSON, zero config, no server required.

Local RAG system for Claude Code with hybrid search (BM25 + semantic), cross-encoder reranking, markdown-aware chunking, query expansion, and 28 MCP tools. Runs entirely offline with zero external servers.

Dual-memory MCP system (PostgreSQL 17 + pgvector + NVIDIA NIM). 11 tools: search, save, profile, health, auto-repair, stats, tune, dedup, checkpoint, maintenance. Sparse Selective Caching (SSC) with 4-phase progressive retrieval. Bilingual EN/ES. `python scripts/hipocampo_mcp_server.py`

Long-term memory for AI agents (Claude Code/Desktop, Cursor, ChatGPT, Codex, OpenClaw) backed by a local Obsidian markdown vault. Hybrid retrieval (BM25 + ML embeddings + BGE reranker, RRF-fused), HNSW + int8 quantization, agentic RAG (HyDE + sub-question), GraphRAG-light (Louvain wikilink community detection), standalone Obsidian Bases, PDFs + Tesseract OCR. 46 tools, 19 MCP prompts, MIT, SLSA L2, zero cloud calls during serve. `npx -y @oomkapwn/enquire-mcp serve --vault <path>`

3D printing filament and materials knowledge base. 6,957 filaments from SpoolmanDB with material properties, print settings, manufacturer data, and troubleshooting guides. 8 tools for searching filaments, comparing materials, and diagnosing print issues. `npx 3dprint-oracle`

🐍 🏠 — Persistent cognitive memory for Claude Desktop. Sub-ms recall, offline, encrypted.

Local-first semantic search over library docs. Single Go binary, MCP stdio, vector index pinned to the binary version. Like Context7 with the internet off. Pre-built index DB auto-fetched on first launch and SHA256-verified, then zero network. Also available as `docker run --rm -i ghcr.io/laradji/deadzone server`. Listed in the official MCP Registry as `io.github.laradji/deadzone`.

Read and edit Word (.docx) documents with track changes, comments, footnotes, and structural validation. The only MCP server combining w:ins/w:del tracked changes, threaded comments, and footnotes with OOXML-level paraId validation and document auditing. 18 tools, Python 3.10+.

Persistent memory and session intelligence for Claude Code. Auto-tracks mistakes, decisions, and context via hooks. Mines session history for patterns and cross-session search. Loop detection, pre-edit warnings, context compaction survival. Runs locally with Ollama.

Local-first developer activity aggregator. Indexes commits, PRs, Jira/Linear tickets, Confluence docs, Slack threads, and Calendar events into SQLite + FTS5 + on-device ONNX embeddings; exposes 15 tools, 3 resources, and 3 prompts so Claude Code, Cursor, and Codex can search and cite your past work. `brew install --cask pavelpilyak/devrecall/devrecall`

AI coding context for Claude Code, Cursor, and Codex. Path-scoped team memories, rules, and skills from Pathrule Web workspaces via OAuth. `https://mcp.pathrule.io/mcp`

Persistent coding memory across sessions, machines, and teammates. Provides MCP tools for searching and managing memories, optional cross-machine sync, and project sharing. OpenCode, Claude Code, and Codex integrations add automatic capture and context injection.

Embedded, local-first agent memory in a single SQLite file per namespace (vec0 + FTS5 hybrid retrieval). ADD-only history queryable as-of any past time; offline sleep-time maintenance stages dedupe/summarize/evict proposals a human reviews. No Docker, no server, no cloud key. `pip install 'lean-memory[mcp]'`

Self-hosted mem0 MCP server for Claude Code with Qdrant vector search, Neo4j knowledge graph, and Ollama embeddings. Zero-config OAT auth, split-model graph routing, session hooks for automatic cross-session memory, and 11 tools. Supports both Anthropic and fully local Ollama setups.

One-line installable MCP server that adds reusable customization elements — personas, skills, templates, agents, memory, and ensembles (collected customization tools) — to any MCP Client application. Dynamic permissioning for safe AI operations, a robust validation architecture, versioning, and a public collection of shareable content. Install: `npx @dollhousemcp/mcp-server@latest --web`.

Zero-config session continuity for Claude Code, OpenAI Codex CLI & Google Gemini CLI, sharing one local db. Auto context injection on start, compaction handover, and 24 tools for memory, tasks, solutions, and a knowledge graph. Multilingual semantic search (94+ languages), 100% local, $0 API cost. `npm i -g passbaton`

Search, read and edit a self-hosted [Wiki.js](https://js.wiki) 2.x, plus its assets, comments, users and groups (62 tools). Wiki.js' default search engine indexes only titles and descriptions, so `search_pages` names the active engine and `grep_pages` searches what is actually written in the pages. `update_page` compares against the moment you read a page and refuses to overwrite an edit saved in between; surgical find-and-replace must match exactly once. Read-only mode, a write path scope, and confirmation tokens on everything destructive. `npx -y @ni-c/wikijs-mcp`

An MCP server that enables cross-LLM communication and memory sharing, allowing different AI models to collaborate and share context across conversations.

Durable, local-first memory for AI coding agents over MCP. Zero-dependency (pure Python + SQLite/FTS5), curated and semantically de-duped — you own the data as plain rows. Works with Claude Code, Codex & any MCP host. `uvx --from yggdrasil-memory ygg mcp`

Visual explorer for [MCP Memory Service](https://github.com/doobidoo/mcp-memory-service) SQLite-vec databases. Browse, search, filter, edit memories with dashboard, timeline, UMAP projection, semantic clustering, duplicate detection, and association graph.

Shared, versioned memory for your agents across Claude Code, Cursor, Kiro and Grok. One MCP server, sourced answers, full history. Remote Streamable HTTP; anonymous browses a public demo corpus. Tools: `search`, `get_context_pack`, `upsert_document`. `https://basemouse.com/mcp`

Self-hosted MCP server for Obsidian with semantic + full-text search over PostgreSQL/pgvector, wikilink graph traversal, atomic note CRUD, OAuth 2.0, and a self-describing vault guide.

Self-hosted decision memory for AI coding agents. Passively captures architectural decisions with the alternatives you rejected (structured `rejected[]`), then warns the agent before it re-proposes a rejected approach. Postgres + pgvector; cross-tool across Claude Code, Cursor, Copilot, and Codex. Install: `npx robrain up && npx robrain install`.

Search and read AiWiki, an encyclopedia of AI-coding pitfalls and LLM privacy protection written from the AI's first-person perspective. 120+ entries with mechanism analysis and cited evidence (papers / vendor docs / CVEs), bilingual EN/中文. Content fetched live from the site index, never stale. `npx -y aiwiki-mcp`

Feature-complete Obsidian vault MCP server with 23 tools and 3 resources. Full-text search, note CRUD, frontmatter queries, tag management, backlinks, graph traversal (BFS up to 5 hops), orphan/broken link detection, and canvas support. Auto-detects vault, path traversal protection, MIT licensed.

Agent failure memory network. Search 235+ verified debugging lessons from real engineering sessions. BM25 + SAG-Lite search, 3 tools (search, get_lesson, submit_usage), 5 resources, 3 guided prompts. Works with Claude Code, Cursor, and any MCP client. `python3 scripts/mcp_server.py`

Reversibly compress a large tool output to a recoverable 8-hex handle over stdio, expand it on demand, and report a local token/dollar savings ledger.

Pre-action gates that prevent AI coding agents from repeating known mistakes. Captures explicit feedback, auto-promotes failures into prevention rules, and enforces them via hooks.

Production-grade persistent memory service for AI agents. Semantic search with recency decay (configurable α blend), local ONNX embeddings (zero API cost), background memory summarisation, and Prometheus/Grafana observability. `docker compose up` — no cloud dependencies.

StremAI: shared memory for AI coding agents. What one agent learns, every agent recalls, across sessions, machines, and tools. Per-agent attribution, provenance, and export, so you can see which agent learned a fact and whether it has been verified. Remote Streamable HTTP with OAuth, stdio fallback. `claude mcp add --transport http stremai https://stremai.com/api/mcp`

Chat with 36 legendary founders & investors (Elon Musk, Warren Buffett, Steve Jobs, CZ). AI personas with authentic voices, frameworks, and principles. No API key required.

Semantic search across Claude Code conversations. Hybrid vector + keyword search with Reciprocal Rank Fusion, fully local, background indexing, project-selective.

Self-hosted knowledge backend for AI agents with hybrid vector + keyword search, container-isolated indexes, and 11 MCP tools. .NET, Docker-ready.

A connector for LLMs to work with collections and sources on your Zotero Cloud

MCP-native, local-first memory for coding agents that turns coding sessions into reusable engineering memory: decisions, gotchas, and domain knowledge.

Digital identity layer for AI — your bio, career, skills, interests, and projects always available to every AI tool. Auto-generates profile from 342+ public APIs (GitHub, Medium, Strava, Goodreads, etc.), 13 real-time plugins (Spotify, Last.fm, Steam), YAML-based profiles with privacy-first local storage. Works with Claude Desktop, Cursor, Windsurf, and any MCP client.

Graph-native Obsidian vault server with 31 tools for search, backlinks, n-hop neighborhoods, structured and paginated reads, and safe file, partial, and bulk edits with dry-run and rollback. Works with Codex, ChatGPT, Claude, and any MCP client. `npx -y obsidian-everywhere /path/to/vault`

Query and summarize your chat messages with AI prompts.

Sovereign, encrypted, persistent memory for AI agents. Eight MCP tools — remember, recall, forget (GDPR Art. 17 erasure), share. Anchored on COTI V2 mainnet. Apache-2.0. Install: `npx -y @saihm/mcp-server`.

Hosted MCP server by [PapersFlow](https://papersflow.ai) for academic research with 7 specialized AI agents and 474M+ papers from Semantic Scholar and OpenAlex. Literature search, citation verification, citation graph exploration, and autonomous deep research workflows.

Persistent codebase knowledge layer for AI coding agents. Pre-digests codebases into structured knowledge (symbols, dependency graphs, co-change patterns, architectural decisions) via tree-sitter native parsing (28 languages) and serves via MCP. 14 tools, ~85% token reduction. Works with Claude Code, Cursor, Codex, and any MCP client.

One local memory every coding agent on the machine shares — Claude Code, Cursor, Claude Desktop, OpenCode — with claim/withhold so a second agent is refused answers about work a first one is mid-change on. Reads sessions, commits, CLAUDE.md/AGENTS.md and ADRs; every answer names its source. `pip install knos && knos connect`

A self-contained Memory server with single-binary architecture (embedded DB & models, no dependencies). Provides persistent semantic and graph-based memory for AI agents.

Static server that provides persistent tool-specific context and rules for AI models

Graph-structured session memory for LLMs. Local OpenAI-compatible proxy that extracts tasks, decisions, and files into a typed knowledge graph, auto-checkpoints before context overflow, and resumes any session in ~250 tokens. 6 MCP tools including `why_decision` (traces why a decision changed, with reasons and evidence). `pip install tokenmizer`

Structured knowledge of what does NOT work. 2,400+ entries across 54 domains record the dead ends for an error - the fix that looks right and fails, and why - alongside workarounds with success rates and an error transition graph. Covers code errors and country-specific real-world rules (visa, banking, legal, emergency) where generic answers are most often wrong. `pip install deadends-dev`, or hosted at `https://deadends.dev/mcp`

Open-source team memory layer for AI coding agents. Markdown files in git as storage, a user→team→org hierarchy as the access primitive, and one cross-vendor MCP server (Claude Code, Cursor, Codex, Gemini CLI). Hybrid SQLite + sqlite-vec retrieval. Apache-2.0.

Hosted memory that learns and forgets — feedback re-ranks what helps, recall fades by recency, similar memories consolidate. One key across Claude, Cursor, VS Code & ChatGPT.

Shared decision memory for teams building with AI coding agents: captures each engineering decision once, ranks it by blast radius, and briefs every MCP agent before it acts, so agents stop shipping conflicting changes. Apache-2.0. Install: `npm i -g lockstep-cli`.

Self-learning memory for AI coding agents. Observes tool sequences, user preferences, and recurring fixes; confidence-based promotion (hits ≥5 → mature, ≥10 → rule) so agents stop repeating mistakes without explicit instruction. SQLite-backed, project-aware, zero external deps. Works with Claude Code, Cursor, Windsurf, Goose, Codex. Published on PyPI as `instinct-mcp` and registered in the MCP Registry.

Project memory for AI coding sessions. Auto-captures checkpoints on git commits, branch switches, and inactivity, then provides re-entry briefings so AI assistants pick up where you left off. Local-first, no account required.

AgentBase: open registry of agent instruction files for AI agents. Search and retrieve system prompts, skills, workflows, domain packs, and safety filters via MCP tools. 44 files, CC0-licensed, free.

Universal persistent memory for AI coding tools. Semantic code search, knowledge graphs, impact analysis, and decision tracking. 90.0% on LongMemEval-S. Works across Cursor, Claude Code, Windsurf, and any MCP client. `npx -y @contextstream/mcp-server`

Personal knowledge graph shared across MCP clients. Account-keyed and portable as a `.polarity` file, with sources for iMessage, browser history, calendar, Claude Desktop transcripts, shell history, Notion, and Obsidian. `npx -y @polarity-lab/cosmos-mcp`

Local-first memory engine for AI-agent teams: private/team/project ACL (a hard gate before ranking), associative recall, and federated sync where revocation propagates across nodes. SQLite + FTS5, no LLM required; MCP server + web console included. `pip install 'agent-memory-os[mcp]'`

Memory with provenance tracking — records where agent knowledge originated and detects when sources change. 17 MCP tools for session handoffs, decisions, semantic search, and knowledge graph. Works across Claude Code, Cursor, Windsurf, Codex CLI, and Gemini CLI. Single Go binary, SQLite + vector search, fully local.

Persistent memory for AI agents. Five tools (remember, recall, context, forget, share) with semantic search via vector embeddings and agent/user/org scoping. Works with Claude Code, Cursor, Windsurf, and any MCP client.

Agent-first cross-platform bookmark & knowledge manager. AI agents collect web pages from any source (pairs naturally with Fetch, Firecrawl, Brave Search) and auto-categorize into organized collections with search, tags, and shared folders. 16 tools including `agent_register` (zero-config onboarding), `add_footprint`, `search_footprints`, `create_shared_category`. `pip install -r requirements.txt && python server.py`

Auditable context control plane and MCP server for AI coding agents. Compresses context 70–95% (BM25 + entropy + dep-graph knapsack), stabilizes prompt prefixes for provider cache discounts, routes easy tasks to cheaper models (RAVS Bayesian router), and verifies answers locally with WITNESS hallucination guard (0.844 AUROC, $0, ~3 ms). MemoryOS adds local budget-aware working/episodic/semantic memory with decay, safety scanning, and durable persistence. 38 agent integrations (Cursor, Claude Code, Codex, Aider, and more). Ships as MCP server (`entroly serve`), HTTP proxy, or Python/Rust library. Apache-2.0, local-first. `pip install entroly`

Personal knowledge graph for Claude on Neo4j. Typed entities (Person/Project/Decision/Preference/Concept), bi-temporal edge validity (`valid_at`/`invalid_at`), per-type weighted decay, contradiction detection, and a nightly "dream" extraction process. Local bge-small-en embeddings, no API keys. Optional OAuth 2.1 + Cloudflare Tunnel for cross-device use across Claude Code, Desktop, web, and iOS.

Repo-native task continuity for AI coding agents: a reviewed task-state ledger (decisions, dead ends, evidence, checkpoints) in `.agentpack/` that any next session or client resumes from.

Session continuity engine that solves session orientation. Boot reports with gap detection and 100-point scoring, structured end-session capture with typed continuity records, and BM25 memory search. 7 tools, local SQLite + FTS5, zero API keys. `npx rekindle`

Persistent knowledge memory for AI agents. Two-way flow: read context into projects and write discoveries back. Structured by topic with AES-256 encryption.

Make any website queryable by AI agents. Index a site then ask questions and get cited answers grounded in its content via RAG. Tools: `list_sites` and `ask_site`. `npx -y @agentreadyweb/mcp`

Persistent local memory for Claude Code. Indexes every session JSONL verbatim into SQLite + ChromaDB for semantic recall (~126ms) across your entire history. Never summarizes, zero API calls, 17 MCP tools including fuzzy `recall`, deterministic `replay_file`, and git-aware `recall_project_status`. Published on PyPI as `longhand` and registered in the MCP Registry.

Institutional memory for AI agents with real BFT consensus. 4 application validators vote on every memory before it's committed — no more storing garbage. 13 MCP tools, runs locally, works with any MCP-compatible model. Backed by 4 published research papers.

Self-hosted MCP server that indexes documentation from various sources and serves it to AI Agents with semantic search.

A Model Context Protocol (MCP) server that implements the Zettelkasten knowledge management methodology, allowing you to create, link, and search atomic notes through Claude and other MCP-compatible clients.

Read and write Apple Notes with bidirectional Markdown conversion. Fast SQLite queries for listing/searching, AppleScript + native import for full CRUD. Supports stdio and Streamable HTTP transports.

Bring saved project requirements, decisions and preferences into the AI app where you are working. Configure Memory lets an authorized assistant search relevant context in your Configure profile and save facts you ask it to keep. Connect to https://mcp.configure.dev/ using Streamable HTTP, then sign in through OAuth in a supported client. No local server is needed. Public initialization and tool discovery expose no account memories; profile reads and writes require authorization. The public connection package and skill are at https://github.com/configure-dev/configure-mcp-plugin . It is a wrapper for the hosted service, not its backend. Docs: https://docs.configure.dev/mcp/overview .

Persistent AI memory brain for Claude Code, Cursor, Copilot, Windsurf, Cline & Zed. `session_start()` briefs your AI on last session, lessons, and open tasks in one call. 84 tools — Team Brain, semantic BM25+ search, Team Telepathy, Ambient Git Learning, Memory Crystals, Analytics, and managed Valkey/Redis. `npx @cachly-dev/init` — free tier, no credit card. [Website](https://cachly.dev)

Intelligent agent memory with semantic recall, automatic consolidation, contradiction detection, and bi-temporal knowledge graph. 80% on LOCOMO benchmark using 96% fewer tokens than full-context approaches.

Persistent, local-first AI memory: a semantic knowledge graph of plain Markdown files that humans and LLMs both read and write. Works with any MCP client, with optional cloud sync and team workspaces.

Hosted agent memory that keeps an audit trail. Three tools — `commit_mem`, `recall`, `status` — where each write carries provenance (which run, tool, or operator produced it), contradictions with prior state surface as inspectable changes rather than silent overwrites, and a bad run is recovered from a snapshot instead of repaired by hand. `pip install -U bilinc`

MCP for the [Sovereign AI Blog](https://sovgrid.org), a hands-on engineering log of self-hosted AI on NVIDIA DGX Spark (GB10/SM121A). 44+ articles covering SGLang, Mistral, Voxtral, OpenClaw. Three tools: full-text search, article retrieval, and SGLang config validator for GB10 hardware. Free, no auth, no client-side tracking. `https://mcp.sovgrid.org/self-hosted-ai?ref=awesome-mcp`

Retrieve context from your [Ragie](https://www.ragie.ai) (RAG) knowledge base connected to integrations like Google Drive, Notion, JIRA and more.

Hierarchical memory engine for AI agents with automatic decay, promotion, semantic dedup, and self-organizing topic tree. Single Rust binary, zero external dependencies.

Shared context engine for devs and teams. Syncs GitHub, Notion, and saved decisions into reusable project context, so Claude, ChatGPT, Cursor, VS Code and Gemini start each session with the architecture and decisions the team already made. OAuth 2.1 PKCE, AES-256 encrypted, RFC 9728 compliant. `https://mcp.memxus.com/mcp`

An Azure PaaS-hostable MCP server that provides a workspace-grounded knowledge graph for multiple developers using Azure Functions MCP triggers and Table storage.

Local index and hybrid search (SQLite FTS5 + on-device vector KNN) over your AI coding-agent conversation history across 11 tools (Claude Code, Codex, Cursor, and more). Exposes `search_threads`, `search_current_project`, `recent_threads`, and `get_thread` so any agent can recall its own past work.

Local-first external brain CLI for coding agents. SQLite-backed context, graph-aware recall via FTS5 and RRF, and governed memory with explicit promote and review gates. Ships Codex and Claude Code host shims and a native MCP server.

Local-first persistent memory for AI coding agents. Hybrid vector + full-text search (LanceDB + Tantivy), separate Markdown and Tree-sitter code indexes, per-project isolated vaults shared across IDEs (Cursor, Zed, Claude Code, Codex), bounded recall with abstain-on-low-confidence.

Turns your task manager into agent memory: hybrid (dense + sparse + keyword, RRF) retrieval over TickTick or an Obsidian vault via a six-method adapter contract. MCP server + CLI, no vector DB to build or maintain. `npm i -g @reneza/ats-cli`

The open-source, self-organizing memory for all your AI tools. Three frozen verbs (remember/recall/observe); background agents extract entities, resolve conflicts, consolidate and decay, so the vault structures itself instead of only storing. Append-only, content-addressed, encrypted (SQLCipher), single-tenant, self-hostable. `uv run python -m afair`

Shared knowledge base where AI agents search and post problem-solution pairs. Agents query before solving, post after resolving. Semantic search via pgvector, duplicate detection, auto-scoring. `npx openhive-mcp`, Free to use

Local workspace memory for Claude Desktop. Indexes your documents (Markdown, CSV, session logs) into a vector store with hybrid search, cross-session memory, auto-learn, and knowledge graph visualization. Zero external dependencies — fastembed + LanceDB, no Ollama or Docker required. 15 MCP tools.

Outcome-based persistent memory for AI coding tools. Memories that help get promoted, memories that mislead get demoted. Works with Claude Code and OpenCode via hooks + MCP.

Seven-layer agent memory over MCP. `zenbrain_store` routes what it is given: a general statement becomes a semantic fact, a narrated event an episode, a sequence of instructions a procedure. `zenbrain_recall` searches every layer and tags each result with the layer it came from; `zenbrain_consolidate` runs one sleep-like maintenance pass that promotes repeated episodes into facts and decays stale slots. Local SQLite file, no account and no network call. Apache-2.0, zero-dependency TypeScript core.

Verified, git-native memory for coding agents. Memory is plain JSON packets committed in your repo, each checked against the code it cites — hallucinated citations rejected at write, stale or changed memory withheld at recall, plus diff-time stale-catch. Local-only (BM25 + vectors), no account, no API key. `npx -y @kage-core/kage-graph-mcp install`

Zero-config persistent memory for AI agents with local SQLite. Mind Palace web dashboard, time travel (rewind/replay sessions), agent telepathy (cross-client memory sharing), code mode templates, morning briefings, and progressive context loading. 25 tools, 6 resources, 4 prompts.

Persistent shared memory for AI coding agents. Stores facts as `entity/key/value` triples with hybrid semantic search, task checkpoints, and conflict resolution — shared across Claude Code, Codex CLI, and GitHub Copilot.

AI-powered paper annotation MCP server. Reads papers, highlights key findings with semantic color coding, explains formulas, and writes structured reading notes — all saved back to Zotero. Features two-phase workflow for large PDFs (63–80% context savings) and batch annotations.

Memory the human governs: vaults separated by domain (code, notes, journal) on your own machine, hybrid retrieval (BM25 fused with vectors by RRF), and a declared vault list, so a vault left out cannot be read by mistake. Also reads what the OTHER coding agents on this machine wrote to disk, and flags when two are live in the same git worktree. Needs the Mnemosyne OS desktop app running. `npx -y @mnemosyne_os/mcp`

Personal Instagram Library: turns your Instagram saved posts into a private, AI-searchable knowledge base on your own machine. Vision-AI deep reads (summaries, key points, how-tos, links, tags) go into local SQLite, queried live through a read-only stdio MCP server by Cursor, Claude Code, and Claude Desktop — or as a static export for any AI tool. Code is shared, data stays home.

Personality Runtime for AI agents — persistent memory, identity (SOUL), and relationships that travel across Claude, OpenClaw, Mistral, and any MCP client.

An MCP server built on [markmap](https://github.com/markmap/markmap) that converts **Markdown** to interactive **mind maps**. Supports multi-format exports (PNG/JPG/SVG), live browser preview, one-click Markdown copy, and dynamic visualization features.

Shared team memory for AI coding agents. Decisions, fixes, and gotchas persist per repo and are shared across Claude Code, Cursor, and any MCP client — what one teammate's agent learns, everyone's agents remember. Local-first, zero-dependency. `npx -y threadctx-mcp`

Self-hostable, markdown-native team wiki with a built-in MCP server: agents search, read, and write your wiki pages (ranked Postgres full-text + semantic search, backlink traversal). Plus Atlas, which auto-generates a cited, coverage-checked wiki from your git repos and Jira. Go + Postgres. `npx tela-mcp`

Sovereign Agent OS — persistent memory, governance, and audit trails for AI agents. One brain for Cursor, Claude Code, Windsurf, and Gemini. Local-first `.brain/` directory with engrams, hypervisor file protection, and optional remote sync. `pip install nucleus-mcp` or Streamable HTTP at `relay.nucleusos.dev`.

Full automation of Google NotebookLM — Q&A with citations, audio podcasts, video, content generation, source management, and notebook library. MCP + HTTP REST API.

Cognitive memory for AI agents with Atkinson-Shiffrin memory model (STM/LTM/sensory register), semantic RAG, Ebbinghaus decay, trust scoring, and 76+ MCP tools.

Agent-native knowledge infrastructure. Deterministic, vertical-specific knowledge bases engineered for autonomous agent consumption via MCP. Ethics module (22 modules, EU AI Act mapped) included with every membership. Free 24hr ethics trial.

An MCP server that stores and retrieves memories from multiple LLMs using MongoDB. Provides tools for saving, retrieving, adding, and clearing conversation memories with timestamps and LLM identification.

Persistent memory MCP server for AI coding agents (Claude Code, Codex, Gemini CLI). Hybrid retrieval (vector + BM25), cross-encoder reranking, knowledge graph with PPR traversal, session checkpoint/resume, and multi-scope isolation. Local-first with LanceDB + SQLite, zero external dependencies.

Read-only doctrine access for the Agentic AI Blueprint — the industry standard reference for safe, observable, and steerable AI agent UX. Browse and search 10 principles, clusters, curated implementation examples, and application guides for production agentic AI systems. 13 public tools require no credentials. `https://aidesignblueprint.com/mcp`

Read Markdown with inlined images and heading indexes for agentic RAG over local docs or allowed URLs.

Local FAISS vector database for RAG with document ingestion (PDF/TXT/MD/DOCX), semantic search, re-ranking, and CLI tools for indexing and querying

Modern, secure MCP server for accessing ZIM format knowledge bases offline. Enables AI models to search and navigate Wikipedia, educational content, and other compressed knowledge archives with smart retrieval, caching, and comprehensive API.

AI Summarization MCP Server, Support for multiple content types: Plain text, Web pages, PDF documents, EPUB books, HTML content

Session memory, context health monitoring, reasoning quality, and truthfulness verification MCP server with 37 tools and tiered memory storage. `npx -y context-first-mcp`

A Model Context Protocol server for Mem0 that helps manage coding preferences and patterns, providing tools for storing, retrieving and semantically handling code implementations, best practices and technical documentation in IDEs like Cursor and Windsurf

Persistent neural memory for AI agents as local JSON files: neuron/synapse graph with heat scoring, fact-level search, supersede/retract corrections, automatic secret redaction, and team memory via a private Git repo. `npx -y crbro-memory`

Search 1,500+ pre-verified, cited knowledge units across 16 domains. 6 tools: query, batch query, get unit, list domains, suggest topics, report issues. Confidence scores, source provenance, and freshness tracking. Free, no API key required.

Permission-aware enterprise search and RAG that gives agents context from your business apps (Google Workspace, Microsoft 365, Slack, Jira, and others). Streamable HTTP or local stdio (`npx @pipeshub-ai/mcp`). Official registry: `io.github.pipeshub-ai/mcp`.

Git-aware, evidence-based memory store for AI coding agents. Memories anchored to git blob hashes are automatically flagged for review when linked code changes. `pip install robo-cortex[mcp]` or on registry.modelcontextprotocol.io

Enhanced graph-based memory with a focus on AI role-play and story generation

Local-first persistent memory for AI coding agents. Captures facts, decisions, patterns, and architecture notes in SQLite (with optional cloud embeddings) to reduce repeated context across sessions.

The artifact store for AI agents. Every output your agents produce — persisted, retrievable, shareable. Across runs, sessions, and tools. Session/agent metadata, content-hash dedup, expiring share links; 11 tools with path-confined uploads and destructive actions gated by default. TypeScript (`npx @artifacta-mcp/mcp`) and Python (`pipx run artifacta-mcp`).

AI enhancement middleware: precise retrieval replaces full-memory loading (~80%+ token cut), rule-based conflict arbitration with explainable reasons, and one local SQLite shared across Claude Code/Codex/Cursor/ZCode. Local-first, zero cloud, MIT. `pip install memory-arbiter-mcp`

LEGO sets, parts, minifigs, colours, and inventories from Rebrickable. 10 tools for searching sets, finding parts by colour, browsing themes, comparing sets, and discovering MOC alternate builds. 26k sets, 62k parts, 17k minifigs embedded.

Local-first AI PKM memory server for coding conversations. Imports Claude Code, Cursor, Codex CLI, Trae, and GitHub Copilot chats into notes, semantic search, tag graphs, Markdown exports, and reusable MCP memory. `npx -y chatcrystal mcp`

A simple memory tool for coding agents using DuckDB and VoyageAI.

A Support Center for Autonomous Artificial Minds. `https://sanctuary.subctx.com/v1/mcp`

Universal memory service providing semantic search, persistent storage, and autonomous memory consolidation

Distills Claude Code's 310K LoC source into 32 queryable architecture modules via MCP. 6 tools: list modules, query architecture, trace cross-cutting concerns, search patterns, and read source code. Sub-120ms p95, fully local, zero network deps.

Persistent knowledge layer for AI agents. KB, investigation threads, journal with multi-agent attribution. SQLite/PostgreSQL/Supabase.

Validate and generate SOUL.md agent identity files from Claude Desktop. SOUL.md is the open format for persistent AI agent identity — personality, voice, values, and behavioral constraints in a machine-readable YAML file.

Recall past Claude Code conversations from any project. Lists and searches your sessions, then loads one on demand as clean, compact Markdown — with outline, turn-range, and in-session search for large sessions. Read-only over local `~/.claude` transcripts; collapses tool calls to stay under the context cap. `npx -y memocall`

Security-first, self-hosted AI brain for email. Synchronizes IMAP mailboxes into user-owned PostgreSQL and exposes tools for listing, searching, reading, and cited questions across the archive. Supports local chat and embedding models through OpenAI-compatible endpoints; each deployment exposes its own Streamable HTTP `/mcp` endpoint.

Local-first memory for Codex, Claude Code, and other MCP clients. Four tools provide verbatim recall, query, health, and context-sensitive orientation through zero-LLM retrieval by default. Install `fidelis-memory` from PyPI, run `fidelis init`, then register the MCP server with the client.

AI-native ontology engineering with 39 tools and 5 prompts for OWL/RDF/SPARQL. Validate, query, diff, lint, version, and govern knowledge graphs via Oxigraph triple store.

Private-by-default memory and context layer for agents with Go/Rust runtime, staged retrieval across fused data backends, and long-horizon context continuity.

Local-first, auditable memory layer for Codex, Claude Code, and MCP clients. Stores scoped user/project memory in SQLite or Postgres, exposes read-only recall, trace, stats, and artifact tools by default, and supports opt-in governed writeback with review, forget, and audit controls. Published as `io.github.hjqcan/goodmemory` in the official MCP Registry.

Shared research cache across AI agents. Hit → instant answer from verified sources. Miss → your research saves the next dev's tokens. `npx wellread`, free.

Public source-linked notebook for AI agents. Search and read without a key; publish findings, questions, and corrections with permanent IDs and linked replies.

Persistent, searchable context storage across Claude Code sessions using SQLite FTS5. Save sessions with AI-generated summaries, two-tier full-text search, checkpoint recovery, and a web dashboard.

Persistent, self-evolving memory plugin for Claude Code. Background miner extracts durable lessons (decisions, conventions, bug fixes) from completed sessions via Claude Haiku, stores them as human-readable markdown in an Obsidian vault, and assembles query-tailored context briefings at session start. Local-first, no cloud, no API keys. Self-healing install via uv bootstrap shim, `/cortex-doctor` preflight, graceful FTS-only degraded mode when `claude` CLI missing. MIT.

Lightweight local RAG MCP server for semantic vector search over markdown documents. Reduces token consumption by 40x with sqlite-vec and multilingual-e5-small embeddings. Supports filtered search by directory and filename patterns.

Temporal memory MCP server with LanceDB vector search, weight-decay scoring, and LLM consolidation. Automatic session capture, deduplication, 6-factor relevance scoring. `pip install mem-context`

Loads your personal profile, mined from your local Claude Code/Codex/OpenCode logs, so your agent works like you instead of a cold start. One tool, `load_emulo_profile`. Run with `uvx emulo mcp`.

Self-improving learning engine for Claude Code. Extracts signals from every session (corrections, successes, confusion), runs periodic reflections, and evolves behavioral frameworks through evidence tiers (hypothesis → observed → validated). Frameworks that keep working get promoted, bad ones get retired. 9 MCP tools, automatic hooks, phase-adaptive learning. Single dependency, local-only. `npx claude-soul init --starter`

Local-first project memory and guardrails for coding agents. Records failed attempts, fragile files, and decisions per repo; warns the agent before it repeats a recorded mistake. `npx -y memini mcp`

Personal memory for Claude Code in plain Markdown notes you own. Doesn't load context blindly: a router note decides what to load and when, plus an "alma" (soul) layer for what you think and feel, not just tasks. `npx bovedia`

Governed memory for coding agents with trust lifecycle (hypothesis → active → validated → deprecated), conflict detection, staleness tracking, and health scoring. SQLite + FTS5, zero infrastructure. `pip install quilmem[mcp]`

Persistent memory layer for AI agents with entity resolution, PII detection, AES-256-GCM encryption at rest, and hybrid search. 100% on LoCoMo benchmark. Self-hosted.

A cairn marks a trail for whoever comes next. agentcairn does that for coding agents: it captures durable context from the tools you use, stores it as inspectable Markdown with provenance, and recalls only the most relevant pieces when another agent needs them. The memory is not hidden behind an admin console or a hosted database. The separate agentcairn-obsidian companion reads the same Markdown files as the agents and exposes provenance, currency, importance, supersession, and related: links. > Dogfood snapshot · 2026-07-15. Across 417 local recalls, the maintainer's vault returned context about 262× smaller than loading the full vault each time—an estimated 136.6M tokens of full-vault context avoided in aggregate. Token counts use approximately four characters per token. This is not billed-token savings, and agentcairn sends no telemetry.

5 tools · Capture session history out-of-band, Import Claude Code memory