Context Injection

Unlike static prompt engineering, context injection is a runtime operation. Information is fetched and inserted just-in-time based on the specific query or task. This enables the model to access information that is:

• Real-time (e.g., current stock prices, live system status)
• Extremely large (datasets far exceeding the model's native context window)
• Private or proprietary (internal documents, databases not in the training data)

The client decides what context to inject, governed by the logic of the application and the available MCP servers.

Injected context originates from MCP Resources, which provide a uniform interface to data. Each resource has:

• A unique Resource URI for identification.
• A declared MIME type (e.g., text/plain, application/json) so the client knows how to handle the content.
• Metadata including a name and description for discovery.

This structure allows the client to treat diverse data sources—files, database rows, API responses—identically during the injection process, promoting a clean separation between data access and model interaction.

Context is often the result of a prior tool invocation. For example:

1. Client invokes a SQL query tool with a natural language question converted to SQL.
2. The Tool Handler executes the query and returns a JSON result.
3. The client injects this JSON result as context for a follow-up model call to generate a natural language summary.

This creates a powerful perception-action loop: the model uses context to decide on an action (tool call), and the result of that action becomes new context for further reasoning.

The MCP server exposes capabilities, but the MCP Client owns the injection logic. The client is responsible for:

• Orchestration: Deciding the sequence of resource reads and tool calls.
• Context Window Management: Prioritizing, summarizing, or truncating information to fit token limits.
• Prompt Construction: Seamlessly blending injected context with user instructions and system prompts.
• Error Handling: Managing failures in resource retrieval or tool execution gracefully.

This makes the client the intelligent controller of the agent's working memory.

By injecting verifiable, external data, the system shifts from generative recall to deterministic reference. The model's output is grounded in the provided context, which:

• Reduces Hallucinations: The model reasons over provided facts instead of relying solely on parametric memory.
• Improves Auditability: Every response can be traced back to the specific resources or tool results that informed it.
• Ensures Consistency: The same query with the same underlying data will produce a consistent response, as the variable context is controlled.

This is the foundation for building reliable, enterprise-grade AI applications.

Performance is critical. Context injection architectures optimize for:

• Parallel Retrieval: Fetching multiple resources or invoking independent tools concurrently.
• Client-Side Caching: Temporarily storing frequently accessed resource contents to avoid redundant server calls within a session.
• Efficient Transports: Using lightweight protocols like JSON-RPC over stdio or SSE to minimize serialization and network overhead.
• Structured Data Handling: Using JSON Schema allows for efficient parsing and validation of tool inputs and resource contents, preventing costly processing errors.

The goal is to augment the model with external context with minimal impact on the user-perceived response time.

An MCP Resource is a readable data object exposed by an MCP server. It is the primary unit of information retrieved for Context Injection. Each resource has a unique URI, a MIME type, and metadata. Examples include:

• A text file from a code repository
• A row from a database table
• The output of a static API call When a client requests a resource, its contents are fetched and can be injected into the model's context.

An MCP Tool is an executable function exposed by an MCP server. It is defined by a name, description, and a strict input JSON Schema. Tool invocation is a dynamic form of Context Injection where the result of the tool's execution is injected. For example, a client could invoke a get_weather tool, and the API's JSON response containing the forecast would be injected into the model's context to inform its answer.

Dynamic Context refers to the live, on-demand information that is injected into a model's session via MCP, as opposed to static, pre-loaded knowledge. This context is ephemeral and specific to a single query or task. It is the output of the Context Injection process, ensuring the model's responses are grounded in the most current and relevant external data available at the moment of execution.

Tool Invocation is the specific act where an MCP client sends a request to a server to execute a defined tool. This process involves:

1. The client formats the request with arguments validated against the tool's input schema.
2. The server receives the request and executes the corresponding tool handler function.
3. The server returns the result (or error) to the client. The client then typically injects this result as context for the model, closing the loop from request to informed response.

JSON-RPC is the lightweight remote procedure call protocol that serves as the messaging backbone for MCP. All communications for Context Injection—including listing resources, fetching resource contents, and invoking tools—are structured as JSON-RPC requests and responses. This standardized envelope ensures reliable, language-agnostic communication between the AI client and any MCP server, whether it's a local script or a remote API gateway.