Library / SDK

Procedural memory — learns how to do tasks and rewrites the agent's own behavior/prompts.

Best for: Teams already on LangChain/LangGraph who need agents that improve from feedback

An agentic memory library that structures memories dynamically using Zettelkasten principles: each new memory becomes a note with generated context, keywords, and tags, then is linked to related notes — and adding memories can trigger evolution of existing ones. Published at NeurIPS 2025.

Best for: Agents needing adaptive, self-linking long-term memory without fixed memory ops

A persistent-memory compression system for Claude Code and other agent CLIs. Lifecycle hooks capture what the agent does during a session, an AI worker compresses those observations, and a search skill injects relevant context back into future sessions.

Best for: Developers wanting drop-in persistent session memory for Claude Code and similar coding-agent CLIs

A persistent-memory server for AI coding agents, built on the `iii` engine and extending Karpathy's LLM-wiki pattern with confidence scoring, lifecycle, knowledge graphs, and hybrid search. Exposes 53 MCP tools and 12 auto-hooks; zero external databases required.

Best for: Coding agents needing a self-contained, no-external-DB persistent memory with hybrid search and team/namespacing

Agent-agnostic persistent memory for AI coding agents: a single, dependency-free Go binary backed by SQLite + FTS5 full-text search, exposed via an MCP (stdio) server, an HTTP API, a CLI, and an interactive TUI. Works with any MCP client (Claude Code, Codex, Gemini CLI, Cursor, Windsurf, VS Code Copilot, OpenCode, and more).

Best for: Coding agents needing a lightweight, local, agent-agnostic persistent memory that survives session and compaction boundaries

Local-first AI memory distributed as a Python CLI/library plus an MCP server. Stores conversation and project history as verbatim text — it explicitly does not summarize, extract, or paraphrase — and retrieves it with semantic search over a structured index where people/projects are 'wings', topics are 'rooms', and original content lives in 'drawers' so searches can be scoped rather than run flat. Bundles a temporal entity-relationship knowledge graph with validity windows.

Best for: Local-first agent memory where verbatim, source-traceable recall and scoped semantic search matter more than fact extraction

A single-file memory layer for AI agents that packages data, embeddings, search structure, and metadata into one portable '.mv2' file — no server, database, or sidecar files. Organized as an append-only sequence of immutable 'Smart Frames' (content + timestamps + checksums), giving time-travel queries over past memory states. Core is a Rust crate (memvid-core) with Node.js, Python, and CLI SDKs on top.

Best for: Agents or apps needing portable, serverless, single-file memory they can copy/version/share, with offline hybrid + multimodal retrieval

Local cognitive memory for MCP-compatible agents, shipped as a single ~25MB Rust binary with a 13-tool MCP server (consolidated from 34 tools in the v2.2.0 'Tool Consolidation' release — old names remain dispatchable as hidden back-compat aliases), an Axum HTTP/WebSocket server, and a SvelteKit 3D memory dashboard. Implements neuroscience-grounded mechanisms — FSRS-6 spaced repetition, prediction-error gating, synaptic tagging, spreading activation, dual-strength model, Retroactive Salience Backfill, and 'memory dreaming' consolidation — across ~30 stateful cognitive modules. 100% local.

Best for: Developers wanting a fully-local, inspectable cognitive memory for coding agents that decays, consolidates, and forgets like a brain

A framework-agnostic, fully-offline AI memory system (Python library `taosmd` + optional MCP server) built around 'provable memory': everything lands first in an append-only verbatim archive that is never edited or deleted, and the searchable memory is derived from that archive, never written over it. Because the source is retained, a verifier checks each extracted fact against the exact text it came from and leaves out what it can't support. Part of the taOS ecosystem; runs on 8GB+ RAM (Raspberry Pi 4B to workstation), zero cloud.

Best for: Offline / air-gapped or low-resource deployments needing auditable, source-preserving memory with no cloud dependency

A single Rust binary that gives AI agents durable cross-session memory as an MCP-native server — one binary, one SQLite file, no Docker, Postgres, or cloud. Exposes 55 MCP tools spanning entity CRUD, hybrid search/RAG, an entity link graph, an immutable journal/audit trail, key-value state with TTL, and a memory lifecycle engine. Ships framework adapters for LangChain, CrewAI, Haystack, Pydantic AI, Google ADK (all on PyPI), plus source-only LangGraph and AutoGen adapters and a web dashboard. Renamed from Mimir (earlier Mneme) on 2026-07-08.

Best for: Local-first or air-gapped agents wanting a single-binary, MCP-native memory store with hybrid search, audit trail, and lifecycle decay

A two-tier memory API server for AI agents built on Redis. Working memory is session-scoped and fast; long-term memory is persistent and searchable across sessions. Exposes both a REST API and a Model Context Protocol (MCP) server from the same backend, so any MCP-capable agent or HTTP client can connect without code changes. Memory extraction strategy (discrete facts, conversation summary, user preferences, or custom) is configurable per deployment.

Best for: Agents already running in Redis-backed infrastructure that want persistent memory without adding a new database · Teams wanting a single memory server accessible from both HTTP clients and MCP-native agents

Non-parametric self-evolving agent memory that applies runtime reinforcement learning on an episodic memory store. Instead of passive semantic matching (retrieve nearest neighbours and hope), MemRL uses environmental feedback signals to learn which past episode strategies are actually useful and promote them via a Two-Phase Retrieval mechanism — decoupling stable reasoning from the plastic memory. Agents improve from experience without weight updates or fine-tuning.

Best for: Research and agentic systems where agents repeatedly solve similar tasks and can provide environmental feedback (reward signals) to improve memory selection over time

BEAM (Bilevel Episodic-Associative Memory): a working-memory tier (hot context, auto-injected before LLM calls, TTL eviction) consolidates into an episodic long-term tier, alongside a TripleStore temporal knowledge graph with version chains and as-of queries. Optional LLM-driven fact extraction and entity extraction at write time; a `sleep` command runs consolidation. Memory banks give per-domain isolation. Ships Hermes-first (native plugin with lifecycle hooks) but is framework-agnostic via MCP, Python SDK, and CLI.

Best for: Local-first or offline personal agents where memory must stay on-device with no cloud in the read path · Coding-agent memory over MCP (Claude Code, Cursor, Codex CLI, Windsurf) with sub-millisecond in-process recall · Low-resource deployments (Raspberry Pi, 1 GB VPS) that can't carry a vector DB or Postgres · Hermes Agent users wanting a native memory provider with automatic context injection