Your AI coding agent
has amnesia.

Why codevira exists

“ Every AI tool you open reads and writes the same project memory. What one learns, all of them know. What one is forbidden to break, none of them can.

Four moments in the life of a memory

Watch the loop: a decision is recorded once, shared everywhere, enforced forever — and your agents keep learning on top.

Memory you can see

Run codevira graph and your project's decision memory renders as an interactive, fully offline HTML viewer — decisions, files, tags, and the lineage between them. This is a live miniature. Drag the nodes. Click one.

Memory that pushes back

Your tools alone vs. with codevira

Every IDE has some context feature. None of them persist across tools, none of them enforce, and the moment you switch IDEs you start from zero.

Codevira doesn't replace your IDE's features — it's the layer underneath all of them.

Memory is cheaper than amnesia

Re-explaining your project every session costs real tokens — and real money. Codevira's read surface is summary-first by design: one ~500-token call replaces the catch-up conversation entirely.

Illustrative sessions from codevira's own development. The injection side is just as frugal: ≤3 relevant decisions per prompt, 0 tokens when off-topic, ~30 tokens for your style profile.

Your memory moves with you

New laptop? Two commands. Project memory already travels with git clone — the transfer archive brings your cross-project learning (preferences, learned rules) on top.

# old machine — one archive with everything
$ codevira export setup
✓ codevira-setup.tar.gz
  project memory (.codevira/) + global learning

# new machine
$ pipx install codevira
$ codevira import codevira-setup.tar.gz
✓ project memory restored
✓ global learning merged — never overwrites what's already there
$ codevira init   # re-register IDEs, rebuild caches

MCP is the SDK

Codevira speaks the Model Context Protocol — the open standard every major AI tool already implements. codevira setup auto-configures everything it detects; here's what it writes, per tool, if you'd rather do it by hand.

# one command — detects installed AI tools, writes MCP configs,
# installs Claude Code lifecycle hooks, generates AGENTS.md
$ codevira setup

✓ Claude Code    MCP config + 5 lifecycle hooks
✓ Cursor         MCP config + AGENTS.md
✓ Windsurf       MCP config + AGENTS.md
✓ Gemini CLI     MCP config + AGENTS.md

// ~/.claude.json  (written by `codevira setup`)
{
  "mcpServers": {
    "codevira": {
      "command": "/path/to/codevira-python",
      "args": ["-m", "mcp_server"],
      "cwd": "/path/to/your/project"
    }
  }
}

// ~/.cursor/mcp.json
{
  "mcpServers": {
    "codevira": {
      "command": "/path/to/codevira-python",
      "args": ["-m", "mcp_server"],
      "cwd": "/path/to/your/project"
    }
  }
}

// ~/.codeium/windsurf/mcp_config.json
{
  "mcpServers": {
    "codevira": {
      "command": "/path/to/codevira-python",
      "args": ["-m", "mcp_server", "--project-dir", "/path/to/project"]
    }
  }
}

# Codevira is a standard MCP stdio server — any client in any
# language connects with the usual MCP SDK. Python example:

from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client

params = StdioServerParameters(command="codevira-python", args=["-m", "mcp_server"])
async with stdio_client(params) as (r, w):
    async with ClientSession(r, w) as s:
        await s.initialize()
        ctx = await s.call_tool("get_session_context", {})

# No SDK at all? The memory is just files in your repo.
$ cat .codevira/decisions.jsonl | jq '.decision'
"Use bcrypt for password hashing"
"JSONL is the canonical store; SQLite is a rebuildable index"

# Every language that can read a file can read codevira memory.
# That's the point.

Python, TypeScript, JS/JSX, Go, and Rust get full symbol tools; for other languages the agent reads the file directly.