Continue codebase context with persistent project structure

What is Continue codebase context?

Continue codebase context is the project information available to Continue's Chat, Edit, and Agent modes. Agent mode can explore files with tools, include user-selected context, follow project rules, use Git history, and call MCP tools configured for the workspace. The model sees only the context and tool results the host selects or exposes.

• Rules explain project boundaries, commands, conventions, and when to use a tool.
• File and search tools retrieve current source and exact strings.
• Git history explains changes but does not replace architecture relationships.
• MCP tools can provide bounded structural queries.

How does Graphify add persistent context to Continue?

Graphify builds reusable graph artifacts from code and project sources. Continue can consult GRAPH_REPORT.md for a concise architecture briefing, read graph.json when appropriate, or query Graphify through MCP for paths, affected nodes, and explanations. The graph supplies a durable map; Continue still opens the cited source before editing.

• Keep graphify-out with the repository when the team needs one shared context artifact.
• Use the report to choose where to begin, then inspect source.
• Use MCP for bounded structural answers instead of inserting a large graph file into every prompt.
• Reject graph claims that cite missing files or symbols in the current checkout.

How do you install the Continue and Graphify workflow?

Install graphifyy, build the repository graph, create a Continue rule that explains the workflow, and optionally register a local Graphify MCP server. Graphify does not currently document a native Continue installer, so use the documented rules and MCP surfaces instead of inventing a one-command integration.

• Install Python 3.10 or newer and the graphifyy package.
• Run graphify extract from the repository root and inspect graphify-out.
• Add a project-level rule under .continue/rules.
• Add an MCP block under .continue/mcpServers only when structured tools improve the task.
• Restart or reload Continue if newly added project configuration does not appear.

What belongs in a Continue rule for Graphify?

The rule should describe when to query the graph, which artifacts are authoritative, how to verify results, and when to refresh the graph. It should not copy the entire architecture into prompt text or instruct Continue to trust inferred edges without opening source.

• List the build, test, and graph-refresh commands that actually work in the repository.
• Require graph queries for cross-module dependencies and blast radius.
• Require file search for exact strings, current diagnostics, and recent edits.
• Require source reads before edits and tests before completion.
• State the revision or freshness policy for long-running branches.

When should Continue call Graphify through MCP?

Use MCP when Continue needs a small structured answer such as a path, explanation, or affected-node list. Read a report or graph.json directly when the task needs artifact inspection without a running server. Use ordinary Continue file tools for exact text, current source, and compiler diagnostics.

• MCP is strongest for repeatable bounded graph questions.
• Artifacts are stronger for review, archival, and branch handoff.
• File search is stronger for exact errors and configuration values.
• The compiler and tests remain authoritative for code behavior.

How should teams secure and refresh the integration?

Keep graph data inside the same trust boundary as the repository, expose only read-only tools where possible, and refresh after structural changes. Review generated project configuration before committing it, especially if the rules or MCP settings contain local paths or credentials.

• Do not expose write, shell, or arbitrary file-system tools from a graph server.
• Exclude secrets, generated output, and sensitive repositories with Graphify ignore rules.
• Refresh code relationships after file moves, interface changes, and dependency upgrades.
• Run a full graph refresh when semantic source documents change.

What is a safe first-week Continue workflow?

Build the graph once, add a minimal project rule, and use Continue normally for current files and tests. Introduce MCP after the team confirms the graph is fresh and the rule produces bounded queries. Review the first week's accepted and rejected graph answers before expanding to more repositories.

• Start with GRAPH_REPORT.md as the architecture briefing.
• Test one path, one reverse dependency, and one ambiguous symbol query.
• Keep exact source search in Continue for errors and configuration values.
• Record graph revision and source files with accepted answers.
• Ask Continue to run focused checks after using graph context.
• Remove or correct rules that produce duplicated exploration.

Which failure modes should the team monitor?

The highest-risk failures are stale graph data, ambiguous symbol resolution, MCP payloads that consume too much context, and project rules that tell Continue to trust graph summaries over source. Monitor these directly rather than measuring only page views or tool-call counts.

• Track answers that cite deleted files or symbols.
• Inspect truncated or oversized MCP responses.
• Review repeated graph queries that add no new source evidence.
• Check that sensitive files are excluded from artifacts and prompts.
• Confirm the compiler and tests still run after repository changes.
• Update the graph when docs, diagrams, or code boundaries change.

What should Continue not infer from Graphify?

Continue should not infer that an edge is a runtime call, that an old recommendation still matches the branch, or that a graph summary replaces compiler diagnostics and tests. Graph confidence describes how a relationship was derived; it does not certify behavior, compatibility, security, or performance.

• Do not treat an inferred edge as a confirmed runtime dependency.
• Do not reuse a graph that predates the active source revision.
• Do not let a project rule override current compiler errors.
• Do not send secrets or excluded files into a graph query.
• Do not accept an oversized MCP response when a narrower query is available.
• Do not merge code based only on graph-derived architecture claims.

How do you verify a Continue answer that cites the graph?

Ask Continue to name the graph edge, source files, symbols, confidence, and tests supporting its conclusion. Open those files, confirm the graph revision, and run the focused checks. A graph path identifies a candidate relationship; it does not prove that the current branch compiles or behaves correctly.

• Confirm every cited symbol and path exists in the active checkout.
• Compare extracted, inferred, and ambiguous claims separately.
• Run type checks and tests selected from the affected paths.
• Refresh the graph and repeat the query when the source differs.