convez.ai
PluginProdutividadeIntermediário
BMC-INC

IronMem

BMC-INC/Iron-mem

Memória persistente de sessão para assistentes de IA em desenvolvimento

Ver no GitHub
BomPluginScore · de 0 a 100

Plugin que mantém memória persistente para assistentes de IA em desenvolvimento, registrando sessões de codificação e injetando contexto automaticamente nas próximas. Funciona com Claude Code, Cursor, Copilot e Windsurf como binário único em Rust, local-first, eliminando a necessidade de re-explicar projetos.

Instalação

$npx convez-ai BMC-INC/Iron-mem

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
5
Forks
0
Acompanhando
1
Saúde
87%
Último commit
há 2 semanas
Versão
v0.4.1
Issues abertas
0
Contribuidores
2

Casos de uso

  • Manter contexto de projeto entre sessões de codificação
  • Recuperar automáticamente arquitetura e decisões técnicas anteriores
  • Integrar com múltiplos IDEs e assistentes (Claude, Cursor, Copilot, Windsurf)

Veredito

Solução robusta em Rust que resolve um problema real: context-bleeding entre sessões de IA. Implementação sofisticada com tipagem de memórias, compressão reversível e suporte multi-provider, mas requer setup técnico e conhecimento de MCP servers para máximo proveito.

README

A tradução para o português deste README ainda está na fila.


What's New in v0.4.0

Lossless, reversible memory — plus a real memory model: scoping, typed memories, an always-on user profile, and a correction miner.

  • CCR — losslessly reversible memory (Headroom pattern) — every truncated tool output and the verbatim pre-LLM session transcript is preserved in a content-addressed, deduplicated, byte-exact compressed blob store inside the DB. The new retrieve_original tool pulls the exact original back behind any compressed memory. No more lossy truncation.
  • Memory scoping & typed memories (Supermemory patterns) — memories carry a scope (project vs. user/cross-project) and a kind (session, error_solution, preference, architecture, learned_pattern, project_config, profile). Session-start injection ranks project ∪ user memories and boosts durable kinds.
  • remember tool — store an explicit, typed memory in one call (scope, kind, text, tags). User-scope facts follow you into every project.
  • User profile — your cross-project memories are distilled into a single always-injected profile (LLM summary, or a deterministic local rollup when offline). Read/regenerate with get_profile / refresh_profile.
  • Correction miner — error→fix loops in a session (a failing command, edits, then the same command passing) are mined into error_solution memories and surfaced via list_corrections, so past fixes resurface when the work recurs.
  • 18 MCP tools now — adds retrieve_original, remember, get_profile, refresh_profile, list_corrections.
  • Still zero telemetry. Still local-first. Your data stays yours.
  • Multi-provider compression — use OpenAI, Google Gemini, or Anthropic as your LLM. Set "provider": "openai" in settings.
  • Neovim plugin — native Lua plugin with auto session lifecycle, :IronMemSearch, :IronMemStatus
  • Windows support — install.ps1, platform-aware messages, robust home directory detection
  • Web UI — browse, search, and delete memories at http://localhost:37778/ui
  • Discovery tools — list known projects, search across all projects, and inspect per-project session history
  • Still zero telemetry. Still local-first. Your data stays yours.
  • 13 MCP tools — session_start, session_end, record_event, compress_session, get_context, get_status, list_memories, search_memories, search_global, list_projects, list_sessions, inject_context, wipe_project
  • Dual database — SQLite (local, FTS5 full-text search) + Postgres (self-hosted, tsvector) via DATABASE_URL
  • Every MCP client — Claude Desktop, Claude Code, Cursor, Windsurf, ChatGPT Desktop, Zed, and more
  • Docker deployment — docker-compose up for remote/team setups with Postgres
  • ironmem mcp — new subcommand for direct MCP stdio transport (Claude Desktop/Code)
  • REST server still works — existing hooks and curl-based workflows unaffected

IronMem gives AI coding tools persistent memory across sessions. It silently records what happened during your session, compresses it into concise memory, and injects that context into your next session automatically.

No copy-pasting. No rebuilding context from scratch. No "remember when we refactored auth yesterday?"

Works with every major AI coding tool — Claude Code, Claude Desktop, Cursor, Windsurf, ChatGPT Desktop, GitHub Copilot, Zed, VS Code, and any MCP-compatible client.

Compress with the LLM you already pay for — Anthropic Claude, OpenAI GPT-4o, or Google Gemini. Switch providers with one config change.

