Code knowledge graph
A structured map of a codebase where every declaration is a node and every real relationship between them is an edge.
A code knowledge graph is a structured map of a codebase in which every declaration, meaning every function, class, method, type and file, is a node, and every relationship between them is an edge. The edges are the point. A call is an edge, an import is an edge, inheritance is an edge, and so is an HTTP request that leaves one service and arrives in another.
It differs from text search in what it stores. A text index stores strings and finds the ones that look similar to your question. A graph stores resolved structure, so it can answer a question about how the code is connected rather than about which files happen to contain the same words. That is why it can tell you what breaks if you change something, and a search box cannot.
Model Context Protocol (MCP)
An open standard that lets an AI model call external tools and read external data through one common interface.
The Model Context Protocol is an open standard that lets an AI model call external tools and read external data through one common interface. Anthropic introduced it in November 2024 and it has since been adopted well beyond Anthropic tooling.
It matters because it removes the integration problem. Before a shared protocol, connecting a data source to five different coding agents meant five different integrations. With MCP, a data source implements the protocol once and every MCP capable client can use it. That is why one MCP server can serve Claude Code, Cursor, Windsurf, Codex, Cline, Zed and others without knowing anything about them individually.
MCP server
A program that exposes tools or data to an AI agent over the Model Context Protocol.
An MCP server is a program that exposes tools or data to an AI agent over the Model Context Protocol. The agent is the client, the server is whatever you want the agent to be able to reach, and the protocol is the contract between them.
Servers can run locally on your own machine or remotely over a network. A local server is the right shape when the data should not leave the machine, which is the usual case for source code. Koragraph MCP is a local server: it builds the graph on your machine and answers from it there, with no source code sent anywhere.
Blast radius
Everything that could break if you change one piece of code, including the parts of it that no test covers.
Blast radius is everything that could break if you change one piece of code. It is the set of callers, and the callers of those callers, and the code paths that reach the thing you are about to edit, including the ones that cross a repository boundary.
The reason it is worth naming is that it is the question people actually ask before editing, and it is a question text search answers badly. Finding every string that matches a function name is not the same as finding everything that depends on it, and neither one tells you which of those paths has no test covering it. A graph can answer both, because dependence is an edge it already stored.
Call graph
The subset of a code graph that records which functions call which other functions.
A call graph is the part of a code graph that records which functions call which other functions. Follow the edges forward from a function and you get everything it depends on. Follow them backward and you get everything that depends on it.
The quality of a call graph depends entirely on how the edges were made. An edge guessed from a matching name is wrong whenever two unrelated functions share a name, which in a large codebase is constantly. An edge resolved against the syntax tree is an edge only where the code really connects.
Cross service edge
A dependency that leaves one repository or service and lands in another, which single repository tools cannot see.
A cross service edge is a dependency that leaves one repository or service and arrives in another. An HTTP call from a frontend to an API, a gRPC method defined in a shared protobuf file, a message published to a topic that another service consumes, a package published by one repository and imported by a second.
These edges are where single repository tooling goes quiet. Each repository is internally consistent and complete on its own terms, so an index built inside one of them cannot see that the function it just described is called by something in a repository it was never pointed at. Resolving those edges is what turns several graphs into one.
Git co-change
Two pieces of code that keep getting changed in the same commits, which reveals coupling the syntax does not show.
Git co-change is the observation that two pieces of code keep getting modified in the same commits. It is mined from repository history rather than from the code itself.
It is useful because it finds coupling that no parser can see. Two files with no import between them and no shared symbol can still be joined by an undocumented contract, a serialisation format, a magic constant, or a convention nobody wrote down. If they have changed together forty times, they are coupled, whatever the syntax says. That is a real dependency and it is invisible to static analysis alone.
Tree-sitter
A parser generator that turns source code into a concrete syntax tree, fast enough to run over a whole codebase.
Tree-sitter is a parser generator that turns source code into a concrete syntax tree. It was built for editors, so it is fast, it is incremental, and it can parse a file that does not currently compile, which matters because code spends a lot of its life in that state.
For graph building it means declarations can be extracted from the structure of the code rather than from pattern matching over text. Koragraph MCP uses tree-sitter across twelve languages, which is why the same extraction logic behaves consistently whether it is looking at Go, Python, Rust or TypeScript.
GraphRAG for code
Retrieval that walks a graph of a codebase to assemble context, instead of returning the chunks that scored highest for similarity.
GraphRAG for code is retrieval that walks a graph to assemble context, rather than returning the text chunks that scored highest on similarity to the question. Ordinary retrieval augmented generation embeds chunks of a codebase and returns the nearest ones. Graph based retrieval starts from a node and follows real edges out from it.
The difference shows up in what comes back. Similarity search returns code that resembles the question. A graph walk returns the code the answer actually depends on, including pieces that share no vocabulary with the question at all, which is a common case in code because the caller and the callee are frequently written in completely different terms.
Context window
The fixed amount of text a model can consider at once, which is a budget rather than a container.
A context window is the fixed amount of text a model can take into account in a single request. Everything the model knows about your specific situation has to fit inside it.
Treating it as a budget rather than a container is the useful shift. A window filled with whole files spends most of itself on code that has nothing to do with the question, and long inputs measurably degrade reliability well before the stated limit is reached. The job of a context layer is to decide what goes in, so the same answer costs a fraction of the window and the model is not asked to ignore most of what it was handed.
Context layer
The system that decides which parts of your codebase an AI agent sees for a given question.
A context layer is the system that sits between your codebase and your AI agent and decides what the agent sees for any given question. The agent supplies the reasoning. The context layer supplies the facts and, more importantly, chooses which facts.
Without one, an agent rediscovers your codebase on every request by reading files until it runs out of room. With one, the selection is made against a structure that already knows how the code connects, so what arrives in the window is the resolved subgraph the question needs rather than the files whose names looked promising.
