Model Context Protocol (MCP) Server: ai.kinlab/kin

The MCP server ai.kinlab/kin is described as “The system of record for AI-written software.” It is associated with semantic representations and agent workflows for code-related tasks, including code review and static analysis. The repository is positioned as open source and includes MCP server functionality.

🛠️ Key Features

System of record for AI-written software (as stated in the description)
Focus on semantic knowledge and knowledge-graph concepts (from topics)
MCP server category (from topics)
Rust and tree-sitter listed among topics

🚀 Use Cases

AI agents writing changes and capturing what constitutes the change (from the readme excerpt: “The diff is not the change.”)
Code review workflows (from topics: code-review)
Static analysis and version-control oriented contexts (from topics: static-analysis, version-control)
Semantic knowledge graph usage (from topics: knowledge-graph)

⚡ Developer Benefits

Developer tooling ecosystem signals: developer-tools, mcp-server, graph-database (from topics)
Integration targets or compatibility signals: claude, copilot, gemini-cli-extension, cursor (from topics)
LLM-oriented semantic processing (from topics: llm, semantic, ai-native)

⚠️ Limitations

The provided material does not list specific MCP tools, endpoints, or counts (only topics, name, description, and a partial readme excerpt are present).

Kin, a code repository for people and AI agents

A new foundation for code.

Kin is a graph-native code repository for people and AI agents. It stores source, recorded code relationships, and versioned history as repository state. The graph is the repository model, not a search index maintained beside another repository.

Functions, types, and the relationships between them are data you commit, branch, and merge. Exact source is preserved byte for byte, and filesystem projections let supported tools keep working with ordinary files.

Public alpha. Start with a small repository you know well. Expect rough edges and breaking changes.

Quickstart · Documentation · Browser demo

kin impact human_bytes --file crates/kin-cli/src/commands/cache.rs --kind function --depth 1, showing its direct callers in Kin's own codebase next to a git grep search for the same name

A star helps other people find Kin, and Discussions is where to bring a question about it.

See what connects

Before changing a shared function, what else should you inspect? Kin lets you look up its recorded callers and explore related code. The CLI and MCP server query the same graph, so you and your agent can work from the same record.

A recorded kin impact query on ripgrep, showing related entities for a signature change

Recorded on a prepared ripgrep graph at e89fff89ac9af12e8d4ce9d5fd07beb408ca730f. Raw run artifacts are not public. This illustrates a workflow, not a performance benchmark.

Use it from Claude Code, Codex or Cursor

For Claude Code:

code

/plugin marketplace add firelock-ai/kin
/plugin install kin@kin

For Codex, add the marketplace and install the plugin, or let kin setup --intent agent write the MCP server into ~/.codex/config.toml for you.

For Cursor, add the MCP server by hand; see plugins/kin-cursor for the exact snippet.

After installing, run kin init . in a small repository you know well; the kin-setup skill walks you through the rest.

Kin is not published on crates.io. The kin crate there is an unrelated project.

Quickstart

Use a disposable copy of a small Git repository. Import includes its full reachable history and can take substantial time and memory. Shallow clones, submodules, and Git LFS are not supported.

1. Install

One command, and it is the same on macOS, Linux, Windows and WSL. It installs Kin, connects the AI coding tools it finds, and needs Node.js 20 or newer:

npx -y @kinlab/kin setup

On a machine without Node, run the installer instead. get.kinlab.ai and get.kinlab.dev serve the same script:

curl -fsSL https://get.kinlab.dev/install | sh

Either way, reload your shell as a separate command, because the install puts kin in ~/.kin/bin and adds that directory to your shell profile for new sessions:

exec "$SHELL" -l

For Windows PowerShell, other installers, or troubleshooting, see the full quickstart.

2. Initialize the repository

At the new prompt, replace the path below:

cd /path/to/your/repository &&
kin init . &&
kin overview &&
kin status

kin overview shows the entities Kin imported. kin status shows what was admitted and the working tree's state against it. kin graph status reports the daemon's live query graph and coverage. Uncommitted and untracked changes are not part of the imported Git history; kin init reports what it left out.

3. Ask a question you can check

Look for something you already know is in the code:

kin locate "<something you already know is in this repository>"

Replace ExactEntityName below with a symbol from the result:

kin refs ExactEntityName
kin trace ExactEntityName
kin impact ExactEntityName

refs returns recorded references, trace brings in nearby context, and impact explores potential effects through the graph. Check the results against the source.

4. Connect your agent

Prepare local embeddings, then configure detected MCP clients:

kin embed &&
kin setup --intent agent &&
kin setup status --json

Kin supports Claude Code, Codex, Cursor, Gemini, and other MCP clients. Use kin setup --intent editor for VS Code. Kin also includes kin agent run for local or hosted OpenAI-compatible model endpoints.

Client configuration · MCP tools · Built-in agent

Local imports, storage, and queries run on your machine. Installation and the initial embedding-model download need network access. Before embeddings are ready, kin locate uses lexical and graph signals and reports the missing vector coverage.

Review a change

After running kin init on the Git branch you want to review, compare explicit commit SHAs against main:

kin review shadow "$(git rev-parse main)..$(git rev-parse HEAD)"

The report returns PASS, NEEDS ATTENTION, or WOULD BLOCK, with graph-derived impact and supporting evidence. It is advisory: it does not block a merge or change graph state. Authorship is declared, not independently verified.

Use Kin with or without Git

Kin has its own commits, branches, merges, diffs, and history, including in repositories with no Git underneath. Existing Git repositories can be imported, and supported workflows can export a new Git repository.

Native version-control walkthrough · Git interoperability and export limits

Alpha limits

Coverage is incomplete. Supported languages are parsed into entities and relationships; other files remain available as content and history. An empty result does not prove there are no callers or dependencies. Keep using your compiler, tests, and review. See language support.

Compatibility varies. Filesystem projection has separate platform and tool restrictions. Check platform notes before relying on it.

Preserve Kin-only state. Deleting .kin and re-importing from Git does not recover commits, reviews, or other state that existed only in Kin. Read the import, recovery, and upgrade notes.

Windows. Native Windows x86_64 support is early. Repository admission works: kin init imports a Git repository and publishes graph authority, and graph, lexical, and daemon-backed queries answer natively. Transparent filesystem projection is not shipped on Windows, and the end-to-end install proof does not yet cover MCP or review workflows there, so WSL2 remains the recommended path for the full Kin experience.

Why I built Kin

I kept watching coding agents piece together parts of a codebase we'd already worked through. Then I'd do a version of that work myself to review their changes. I started wondering why more of that structural understanding wasn't part of the repository itself.

That's what I'm building with Kin.

Troy

Learn more and contribute

CLI reference · Architecture and detailed limits · Contributing · Issues · Security

Kin and its local stack, including kin-db, are Apache-2.0. KinLab is the separate proprietary hosted product. Public repository onboarding is still in development.

Kin