Free and open source. Runs locally or on your own infrastructure. No telemetry. No cloud dependency. No subscription. SQLite or Postgres storage. Plain markdown output. Single Rust binary.

Why this exists

AI coding tools are great inside a session and terrible across sessions. They help you ship faster, but every fresh session forgets your architecture decisions, debugging trail, and what changed yesterday.

IronMem fixes the handoff.

Before vs after

Without IronMem:

"We already changed the auth middleware, switched to JWT, updated the migration, and fixed the failing tests in billing. Let me explain the whole thing again."

With IronMem:

Open a new session. Your assistant already has the recent project context.


Quick Start

  1. Install IronMem:
    curl -fsSL https://raw.githubusercontent.com/BMC-INC/Iron-mem/main/install.sh | bash
    
  2. Add your API key to IronMem's key file:
    echo "your-key-here" > ~/.ironmem/api_key && chmod 600 ~/.ironmem/api_key
    

    Prefer the key file over export ANTHROPIC_API_KEY. Claude Code (and some other tools) bill against ANTHROPIC_API_KEY whenever it's set in your shell — using pay-as-you-go API credit instead of your Claude subscription. The key file keeps IronMem's key out of your environment so it can't change how other tools bill. (IronMem still honors ANTHROPIC_API_KEY if you prefer the env var.)

  3. Start coding! IronMem handles the rest silently in the background.

Table of Contents


The Problem

Every time you start a new session with Claude Code, Cursor, Copilot, or any AI coding assistant — it starts from zero. It doesn't know what you built yesterday. It doesn't know what broke. It doesn't know what you decided.

You end up re-explaining context every single session.

The Fix

IronMem silently records what happens during your coding session, compresses it into a concise memory using your LLM provider of choice (Anthropic, OpenAI, or Gemini), and injects that context into your next session automatically.

No setup per session. No copy-pasting. No "remember when we..."

Without IronMem: "Hey Claude, remember yesterday we refactored the auth middleware and switched to JWT? And the database migration for the users table? And..."

With IronMem: You open a new session. It already knows.


Who Should Use This?

IronMem is designed for:

  • Developers frustrated with re-explaining context to AI tools every single session.
  • Teams working on large, multi-session projects where context gets easily lost.
  • Developers frequently switching between multiple AI tools like Copilot, Claude Code, Windsurf, or Cursor.
  • Solo developers who want to maintain flow and continuity without manual effort.

How It Works

flowchart LR
    A["🟢 Session Start"] -->|inject memories| B["📄 IRONMEM.md"]
    B --> C["🤖 AI reads context"]
    C --> D["🔧 You code"]
    D -->|every tool call| E["🗄️ SQLite"]
    D --> F["🔴 Session End"]
    F -->|compress via LLM| G["🧠 Memory"]
    G -->|next session| A

    style A fill:#22c55e,color:#fff,stroke:none
    style F fill:#ef4444,color:#fff,stroke:none
    style G fill:#8b5cf6,color:#fff,stroke:none
    style E fill:#0ea5e9,color:#fff,stroke:none

Everything runs locally. Your data stays on your machine.


Install

curl -fsSL https://raw.githubusercontent.com/BMC-INC/Iron-mem/main/install.sh | bash

Or clone and build manually:

git clone https://github.com/BMC-INC/Iron-mem.git
cd Iron-mem
chmod +x install.sh
./install.sh

Windows:

git clone https://github.com/BMC-INC/Iron-mem.git
cd Iron-mem
powershell -ExecutionPolicy Bypass -File install.ps1

Add IronMem to your PATH (in ~/.zshrc or ~/.bashrc) and write your API key to IronMem's key file:

export PATH="$HOME/.ironmem/bin:$PATH"          # in ~/.zshrc / ~/.bashrc
echo "your-key-here" > ~/.ironmem/api_key && chmod 600 ~/.ironmem/api_key

Use the key file, not export ANTHROPIC_API_KEY — a global ANTHROPIC_API_KEY makes Claude Code (and similar tools) bill against pay-as-you-go API credit instead of your subscription. IronMem reads ~/.ironmem/api_key automatically.

Restart your terminal and Claude Code. That's it.

