MCP Context Mode: Session Memory and Context Management for GitHub Copilot

Fri, 21 Aug 2026 00:00:00 +0000

Every Copilot session has a limited context window. As a coding task grows, the conversation fills with file contents, terminal output, tool calls, errors, and decisions. When the context is compacted, Copilot can lose the details that explain what has already been investigated and what still needs to be done.

Context Mode is an MCP server and context-management tool designed for this problem. It keeps large tool output outside the model’s context, indexes useful project and session data locally, and retrieves relevant information when it is needed. Its documentation lists VSCode Copilot as a supported platform.

Context Mode focuses on the history of coding work and on controlling how much raw data reaches the model.

%%{init: {'theme': 'base'}}%% flowchart LR A[VS Code Copilot
Agent mode] -->|prompts + tool events| B[Context Mode
MCP tools + hooks] B -->|store and index| C[(Local SQLite + FTS5
session history + project index)] C -->|search relevant data| D[Focused context
snippets + next steps] D -->|restore context| A E[Large inputs
logs · files · APIs] -->|process outside chat| B B -->|return only useful data| F[Compact output
less context pressure] F --> A classDef copilot fill:#dbeafe,stroke:#2563eb,stroke-width:3px,color:#172b4d classDef mode fill:#fce7f3,stroke:#db2777,stroke-width:3px,color:#5e163d classDef storage fill:#dcfce7,stroke:#16a34a,stroke-width:3px,color:#24592b classDef result fill:#fef3c7,stroke:#d97706,stroke-width:3px,color:#604e12 classDef input fill:#f3f4f6,stroke:#6b7280,stroke-width:3px,color:#344054 classDef output fill:#fee2e2,stroke:#dc2626,stroke-width:3px,color:#7a2825 class A copilot class B mode class C storage class D result class E input class F output linkStyle 0 stroke:#2563eb,stroke-width:3px linkStyle 1 stroke:#db2777,stroke-width:3px linkStyle 2 stroke:#16a34a,stroke-width:3px linkStyle 3 stroke:#d97706,stroke-width:3px linkStyle 4 stroke:#6b7280,stroke-width:3px linkStyle 5 stroke:#dc2626,stroke-width:3px linkStyle 6 stroke:#dc2626,stroke-width:3px

The diagram shows the central idea: Copilot sends prompts and tool events to Context Mode, Context Mode stores or indexes the useful data locally, and only relevant snippets or summaries return to Copilot.

What You Will Build

You will investigate one small API exception to see how Context Mode stores useful project context and retrieves it in a later Copilot session:

Session 1: Investigate the GET /api/todos exception and fix its cause.

Session 2: What caused the exception, which file changed, and what test is missing?

In Session 1, Context Mode indexes the API log and records useful work. In Session 2, it retrieves the relevant result instead of making you repeat the investigation.

Use Context Mode in VSCode

There are two parts to a VSCode Copilot setup:

Add Context Mode as an MCP server so Copilot can call ctx_* tools.
Enable the Context Mode Copilot integration if you want automatic session capture and context restoration.

The MCP server alone gives Copilot context-processing tools. It does not automatically turn every existing Copilot conversation into searchable history.

Prerequisites

VSCode with GitHub Copilot Chat and agent mode enabled.
Node.js 20 or later and npx available in the integrated terminal.
A project folder where you can test the integration without exposing secrets.

Add the MCP Server

Open the Command Palette, run MCP: Open Workspace Folder MCP Configuration, and create or edit .vscode/mcp.json:

{
    "servers": {
        "context-mode": {
            "command": "npx",
            "args": [
                "-y",
                "context-mode"
            ]
        }
    }
}

The package and configuration options can change, so check the Context Mode repository when installing a newer version. After saving the file, use the MCP server controls in VSCode to start or restart context-mode.

Verify the Connection

Open Copilot Chat in agent mode and send this prompt:

