Codevira MCP

Persistent adaptive memory for AI coding agents — learns from every session, works with every tool, remembers across every project.

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:

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.

33 MCP Tools

Graph Tools

Roadmap Tools

Changeset Tools

Search Tools

Adaptive Learning Tools (v1.4)

Code Reader Tools

Playbook Tool

Agent Personas

Seven role definitions in agents/ tell each agent exactly what to do and when:

Project Structure

.agents/
├── PROTOCOL.md              # Session protocol — read this first
├── config.example.yaml      # Config template
├── config.yaml              # Your config (git-ignored)
├── roadmap.yaml             # Phase tracker (auto-created, git-ignored)
├── mcp-server/
│   ├── server.py            # MCP server entry point
│   └── tools/
│       ├── graph.py
│       ├── roadmap.py
│       ├── changesets.py
│       ├── search.py
│       ├── playbook.py
│       └── code_reader.py
├── indexer/
│   ├── index_codebase.py    # Build/update ChromaDB index + background file watcher
│   ├── chunker.py           # AST-based code chunker
│   ├── treesitter_parser.py # Multi-language AST parsing (16+ languages)
│   ├── sqlite_graph.py      # SQLite graph database backend
│   └── graph_generator.py   # Auto-generate graph stubs
├── requirements.txt         # Python dependencies
├── agents/                  # Role definitions
│   ├── orchestrator.md
│   ├── planner.md
│   ├── developer.md
│   ├── reviewer.md
│   ├── tester.md
│   ├── builder.md
│   └── documenter.md
├── rules/                   # Engineering standards
│   ├── master_rule.md
│   ├── coding-standards.md
│   ├── testing-standards.md
│   └── ...13 more
├── graph/
│   ├── graph.db             # SQLite Context Graph and Session Memory (git-ignored)
│   └── changesets/
├── hooks/
│   └── install-hooks.sh
└── codeindex/               # ChromaDB files (git-ignored)

Language Support

All session management, graph, roadmap, and search features work for any language. Code parsing and extraction (search, graph generation, signature reads) are powered by robust ast and Tree-Sitter integrations.

Requirements

• Python 3.10+

• ChromaDB

• sentence-transformers

• PyYAML

pip install -r .agents/requirements.txt

Background

Want to understand the full story behind why this was built, the design decisions, what didn't work, and how it compares to other tools in the ecosystem?

Read the full write-up: How We Cut AI Coding Agent Token Usage by 92%

Contributing

Contributions are welcome — this is an early-stage open source project and there's a lot of room to grow.

Read CONTRIBUTING.md for the full guide: forking, branch naming, commit format, and PR process.

Good first areas:

• Graph visualization exports (Dot/Mermaid)

• Additional playbook entries for common task types

• IDE-specific setup guides

• Bug reports and edge case fixes

Reporting a bug? → Open a bug report

Requesting a feature? → Open a feature request

Found a security issue? → Read SECURITY.md — please don't use public issues for vulnerabilities.

Please open an issue before submitting a large PR so we can discuss the approach first.

FAQ

Common questions about setup, usage, architecture, and troubleshooting — see FAQ.md.

Roadmap

See what's built, what's coming next, and what's being considered — see ROADMAP.md.

Want to influence priorities? Open a feature request or upvote existing ones.

Code of Conduct

This project follows the Contributor Covenant Code of Conduct. By participating, you agree to maintain a respectful and welcoming environment.

License

MIT — free to use, modify, and distribute.