GraphitAI ENGINEERING
GitHub ↗
Context + control for AI engineering v0.1.26

Make AI software work complete, not merely plausible.

Graphit gives every coding agent the same structural code map, searchable documentation, persistent memory, reusable ecosystem context, and deterministic work ledger—inside the tools where your team already builds.

Install Graphit ↓ Explore the source ↗
Multi-agentMulti-systemLocal-firstAny MCP clientOpen source
graphit-labs/graphit-code · AST Explorer
Graphit AST Explorer visualizing the graphit-code repository
Real project data from Graphit analyzing its own codebase.
01ASTstructure & relationships
02MEMORYdecisions that persist
03WIKIconnected project knowledge
04TASKshared work with safe takeover
05HUBreusable ecosystem context

The operating loop

Models stay probabilistic. Engineering control does not.

Graphit surrounds AI reasoning with source-backed context and deterministic state transitions: discover broadly, verify structurally, claim work atomically, and complete only against explicit evidence.

01 / UNDERSTAND

Map the code

Query symbols, callers, dependencies, imports, inheritance, complexity, and source through a structural graph.

02 / REMEMBER

Keep the why

Store corrections, decisions, conventions, and discoveries so the next session starts with project context.

03 / CONNECT

Compile the docs

Turn maintained documentation into a searchable wiki with provenance, confidence, and cross-references.

04 / CONTROL

Make work complete

Claim shared tasks atomically, fence stale owners, order dependencies, preserve audit history, and require evidence before completion.

05 / DISTRIBUTE

Bring it everywhere

Install the right rules, skills, MCP tools, languages, and versioned artifacts for each project, agent, and system.

One observatory

See the code and the knowledge around it.

Knowledge Explorer
Graphit Knowledge Explorer showing the graphit-code architecture documentation
Knowledge with provenance. Browse source-backed pages, confidence, links, and update history.
Memory Explorer
Graphit Memory Explorer showing a graphit-code design decision
Memory with intent. Keep the decisions and corrections that code alone cannot explain.
AST

Structural code exploration

Language-aware entities and relationships across Go, TypeScript, Python, Java, C, SQL, and more.

SEARCH

FTS + vectors + RRF

Combine BM25 full-text precision and semantic recall, then fuse both ranked lists deterministically before reading sources.

MEMORY

Persistent across sessions

Keep project decisions and corrections separate from user conventions, with mandatory recall, revision history, and optional shared storage.

KNOWLEDGE

Living documentation

Search active guides, specs, architecture, and decisions with traceable sources.

TASK

Deterministic multi-agent work

Use shared LanceDB claims, fencing tokens, leases, versioned specifications, dependencies, subtasks, audited scope changes, and evidence gates.

HUB

Shareable artifacts

Discover and distribute rules, skills, agents, MCP servers, languages, ASTs, and knowledge bundles.

OBSERVATORY

One operational UI

Inspect project context, explorers, daemon state, Dream, ecosystem projects, and live agent runs.

ON THE FLY

Fresh context without copies

Mount Icebug graphs into an in-memory catalog, query Lance indexes in place, and assemble disposable Live Search workspaces from selected artifacts.

Designed for collaborative engineering

One operational truth for every agent and machine.

A human, a coding agent, a CI worker, and a remote MCP client can enter the same project without reconstructing its history from chat. Graphit gives them durable identity, shared artifacts, explicit ownership, and takeover-safe work.

  • Shared workAtomic claims, leases, fencing tokens, dependencies, subtasks, checks, flags, and an immutable audit trail.
  • Shared memoryProject and user scopes preserve decisions across sessions; mandatory memories load before contextual recall.
  • Many agentsNative adapters for Codex, Claude, Cursor, Gemini, Kiro, OpenCode, and Antigravity, plus MCP for any compatible client.
  • Many systemsVersioned code graphs, knowledge, rules, skills, agents, commands, MCP definitions, and language packs move through the Hub.

Find broadly, prove exactly

Retrieval is a pipeline, not a guess.

Start with lexical and semantic recall, fuse results with RRF, select the right source, then use graph traversal and bounded source reads for evidence.

FULL TEXT

Names, terms, and exact language

LanceDB BM25 reaches identifiers, paths, prose, and technical vocabulary without requiring an AI model.

SEMANTIC

Intent beyond wording

Local or remote embeddings retrieve related code and knowledge even when the query and source use different words.

STRUCTURE

Relationships you can prove

Cypher follows callers, imports, inheritance, database objects, and other exact AST relationships after discovery.

MULTI-WIKI

Project + memory + ecosystem

