AI-native graph platform

CodeMind Graph

A persistent engineering workspace that turns repositories into deterministic symbol graphs, repo maps, and read-only context tools for AI coding agents.

View GitHubExplore workflow
Local-firstprivate repository context
Read-onlyMCP integration boundary
Bilingualglobal developer entry point

Why CodeMind Graph

AI coding agents need more than raw files

Large repositories overwhelm context windows, hide architecture behind file trees, and lose decisions between sessions. CodeMind Graph turns repository structure into a persistent knowledge layer that both humans and agents can inspect.

Limits

Context windows fragment

A model can read a few files, but it rarely keeps the whole dependency story in view during long-running engineering work.

RAG alone is approximate

Similarity search helps discovery, but it does not provide deterministic symbol ownership, import paths, or module boundaries.

Project memory drifts

Decisions, generated maps, and handoff state become unreliable when they are not grounded in the current repository graph.

CodeMind Graph

Knowledge graph

Files, modules, symbols, imports, exports, and traces become addressable graph entities instead of loose text chunks.

Local-first runtime

Repository intelligence is generated locally and stored under `.codemind/`, preserving privacy and low-latency lookup.

Persistent engineering memory

Repo maps and read-only MCP tools give agents stable context across sessions without exposing private engineering notes.

Workspace graph

Repository context as a navigable graph

CodeMind Graph maps files, modules, symbols, imports, exports, and agent-facing context into one deterministic workspace layer.

Symbol Graphfunctions, classes, interfaces
Repo MapCODEMIND.md generated context
MCP Toolsfind_symbol and get_repo_map
Session Memorypersistent engineering handoff
  1. 01index repo
  2. 02build graph
  3. 03rank context
  4. 04guide agent

Engineering practices

AI-native, local-first engineering standards

CodeMind Graph treats structured context as a first-class engineering artifact. The product is built around deterministic graphs, privacy-preserving local processing, and read-only agent integration.

AI-first development

The repository is shaped for agents as well as humans: commands are deterministic, outputs are diffable, and context is structured.

Local-first processing

Source analysis runs on the developer machine. Generated graph data stays local unless the owner explicitly publishes a public demo.

Privacy-first architecture

MCP tools are read-only by default and do not expose session notes, private docs, environment variables, or write operations.

Source of truth management

The persisted graph, repo map, and docs-as-state files make long-running engineering sessions resumable and auditable.

Architecture standard

The v0.1 architecture starts with a TypeScript Compiler API adapter, a deterministic core graph model, a CLI-first query surface, and a read-only MCP server.

Knowledge Graph RuntimeRepresent files, modules, symbols, imports, exports, and traces as stable nodes and edges.
AI-native WorkflowGive implementer, evaluator, and reviewer agents the same structured context before they act.
Persistent Context SystemUse generated repo maps and project state docs as handoff artifacts for long engineering sessions.
Graph-based Code IntelligencePrefer deterministic symbol navigation over approximate raw-file prompting for architecture work.
Read engineering practices

Brand positioning

A code knowledge graph platform, not another document layer

CodeMind Graph is designed for large repositories, AI agents, and persistent engineering work. It combines graph-driven code intelligence with local-first safety.

Not
  • Not a generic document tool
  • Not only a vector database
  • Not a raw RAG wrapper
Is
  • AI-native code knowledge graph
  • Local-first repository intelligence layer
  • Graph-driven context system for long-running agents

Core capabilities

Features

Visual thought mapping

Represent project structure as readable nodes and relationships instead of raw file dumps.

AI-assisted knowledge linking

Give agents stable symbol and dependency context before they modify large codebases.

Persistent engineering memory

Keep decisions, state, and generated repo maps separate from private source code exposure.

Multi-agent collaboration

Prepare one shared graph context for implementer, evaluator, and librarian workflows.

AI-native workspace

Design the repo itself as an agent-readable workspace with deterministic command output.

Graph-based context system

Move from approximate search to structured navigation across symbols and modules.

Agent workflow

From repository to agent-ready context

01

Index

Scan TypeScript sources and write .codemind/graph.json.

02

Map

Generate CODEMIND.md for human and agent review.

03

Serve

Expose read-only MCP tools for targeted graph retrieval.

04

Reason

Use graph structure to guide persistent engineering sessions.

Developer-first

Start with a deterministic repo map

CodeMind Graph is built for local-first engineering. Generate the graph, inspect symbols, and expose safe read-only context to your agent workflow.

pnpm check && node packages/cli/dist/index.js map --root examples/ts-basic --format markdown
GitHub