MIE - Memory Intelligence Engine

Persistent knowledge graph MCP server that gives AI agents shared memory across sessions and providers. Stores facts, decisions, entities, and events with typed relationships.

Stop re-explaining yourself to every AI agent. MIE gives all your agents — Claude, ChatGPT, Cursor, Gemini — a shared, persistent knowledge graph they can read and write. Decisions, context, facts, and relationships survive across sessions, tools, and providers.

You explained your entire architecture to Claude. Two hours of context, decisions, tradeoffs. Next day, new conversation — it knows nothing. So you explain it again. Then you switch to Cursor for implementation. Zero context. You open ChatGPT to brainstorm a different angle. Blank slate.

Every AI agent you use is brilliant but amnesiac. And none of them talk to each other.

MIE fixes this.One knowledge graph. Every agent reads from it. Every agent writes to it. Your decisions, your context, your rules — always available, everywhere.

You: "We chose PostgreSQL over DynamoDB because we need ACID transactions for the payments module. Alternative was Aurora but too expensive at current stage." Claude stores this via MIE ↓ ┌─────────────────────────────────────────────┐ │ MIE Knowledge Graph │ │ │ │ Decision: PostgreSQL over DynamoDB │ │ Rationale: ACID transactions for payments │ │ Alternatives: [DynamoDB, Aurora] │ │ Entities: payments-module, PostgreSQL │ │ Status: active │ └─────────────────────────────────────────────┘ ↓ Next week, in Cursor, different project: "What database did we choose and why?" → Cursor queries MIE, gets full context instantly

No copy-pasting. No "as I mentioned before." No starting from zero.

Why Not Just Use Claude's Memory / ChatGPT's Memory?

mie init # Quick setup with defaults mie init --interview # Interactive — asks about your stack, team, and project

{ "mcpServers": { "mie": { "command": "mie", "args": ["--mcp"] } } }

{ "mcpServers": { "mie": { "command": "mie", "args": ["--mcp"] } } }

That's it. Your agents now share a brain.

MIE isn't a chat log. It stores structured knowledge as a graph:

Facts— Things that are true about your world."Our API uses JWT with RS256 signing." · "The team is 6 engineers across 3 timezones."

Decisions— Choices with rationale and alternatives."Chose Go over Rust for CIE because of CGO CozoDB bindings. Alternatives: Rust, Python."

Entities— People, companies, projects, technologies."Kraklabs — independent software and AI lab." · "CIE — Code Intelligence Engine."

Events— Timestamped occurrences."Launched v0.4.0 on 2026-01-15." · "Client demo scheduled for March 10."

Topics— Recurring themes that connect everything."Architecture" · "Security" · "Product Strategy"

These connect through typed relationships — a decision references entities, relates to topics, and may be triggered by events. When an agent queries "what do you know about our security decisions?", MIE traverses the graph and returns structured context, not keyword matches.

MIE exposes 12 tools through the Model Context Protocol:

Unlike other memory solutions that run an LLM on the server to classify what to store, MIE uses anagent-as-evaluatorpattern. The server provides context; your agent (which is already running an LLM) decides what matters. This means zero additional inference cost — your memory layer doesn't burn tokens.

This philosophy extends to importing: when you ask your agent to "import knowledge from this repo", the agent reads your files, ADRs, or git history directly and usesmie_bulk_storeto persist what it extracts. MIE stays as a pure storage engine — the connected agent IS the LLM.

┌─────────────────────────────────────┐ │ Any MCP Client │ │ Claude · Cursor · ChatGPT · etc │ └──────────────┬──────────────────────┘ │ MCP (JSON-RPC over stdio) ┌──────────────▼──────────────────────┐ │ MIE Server (one per MCP client) │ │ 12 tools · semantic search · │ │ graph traversal · conflicts │ └──────────────┬──────────────────────┘ │ Unix domain socket ┌──────────────▼──────────────────────┐ │ MIE Daemon (shared singleton) │ │ Manages exclusive DB lock · │ │ Serves multiple clients │ └──────────────┬──────────────────────┘ │ Datalog queries ┌──────────────▼──────────────────────┐ │ CozoDB (embedded) │ │ Graph DB · HNSW vectors · ACID │ └─────────────────────────────────────┘ + Ollama (optional, local embeddings)

ChatGPT via custom GPT Actions pointing to MIE Cloud (coming soon).

Store Query Evolve ───── ───── ────── Your agent learns → Next session, any → Facts change. something new. agent queries MIE Old ones get It stores a fact, for context before invalidated, not a decision, or an responding. Full deleted. The graph entity — with graph of related keeps history of confidence scores knowledge returns what was known and relationships. in milliseconds. and when.

# .mie/config.yaml version: "1" storage: engine: rocksdb # rocksdb, sqlite, or mem embedding: enabled: true provider: ollama # ollama, openai, or nomic model: nomic-embed-text mcp: # Option A: only expose these tools (whitelist) include_tools: - mie_analyze - mie_store - mie_query # Option B: expose all except these (blacklist) # exclude_tools: # - mie_export # - mie_repair

mie init # Create config with defaults mie init --interview # Interactive project bootstrapping mie --mcp # Start as MCP server (auto-starts daemon) mie daemon start # Start daemon in background mie daemon start --foreground # Start daemon in foreground (for debugging) mie daemon stop # Stop running daemon mie daemon status # Check if daemon is running mie status # Show graph statistics mie export # Export memory graph mie import -i backup.json # Import from JSON or Datalog mie reset --yes # Delete all data mie query "<cozoscript>" # Raw Datalog query (debug)

{ "mcpServers": { "cie": { "command": "cie", "args": ["--mcp"] }, "mie": { "command": "mie", "args": ["--mcp"] } } }

CIE gives your agent deep understanding of your codebase. MIE gives it memory of everything else — decisions, architecture, people, events. Together, your agent knows your codeand*remembers why it's built that way.

- Import from ADRs, markdown, and git history (agent-driven self-import)
- Git post-commit hook — auto-capture decisions from commits
- Browser extension — auto-capture knowledge from claude.ai, chatgpt.com, gemini
- MIE Cloud — sync across devices, team shared memory
- ChatGPT integration via custom GPT Actions
- Web UI for exploring and managing your knowledge graph

- AGPL-3.0— Free for open-source use
- Commercial License— For proprietary use. Contactsales@kraklabs.com

We welcome contributions. Seecontributing.mdfor guidelines.

Built byKraklabs· Makers ofCIEand MIE

A knowledge graph-driven persistent memory layer for coding agents and LLM workflows.