Codevira MCP

Persistent memory and project context for AI coding agents — across every session, every tool, every file.

Works with: Claude Code · Cursor · Windsurf · Google Antigravity · any MCP-compatible AI tool

---

The Problem

Every time you start a new AI coding session, your agent starts from zero.

It re-reads files it has seen before. It re-discovers patterns already established. It makes decisions that contradict last week's decisions. It has no idea what phase the project is in, what's already been tried, or why certain files are off-limits.

You end up spending thousands of tokens on re-discovery — every single session.

Codevira fixes this.

---

What It Does

Codevira is a Model Context Protocol server you drop into any project. It gives every AI agent that works on your codebase a shared, persistent memory:

| Capability | What It Means | |---|---| | Live auto-watch | Background file watcher auto-reindexes on every save — no manual trigger or git commit needed | | Context graph | Every source file has a node: role, rules, dependencies, stability, do_not_revert flags | | Semantic code search | Natural language search across your codebase — no grep, no file reading | | Roadmap | Phase-based tracker so agents always know what phase you're in and what comes next | | Changeset tracking | Multi-file changes tracked atomically; sessions resume cleanly after interruption | | Decision log | Every session writes a structured log; past decisions are searchable by any future agent | | Agent personas | Seven role definitions (Planner, Developer, Reviewer, Tester, Builder, Documenter, Orchestrator) with explicit protocols |

The result: ~1,400 tokens of overhead per session instead of 15,000+ tokens of re-discovery.

---

How It Works

Agent Session Lifecycle

flowchart TB

Start([Start Session])

subgraph Orientation
A[Check Open Changesets]
B[Get Project Roadmap]
C[Search Past Decisions]
D[Load Graph Context\nget_node • get_impact]
end

subgraph Execution
E[Plan Task]
F[Implement Code]
G[Run Tests / Validation]
end

subgraph Completion
H[Update Graph Metadata]
I[Write Session Log]
J[Complete Changeset]
end

Start --> A
A --> B
B --> C
C --> D
D --> E
E --> F
F --> G
G --> H
H --> I
I --> J

---

Code Intelligence Model

flowchart TB

A[Source Code]

subgraph Structural Analysis
B[AST Parser]
C[Function / Class Extraction]
D[Dependency Analysis]
end

subgraph Knowledge Stores
E[(Semantic Index<br/>ChromaDB)]
F[(Context Graph<br/>SQLite DB)]
end

subgraph Runtime Access
G[MCP Query Layer<br/>search_codebase • get_node • get_impact]
end

H[AI Coding Agent<br/>Claude Code • Cursor]

A --> B
B --> C
C --> E

B --> D
D --> F

E --> G
F --> G

G --> H

Quick Start

1. Install

pip install codevira-mcp

2. Initialize in your project

cd your-project
codevira init

This single command:

• Creates .codevira/ with config, graph, and log directories
• Adds .codevira/ to .gitignore (index is auto-regenerated, no need to commit)
• Prompts for project name, language, source directories (comma-separated), and file extensions
• Builds the full code index using SHA-256 content hashing (only changed files are re-indexed)
• Auto-generates graph stubs for all source files
• Bootstraps .codevira/roadmap.yaml from git history
• Installs a post-commit git hook for automatic reindexing
• Prints the MCP config block to paste into your AI tool

Live Auto-Watch: When the MCP server starts, it automatically launches a background file watcher. Every time you save a source file, the index is updated within 2 seconds — no manual commands needed. The post-commit hook and codevira index CLI remain available as alternatives.

3. Connect to your AI tool

Depending on your IDE and environment, codevira-mcp may not automatically be in your PATH. You can use uvx (the easiest option) or provide the absolute path to your Python virtual environment.

Option A: Using uvx (Recommended for all IDEs without local install) If you use uv, you can run the MCP server seamlessly without managing virtual environments per project.

Claude Code (.claude/settings.json), Cursor / Windsurf (Settings → MCP):

{
  "mcpServers": {
    "codevira": {
      "command": "uvx",
      "args": ["codevira-mcp", "--project-dir", "/path/to/your-project"]
    }
  }
}

Option B: Using Local Venv (Recommended, works everywhere) Point your AI tool directly to the Python runtime inside your .venv where codevira-mcp is installed.

Claude Code (.claude/settings.json) or Cursor / Windsurf (Settings → MCP):

