Codebase context for AI assistants — without the code leaving the machine

Most tools that give AI assistants codebase context work by uploading the codebase: hosted indexes, embedding services, cloud retrieval. If your job is to say no to that, Graphify is the tool shaped around your constraint — the parsing, the graph, and the queries all run on the developer's machine, and the source is MIT-licensed so you can verify every claim on this page by reading the code.

The problem: retrieval usually means upload

Engineering wants assistants that understand the codebase. The common path there — chunk the repo, embed it, host the index — creates exactly the exposure you exist to prevent: a copy of your source in a vendor's infrastructure, governed by their retention and their breach surface. Blocking the tool makes you the bottleneck; approving it makes you the risk owner. The useful question is whether the retrieval layer can run without the upload.

How Graphify's model is different — structurally

Graphify's privacy model isn't a policy promise; it's architecture. The open-source core has no server behind it. Source code is parsed entirely on-device by 36 bundled tree-sitter grammars — no API is called to read or analyze your code. The resulting graph is a set of plain local files (graph.json, graph.html, GRAPH_REPORT.md) your team can open and inspect. Querying the graph is a local read, not a network request, and the CLI sends no telemetry — there is nowhere for your data to go. Assistants connect through a locally installed skill or an MCP server that runs over stdio by default, or as HTTP you self-host; either way the transport stays inside your infrastructure. The full data-flow breakdown — what stays local versus what your model provider sees — is on the security page, and the pipeline details are in concepts.

Compared to the embedding route, there's also less to govern: no hosted index to audit, no re-embedding jobs shipping code on every change. Graphify vs RAG covers that comparison honestly, including where embeddings remain the right tool.

The honest boundary

Graphify adds no channel of its own — but it doesn't change where the assistant itself sends prompts. Whatever your engineers' AI assistants already transmit to their model provider, under your API keys and agreements, continues exactly as before; graph queries reduce how much raw code gets pasted into that channel, but the channel is the assistant's, not ours to close. If code is read by a model for the optional non-code inference step, that uses the model backend you configure — including local options like Ollama for teams that want zero external calls. Scope your review accordingly: Graphify narrows the surface; your assistant policy still governs the rest.

For regulated and air-gapped environments

The open-source core already runs air-gapped: bundled grammars, no account, no license check, no phone-home. For organizations that want the graph powering merge-gate verification, graph-aware review, and an engineering digest, Graphify Enterprisedeploys self-hosted in your VPC or on-prem — it's in early access with a first design-partner cohort, and air-gapped deployments are on the table for design partners. On compliance, the precise status: SOC 2 Type II is in progress for the enterprise offering — there is no report yet, and we publish status on the security pageas the audit progresses. We won't claim a certification we don't hold.

Verify it yourself

The fastest security review is reading the source: the CLI is MIT-licensed, installs with one command, and the docsshow exactly what it writes and where. Run it on an internal repo on an offline machine and watch the network — that's the claim, falsifiable on purpose. Found something anyway? We respond to responsible disclosure within one business day, via the contact on the security page.