The missing map in AI coding
When a coding assistant says it “understands your project,” it often means that it has read the current file, a few neighbouring lines, or a bundle of files someone manually attached to a chat. That is adequate for a toy repository. In a real software system, it has barely reached the actual problem.
A product change can cross an API, a type definition, a service layer, an event handler, tests, docs, and Git history. The hard questions are not simply about fitting more tokens into a context window. They are: what role does this code play in the project, who is affected by changing it, and which piece of context should be read next?
Context Hub starts there. Instead of compressing an entire repository into one oversized prompt, it builds and maintains a project semantic index on the developer’s machine. AI no longer sees only the text in front of it; it has a map it can query, follow, and update.
<div className="article-callout">
<p className="article-callout-label">Core idea</p>
<p>A context window answers “how much can fit.” A project semantic index answers “what belongs here now.” The latter sets the reliability ceiling for AI in a large codebase.</p>
</div>
A local semantic index, not a prompt dump
When a project opens, Context Hub uses a built-in on-device model to create an index locally and writes the result under <code>.hydite/index/</code> in the project directory. Building, storage, and default retrieval all happen on the machine. The index remains on disk after the IDE closes, loads again on the next open, and updates only the affected portions when files change.
That sounds like an implementation detail, but it defines the product boundary. A repository is not a disposable attachment. It contains customer logic, deployment conventions, architectural decisions, and team knowledge; the index can be sensitive too. Making “upload first, understand later” the default rules out many regulated, offline, and high-security projects before work even begins.
Local-first does not reject cloud capability. It keeps project understanding close to the code and lets the user choose what happens next. In High Privacy mode, both retrieval and explanation can stay on-device. In Standard mode, only the minimum relevant slices needed for the present question reach a cloud prompt—not the entire index.
One graph across code, history, and tests
Conventional RAG often splits a repository into fixed-length text chunks and retrieves them by keyword or vector similarity. It can find passages that look related, but it struggles with engineering questions such as “who calls this function?”, “where is this interface implemented?”, or “which tests will this type change affect?”
Context Hub indexes more than text: semantic chunks for functions, classes, and modules; symbols, types, interfaces, and exports; call and implementation relationships; two-way links between code and tests; recent Git changes at file or function granularity; and READMEs, comments, ADRs, and design docs. Optionally, Design Hub tokens and resources exposed by MCP servers can join the same semantic relationships.
The value is not merely adding more columns to a search result. These dimensions form one graph. When a developer asks why a function exists, the system can retrieve callers, recent changes, matching tests, and the design record—not just guess from the local implementation. Before a shared type is refactored, it can prioritise real references and dependency paths instead of filling a prompt with every file in the repository.
<div className="article-metrics">
<div><strong>Local</strong><span>index construction and default storage</span></div>
<div><strong>Incremental</strong><span>only affected index entries update after a change</span></div>
<div><strong>5–10%</strong><span>relevant slices selected first for long tasks</span></div>
</div>
Context for Agent, Edit, and Assistant
The same map supports different ways of working. In a multi-step task, Agent actively retrieves context: an API implementation can begin with existing controller patterns, relevant DTOs, and nearby test examples; a refactor can surface callers and type dependencies; a bug investigation can bring together the functions in a stack trace, their recent changes, and related implementations.
Edit is lighter-weight, but it should not rely on selected text alone. When a developer starts an edit over a code region, Context Hub can add nearby type definitions, called functions, and related tests. The resulting diff has a better chance of referring to symbols that genuinely exist in the project rather than inventing a plausible-looking API from general training data.
Assistant turns that map into immediate local questions and answers. Ask “what does this function do?”, “who uses this endpoint?”, or “why was this written this way?” The response is grounded in targeted retrieval from the project semantic index rather than a narrow cross-section of the open file.
<blockquote>
Reliable AI collaboration is not making a model read the whole repository at once. It is making each step aware of what to read next—and why.
</blockquote>
Privacy and long-context routing
As projects grow, the usual trade-off is between stuffing in more material and truncating later. Context Hub uses two layers instead: first, it semantically compresses the question by choosing the most relevant pieces from the graph; only when a task truly exceeds the active model’s window does it route according to user authorisation and privacy mode, to a long-context model or an on-device long-window model.
Long context is therefore not the only answer. Million-token windows are useful for complex work, but without discriminating retrieval, extra irrelevant material dilutes the signal, raises cost, and widens the data exposure surface. High Privacy, Standard, and Self-hosted Enterprise modes differ in who explains the retrieved result—not in whether the project index is first uploaded. Index construction remains local.
This separation matters especially in finance, government, and regulated industries. The foundation for understanding code can remain on-device; only explicitly permitted, minimum relevant context can leave for external inference. Organisations can also route inference through their own private Vtslx AO gateway.
Incremental by design
A project map only earns its place in a daily workflow if it remains light. Context Hub ignores generated directories such as <code>node_modules</code> and <code>dist</code> by default, and offers <code>.hydite/index.ignore</code> and <code>.hydite/index.include</code> for precise control. Developers can rebuild an index, pause incremental updates, inspect its size, or configure a local shared cache for multiple projects.
For a monorepo, the default is one repository-wide index, so cross-package references remain traceable. Teams that need only selected workspaces can make that scope explicit. Git branch changes do not force the system back to zero: the index is Git-aware and performs the minimum incremental update for what changed.
That is the promise behind Context Hub: understanding an engineering system should not depend on one expensive, opaque attempt to “read the whole repo.” It should be stable, auditable, and controllable infrastructure. Models will change, editors will change, and teams will change their workflows. Every intelligent collaboration surface still needs an accurate, private map of the project beneath it.
Source
This article is based on Hydite’s Context Hub product guide. Its capabilities, privacy modes, index location, control surfaces, and boundaries are described only as disclosed in that guide; this article does not present them as undisclosed model, retrieval, or performance guarantees.