# Logica Mind > The continuity substrate for AI agents β€” memory that becomes a mind: a versioned self-model, a cognitive heartbeat, a shared cortex, metacognition & debate, on temporal-graph memory. Apache-2.0, zero-dep core. - **Type:** MCP server - **Install:** `agentstack add mcp-rovemark-logica-mind` - **Verified:** Yes β€” security-reviewed for prompt injection and unsafe behavior - **Seller:** [Rovemark](https://agentstack.voostack.com/s/rovemark) - **Installs:** 0 - **Category:** [AI & ML](https://agentstack.voostack.com/c/ai-and-ml) - **Latest version:** 0.1.0 - **License:** Apache-2.0 - **Upstream author:** [Rovemark](https://github.com/Rovemark) - **Source:** https://github.com/Rovemark/logica-mind - **Website:** https://github.com/Rovemark/logica-mind ## Install ```sh agentstack add mcp-rovemark-logica-mind ``` Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent. ## About # 🧠 Logica Mind ### Memory that thinks like a brain, not a database. **Long-term memory for AI agents β€” episodic, semantic, a temporal knowledge graph & a dialectic user model in one library.** [](https://huggingface.co/spaces/rovemark/logica-mind-demo) [](https://pypi.org/project/logica-mind/) [](https://github.com/Rovemark/logica-mind/blob/main/LICENSE) [](https://www.python.org/) [](#%EF%B8%8F-building-from-source) [](#-model-context-protocol-mcp) **β–Ά [Try the live demo](https://huggingface.co/spaces/rovemark/logica-mind-demo) β€” explore the temporal graph in your browser, nothing to install.** --- Most memory libraries for AI agents are a vector store with a friendlier API: you write a fact, you search it back, and the moment a fact changes, the old one is overwritten and gone. That's a flat database β€” it can tell you what your agent believes *now*, but never what it believed last Tuesday when it made the call that broke production. **Logica Mind is built differently.** Four memory layers and a *temporal* knowledge graph where every belief is stamped with when it became true and when it stopped β€” so you can replay your agent's entire knowledge state at any past instant, trace why any fact is believed, and watch a sleep-time cycle consolidate, infer, and forget while the agent sits idle. ```python mind.state_at("2026-01-01") # replay everything the agent knew, at any past instant mind.contradictions() # every belief that changed value β€” and exactly when ``` It runs fully offline on the standard library β€” **zero dependencies, no API key to start** β€” and is covered by **202 tests**, so you can verify every claim on this page in five minutes. It then lights up Voyage, OpenAI, Supabase, Postgres or Redis whenever you want them. The built-in dashboard: edges hued by relation type, nodes sized by centrality, emergent co-mentions, a full filter bar, point-in-time replay β€” and intelligence (path-finding, bridges, suggested links) a hand-linked note graph can't have. Organize it as an organic web, as facet orbits (hubs with their members around them β€” by channel, agent, life-area or entity type) or as concentric importance rings; click a hub and only its participants stay lit. --- ## ⚑ Install ```bash pip install logica-mind # core: zero dependencies, fully offline pip install "logica-mind[onnx]" # + TRUE semantic recall without torch (~50MB; +22% recall@5 β€” see bench/) pip install "logica-mind[voyage]" # + Voyage embeddings & reranker pip install "logica-mind[sqlcipher]" # + at-rest encryption for the SQLite store pip install "logica-mind[all]" # + Voyage, OpenAI, Supabase, Postgres, Redis, local ``` ## πŸš€ 30-second quickstart ```python from logica_mind import LogicaMind mind = LogicaMind(namespace="my-app") # SQLite + offline embedder, no keys # remember durable facts β€” extraction, dedup and conflict-resolution are automatic mind.remember("The user prefers dark mode and concise answers.") mind.remember("The user is based in Lisbon and works in fintech.") # recall the most relevant memories (hybrid: semantic vector + lexical, ranked) for hit in mind.recall("what does the user like?"): print(f"{hit.score:.2f} {hit.memory.content}") # see it live β€” open the dashboard mind.serve() # -> http://127.0.0.1:8420 ``` > Prefer the terminal? `logica-mind demo` loads a fictional dataset so you can > explore every feature instantly, and `logica-mind demo --clear` removes it. --- ## ⭐ What no other memory library does This is the heart of Logica Mind. Everything below is **shipped and tested**. ### πŸ•°οΈ It's a time machine, not a log Memory isn't just *what* you know β€” it's *when it became true and when it changed.* ```python mind.graph.edges(at="2026-01-01") # replay the ENTIRE knowledge state at a past instant mind.state_at("2026-01-01") # "what did the agent know when it made that decision?" mind.contradictions() # every belief that changed value β€” and exactly when mind.diff(since, until) # a memory changelog: "what did this agent learn this week?" ``` - **Point-in-time replay** β€” reconstruct the full graph (or the whole mind) at any past date. Audit and debug agent behavior after the fact. - **Temporal contradictions** β€” a new fact *closes* the old one instead of deleting it; the timeline stays queryable. - **Memory changelog** β€” a first-class diff over what was learned in any window. Flat vector stores can't give you this. ### 🧬 A memory that behaves like a brain ```python mind.forget_curve(days_halflife=30) # Ebbinghaus decay: unused beliefs fade, recall reinforces mind.dream(infer_links=True) # sleep-time cycle: consolidate, reinforce, forget, INFER mind.stale_beliefs() # epistemic self-doubt: "I'm not sure about this anymore" ``` - **Ebbinghaus forgetting curve** β€” beliefs decay exponentially if never recalled; recalling one resets its clock. The only memory layer where knowledge actually *ages*. - **Inductive dreaming** β€” beyond consolidate/prune, the dream cycle **generates new inferred facts** (Aβ†’B, Bβ†’C ⟹ A relates to C) while idle. It doesn't just store; it reasons. - **Epistemic self-doubt** β€” surfaces old, never-recalled, low-confidence beliefs the agent should re-verify. No other memory system exposes its own uncertainty. - **Contested beliefs & surprise score** β€” when a new high-confidence belief overturns an old one, both are surfaced as *contested* and scored by how much the worldview shifted. - **Dream journal** β€” every consolidation cycle is recorded (distilled / reinforced / forgotten / inferred) so you can *watch the memory think over time*. ### πŸ—‚οΈ It learns what each fact *is* Hand it raw text and it doesn't just store β€” it **decomposes** the message into atomic facts and tags each with a **category** (an open label it coins) and a **dimension** from a 34-dimension taxonomy across four groups: **Personal** (mapped to Maslow's hierarchy), **Projects**, **Organization**, and **Business & Finance**. ```python mind.remember("I'm a Scorpio who loves flat whites; we hit $45k MRR and the launch is blocked on a payments bug.") # β†’ IdentityΒ·"Zodiac sign", PreferenceΒ·"Coffee preference", # BusinessΒ·"MRR", ProjectΒ·"Launch blocker" β€” four facts, four dimensions mind.dimensions() # the whole profile, grouped by dimension + Maslow tier ``` Live: hand it a messy sentence and watch it extract the fact, check it against what it already believes, and index it β€” no save button for each fact, no schema. The Profile view: a person and their work, organized β€” personal facts up Maslow's pyramid, plus Projects, Organization, and Business & Finance. The same animation shows it learning each categorized fact live. - **Person *and* work** β€” the taxonomy models a human (identity, health, spirituality, ambitions) and the work (project blockers, OKRs, MRR, runway) in one place. - **Everywhere** β€” category + dimension ride on every memory: the Profile view (cards **and** a clickable knowledge-map), the colour-by-area knowledge graph, the `lm_dimensions` MCP tool, `recall`/`remember`, `/api/memories?dimension=`, and the ⌘K search. Full guide: **[Fact categorization](https://github.com/Rovemark/logica-mind/blob/main/docs/categorization.md)**. - **Zero-key option** β€” categorization needs an LLM; it auto-detects an `ANTHROPIC_API_KEY` / `OPENAI_API_KEY`, or uses your **local Claude CLI** with no API key at all (`LOGICA_MIND_LLM=claude-cli`). See **[LLM providers & auto-detection](https://github.com/Rovemark/logica-mind/blob/main/docs/providers.md)**. ### πŸ•ΈοΈ A graph that reasons about itself A note app's graph is a *picture* of links you typed by hand. Because Logica Mind has a real memory engine underneath β€” typed predicates, confidence, provenance, temporal validity β€” its graph is an **instrument**. ```python mind.how_related("the billing service", "Priya Nair") # the billing service β€”part_ofβ†’ Acme Inc β€”works_atβ†’ Priya Nair (a typed, narrated path) mind.bridges() # load-bearing connectors β€” entities whose removal fragments the graph mind.suggested_links() # predict the missing edge: pairs with a strong shared neighbourhood, no link yet ``` - **"How is A related to B?"** β€” a confidence-weighted shortest path as an ordered chain of *typed* hops. The dashboard traces it and spotlights it on the canvas. A hand-linked note graph can't answer this β€” its links are untyped. - **Bridges** β€” articulation points; the brokers between clusters, often low-degree nodes pure centrality misses. - **Suggested links** β€” Adamic-Adar link prediction proposes the edges you're *missing*. Note tools make you author every link; here the graph proposes them. - **Emergent + semantic layers** β€” beyond explicit edges: **co-mentions** (entities named together) and opt-in **semantic affinity** (similar memory-neighbourhoods), each a toggle. - **A professional canvas** β€” edges hued by relation type with arrows + confidence-weighted width, nodes sized by **PageRank centrality**, a local/ego graph with a depth slider, hover previews, and a top filter bar (colour-by, layers, search-focus, min-confidence, per-relation-type). Full guide: **[Graph intelligence](https://github.com/Rovemark/logica-mind/blob/main/docs/graph-intelligence.md)**. Path mode answers "how is A related to B?" β€” a typed, narrated chain, spotlighted on the canvas while the rest dims. ### 🀝 Multi-agent native ```python mind.for_namespace("agent-a") # one store, N agents/clones, each its own namespace mind.knowledge_gap("agent-b") # "what does B know that A doesn't?" β€” directional mind.transfer_to("agent-b", fact_id) # move a fact between agents, with provenance mind.observe_peer("a", "b", "...") # directional theory-of-mind: what A believes about B ``` - **One brain, every agent** β€” a single store serves any number of agents/clones, with an aggregate graph that **detects entities shared across agents** (the gold nodes in the screenshot). - **Structured run records** β€” `record_session(...)` captures a whole multi-agent run (participants, roles, contributions, metrics, links) as rich, queryable memory β€” framework-agnostic, maps onto CrewAI / LangGraph / AutoGen or your own loop. - **Multi-perspective peers** β€” model what one participant knows about another, directionally, not merged. ### πŸ”’ Trust, provenance & portability ```python mind.provenance(fact_id) # "why do I believe this?" -> the source turns it came from mind.forget_about("Acme Inc") # GDPR-native erase across ALL layers + the graph, one call bundle = mind.export_bundle(secret=k) # HMAC-signed, portable memory you can move between vendors ``` - **"Why do I believe this?"** β€” trace any fact back to the exact source turns/documents it was distilled from. Belief explainability a vector can't give you. - **GDPR-native erase** β€” `forget_about(entity)` deletes every memory mentioning an entity across all four layers *and* the graph, in one call. Right-to-be-forgotten as a primitive. - **Portable, signed memory** β€” export an HMAC-signed bundle and carry your memory between apps and vendors. Tamper-evident, provider-independent. *Your memory follows you.* - **Source attribution** β€” every captured memory is tagged with the client that produced it (Claude Code / Cursor / ChatGPT …), read from the MCP handshake. - **PII redaction** β€” `redact_pii()` masks emails, phone numbers and long digit runs from recall output in shared contexts. ### πŸ–₯️ Built to be lived in - **A graph that explains itself** β€” not a hairball of identical lines. Edges are **hued by relation type** with directional arrows and confidence-weighted width; nodes are **sized by PageRank centrality** so hubs stand out. A real top filter bar: **colour by** namespace / community / life-area / centrality, toggle connection **layers** (relations, co-mentions, semantic affinity, suggested), search-to-focus, a min-confidence declutter slider, and per-relation-type filters. Plus the intelligence a hand-linked note graph can't have: **"how is A related to B?"** (a narrated, spotlighted path), **bridges** (load-bearing connectors), **suggested links** (the edge you're missing, predicted), a **local/ego graph** with a depth slider, **hover previews**, and a **time-scrubber** that replays the graph at any past date. Served by the standard library β€” no Node for end users. - **Backlinks that write themselves** β€” Obsidian makes you *type* `[[links]]`; here the connective tissue is **inferred**. Open any memory and the **Connected** panel shows the entities it mentions, the relations among them, other notes that touch the same entities, and siblings sharing its category β€” all derived from the graph, nothing to maintain. Click to walk note-to-note; `[[wikilinks]]` in content are clickable too. Exposed as `mind.connections(id)` and the `lm_connected` MCP tool. - **Context survives compaction** β€” a `PreCompact` hook distills the conversation into durable memory *right before the host truncates the window*, then brings the relevant slice back on the next session. The fix for "it compacted and we lost everything." - **Sessions that follow you across machines** β€” sessions auto-name from their first message, can be renamed and exported, and import directly from your local assistant history. Take your session index anywhere. - **Danger-zone controls** β€” scoped erasure from the dashboard: clear by layer, clear stale (old & untouched), or reset a namespace β€” all behind a typed confirmation. - **A demo you control** β€” ship empty, load a rich fictional dataset to explore, then clear it with one click (it only removes the demo, never your data). Open any memory and the Connected panel derives its neighborhood β€” the entities it mentions, the typed relations among them, and the other notes that link here β€” with no hand-typed links. Click any of them to walk note-to-note. ### 🧰 More than memory β€” a coding-context server too The *same package* is also a Logica-Context-class devtools server: a sandboxed code `execute`, **Project DNA** (`scan` any repo for its languages, frameworks and key files), `git` context, a token `budget` meter, an MCP aggregator, and a shared team knowledge base. One install is a deep memory brain **and** a coding assistant's context layer. --- ## πŸ“Š Benchmarks Measured on **LoCoMo** (1,540 scored questions) under the *same published protocol as the [Mem0 paper](https://arxiv.org/abs/2504.19413)* β€” gpt-4o-mini answerer **and** judge, adversarial category excluded. Full methodology, every competitor number with its primary source, and one-command reproduction: **[BENCHMARKS.md](https://github.com/Rovemark/logica-mind/blob/main/BENCHMARKS.md)**. | Mode | **accuracy (J)** | **retrieval latency** | **median context** | |---|---|---|---| | **full pipeline** (1 LLM call per *session* at write) | **72.5%** | 1.6 / 2.9 s p50/p95 (network Γ—2) | 3,525 tokens | | zero-LLM writes, `openai` embedder | **67.3%** | 584 / 1,452 ms p50/p95 (network) | 2,648 tokens | | zero-LLM writes, `onnx` embedder β€” **no API keys at all** | **60.9%** | 87 / 338 ms p50/p95 (local) | 2,738 tokens | How that places against the market, in the published protocol (every number sourced in [BENCHMARKS.md](https://github.com/Rovemark/logica-mind/blob/main/BENCHMARKS.md)): | System | LoCoMo J | LLM at write time? | |---|---|---| | Letta (filesystem agent) | 74.0% | agent-managed | | Full-context baseline (no memory system) | 72.9% | β€” | | **Logica Mind β€” full pipeline** | **72.5%** | **1 call per session (~35Γ— fewer)** | | Mem0ᡍ (graph variant) | 68.4% | every write | | **Logica Mind β€” zero-LLM writes** | **67.3%** | **none** | | Mem0 | 66.9% | every write | | Zep | 66.0% | every write | | Best RAG baseline | 61.0% | none | | **Logica Mind β€” fully keyless (onnx)** | **60.9%** | … ## Source & license This open-source MCP server is cataloged on AgentStack and links to its original source β€” we do not rehost the code. - **Author:** [Rovemark](https://github.com/Rovemark) - **Source:** [Rovemark/logica-mind](https://github.com/Rovemark/logica-mind) - **License:** Apache-2.0 - **Homepage:** https://github.com/Rovemark/logica-mind Install and usage instructions live in the source repository linked above. ## Pricing - **Free** β€” Free ## Security capabilities Automated source analysis of v0.1.0 β€” what this tool can access: - **Network access:** no - **Filesystem access:** no - **Shell / process execution:** no - **Environment & secrets:** no - **Dynamic code execution:** no *"Yes" means the capability is present in the source β€” more access means more to trust, not that it is unsafe.* ## Versions - **0.1.0** β€” security scan: passed β€” Imported from the upstream source. ## Links - Listing page: https://agentstack.voostack.com/l/mcp-rovemark-logica-mind - Seller: https://agentstack.voostack.com/s/rovemark - Browse the marketplace: https://agentstack.voostack.com/browse --- Listed on AgentStack β€” the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.