Use Context Mode to run ctx doctor and report whether the MCP server,
runtime, SQLite/FTS5 search, and Copilot integration are ready.

You should see a context-mode tool call and a diagnostic result. If Copilot does not offer the tool, restart the MCP server and reload the VSCode window.

A Simple Scenario: Fix an API Exception

Assume a small ASP.NET Core Todo API returns HTTP 500 from GET /api/todos. The application writes this exception to app.log:

System.NullReferenceException: Object reference not set to an instance of an object.
    at TodoService.GetAll() in TodoService.cs:line 42

You want Copilot to find the exception in Session 1 and remember the fix in Session 2.

Session 1: Index the API Log

Send this prompt to Copilot:

Use Context Mode to index app.log.
Do not print the full file.

Context Mode chunks app.log and stores searchable content locally. The useful result is a small confirmation, not the complete log.

Session 1: Find the Exception

Now ask Copilot to search the indexed log:

Search the indexed app.log for the exception from GET /api/todos.
Explain the likely cause and identify the file to fix.

Context Mode searches the index and returns only the matching exception. Copilot can reason about the failure without loading the entire log.

Session 2: Retrieve the Previous Work

Close the first chat, start a new Copilot session, and send:

Continue the Todo API investigation from the previous session.
What caused the exception, which file changed, and what test is missing?

When the Copilot integration and hooks are active, Context Mode restores the relevant session context instead of replaying the complete conversation. Copilot can answer with the exception cause, changed file, and missing test.

Check Context Savings

Finish with this prompt:

Use Context Mode to show ctx stats for this session.
How much output was processed, and how much context was saved?

The exact numbers depend on file size, tool output, query shape, and the active adapter. Treat benchmark values from the repository as examples, not as a guarantee for every project.

The Context Window Problem

A coding agent receives more than your written prompt. It also receives tool input and tool output:

File contents
Directory listings
Git history
Build and test output
API responses
Logs
Browser or Playwright snapshots
Results from other MCP servers

Large responses consume context quickly. Reading fifty files directly may leave less room for reasoning about the implementation. Context Mode moves data processing closer to the tool call and returns a smaller result to the model.

For example, instead of placing a large log file into the conversation, an agent can process it and return only matching errors, counts, or summaries. Instead of loading an entire document, it can index the document and retrieve relevant sections later.

Core Capabilities

1. Session Continuity

Context Mode records useful events from a coding session, including prompts, decisions, tool activity, errors, and task progress. When a session is resumed or the context is compacted, it can restore relevant working state instead of forcing Copilot to start from an empty context.

The restored context can answer questions such as:

What caused the Todo API exception?
Which file did we change?
What test is still missing?

Session continuity is project-oriented. It is intended to help an agent continue development work, not to reproduce every message exactly as a chat export.

2. Local Session Storage

Context Mode stores session and indexed-content data locally in SQLite. Its search layer uses SQLite FTS5 and BM25 ranking to find relevant text. This gives the agent searchable history without requiring a separate database server.

The repository documents storage under a Context Mode data directory, with project-scoped content and session data. The exact location can vary by adapter and configuration, so inspect the installed version before backing up or changing retention behavior.

3. Context Reduction

Context Mode can run code, process files, batch operations, and inspect large outputs while returning only standard output or relevant matches. This reduces the amount of raw data added to the model context.

Its MCP tools include capabilities for:

Running code in a sandboxed subprocess
Processing a file without returning its full contents
Running multiple commands or searches in one operation
Indexing local files and directories
Fetching and indexing web pages
Searching indexed content
Fetching only selected observations or snippets

This is useful for repositories, logs, CSV files, API responses, and documentation that are too large to paste into a chat.

4. Full-Text Retrieval

The ctx_index tool chunks content while preserving useful structure such as headings and code blocks. The ctx_search tool then searches indexed content and returns focused snippets rather than an entire document.

