MemForge
OfficialConnects Confluence as a memory source, syncing pages into MemForge so agents can search team documentation and cite the source passages.
Syncs documentation from GitHub repositories into MemForge, making repository docs searchable as cited memories for agents.
Syncs GitHub Pages documentation into MemForge so agents can search published docs and cite the original pages.
Connects Jira as a memory source, syncing tickets into MemForge so agents can recall decisions and conventions with ticket citations.
Connects Notion as a memory source, syncing pages into MemForge so agents can search team knowledge and cite the source.
This server does not currently have a deployable release on Glama. Follow the repository's setup instructions to install and configure it for your MCP client, including any required credentials and local dependencies.
Give every agent your team's brain on day one.
The memory layer for AI agents. Everything your team knows. Cited, and always up to date. Built from your docs, tickets and chat.
Why MemForge
Turns your team's wiki, tickets and chat into memory your coding agents can search. On its own, a coding agent sees only the local checkout. MemForge syncs sources such as Confluence, Jira and Teams ahead of time and builds one memory from them, so agents search that memory instead of querying each tool. New sources plug into the same connector interface, so the list can keep growing.
Continuously detects stale facts and conflicts as your docs change. Each sync, on demand or on a schedule, rechecks the facts taken from changed docs and keeps, replaces or retires each one. New facts are also compared with what's already in memory. When it finds two docs that disagree, the agent gets both, with a note saying they conflict or which is newer.
Gives agents precise facts, not documents that blow up their context. At sync, a model turns your sources into memories: precise facts and decisions that keep their conditions and exceptions. Agents search them over MCP by keyword, and by meaning if you add an embedding model. Search results carry no document text, so a full document enters the context only when the agent asks for it.
Always justifies each fact with its real source. Every fact from a source cites the passage behind it and, where one exists, links to the original page, ticket or file. If no source supports a fact any more, it is retired. The citation can be a paraphrase, so MemForge also keeps the source text it read, and you or the agent can open it to confirm.
Runs on your machine, with team sharing on the way. The open-source edition is Apache-2.0 and single-user, with local storage and your own model keys. Source text goes to the model providers you choose, and the agent plugins don't record your sessions. The hosted Team Cloud Edition will give the whole team one shared memory.
Related MCP server: Kage
Quick start
Beta. APIs, storage formats and plugin packaging may change. An upgrade that migrates your data saves a recovery point first (Upgrading).
You need Docker with Compose v2 and an API key for OpenRouter, OpenAI or Anthropic.
Let your agent set it up. Paste this into Claude Code or Codex:
Set up MemForge for me. Fetch this guide with curl and follow it exactly:
https://raw.githubusercontent.com/dodo-labs-ai/mem-forge/main/docs/agent-setup.mdThe agent starts MemForge and installs its plugin, then hands you the admin UI to enter your model key and connect a source, so your keys never pass through the agent.
Start MemForge.
git clone https://github.com/dodo-labs-ai/mem-forge.git && cd mem-forge cp .env.example .env docker compose up --buildThe admin UI is at http://localhost:5174.
Choose models. In Settings, choose a generation model, which writes the memories, and optionally an embedding model for semantic search. After Save and validate, each one shows Ready.
Connect a source. In Sources, add a source, such as a Confluence space or a GitHub repository, and run a sync. Turn on Sync automatically to keep it current. The source shows the memories it made as the sync runs.
Install the agent plugin.
# Claude Code (inside a session) /plugin marketplace add dodo-labs-ai/mem-forge /plugin install memory@memforge# Codex codex plugin marketplace add dodo-labs-ai/mem-forge codex plugin add memory@memforgeAsk. Start a new agent session in your project and ask:
Before you change this, check MemForge for decisions and conventions that apply, and show the source for each one you rely on.The agent answers with the memories that apply and names the source of each.
The quickstart covers every model provider, local folders, the host CLI and network details.
How it works
flowchart LR
subgraph You["Your machine"]
CC["Claude Code / Codex"]
Plugin["MemForge plugin"]
API["MemForge"]
Extract["Write short memories,<br/>each citing its source"]
Recheck["Recheck when a source changes,<br/>link related memories"]
Store[("Local storage")]
end
Docs["Your team's wikis, tickets,<br/>repositories and chat"]
CC --> Plugin
Docs -- "sync" --> API
API --> Extract --> Recheck --> Store
Plugin -- "search, read a memory,<br/>open its source" --> API
API -- "read" --> StoreSync. Connectors read your docs, tickets and chat, on a schedule or when you ask.
Extract. A model turns each source into short memories, each citing the passage it came from.
Recheck. When a source changes, the memories built on it are kept, replaced or retired, and related memories are linked.
Recall. Agents search memory and open its sources over MCP.
More detail: architecture overview.
Integrations
MemForge sits between the systems where your team writes things down and the agents that do the work.
Agent integrations
Memory sources
Add a source lists what each one syncs and how to scope it. Need one that is missing? Vote for the next source.
Limits
The open-source edition runs for one person on one machine. It has no accounts or authentication and listens on
127.0.0.1only, so do not expose it on a network. For memory your whole team shares, join the Team Cloud Edition waitlist.Model extraction and semantic judgments can miss useful knowledge or make mistakes. Check the cited Evidence before relying on a consequential claim.
A generation model is required; without one, syncs store content but create no memories.
Documentation
Quickstart: setup, models, plugins, sources, CLI, development from source
Docs index: quickstart, architecture, API and release guides
How MemForge compares: when to choose MemForge and when another tool fits better
License
Apache License 2.0. See LICENSE.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
This server cannot be deployed
Maintenance
Related MCP Connectors
Team memory for AI coding agents and code reviews, reviewed by humans and served over MCP.
A second brain for your AI agent. Shared memory for your team's AI agents, plus public and private knowledge bases — works with ChatGPT, Claude, Cursor and any MCP client.
Give your AI agent persistent, governed memory for every project. At task start it recalls the approved decisions, conventions, risks and architecture (semantic search, ranked by importance); at close it proposes what was learned as typed memories that you review and approve — governance, not a notes dump. Agents propose, humans govern: edits go back to pending and deletion is human-only by design. Connect Claude Code, Cursor, Claude Desktop or any MCP client in two minutes with just your API key — hosted (nothing to install) or locally via `uvx solucortex-mcp`. Built by SoluAI and dogfooded daily: SoluCortex is developed using its own living memory.
Persistent AI memory shared across Claude, ChatGPT, coding agents, and compatible MCP clients.
Related MCP Servers
- AlicenseAqualityCmaintenanceProvides persistent memory for AI coding agents via MCP, enabling teams to share and recall facts across sessions. Automatically captures, classifies, and curates knowledge from supported transcript sources.1831 npm1AGPL 3.0
- AlicenseAqualityCmaintenanceShared, code-grounded memory for developers and their coding agents. Capture a learning once and the whole team plus every agent recalls it; memory is grounded in your code and stored as git-tracked JSON reviewed in PRs, with citations validated on write and stale memory withheld from recall. Works with any MCP client.1141GPL 3.0
- AlicenseNot gradedqualityAmaintenanceEnables AI agents to share persistent memory by capturing, classifying, synthesizing, and retrieving knowledge from sources like Obsidian, code, and transcripts via MCP and REST APIs. Provides token-optimized search, three-tier memory, and self-learning capture of sessions and fixes so multiple agents can build on prior context.10 npmMIT
- AlicenseNot gradedqualityAmaintenanceEnables AI agents to share a persistent, self-improving memory by ingesting sources such as Obsidian vaults, code, transcripts, and bookmarks, then classifying, promoting, synthesizing, and retrieving that knowledge through token-optimized search across MCP and REST interfaces. Agents can capture sessions and fixes so context compounds across sessions and across Claude, Codex, Gemini, and any other MCP client.10 npmMIT