# Context Forge

> Capture context and decisions across sessions — durable agent memory in markdown.

[Canonical HTML page](https://top-mcps.com/mcp/mcp-context-forge) · [server.json](https://top-mcps.com/mcp/mcp-context-forge.json) · [methodology](https://top-mcps.com/about/methodology)

## Install

### Claude Desktop — `claude_desktop_config.json`

Paste under mcpServers. Fully quit and reopen Claude after editing.

```json
{
  "mcpServers": {
    "mcp-context-forge": {
      "command": "npx",
      "args": [
        "-y",
        "context-forge-mcp"
      ]
    }
  }
}
```

### Claude Code — `CLI or .mcp.json`

Run from your repo. Commit .mcp.json to share with your team.

```shell
claude mcp add mcp-context-forge -- npx -y context-forge-mcp
```

### Cursor — `.cursor/mcp.json`

Global path: ~/.cursor/mcp.json. Reload window after editing.

```json
{
  "mcpServers": {
    "mcp-context-forge": {
      "command": "npx",
      "args": [
        "-y",
        "context-forge-mcp"
      ]
    }
  }
}
```

### VS Code — `.vscode/mcp.json`

VS Code uses the "servers" key (not "mcpServers").

```jsonc
{
  "servers": {
    "mcp-context-forge": {
      "command": "npx",
      "args": [
        "-y",
        "context-forge-mcp"
      ]
    }
  }
}
```

### Windsurf — `~/.codeium/windsurf/mcp_config.json`

Open via Cascade → hammer icon → Configure.

```json
{
  "mcpServers": {
    "mcp-context-forge": {
      "command": "npx",
      "args": [
        "-y",
        "context-forge-mcp"
      ]
    }
  }
}
```

### Cline — `cline_mcp_settings.json`

Open via the Cline sidebar → MCP Servers → Edit.

```json
{
  "mcpServers": {
    "mcp-context-forge": {
      "command": "npx",
      "args": [
        "-y",
        "context-forge-mcp"
      ]
    }
  }
}
```

### Continue — `~/.continue/config.json`

Continue uses modelContextProtocolServers with a transport block.

```json
{
  "experimental": {
    "modelContextProtocolServers": [
      {
        "transport": {
          "type": "stdio",
          "command": "npx",
          "args": [
            "-y",
            "context-forge-mcp"
          ]
        }
      }
    ]
  }
}
```

### Codex CLI — `~/.codex/config.toml`

Codex uses TOML. Each server is a [mcp_servers.<name>] subtable.

```shell
# ~/.codex/config.toml
[mcp_servers.mcp-context-forge]
command = "npx"
args = [
  "-y",
  "context-forge-mcp",
]
```

### Zed — `~/.config/zed/settings.json`

Zed calls them "context_servers". Settings live-reload on save.

```jsonc
{
  "context_servers": {
    "mcp-context-forge": {
      "command": {
        "path": "npx",
        "args": [
          "-y",
          "context-forge-mcp"
        ]
      }
    }
  }
}
```

### ChatGPT — `ChatGPT → Apps directory`

Context Forge doesn't ship a hosted HTTPS endpoint today. ChatGPT supports remote MCP servers only — to use this server in ChatGPT you'll need to deploy it to a public HTTPS URL first (e.g. via Cloudflare Workers or Vercel) or wait for an official remote build.

```none

```

## At a glance

- **Maintainer:** Community
- **Transport:** stdio
- **Auth model:** None
- **Required secrets:** None
- **Supported clients:** Claude, Claude Code, Cursor, Any MCP-compatible client
- **License:** MIT
- **Language:** TypeScript
- **Latest version:** latest
- **Last verified:** 2026-05-26
- **Score:** 58/100 (rubric 2026-04 — see https://top-mcps.com/about/methodology)
- **Source:** https://github.com/chrisleekr/context-forge-mcp

## Security & scope

- **Access scope:** read-write
- **Sandbox:** Reads and writes a single markdown file inside the project root.
- **Gotchas:**
  - Anything stored is plaintext in the repo — do not put secrets here.
  - Conflicting writes from concurrent agents are not coordinated; one writer at a time.

## Quick answer

**What it does.** Exposes tools to add and update entries in a project memory file, list recent decisions, query by topic, and reset stale entries. Designed as a complement to per-conversation memory.

**Best for:**
- Multi-agent project memory
- Decision logs that survive context resets
- Onboarding fresh agent sessions
- Cross-team agent collaboration

**Not for:**
- Single-session work
- Sensitive decision tracking

## Description

Context Forge maintains a structured project memory across agent sessions. Decisions, open questions, conventions, and learnings get captured as durable markdown that subsequent agents read on session start, so the context window does not have to.

## Why it matters

Most agent memory tools optimize for inside-a-session recall. Context Forge optimizes for inside-a-project recall — the agent that joins the project on day 10 reads what was decided on day 1 without re-asking.

## Key features

- Markdown-backed persistence
- Topic indexing
- Decision log
- Convention capture
- Versionable via git

## FAQ

### How is it different from the Memory MCP?

Memory stores a knowledge graph of entities; Context Forge stores narrative decisions and conventions in markdown. They complement each other — facts in Memory, rationale in Context Forge.

### Should I check the memory file into git?

Usually yes — that is the point. Decisions become part of the repo history. Sensitive content should be excluded via gitignore.

### Does it scale to large projects?

The markdown grows linearly with decisions. At a few hundred entries, the indexing tools become essential to avoid bloated reads.

## Changelog

- **2026-05-26** — Refreshed install snippets and fact sheet; verified for 2026.
- **2025-03-10** — Initial directory listing.