Requirements: Rust/Cargo (the installer will tell you if it's missing)


CLI

ironmem server              # Start REST + MCP SSE server
ironmem mcp                 # Start MCP stdio server (for Claude Desktop/Code)
ironmem serve               # Start SSE server with bearer token auth
ironmem serve --public      # Same + Cloudflare Tunnel for remote MCP clients
ironmem serve --public --no-auth  # Authless public tunnel for claude.ai personal use
ironmem status              # Health check + DB stats
ironmem projects            # All projects with stored memories
ironmem list                # Recent memories for current project
ironmem search "auth middleware"  # Hybrid (keyword + semantic) search across memories
ironmem search-global "auth middleware"  # Search across all projects
ironmem sessions            # Session history for current project
ironmem inject              # Manually rebuild IRONMEM.md (relevance-ranked)
ironmem remember "..."      # Store an explicit memory (--scope user, --kind preference, --tags)
ironmem profile             # Show the user profile (--refresh to regenerate it)
ironmem corrections         # List mined error→fix memories (--all for every project)
ironmem compress <id>       # Manually compress a session
ironmem embed               # Backfill semantic embeddings for existing memories
ironmem gc                  # Reclaim unreferenced CCR blobs (after wipes)
ironmem wipe                # Delete all memories for current project
ironmem config              # Print current settings

Multi-Provider Support

IronMem works as an MCP server (native integration) or via IRONMEM.md (plain markdown, universal):

PlatformMCP NativeIRONMEM.mdSetup
Claude CodeYesYesSetup →
Claude DesktopYesYesSetup →
claude.aiYesYesSetup →
CursorYesYesSetup →
WindsurfYesYesSetup →
ChatGPT DesktopYes—Setup →
ZedYes—Setup →
VS Code (Copilot/Continue/Cline)YesYesSetup →
Any MCP ClientYes—stdio or SSE transport
Any AI Tool—YesRead IRONMEM.md as project context

MCP Setup

IronMem supports two MCP transports:

  • stdio — for local clients that launch the server themselves (Claude Code, Claude Desktop, Cursor)
  • Streamable HTTP — for remote/cloud clients that connect over HTTP. Uses standard request/response and bearer-token auth, so it works through tunnels and reverse proxies for clients that support static bearer tokens.

Once connected over MCP, IronMem now supports project discovery directly:

  • list_projects — show every project with stored memories
  • search_global — search across all projects
  • list_sessions — inspect session history inside a project

Claude Code MCP Setup

Claude Code connects via stdio — it launches ironmem mcp directly.

Option A: CLI (recommended)

claude mcp add ironmem -- ~/.ironmem/bin/ironmem mcp

Option B: Project .mcp.json (share with your team)

Create .mcp.json in your project root:

{
  "mcpServers": {
    "ironmem": {
      "command": "~/.ironmem/bin/ironmem",
      "args": ["mcp"],
      "env": {
        "ANTHROPIC_API_KEY": "your-key-here"
      }
    }
  }
}

Note: Claude Code hooks (installed by install.sh) and MCP can coexist. The hooks use the REST API for automatic observation recording; MCP gives you direct tool access. You can use both, or just one.

Claude Desktop MCP Setup

Claude Desktop also connects via stdio.

Add to your claude_desktop_config.json:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json Windows: %APPDATA%\Claude\claude_desktop_config.json

{
  "mcpServers": {
    "ironmem": {
      "command": "/Users/YOU/.ironmem/bin/ironmem",
      "args": ["mcp"],
      "env": {
        "ANTHROPIC_API_KEY": "your-key-here"
      }
    }
  }
}

Replace /Users/YOU with your actual home directory path. Restart Claude Desktop after saving.

claude.ai (Web)

claude.ai runs in the cloud, so it cannot reach localhost.

IronMem is a local-first tool. The recommended setup for full MCP access is Claude Code or Claude Desktop using stdio.

Anthropic's current claude.ai custom connector UI supports authless and OAuth-based remote MCP servers, but not a manual static bearer-token field. For personal use, the honest compatibility path is an authless ephemeral tunnel:

ironmem serve --public --no-auth

That command does three things:

  1. Starts the SSE server with no auth
  2. Launches a Cloudflare Tunnel (free, no account needed) to expose it publicly
  3. Prints the public URL
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
  IronMem SSE Server
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
  Local:  http://127.0.0.1:37779/mcp
  Auth:   Disabled (--no-auth)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
  Public URL: https://xxx-yyy-zzz.trycloudflare.com
  Remote MCP setup:
    URL:   https://xxx-yyy-zzz.trycloudflare.com/mcp
    Auth:  None
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

In claude.ai:

  1. Open Settings
  2. Open Integrations
  3. Choose Add custom connector
  4. Set Name to IronMem
  5. Paste the printed https://...trycloudflare.com/mcp URL into Remote MCP server URL
  6. Leave the OAuth fields blank

The trycloudflare.com URL is ephemeral and changes whenever you restart the public tunnel, so update your connector URL each time you relaunch ironmem serve --public --no-auth.

This is no longer local-only. The tunnel exposes your MCP endpoint over the internet for as long as it is running.

For a personal local tool, this tradeoff is often acceptable because the URL is short-lived and changes on each restart. Still, use --no-auth deliberately and only when you understand that you are trading security for compatibility.

Without --no-auth: ironmem serve and ironmem serve --public use bearer-token auth for clients that support static bearer tokens.

Requirements: Install cloudflared for best results (brew install cloudflared on macOS, winget install Cloudflare.cloudflared on Windows). Falls back to npx cloudflared if not installed.

Cursor / Windsurf MCP Setup

Both use stdio. Add to your MCP settings:

Cursor: Settings → MCP → Add Server

Windsurf: Settings → MCP → Add Server

{
  "ironmem": {
    "command": "~/.ironmem/bin/ironmem",
    "args": ["mcp"]
  }
}

Other MCP Clients

Any MCP client that supports stdio transport can use IronMem:

{
  "command": "~/.ironmem/bin/ironmem",
  "args": ["mcp"]
}

For clients that support Streamable HTTP, start the server and point the client at http://localhost:37779/mcp:

ironmem serve

Neovim Plugin

IronMem includes a native Neovim plugin that communicates via MCP stdio.

Install with lazy.nvim:

{
  "BMC-INC/Iron-mem",
  config = function()
    require("ironmem").setup({
      -- binary = "~/.ironmem/bin/ironmem",  -- default
      -- auto_start = true,   -- session_start on VimEnter
      -- auto_end = true,     -- session_end on VimLeavePre
      -- record_events = true, -- record buffer writes
    })
  end,
}

Commands:

CommandDescription
:IronMemStartManually start a session
:IronMemEndEnd session and compress
:IronMemStatusShow database stats
:IronMemSearch <query>Search memories in a split buffer

Web UI

When the REST server is running, a built-in memory browser is available at:

http://localhost:37778/ui

The UI shows sessions, memories, and database stats. You can browse, search, and delete memories directly from the browser.


Configuration

~/.ironmem/settings.json:

{
  "port": 37778,
  "provider": "anthropic",
  "model": "claude-sonnet-4-6-20250627",
  "inject_limit": 5,
  "max_observation_bytes": 2048,
  "db_path": "/Users/you/.ironmem/mem.db",
  "database_url": null,
  "mcp_transport": "stdio",
  "mcp_sse_port": 37779,
  "auth_token": null,
  "embedding": {
    "provider": "auto",
    "model": null,
    "ollama_url": "http://localhost:11434",
    "weights": { "relevance": 0.5, "recency": 0.3, "importance": 0.2 },
    "recency_half_life_days": 30
  }
}

All fields optional. Sensible defaults provided. auth_token is generated automatically the first time you run ironmem serve without --no-auth. The embedding block is optional — omit it entirely and IronMem behaves exactly as before (keyword-only search, recency injection).

Semantic Search & Embeddings

IronMem can blend keyword (FTS) and semantic (vector) retrieval using Reciprocal Rank Fusion, and rank session-start injection by a blend of relevance + recency + importance. Embeddings are stored locally in SQLite via sqlite-vec (or pgvector on Postgres); nothing is sent anywhere unless you explicitly choose an API provider.

Privacy posture: this is a governance tool, so the default is local-first / no data egress. The auto provider prefers a local embedder and silently degrades to keyword-only search if none is available — it never phones home and never hard-fails a command.

embedding.providerBehaviorData egress
"auto" (default)Use local Ollama if reachable, else the built-in ONNX model (if compiled in), else keyword-onlyNone (unless only an API key is configured)
"ollama"Local Ollama embeddingsNone (localhost)
"onnx"In-process ONNX model (requires --features local-onnx build)None
"openai"OpenAI embeddings APISends memory text to OpenAI
"google"Google embeddings APISends memory text to Google
"none"Keyword-only FTS + recency injection (legacy behavior)None

Recommended local setup (no egress):

# Install Ollama, then pull an embedding model:
ollama pull nomic-embed-text
# IronMem's "auto" provider will detect and use it automatically.

Built-in ONNX (no Ollama, no network): compile with the optional feature so embeddings run fully in-process:

cargo install --path . --features local-onnx

Blend weights (embedding.weights) control session-start injection ranking: relevance (semantic match to your current git context), recency (true half-life decay set by recency_half_life_days), and importance (an LLM-assigned 1–10 score per memory). They need not sum to 1.

Backfill existing memories — after enabling embeddings, index memories created before:

ironmem embed              # embed memories missing a vector (all projects)
ironmem embed --project .  # scope to one project
ironmem embed --force      # rebuild the whole index from scratch

Provider

IronMem supports three LLM providers for session compression:

Providerprovider valueDefault modelAPI key env var
Anthropic"anthropic"claude-sonnet-4-6-20250627ANTHROPIC_API_KEY
OpenAI"openai"gpt-4oOPENAI_API_KEY
Google Gemini"google"gemini-2.0-flashGOOGLE_API_KEY

To switch providers, set "provider" in ~/.ironmem/settings.json and ensure the corresponding API key is set. The model field overrides the provider's default model.

Environment Variables

VariableDefaultDescription
DATABASE_URL(none)Postgres URL. Overrides db_path when set.
IRONMEM_MCP_TRANSPORTstdioMCP transport: stdio or sse
ANTHROPIC_API_KEY(none)Required when provider is anthropic (default)
OPENAI_API_KEY(none)Required when provider is openai
GOOGLE_API_KEY(none)Required when provider is google

API Key

IronMem needs an LLM API key to compress session observations into memories.

Recommended (Anthropic): write the key to ~/.ironmem/api_key (echo "your-key" > ~/.ironmem/api_key && chmod 600 ~/.ironmem/api_key). Keeping it in this file rather than a global ANTHROPIC_API_KEY export avoids changing how other tools bill — Claude Code, for instance, charges pay-as-you-go API credit whenever ANTHROPIC_API_KEY is set in the environment, instead of using your subscription. IronMem reads the file automatically (it also works when the background server is spawned via nohup, where some shells strip env vars from child processes).

IronMem still honors the per-provider environment variable if you prefer it — ANTHROPIC_API_KEY, OPENAI_API_KEY, or GOOGLE_API_KEY. The file fallback applies to the default Anthropic provider.


Troubleshooting

Server not starting:

ironmem status                           # Check if server responds
cat ~/.ironmem/server.log                # Check server logs
~/.ironmem/bin/ironmem server            # Run manually to see errors

Observations not being recorded:

ironmem status                           # Check observation count
sqlite3 ~/.ironmem/mem.db "SELECT count(*) FROM observations;"

If count stays at 0, your hooks may not be installed. Re-run ./install.sh or check that ~/.claude/hooks/post-tool-use.sh exists and is executable.

Compression failing (memories always 0):

# Check if the API key is accessible (the key file is the recommended source)
cat ~/.ironmem/api_key                   # Should contain your key
echo $ANTHROPIC_API_KEY                  # Optional env-var fallback (may be empty)

# Try manual compression
ironmem compress <session-id>            # Get session ID from server.log

Hooks not firing: Check that ~/.claude/settings.json has the hooks registered under the "hooks" key. Re-running ./install.sh will fix this.


Architecture

~/.ironmem/
├── bin/ironmem          # Single compiled binary
├── mem.db               # SQLite DB: memories (FTS5) + vectors + CCR blob store
├── settings.json        # Configuration
├── api_key              # Anthropic API key (chmod 600; keeps it out of your shell env)
├── current_session      # Active session ID (ephemeral)
└── server.log           # Worker logs

~/.claude/hooks/         # Auto-installed Claude Code hooks
├── session-start.sh     # Injects memories on session start
├── post-tool-use.sh     # Records every tool call
├── stop.sh              # Triggers compression
└── session-end.sh       # Cleanup

~9,000 lines of Rust. MCP-native. SQLite or Postgres. Lossless, reversible memory. One binary. No external runtimes.


Why Rust?

Rust was chosen for IronMem to deliver:

  • Maximum Performance: Minimal overhead and lightning-fast execution, essential for a tool that hooks into every single CLI command.
  • Zero Dependencies: Compiles down to a single binary. No need to install Python, Node.js, or complex runtime environments.
  • Memory Safety & Reliability: Guaranteed safety without a garbage collector ensures the background worker remains rock-solid and leak-free.

Design Principles

  • Zero friction — hooks run silently, never interrupt your workflow
  • Local-first — runs on your machine by default, your data stays yours
  • MCP-native — speaks the protocol every major AI client is adopting
  • Provider-agnostic — MCP for native integration, plain markdown for everything else
  • Self-hostable — Docker + Postgres for team deployments, still zero cloud dependencies
  • Fail-safe — if IronMem crashes, your coding session is unaffected

Who this is for

IronMem is for developers who use AI coding tools heavily and want continuity across sessions.

It is especially useful if you:

  • switch between Claude Code, Cursor, Copilot, or Windsurf
  • work on projects that span many sessions
  • are tired of re-explaining architecture, bugs, and recent changes
  • want local-first memory instead of a hosted service

Who this is not for

IronMem is not trying to be:

  • a generic memory platform for every kind of agent
  • a cloud sync product
  • a team knowledge base
  • a dashboard-heavy workflow tool

It solves one narrow problem well: session memory for AI coding workflows.


Why not just use CLAUDE.md?

CLAUDE.md is great for static project context — things like "use tabs not spaces" or "we use Axum for routing." But it's manual. You write it, you maintain it, and it doesn't know what happened last session.

IronMem is automatic and session-aware:

CLAUDE.mdIronMem
UpdatesYou write it manuallyAuto-generated from session activity
ScopeStatic project rulesDynamic session history
RotationYou manage itOld memories age out automatically
SearchCtrl+FFull-text search across all sessions
EffortHighZero — hooks handle everything

They work together. CLAUDE.md holds your project rules. IronMem holds what happened.


Docker Deployment

Run IronMem with Postgres for team/remote setups:

ANTHROPIC_API_KEY=your-key docker-compose up --build

This starts IronMem with Streamable HTTP on http://localhost:37779/mcp and Postgres 16, plus the REST server on http://localhost:37778.


Roadmap

Shipped in v0.2.0

  • MCP-native server (stdio + Streamable HTTP)
  • Dual database — SQLite (local, FTS5) + Postgres (self-hosted)
  • Docker deployment with Postgres
  • Bearer token authentication
  • ironmem serve --public with Cloudflare Tunnel for remote MCP clients
  • ironmem serve --public --no-auth for claude.ai personal use
  • Works with Claude Code, Claude Desktop, Cursor, Windsurf, ChatGPT Desktop, Zed, VS Code

Shipped in v0.3.0

  • Multi-provider compression — OpenAI, Google Gemini, or Anthropic (configurable via provider in settings)
  • Neovim plugin (nvim/lua/ironmem/) — auto session lifecycle, :IronMemSearch, :IronMemStatus
  • Windows native support — install.ps1, platform-aware install messages, robust home dir detection
  • Web UI memory browser — http://localhost:37778/ui when REST server is running

Shipped in v0.4.0

  • Semantic foundation — hybrid FTS + vector (RRF) retrieval, local-first embeddings, and relevance-ranked session-start injection
  • Reliability & security hardening — stdio MCP stream is no longer corrupted by log output, UTF-8-safe truncation prevents a crash on multibyte tool output, and 7 dependency advisories were patched
  • CCR — losslessly reversible memory (Headroom pattern): a content-addressed, deduplicated blob store + byte-exact per-content-type compression (zstd + per-type dictionaries) + a retrieve_original tool, so the verbatim original behind any compressed memory is always recoverable — no more lossy truncation. Refcount GC (ironmem gc) + storage stats in get_status. Design »
  • Memory scoping & types (Supermemory patterns): project vs. user (cross-project) scope, typed memories (error_solution / preference / architecture / learned_pattern / …), scope-aware injection with per-kind boosts, and a remember tool
  • Always-injected user profile — cross-project facts distilled into one profile memory (LLM summary or deterministic local rollup); get_profile / refresh_profile
  • Correction miner — error→fix loops become error_solution memories, surfaced via list_corrections

Next

  • Bespoke per-content-type transforms — invertible log timestamp-delta / diff-token / AST-aware code normalization on top of the dictionary codecs (currently documented-future; the byte-exact contract is the gate)
  • Observation-blob lifecycle GC — reclaim CCR blobs behind deleted observations (memory-session blobs are already GC'd)

Contributing

Contributions are welcome. Please read CONTRIBUTING.md before opening a PR.

TL;DR: Open an issue first. Bug fixes and provider compatibility improvements are always welcome. We don't accept changes that add runtime dependencies or complexity.


⭐ Support

If you find IronMem useful, please consider giving it a star! 🌟 This helps others discover the project and motivates further development. Contributions, issues, and feature requests are also highly welcome.


License

Apache-2.0 © 2026 ExecLayer Inc

Maintainer: James Benton

Ver o original no GitHub

Bom para

Relacionados