# keepgoing-dev/mcp-server

**Category:** 🧠 Knowledge & Memory  
**Repository:** https://github.com/keepgoing-dev/mcp-server  
**GitHub Stars:** 3  
**npm Downloads (last month):** 174  
**Views:** 4  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/keepgoing-dev-mcp-server

## Description
Project memory for AI coding sessions. Auto-captures checkpoints on git commits, branch switches, and inactivity, then provides re-entry briefings so AI assistants pick up where you left off. Local-first, no account required.

## Tools
Capabilities this server exposes over MCP:

- **get_momentum** — Get current developer momentum: last checkpoint, next step, blockers, and branch context. Use this to understand where the developer left off. Pass tier or model to control detail level.
- **get_session_history** — Get recent session checkpoints. Returns a chronological list of what the developer worked on.
- **get_reentry_briefing** — Get a synthesized re-entry briefing that helps a developer understand where they left off. Includes focus, recent activity, and suggested next steps. Pass tier or model to control detail level.
- **get_decisions** — Retrieve past architectural decisions automatically captured from high-signal commits. Call this BEFORE modifying code in areas likely to have past decisions: auth systems, database schemas, API contracts, infrastructure config, migrations, or core architectural patterns. Also call when a user asks to change a technology choice, reverse a past approach, or asks "why did we do X". Returns decisions scoped to current branch by default; pass branch: "all" for project-wide history.
- **get_current_task** — Get a bird's eye view of all active Claude sessions. See what each session is working on, which branch it is on, and when it last did something. Useful when running multiple parallel sessions across worktrees.
- **save_checkpoint** — Save a development checkpoint. Call this after completing a task or meaningful piece of work, not just at end of session. Each checkpoint helps the next session (or developer) pick up exactly where you left off.
- **continue_on** — Export KeepGoing context as a formatted prompt for use in another AI tool (ChatGPT, Gemini, Copilot, etc.). Returns a markdown prompt with project status, last session, decisions, and recent commits.
- **get_context_snapshot** — Get a compact context snapshot: what you were doing, what is next, and momentum. Use this for quick orientation without a full briefing.
- **get_whats_hot** — Get a summary of activity across all registered projects, sorted by momentum. Shows what the developer is working on across their entire portfolio.
- **setup_project** — Set up KeepGoing hooks and instructions. Use scope "user" for global setup (all projects) or "project" for per-project setup.

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `npx` (confidence: high):

```json
"mcpServers": {
  "mcp-server": {
    "command": "npx",
    "args": ["-y","@keepgoingdev/mcp-server"]
  }
}
```

## Documentation

## What keepgoing-dev/mcp-server MCP server does

The keepgoing-dev/mcp-server MCP server gives AI coding assistants a local memory of development work. It can save checkpoints describing what was completed, what should happen next, relevant blockers, and files or branches involved. Later sessions can retrieve that information instead of reconstructing project status from the repository alone.

The server also supports session history, re-entry briefings, compact context snapshots, and momentum summaries. These outputs are intended to help an assistant understand where work stopped and what action should follow. Project context is stored locally in `.keepgoing/` at the Git root, and no account is required.

## How it works

After the server is added to an MCP-compatible coding assistant, the assistant can call `save_checkpoint` after a task or meaningful piece of work. On a later session, `get_momentum`, `get_context_snapshot`, or `get_reentry_briefing` can return the current state. `get_session_history` provides recent checkpoints in chronological order.

The optional KeepGoing VS Code extension can automate checkpoint capture when commits are made, branches change, or the developer is inactive. Without the extension, the keepgoing-dev/mcp-server MCP server remains usable through explicit calls to `save_checkpoint`.

For projects using multiple concurrent sessions, `get_current_task` reports active Claude sessions, their branches, and recent activity. `get_whats_hot` summarizes activity across registered projects. `continue_on` formats project context as a prompt for another AI tool, including supported targets such as ChatGPT, Gemini, Copilot, Claude, or a general prompt.

## Setup and configuration

The documented runtime requirement is Node.js 18 or newer. The server can be registered with Claude Code using the following command:

```bash
claude mcp add keepgoing --scope user -- npx -y @keepgoingdev/mcp-server
```

A project-scoped registration is also supported. Cursor, Windsurf, and other MCP clients can use a configuration entry with `npx` as the command and `-y @keepgoingdev/mcp-server` as its arguments. The provided installer can install the CLI and run setup for a selected tool, while `setup_project` supports user-wide or project-specific KeepGoing setup.

## Tools and capabilities

- Retrieve momentum, context snapshots, re-entry briefings, and recent session checkpoints.
- Save checkpoints for completed tasks or meaningful development progress.
- Review architectural decisions captured from high-signal commits, with current-branch scope by default and an option for project-wide history.
- Inspect active Claude sessions across worktrees.
- Export project context into a prompt for another AI tool.
- Summarize activity across registered projects.
- Install KeepGoing hooks and instructions at user or project scope.

Several tools accept options that control output detail, including `tier` and `model` for momentum and briefing responses. Decision detection and session awareness are documented as paid add-ons, while the core server can be used without an account.

## Limitations and notes

The server is focused on local development-session context rather than a general-purpose project database or remote collaboration service. Automatic checkpointing depends on the optional VS Code extension; otherwise checkpoints must be saved through the MCP tool. The documentation specifically describes Claude Code, Cursor, Windsurf, and other MCP tools, but does not define behavior for every client. Decision detection, live session awareness, and license activation are listed as paid add-on functionality.

_Full upstream README: https://allmcps.com/mcp/keepgoing-dev-mcp-server/readme_