Search supports relevance ranking, stemming, substring matching, proximity ranking, fuzzy correction, and smart snippets. These features make it possible to ask for a concept without knowing the exact wording used in the original file.

5. Web and Document Retrieval

Context Mode can fetch a URL, convert it to searchable content, and index it. A later query can retrieve relevant sections without placing the entire web page in the conversation.

It also supports cache behavior for previously indexed URLs. This can avoid repeated downloads and reduce repeated context usage for stable documentation.

6. Tool Routing

On supported platforms, hooks can guide or enforce routing of large operations through Context Mode. The purpose is to prevent a large file, log, or external MCP response from consuming the context window unnecessarily.

This is stronger than a system prompt alone. A prompt can tell the model to use a context tool, while a hook can intercept tool activity and redirect or block selected operations, depending on the platform integration.

7. Statistics and Diagnostics

Context Mode provides utility commands for inspecting its operation:

ctx stats    -> context savings and session statistics
ctx doctor   -> runtime, hook, SQLite, and installation diagnostics
ctx index    -> index a file or directory
ctx search   -> search indexed content
ctx purge    -> remove indexed content

These commands help verify that the integration is active and show how much context has been saved.

How Session Continuity Works

A simplified flow looks like this:

%%{init: {'theme': 'base'}}%% graph LR A[Copilot prompt] --> B[Context Mode hooks] B --> C[Session and tool events] C --> D[(Local SQLite and FTS5)] D --> E[Relevant context retrieval] E --> F[Copilot continues task] classDef copilot fill:#dbeafe,stroke:#2563eb,stroke-width:3px,color:#1e3a8a classDef mode fill:#fce7f3,stroke:#db2777,stroke-width:3px,color:#5e163d classDef events fill:#fef3c7,stroke:#d97706,stroke-width:3px,color:#78350f classDef storage fill:#dcfce7,stroke:#16a34a,stroke-width:3px,color:#14532d class A,F copilot class B mode class C events class D storage class E copilot linkStyle 0 stroke:#2563eb,stroke-width:3px linkStyle 1 stroke:#db2777,stroke-width:3px linkStyle 2 stroke:#d97706,stroke-width:3px linkStyle 3 stroke:#16a34a,stroke-width:3px linkStyle 4 stroke:#2563eb,stroke-width:3px

During a long task, Context Mode captures useful session events. Before compaction, it can create a resumable snapshot. When the agent starts or resumes again, the integration retrieves relevant project and session context and makes it available to the model.

The important detail is selective retrieval. The entire previous conversation does not need to be inserted into the new context window. The agent searches for the current task and receives the most relevant observations.

What Context Mode Does Not Do

Context Mode is not a complete archive of every Copilot chat stored by GitHub. It cannot recover sessions that happened before it was installed or before its integration was enabled.

It also does not guarantee that every Copilot event is captured on every platform. Hook support, session-start behavior, compaction handling, and context injection depend on the client adapter and the installed version. Verify the integration with its diagnostic command before relying on it for important work.

Automatic history capture also requires privacy discipline. Prompts, file paths, tool inputs, command output, and source code can contain secrets or personal information. Configure exclusions, avoid indexing sensitive files, and inspect the local data directory before sharing or committing it.

When to Use Context Mode

Context Mode is a strong fit when:

A coding task spans many Copilot interactions.
Context compaction causes repeated explanations.
Tool output is larger than the useful answer.
You need to search project history or indexed documentation.
You want local session storage and FTS5 search.
You use VSCode Copilot or another supported coding-agent client.

Conclusion

Context Mode gives coding agents a second layer of memory: searchable working history and context management. It can preserve prompts, decisions, tool activity, errors, and next steps while keeping large raw outputs outside the model’s context.

For VSCode Copilot, Context Mode is most useful when Copilot needs to continue a complicated coding task, search previous project activity, or work with large files and tool responses without filling the context window.

Context Management on dotnetuniversity