{
  "mcpServers": {
    "codevira": {
      "command": "/path/to/your-project/.venv/bin/python",
      "args": ["-m", "mcp_server", "--project-dir", "/path/to/your-project"]
    }
  }
}

Google Antigravity — add to ~/.gemini/antigravity/mcp_config.json:

{
  "mcpServers": {
    "codevira": {
      "$typeName": "exa.cascade_plugins_pb.CascadePluginCommandTemplate",
      "command": "/path/to/your-project/.venv/bin/python",
      "args": ["-m", "mcp_server", "--project-dir", "/path/to/your-project"]
    }
  }
}

⚠️ IMPORTANT: Using Global Clients (Antigravity / Claude Desktop) with Multiple Projects

Unlike Cursor, which spins up isolated MCP servers per project automatically, global clients like Antigravity share a single mcp_config.json across all your open projects.

If you configure codevira once for Project A, and then ask a question about Project B, the agent will read the graph and roadmap from Project A.

To fix this: You must register uniquely named servers for each project in your global config. The AI will dynamically choose the right tool prefix based on your conversation context:

{
  "mcpServers": {
    "codevira-project-a": {
      "$typeName": "exa.cascade_plugins_pb.CascadePluginCommandTemplate",
      "command": "uvx",
      "args": ["codevira-mcp", "--project-dir", "/path/to/project-a"]
    },
    "codevira-project-b": {
      "$typeName": "exa.cascade_plugins_pb.CascadePluginCommandTemplate",
      "command": "uvx",
      "args": ["codevira-mcp", "--project-dir", "/path/to/project-b"]
    }
  }
}

4. Verify

Ask your agent to call get_roadmap() — it should return your current phase and next action.

Project structure after init

your-project/
├── src/                   ← your code (indexed)
├── .codevira/             ← Codevira data directory (git-ignored)
│   ├── config.yaml        ← project configuration
│   ├── roadmap.yaml       ← project roadmap (auto-generated, human-enrichable)
│   ├── codeindex/         ← ChromaDB index (auto-regenerated)
│   └── graph/             ← context graph and session memory
│       ├── graph.db       ← SQLite database for nodes, edges, logs, and decisions
│       └── changesets/    ← active multi-file change records
└── requirements.txt       ← add: codevira-mcp>=1.0.0

Roadmap lifecycle: The roadmap is auto-generated during init and updated by the agent through MCP tool calls. See docs/roadmap.md for the full lifecycle guide, manual editing steps, and troubleshooting.

---

Session Protocol

Every agent session follows a simple protocol. Set it up once in your agent's system prompt — then your agents handle the rest.

Session start (mandatory):

list_open_changesets()      → resume any unfinished work first
get_roadmap()               → current phase, next action
search_decisions("topic")   → check what's already been decided
get_node("src/service.py")  → read rules before touching a file
get_impact("src/service.py") → check blast radius

Session end (mandatory):

complete_changeset(id, decisions=[...])
update_node(file_path, changes)
update_next_action("what the next agent should do")
write_session_log(...)

This loop keeps every session fast, focused, and resumable.

---

26 MCP Tools

Graph Tools

| Tool | Description | |---|---| | get_node(file_path) | Metadata, rules, connections, staleness for any file | | get_impact(file_path) | BFS blast-radius — which files depend on this one | | list_nodes(layer?, stability?, do_not_revert?) | Query nodes by attribute | | add_node(file_path, role, type, ...) | Register a new file in the graph | | update_node(file_path, changes) | Append rules, connections, key_functions | | refresh_graph(file_paths?) | Auto-generate stubs for unregistered files | | refresh_index(file_paths?) | Re-embed specific files in ChromaDB |

Roadmap Tools

| Tool | Description | |---|---| | get_roadmap() | Current phase, next action, open changesets | | get_full_roadmap() | Complete history: all phases, decisions, deferred | | get_phase(number) | Full details of any phase by number | | update_next_action(text) | Set what the next agent should do | | update_phase_status(status) | Mark phase in_progress / blocked | | add_phase(phase, name, description, ...) | Queue new upcoming work | | complete_phase(number, key_decisions) | Mark done, auto-advance to next | | defer_phase(number, reason) | Move a phase to the deferred list |

Changeset Tools

| Tool | Description | |---|---| | list_open_changesets() | All in-pro