Search selected project, personal, and Hub knowledge sources as one ranked evidence surface.

RERANK

Second-stage ready

Local, Cohere, Voyage, and Jina adapters are implemented. Current product search uses hybrid RRF; CLI, MCP, and UI do not yet attach the second stage.

SOURCE

Read only what matters

Head, tail, line-range, entity, and pattern slices keep context bounded and preserve source provenance.

Clear trust boundary

Local by default. Shareable when you choose.

Mutable code and documentation stay in their repositories. Compiled graphs, indexes, memory, and tasks live once in the global store; optional S3-compatible storage makes authoritative state and versioned artifacts available across machines.

  • Local coreNo hosted database is required for everyday operation.
  • Explicit sharingHub publishing and remote storage are configured separately.
  • Network-aware UIThe UI binds to loopback by default and is not an authentication layer.
  • Serve it when you want toRun the same core as a container: an MCP endpoint your whole team's agents connect to.

Run it for the whole team

One server. Any AI agent, over MCP.

The repository ships a Dockerfile that runs Graphit as a server: the daemon publishing an MCP endpoint and the Observatory. Your agent connects from wherever you work, brings its own model, and reads the code graphs, documentation and memory the server holds.

ANY CLIENT

Whatever speaks MCP

Claude Code, Codex, Gemini, Cursor, OpenCode, Copilot, Kiro, or your own client. An HTTP URL and a bearer token is the whole integration.

NO CHECKOUT

Artifacts, not paths

The server answers about published knowledge and AST artifacts, addressed by name and version. It holds no source and needs none.

ONE STORE

Published once, read by everyone

Versioned AST and knowledge stores stay mounted at their Hub location. Team laptops do not download or rebuild a copy for every checkout.

docker build -t graphit-code .
docker run -d --name graphit \
  -p 127.0.0.1:8080:8080 -p 127.0.0.1:8081:8081 \
  -v graphit-global:/opt/graphit \
  graphit-code

Point your agent at it

Two values, and it is wired.

Open System → Daemon in the Observatory to see the endpoint and copy the full active value from the masked MCP bearer key control. By default every daemon start generates a new key. Set the secret mcp.api_key configuration or GRAPHIT_MCP_API_KEY to keep an operator-chosen key stable across restarts; changes take effect after restart.

  • URLhttp://your-server:8081/mcp
  • HeaderAuthorization: Bearer <key>
  • Trust boundaryMCP checks the bearer key. The UI has no login and can reveal that key, so protect both from untrusted networks.

Server guide ↗

Start with one binary

From repository to agent context.

Install Graphit, initialize the project for your IDE, then let the daemon keep indexes current — or skip the install and run it as a server your agents connect to.

curl -fsSL https://raw.githubusercontent.com/graphit-labs/graphit-code/main/install.sh | sh
graphit setup
cd your-project
graphit init --ide codex
graphit sync
graphit ui

Read by intent

Evaluate, adopt, operate, extend.

01

Getting started

Install, initialize a project, and make the first AST, knowledge, and memory queries.

Open guide ↗ 02

User manual

Move from daily commands to explorers, shared artifacts, daemon operation, and troubleshooting.

Open manual ↗ 03

Configuration

Every key, default, provider, environment override, feature switch, deployment profile, and runtime control.

Open reference ↗ 04

Retrieval architecture

Choose full text, semantic search, hybrid RRF, source reads, exact Cypher, or agent synthesis deliberately.

Open guide ↗ 05

Filesystem and watchers

Know what Graphit reads, writes, watches, commits, ignores, shares, and can safely regenerate.

Open guide ↗ 06

AST extensibility

Define every YAML field, select grammars and dialects, add Tree-sitter parsers, and integrate ANTLR drivers.

Open guide ↗ 07

AI models and providers

Choose an agent CLI, embedding model, dimensions, credentials, rerank backend, and local or remote boundary.

Open AI guide ↗ 08

Daemon operations

Understand every start path, scheduler, watcher, service, log, maintenance loop, and recovery behavior.

Open operations guide ↗ 09

Run as a server

Serve a team from one container: an authenticated MCP endpoint plus the Observatory.

Open server guide ↗ 10

Deterministic Task

Understand claims, takeover, versioned scope, checks, subtasks, dependencies, flags, audit, and completion gates.

Open specification ↗ 11

Architecture

Understand the launcher, core, stores, compiled wikis, Hub, daemon, UI, and agent adapters.

Open architecture ↗

Graphit Code

Give every agent context—and every task a definition of done.

Install Graphit View on GitHub ↗