nocturne_memory
MCP ServerFreeA lightweight, rollbackable, and visual Long-Term Memory Server for MCP Agents. Say goodbye to Vector RAG and amnesia. Empower your AI with persistent, graph-like structured memory across any model, session, or tool. Drop-in replacement for OpenClaw.
Capabilities13 decomposed
graph-based persistent memory storage with uri-hierarchical addressing
Medium confidenceStores AI agent memories as a four-layer graph model (Node-Memory-Edge-Path) with URI-based hierarchical addressing (e.g., core://agent/identity, user://preferences/language) instead of flat vector embeddings. Each memory is a first-class entity with metadata, relationships, and structural context preserved across sessions. The system uses SQLite or PostgreSQL as the backing store with domain-scoped URI routing enabling semantic organization without semantic shredding.
Uses URI-based hierarchical addressing (domain://path) with a four-layer graph model (Node-Memory-Edge-Path) instead of vector embeddings, preserving structural relationships and enabling deterministic path-based queries. This is fundamentally different from Vector RAG which fragments knowledge into embedding vectors and loses hierarchy.
Preserves memory structure and relationships unlike Vector RAG which causes 'semantic shredding'; enables deterministic URI-based retrieval instead of probabilistic cosine similarity matching, making memory queries reliable and debuggable.
version-controlled memory mutations with rollback capability
Medium confidenceImplements dual version control: Memory version chains track the evolution of individual memory objects (create → update → update), while ChangesetStore records all mutations as atomic transactions with timestamps and metadata. Each change is immutable and reversible, enabling agents to modify their own memories while humans can audit, review, and rollback to any prior state. Uses SQLite/PostgreSQL transaction logs to maintain consistency.
Implements dual version control (Memory version chains + ChangesetStore) where each mutation is immutable and reversible, with full transaction semantics. This enables agents to autonomously modify memories while maintaining complete human-auditable history and point-in-time rollback — a pattern borrowed from version control systems like Git but applied to agent cognition.
Unlike Vector RAG systems which are append-only and immutable, Nocturne enables agents to modify their own memories with full auditability and rollback, combining the mutability of traditional databases with the traceability of version control systems.
change review and approval workflow for memory mutations
Medium confidenceImplements an optional review workflow where memory mutations (create, update, delete) are staged as pending changesets that require human approval before persisting to the main memory graph. Reviewers can inspect the changeset (before/after state), add comments, and approve or reject. Rejected changes are discarded; approved changes are committed atomically. This enables human-in-the-loop learning for agents.
Implements a staged changeset review workflow where mutations are pending until human approval, enabling mandatory oversight of agent learning. This is a safety mechanism not found in Vector RAG systems.
Provides human-in-the-loop control over agent memory mutations through a review workflow, whereas Vector RAG systems have no mechanism for oversight or rejection of learned knowledge.
memory content versioning and diff visualization
Medium confidenceTracks versions of individual memory content (not just mutations) and generates diffs showing what changed between versions. The diff system highlights additions, deletions, and modifications at the character or line level. Humans can browse version history and compare any two versions side-by-side. This enables understanding how a memory evolved and identifying when incorrect information was introduced.
Provides fine-grained content versioning and diff visualization for individual memories, enabling humans to understand exactly how a memory evolved. This is a developer-friendly debugging tool absent from Vector RAG systems.
Enables detailed inspection of memory content evolution through diffs, whereas Vector RAG systems provide no visibility into how knowledge changed over time.
cross-session memory persistence and agent identity continuity
Medium confidenceEnsures memories created in one session persist and are accessible in subsequent sessions, enabling agents to maintain continuous identity and knowledge across disconnected conversations. The system stores memories with session metadata (session_id, timestamp) but retrieves them without session filtering, so an agent can access all its memories regardless of which session created them. This solves the stateless agent problem where each conversation starts fresh.
Solves the fundamental stateless agent problem by persisting memories across sessions and enabling agents to maintain continuous identity. This is the core value proposition of Nocturne Memory — agents are no longer amnesiacs.
Enables true agent continuity and identity across sessions, whereas stateless LLM APIs (OpenAI, Anthropic) lose all context between conversations; Vector RAG can retrieve documents but doesn't solve agent identity.
mcp-native tool interface for agent memory operations
Medium confidenceExposes memory operations as MCP tools (create_memory, read_memory, update_memory, delete_memory, query_memory_by_uri, traverse_graph) that agents can call directly via the Model Context Protocol. Each tool validates inputs against the URI schema, enforces domain constraints, and returns structured responses. The MCP server acts as the AI-facing interface, translating agent intents into graph operations while maintaining consistency and access control.
Implements MCP tools as the primary agent interface, allowing Claude/Gemini to autonomously perform full CRUD operations on its own memory graph. This is distinct from Vector RAG which typically exposes only read-only retrieval; Nocturne agents are active memory managers, not passive consumers.
Provides full CRUD memory operations via MCP tools (not just retrieval), enabling agents to learn and evolve their own knowledge base autonomously, whereas Vector RAG systems force agents into a read-only retrieval pattern.
uri-based memory querying with domain scoping and path pattern matching
Medium confidenceEnables agents and humans to query memories using URI patterns (e.g., 'core://agent/*', 'user://preferences/language') with wildcard matching, prefix filtering, and domain-scoped isolation. The URI system acts as a semantic namespace where domain (core, user, task, knowledge) determines memory category and path determines hierarchical location. Queries return all memories matching the pattern with their full graph context (edges, relationships, metadata).
Uses URI-based hierarchical path matching (domain://path/to/memory) with wildcard support instead of semantic similarity, providing deterministic, debuggable queries. This is a filesystem-like approach to memory retrieval rather than the probabilistic vector similarity used in RAG systems.
Deterministic URI-based queries are debuggable and reproducible, unlike Vector RAG which returns different results based on embedding similarity; enables structural memory organization without semantic shredding.
graph traversal and relationship navigation across memory nodes
Medium confidenceImplements graph traversal algorithms (BFS, DFS, path-finding) to navigate relationships between memory nodes (edges) and discover connected memories. The four-layer model (Node-Memory-Edge-Path) enables rich relationship types: memories can reference other memories, form hierarchies, or represent temporal sequences. Traversal respects domain boundaries and returns full context including intermediate nodes and relationship metadata.
Implements explicit graph traversal with relationship navigation (edges as first-class entities) rather than implicit similarity-based retrieval. This allows agents to discover memories through explicit relationships and understand the reasoning chain that connected them, not just semantic proximity.
Enables agents to reason about memory relationships explicitly (following edges) rather than implicitly (similarity scores), making reasoning chains auditable and debuggable; Vector RAG has no relationship model.
human-facing memory browser and audit dashboard
Medium confidenceProvides a web-based frontend (FastAPI backend + HTML/JS frontend) for humans to browse agent memories, visualize the memory graph, review changes, and approve/reject mutations. The dashboard displays memories organized by URI domain, shows version history with before/after diffs, and enables point-in-time rollback. Authentication is required; the interface is read-only for auditors and read-write for administrators.
Provides a dedicated audit and review interface for human oversight of agent memory mutations, with visual graph browsing and point-in-time rollback. This human-in-the-loop capability is absent from Vector RAG systems which are typically opaque to non-technical users.
Enables human oversight and auditability of agent memory through a visual interface, whereas Vector RAG systems are typically black-box retrieval with no human visibility into what the agent 'knows' or how it learned it.
memory domain isolation and access control
Medium confidenceEnforces domain-based memory isolation where memories are scoped to domains (core, user, task, knowledge) with separate access control rules. Each domain can have different retention policies, visibility rules, and mutation permissions. The URI system ensures memories in one domain cannot accidentally interfere with another (e.g., user preferences cannot overwrite core agent identity). Domain configuration is defined at deployment time and enforced at the database layer.
Implements domain-based memory isolation at the URI level, ensuring memories in different domains (core agent identity vs user preferences vs task state) cannot interfere. This is a structural safety mechanism built into the data model, not an afterthought.
Provides structural isolation of memory types through URI domains, preventing accidental cross-contamination; Vector RAG systems have no built-in isolation mechanism and rely on external access control.
glossary and keyword indexing for memory discovery
Medium confidenceMaintains a glossary of keywords and concepts extracted from memory content, enabling agents and humans to discover memories by topic without full-text search. Keywords are indexed and linked to their source memories, creating a lightweight semantic index. The glossary is automatically updated as memories are created/modified and can be manually curated to add domain-specific terminology.
Provides lightweight keyword-based semantic indexing without embedding overhead, enabling topic-based memory discovery. This is a middle ground between deterministic URI queries and expensive vector similarity, optimized for agent reasoning about topics.
Offers topic-based memory discovery without the computational cost of embeddings or the brittleness of keyword matching; more efficient than Vector RAG for topic-scoped queries.
sqlite and postgresql backend abstraction with migration system
Medium confidenceAbstracts database operations behind a unified client interface (SQLiteClient) that supports both SQLite (for development/single-instance) and PostgreSQL (for production/multi-instance). Includes a migration system for schema versioning, enabling safe upgrades and rollbacks of the database schema. The abstraction layer handles connection pooling, transaction management, and query optimization for both databases.
Provides a unified database abstraction supporting both SQLite and PostgreSQL with a migration system, enabling development-to-production scaling without code changes. This is a pragmatic approach to database flexibility.
Supports both SQLite (for prototyping) and PostgreSQL (for production) with the same codebase, reducing friction in scaling; most memory systems are tied to a single database backend.
docker compose deployment with nginx reverse proxy
Medium confidenceProvides a Docker Compose configuration that orchestrates Nocturne Memory (FastAPI backend), PostgreSQL database, and Nginx reverse proxy in a single deployment. Nginx handles SSL termination, request routing, and load balancing. The configuration includes environment variable injection, volume management for persistence, and health checks. Suitable for single-server deployments or as a base for Kubernetes migration.
Provides a complete, production-ready Docker Compose setup with Nginx reverse proxy, SSL termination, and health checks — not just a Dockerfile. This enables operators to deploy Nocturne Memory without infrastructure expertise.
Offers a turnkey Docker Compose deployment with Nginx and PostgreSQL, reducing deployment friction compared to manual setup or Kubernetes complexity.
Capabilities are decomposed by AI analysis. Each maps to specific user intents and improves with match feedback.
Related Artifactssharing capabilities
Artifacts that share capabilities with nocturne_memory, ranked by overlap. Discovered automatically through the match graph.
Jean Memory
** - Premium memory consistent across all AI applications.
Memory-Plus
** a lightweight, local RAG memory store to record, retrieve, update, delete, and visualize persistent "memories" across sessions—perfect for developers working with multiple AI coders (like Windsurf, Cursor, or Copilot) or anyone who wants their AI to actually remember them.
mem0ai
Long-term memory for AI Agents
mem0
Universal memory layer for AI Agents
letta
Letta is the platform for building stateful agents: AI with advanced memory that can learn and self-improve over time.
Mem0
Persistent memory layer for AI agents.
Best For
- ✓AI agent developers building multi-turn, stateful systems
- ✓Teams implementing agentic AI with persistent identity requirements
- ✓Builders needing structured knowledge graphs instead of vector RAG
- ✓Teams requiring memory auditability and compliance (financial AI, healthcare agents)
- ✓Developers debugging agent behavior by replaying memory state at different points in time
- ✓Systems where human oversight of agent learning is mandatory
- ✓Regulated environments (healthcare, finance) where agent learning must be audited
- ✓Teams implementing human-in-the-loop AI where oversight is mandatory
Known Limitations
- ⚠Graph traversal performance degrades with very large memory graphs (100k+ nodes) without proper indexing strategy
- ⚠URI path design requires upfront schema planning — poor domain structure leads to inefficient queries
- ⚠No built-in distributed graph partitioning — single-instance bottleneck for high-concurrency agent fleets
- ⚠Rollback is point-in-time only — cannot selectively revert individual mutations within a changeset
- ⚠Version chains grow linearly with mutation count — no automatic pruning, requires manual maintenance
- ⚠Rollback latency increases with memory graph size; reverting large graphs can take seconds
Requirements
Input / Output
UnfragileRank
UnfragileRank is computed from adoption signals, documentation quality, ecosystem connectivity, match graph feedback, and freshness. No artifact can pay for a higher rank.
Repository Details
Last commit: Apr 20, 2026
About
A lightweight, rollbackable, and visual Long-Term Memory Server for MCP Agents. Say goodbye to Vector RAG and amnesia. Empower your AI with persistent, graph-like structured memory across any model, session, or tool. Drop-in replacement for OpenClaw.
Categories
Alternatives to nocturne_memory
Are you the builder of nocturne_memory?
Claim this artifact to get a verified badge, access match analytics, see which intents users search for, and manage your listing.
Get the weekly brief
New tools, rising stars, and what's actually worth your time. No spam.
Data Sources
Looking for something else?
Search →