mnemosyne

<div align="center">  # Mnemosyne ### **Cognitive memory for AI agents — structured, bitemporal, isolated.** Not a vector store. A complete memory architecture: 10 cognitive primitives, bitemporal correctness,<br/> database-enforced multi-tenancy, session-to-memory pipeline, and a 7-stage hybrid recall engine. [](./LICENSE) [](./tsconfig.base.json) [](https://nodejs.org) [](https://pnpm.io) [](https://github.com/lucasmailland/mnemosyne/actions/workflows/ci.yml) [](./CONTRIBUTING.md) [](https://github.com/lucasmailland/mnemosyne/stargazers) [Try it in 60 seconds](#-try-it-in-60-seconds) · [Why](#-why-this-exists) · [10 Primitives](#-10-cognitive-primitives) · [Architecture](#-architecture) · [Session Pipeline](#-session-pipeline) · [MCP](#3-mcp-server--give-claude-desktop--cursor-durable-memory) · [Packages](#-packages) </div> --- > **Implementation status:** This project is alpha. Not all described features are wired yet — see [`docs/STATUS.md`](./docs/STATUS.md) for what is working, what is beta/alpha, and what is planned. > Named after **Mnemosyne**, the Greek Titaness of memory and mother of the nine Muses. The Greeks believed nothing could be created without first being remembered. Same idea: an agent is only as good as what it can recall. Mnemosyne is an open-source **cognitive memory layer** that sits between your AI agents and Postgres. It is not a vector store with a nicer API — it is a structured substrate that knows *what* was true, *when* it was true, *when you learned it*, *how confident you are*, *who it belongs to*, and *what kind of thing it is*. Import it as a library, run it as an HTTP API, or plug it into Claude Desktop / Cursor as an MCP server. ``` recall() → 7-stage hybrid: BM25 + dense vectors + graph expansion + rerank remember() → write a fact with provenance, confidence, sensitivity, and valid-time session() → conversations collapse into structured memories automatically (wired end-to-end — beta; requires an LLM provider) forget() → bitemporal soft-invalidate — history is never destroyed ``` --- ## ⚡ Try it in 60 seconds The fastest path is the bundled Docker stack — Postgres + pgvector + the HTTP server, one command. ```bash git clone https://github.com/lucasmailland/mnemosyne cd mnemosyne/docker cp .env.example .env # open .env and set MNEMO_LLM_API_KEY=sk-... (your own OpenAI/Anthropic key) docker compose up -d ``` The server is now live on `http://localhost:3939`. Confirm it's healthy: ```bash curl http://localhost:3939/healthz # -> {"status":"ok"} ``` Mint a workspace-scoped API key (printed exactly once — copy it): ```bash docker compose exec server node scripts/create-api-key.cjs --workspace ws_default # -> mns_live_a3f9k2x... ``` Remember something, then recall it: ```bash # remember curl http://localhost:3939/v1/facts \ -H "Authorization: Bearer mns_live_a3f9k2x..." \ -H "Content-Type: application/json" \ -d '{"content":"Acme prefers communication in Spanish."}' # recall curl http://localhost:3939/v1/recall \ -H "Authorization: Bearer mns_live_a3f9k2x..." \ -H "Content-Type: application/json" \ -d '{"query":"what language should we use with Acme?"}' ``` Or use the **CLI** for direct operator access: ```bash npm install -g @mnemosyne/cli export MNEMO_URL=http://localhost:3939 export MNEMO_KEY=mns_live_... mnemo remember "The user prefers concise responses" mnemo recall "user preferences" ``` Full operator guide in [`docker/README.md`](./docker/README.md). --- ## 🧭 Why this exists Agents forget. Every conversation starts from zero, every session re-discovers what it knew last week, and "memory" usually means dumping the last N turns into the prompt. The common fix — naive RAG over a vector store — papers over the symptom and introduces three failures that get worse at scale: - **No provenance.** A chunk is retrieved, but you can't say *where it came from*, *how confident you are*, or *whether it's still true*. Contradictions silently coexist. - **No time.** "Acme's plan is Pro" and "Acme upgraded to Enterprise" are both just vectors. There is no notion of *valid-from / valid-until*, and no way to ask "what did we believe on March 1st?" - **No tenancy.** Multi-tenant memory bolted on with a `WHERE workspace_id = ?` is one missing clause away from a cross-customer data leak. Mnemosyne treats memory as a **first-class, structured, temporal, isolated** datastore. --- ## 🧠 10 Cognitive Primitives Most memory systems store a flat blob of text. Mnemosyne distinguishes *what kind of thing* is being remembered — because a fact, a decision, and an episode need to be recalled, decayed, and reasoned over differently. <p align="center"> <img src=".github/assets/primitives.svg" alt="The 10 cognitive primitives grouped by decay class — Semantic (slow): fact, decision, strategy, workflow, skill, reasoning; Episodic (medium): episode, entity; Working (fast): task; Immutable (append-only): event" width="100%" /> </p> | Primitive | Purpose | Decay class | |-----------|---------|-------------| | `fact` | Durable behavioral knowledge about a user, agent, or domain — with confidence and a valid-time range | Semantic (slow) | | `decision` | A logged architectural or policy decision with full rationale and a supersede lifecycle | Semantic (slow) | | `strategy` | A `trigger → action` heuristic the agent applies recurrently, scored by success/failure | Semantic (slow) | | `workflow` | A reusable multi-step process template with ordered steps, conditions, and timing | Semantic (slow) | | `skill` | A stored prompt template for a repeatable task, retrievable semantically | Semantic (slow) | | `reasoning` | A stored chain-of-thought — a question, its reasoning steps, and the conclusion reached | Semantic (slow) | | `episode` | A bounded narrative record of a session or event (hierarchical, delta-capable) | Episodic (medium) | | `entity` | A named real-world entity (person, org, project, concept, place) facts and episodes reference | Episodic (medium) | | `task` | A tracked action item with a full lifecycle and delegation/blocking chains | Working (fast) | | `event` | An immutable, append-only record of something that happened (no `updatedAt`) | Immutable (no decay) | > **Why it matters**: when the consolidation worker runs its "sleep cycle," it promotes `episode` fragments to `fact` primitives, clusters related `fact` nodes into `entity` records, and surfaces contradictions for review — all based on primitive type. A flat blob can't do this. --- ## 🎁 What you get | | | |---|---| | **🧠 10 Cognitive Primitives** | Facts, decisions, strategies, workflows, skills, reasoning, episodes, entities, tasks, events — each with a decay class (semantic / episodic / working / immutable) and confidence semantics. Not a flat blob. | | **🔭 7-Stage Hybrid Recall** | BM25 lexical + dense `halfvec(1536)` cosine + Memory-Graph expansion + cross-encoder rerank. HyDE on the query side. One `recall()` call, four retrieval strategies fused. | | **🕰️ Bitemporal Correctness** | Every fact carries a **valid time** (when it's true in the world) and a **transaction time** (when the system learned it). Time-travel queries are first-class. | | **🛡️ Multi-Tenant RLS** | Postgres Row-Level Security with `FORCE`. Isolation is **structural** — enforced by the database, not by a `WHERE` clause you hope every query remembers. | | **💬 Session Pipeline** | Start a session, stream turns, collapse it — the engine extracts facts and decisions automatically. Conversations become memories without any glue code. | | **🔒 Sensitivity Tiers** | Per-fact sensitivity (`public → internal → confidential → restricted`) enforced at the API layer with a numeric ceiling. Agents only see what their role allows. | | **🔌 Bring Your Own LLM** | Never hardcodes a model. OpenAI, Anthropic, Google, Cohere, Mistral, Voyage, Ollama — plus a Router and a BudgetGuard. | | **🕸️ Memory Graph** | Facts form a typed graph. Entities, episodes, and decisions connect through relations with confidence + provenance — expandable during recall, renderable in a UI. | | **🚪 Three Surfaces** | Embed the library, call the HTTP API, or attach the MCP server. Same cognitive engine underneath. | ### How it compares | | Plain vector store | Hosted memory SaaS | Mnemosyne | |------------------------------|---------------------------|----------------------------|--------------------------------------------| | Retrieval | dense only | usually dense + simple BM25 | **BM25 + dense + graph + rerank (7 stages)** | | Cognitive structure | none — flat blobs | none — flat blobs | **10 typed primitives** | | Session → memory pipeline | ❌ | partial | **start / turn / collapse → facts** | | Time semantics | none | timestamps | **bitemporal (valid + tx time)** | | Per-fact sensitivity | none | none | **public/internal/confidential/restricted** | | Tenancy | `WHERE workspace_id = ?` | managed plane | **Postgres RLS `FORCE` — structural** | | Provenance + confidence | optional metadata | partial | **first-class on every primitive + edge** | | LLM coupling | usually picks for you | usually picks for you | **BYO key, router + BudgetGuard** | | Where it runs | their cluster | their cluster | **your Postgres** (or one container) | | License | closed / SaaS | closed / SaaS | **Apache-2.0** | --- ## 🏛️ Architecture <p align="center"> <img src=".github/assets/architecture.svg" alt="Mnemosyne architecture: consumers → access surfaces → cognitive engine → Postgres + LLM providers" width="100%" /> </p> ### The 7-stage recall pipeline A single `recall()` fans out across retrieval strategies and fuses them before returning ranked facts: <p align="center"> <img src=".github/assets/recall-pipeline.svg" alt="Hybrid recall pipeline — query fans out to BM25, dense halfvec(1536) cosine, and graph expansion; results merge, rerank, and emit ranked facts with provenance" width="100%" /> </p> **Bitemporality, concretely.** Each fact row carries both `valid_time` (a range — when the statement holds in the real world) and `transaction_time` (when Mnemosyne recorded it). `forget()` doesn't delete; it closes a validity range. That makes "as-of" queries trivial and means an audit can always reconstruct *what the agent believed at any past moment* — essential when an agent made a decision you later need to justify. **RLS is structural, not advisory.** Every tenant-scoped table runs Row-Level Security with `FORCE ROW LEVEL SECURITY`, so even the table owner is subject to the policy. Each request opens a transaction that sets the workspace context; the database — not your handler — guarantees a query can only ever see its own workspace's rows. --- ## 💬 Session Pipeline Agent conversations don't need to be transcribed manually into memories. Start a session, stream turns as they happen, and collapse it when the conversation ends. The engine extracts facts and decisions automatically. <p align="center"> <img src=".github/assets/session-pipeline.svg" alt="Session pipeline sequence — POST /v1/session/start, stream turns via /v1/session/{id}/turn, then /v1/session/{id}/collapse; the server writes to PostgreSQL and extracts facts, decisions, and entities into primitives in the background" width="100%" /> </p> Three HTTP calls. The cognitive engine handles the rest. ```ts const { sessionId } = await memory.startSession({ workspaceId: "ws_acme", agentId: "agent_support" }); // stream the conversation await memory.appendTurn({ sessionId, role: "user", content: "I need to cancel my subscription" }); await memory.appendTurn({ sessionId, role: "assistant", content: "I've processed the cancellation..." }); // collapse → extract facts + decisions into the memory graph await memory.collapseSession({ sessionId, strategy: "auto" }); ``` --- ## 🔒 Sensitivity Tiers Every fact and primitive carries a sensitivity level. The API enforces a **ceiling** — agents only see facts at or below the level their API key allows. Violations return 404 (not 403) to prevent tenant-probing attacks. <p align="center"> <img src=".github/assets/sensitivity.svg" alt="Sensitivity tiers — public (0), internal (1), confidential (2), restricted (3); an agent reads at or below its numeric ceiling, and over-ceiling reads return 404 not 403" width="100%" /> </p> Sensitivity is stored as a numeric order (`{public:0, internal:1, confidential:2, restricted:3}`). The ceiling check is always a numeric comparison — never string equality — so there's no ambiguity at tier boundaries. --- ## 📦 Packages A pnpm + Turborepo monorepo. All Apache-2.0. See [`docs/STATUS.md`](./docs/STATUS.md) for detailed feature-level status. | Package | Status | Depends on | Description | |---------|--------|------------|-------------| | [`@mnemosyne/types`](./packages/types) | ✅ Stable | — | All port interfaces, domain types, branded types, purity guard tests. Zero logic, zero infrastructure. Foundation for the entire monorepo. | | [`@mnemosyne/core`](./packages/core) | 🔶 Beta | types | Domain engine: 10 cognitive primitives, 7-stage recall pipeline, bitemporal facts, RLS transactions, session collapse, worth/decay. The `src/v3/` domain zone has zero infrastructure imports (enforced by purity guard). | | [`@mnemosyne/adapter-postgres`](./packages/adapter-postgres) | ✅ Stable | types | `StorageAdapter` + `QueueAdapter` + `OutboxAdapter` implementations via Drizzle ORM. Drains the transactional outbox through the `QueueAdapter`/`OutboxAdapter` port (the `OutboxWorker`). 11 v3 migrations. Enforces RLS via `withMnemoTx`. | | [`@mnemosyne/adapter-redis`](./packages/adapter-redis) | ✅ Stable | types | `CacheAdapter` implementation via Redis/Valkey. Powers the ACT-R hot-tier sorted set (`mnemo:{wid}:hot:facts`). | | [`@mnemosyne/llm-providers`](./packages/llm-providers) | ✅ Stable | types | 7 LLM provider adapters (OpenAI, Anthropic, Google, Cohere, Mistral, Voyage, Ollama) + `LLMRouter` + `BudgetGuard`. | | [`@mnemosyne/adapter-llm`](./packages/adapter-llm) | ✅ Stable | types, llm-providers | Bridges `@mnemosyne/llm-providers` to the `LLMAdapter` port. `createLlmAdapter(provider, opts)`. | | [`@mnemosyne/server`](./packages/server) | 🔶 Beta | core, types, adapter-postgres | Hono HTTP API. Bearer auth, OpenAPI 3.1 at `/v1/openapi.json`, Pino logging. Routes requiring LLM return 501 when no provider is configured. | | [`@mnemosyne/mcp`](./packages/mcp) | 🔶 Beta | client-ts | Standalone MCP stdio server. 14 tools (all live). `npx @mnemosyne/mcp`. | | [`@mnemosyne/client-ts`](./packages/client-ts) | ✅ Stable | types | Typed HTTP SDK. Zero runtime deps. Node, Bun, Deno, Cloudflare Workers, browsers. | | [`@mnemosyne/cli`](./packages/cli) | 🟡 Alpha | node built-ins | `mnemo` binary, 5 commands: `recall`, `remember`, `forget`, `status`, `config set/get`. | | [`@mnemosyne/adapter-vector`](./packages/adapter-vector) | ✅ Stable | types | `PgVectorAdapter` — `halfvec(1536)` cosine search over pgvector, implementing the `VectorAdapter` port. | | [`@mnemosyne/consolidation`](./packages/consolidation) | 🔶 Beta | core, types | Sleep-cycle consolidation worker. `ConsolidationGate` + replay validator + scheduler are wired at server boot. | | [`@mnemosyne/federation`](./packages/federation) | 🔶 Beta | core, types | Ed25519-signed peer-to-peer sync. `SyncEngine` + `DrizzleSyncStorage` + LWW `/resolve` + 8 HTTP routes; only the pull transport is still pending. | | [`@mnemosyne/plugins`](./packages/plugins) | ✅ Stable | core, types | In-process plugin runtime. `PluginLoader` is wired at server boot. | | [`@mnemosyne/cup`](./packages/cup) | 🟡 Alpha | core, types | Cognitive Upgrade Protocol — `TypeMapper` for v2→v3 schema migration. Library-only. | | [`docker/`](./docker) | ✅ Stable | — | Self-hostable stack: `pgvector/pgvector:pg17` + `mnemo-migrate` + server. `docker compose up`. | --- ## 🚪 Three ways to consume Same cognitive engine, three surfaces. Pick the coupling that fits your architecture. ### 1. Library — embed the engine in your own Postgres transaction Best when you already own the database and want zero network hops. ```ts import { createMnemoClient, createDrizzleStorage } from "@mnemosyne/core"; // inside one of your own Drizzle transactions: const client = createMnemoClient({ storage: createDrizzleStorage(tx) }); const hits = await client.recall({ workspaceId: "ws_acme", query: "what language should we use with Acme?", vector: queryEmbedding, // you embed with your own model; @mnemosyne/core stays provider-agnostic topK: 5, }); ``` ### 2. HTTP API — talk to a centralized memory service Best when several services share one memory and you'd rather speak RPC than couple to the engine. ```ts import { MnemosyneClient } from "@mnemosyne/client-ts"; const memory = new MnemosyneClient({ url: "https://memory.acme.com", apiKey: process.env.MNEMOSYNE_API_KEY!, }); const { hits } = await memory.recall({ query: "billing escalation policy", limit: 10 }); const written = await memory.createFact({ content: "Acme prefers communication in Spanish.", attribution: { source: "user_stated" }, tags: ["client:acme"], }); console.log("stored fact:", written.id); ``` ### 3. MCP server — give Claude Desktop / Cursor durable memory Best when the consumer is an AI assistant. Add this to `claude_desktop_config.json`: ```json { "mcpServers": { "mnemosyne": { "command": "npx", "args": ["-y", "@mnemosyne/mcp"], "env": { "MNEMO_URL": "https://memory.acme.com", "MNEMO_KEY": "mns_live_..." } } } } ``` Restart the client — `mnemosyne` appears in the MCP tools menu. 14 tools (all live): | Tool | What it does | |------|--------------| | `memory_recall` | Semantic + hybrid search across the workspace | | `memory_remember` | Store a new fact with provenance | | `memory_pin` | Mark a fact as permanently high-priority | | `memory_forget` | Soft-delete (bitemporal — history preserved) | | `memory_timeline` | Retrieve the temporal history of a subject | | `memory_search` | Full-text BM25 search | | `memory_relate` | Create a typed relation between two nodes | | `memory_decide` | Store a decision with rationale | | `memory_entity` | Create or update a tracked entity | | `memory_status` | Check server health and workspace stats | | `memory_remind_when` | Schedule a prospective-memory trigger on a condition or time | | `memory_consolidate` | Trigger a consolidation pass (merge/retire duplicate facts) | | `memory_episode_start` | Open a named episode context (session) | | `memory_episode_end` | Close and collapse an episode, extracting facts from the transcript | See [`packages/mcp/README.md`](./packages/mcp/README.md) for Cursor / Continue config. --- ## 🧪 Bring your own LLM Mnemosyne never ships a model or a key. You wire in a provider; your users pay for exactly what they use. | Provider | Good for | |----------|----------| | `OpenAIProvider` | embeddings (`text-embedding-3-*`) + judgments | | `AnthropicProvider` | high-quality judgment / summarization | | `GoogleProvider` | Gemini embeddings + completions | | `CohereProvider` | embeddings + native rerank | | `MistralProvider` | cost-efficient EU-hosted models | | `VoyageProvider` | retrieval-tuned embeddings | | `OllamaProvider` | fully local / air-gapped | Mix and match per task with the **Router**, cap spend with the **BudgetGuard**: ```ts import { OpenAIProvider, AnthropicProvider, LLMRouter, BudgetGuard, } from "@mnemosyne/llm-providers"; const router = new LLMRouter({ default: new AnthropicProvider({ apiKey: process.env.ANTHROPIC_API_KEY! }), perTask: { embed: new OpenAIProvider({ apiKey: process.env.OPENAI_API_KEY!, model: "text-embedding-3-small" }), }, }); // Wrap anything to enforce a hard daily ceiling: const guarded = new BudgetGuard({ provider: router, dailyUSDCap: 25, perRequestCap: 0.5, unknownCostPolicy: "block", onSpend: (delta, total) => console.log(`+$${delta.toFixed(4)} — $${total.toFixed(2)} today`), }); ``` --- ## 🕸️ The Memory Graph Facts aren't a flat list — they form a typed graph. Nodes come in three tiers — **entity**, **episode**, **decision** — connected by typed **relations** that each carry confidence and provenance. The graph expands during recall and can be rendered in any UI. <p align="center"> <img src=".github/assets/memory-graph.svg" alt="The Memory Graph — typed nodes (entity, episode, decision) connected by typed relations with confidence and provenance" width="100%" /> </p> It ships in two halves split at the database boundary so you can render it anywhere: - **`@mnemosyne/core/graph`** — client-safe. Canvas geometry, node/edge types, layout. **Zero database access**, bundles cleanly into a browser. - **`@mnemosyne/core/graph/server`** — `buildGraphData()` / `buildGraphQuery()`. Touches Postgres under RLS to materialize a workspace's graph. Recommended renderers: [`react-force-graph`](https://github.com/vasturiano/react-force-graph) (2D/3D), [`d3-force`](https://github.com/d3/d3-force), or [`@xyflow/react`](https://reactflow.dev). --- ## ✅ Verified This is alpha, but it is not vapor. Verified against a live `pgvector/pgvector` container: - **11 v3 migrations** apply cleanly from an empty database. - **~150 test cases across 18 test files** — **52 unit tests pass without Docker**; the rest are integration tests that require a `pgvector` container. - **RLS isolation holds** — workspace B sees **0** of workspace A's facts; cross-tenant writes rejected at the database layer. - **Auth works** — bcrypt-hashed API keys, full CRUD + recall round-trips. - **Hexagonal-purity guard** — CI asserts `packages/core/src/v3/` and `packages/types/src/` import zero infrastructure packages. - **Migration-sequence guard** — CI asserts migrations form a contiguous numeric sequence with no gaps. ```bash pnpm test:integration # requires a reachable pgvector instance ``` --- ## 🛠️ Development quickstart ```bash # prerequisites: Node >= 20, pnpm >= 9, Docker (for Postgres + pgvector) git clone https://github.com/lucasmailland/mnemosyne cd mnemosyne pnpm install pnpm build # turbo build across all packages pnpm typecheck # strict TypeScript, whole monorepo pnpm test # unit tests pnpm lint # lint # bring up Postgres + pgvector + server for integration work pnpm docker:up pnpm test:integration pnpm docker:down ``` --- ## 📚 Documentation In-repo documentation — next to the code it describes: **Architecture & internals** (in [`docs/`](./docs/)) - [`docs/architecture/API.md`](./docs/architecture/API.md) — full REST + MCP + gRPC API reference - [`docs/architecture/DATA_MODEL.md`](./docs/architecture/DATA_MODEL.md) — the 10 primitives, schema, decay classes - [`docs/architecture/SECURITY.md`](./docs/architecture/SECURITY.md) — RLS, sensitivity tiers, threat model - [`docs/architecture/FEDERATION.md`](./docs/architecture/FEDERATION.md) — peer-to-peer sync protocol - [`docs/internals/ALGORITHMS.md`](./docs/internals/ALGORITHMS.md) — ACT-R recall, TD(λ) decay, HyDE, rerank - [`docs/internals/ARCHITECTURE.md`](./docs/internals/ARCHITECTURE.md) — hexagonal package design - [`docs/internals/OBSERVABILITY.md`](./docs/internals/OBSERVABILITY.md) — traces, metrics, error codes - [`docs/guides/CLI.md`](./docs/guides/CLI.md) — `mnemo` CLI reference - [`docs/deploy/SERVICES.md`](./docs/deploy/SERVICES.md) — Docker Compose + Kubernetes deployment - [`docs/integration/SDK_INTEGRATION.md`](./docs/integration/SDK_INTEGRATION.md) — SDK consumption patterns **Per-package READMEs** - [`packages/core/README.md`](./packages/core/README.md) — library surface and cognitive primitives - [`packages/server/README.md`](./packages/server/README.md) — HTTP API routes, auth, OpenAPI - [`packages/mcp/README.md`](./packages/mcp/README.md) — MCP setup for Claude Desktop, Cursor, Continue - [`packages/client-ts/README.md`](./packages/client-ts/README.md) — typed SDK with worked examples - [`packages/cli/README.md`](./packages/cli/README.md) — CLI reference --- ## 🗺️ Roadmap - [ ] Worked examples: `nextjs-chat`, `claude-desktop-mcp`, `python-rag` - [ ] **Mnemosyne Studio** — web inspector for browsing memories, the graph, and the bitemporal timeline - [x] Session collapse: live LLM fact extraction from conversation turns (beta — wired end-to-end; requires an LLM provider) - [ ] First-class Python client (`mnemosyne-py`) - [ ] Streaming recall + server-sent provenance events - [x] `@mnemosyne/consolidation` worker runtime — sleep-cycle memory promotion (beta — gate + replay validator + scheduler wired at boot) - [x] `mnemo` CLI — `recall`, `remember`, `forget`, `status`, `config` - [x] MCP server — 14 tools for Claude Desktop / Cursor - [x] Sensitivity tiers — `public / internal / confidential / restricted` - [x] Session pipeline — `start / turn / collapse` - [ ] `2.0.0` stable --- ## 🤝 Contributing PRs, issues, and design discussion are all welcome — see [CONTRIBUTING.md](./CONTRIBUTING.md). The fastest way to help right now: try the Docker quickstart, then open an issue describing anything that surprised you. ## 🔐 Security Found a vulnerability? **Do not** open a public issue — follow the disclosure process in [SECURITY.md](./SECURITY.md). Tenant isolation and provenance integrity are the project's core promises; security reports are taken seriously. ## 📄 License [Apache-2.0](./LICENSE) © Lucas Mailland. <div align="center"> _{Built for agents that should remember. ⭐ the repo if Mnemosyne is useful to you.} </div>