Dynamic Context

Dynamic context is retrieved at inference time based on the immediate needs of the conversation or task. It is not pre-loaded into the model's static weights or long-term memory.

• Example: An agent answering "What's the current server load?" invokes a get_system_metrics tool. The live API response (e.g., CPU: 78%) is the dynamic context injected for the next turn.
• Contrast: Static context includes the model's pre-trained knowledge or a permanently attached project documentation file.

This context is temporary and confined to a single session or context window. It is not persisted across different user sessions or agent lifetimes unless explicitly saved by the application logic.

• Mechanism: Injected into the model's limited context window (e.g., a chat history array) and is displaced by newer interactions.
• Implication: Requires the agent to re-retrieve information if needed later in a long conversation, influencing orchestration design to manage context window limits effectively.

Dynamic context is typically structured data returned from tools (APIs, databases, code execution) or well-defined resources (JSON files, database rows). This structure enables deterministic parsing and reliable use by the agent.

• Formats: JSON objects, API response schemas, rows from a SQL query result, or the text content of a specific file.
• Purpose: Provides the ground truth facts necessary for the model to generate accurate, actionable responses or to make informed decisions for subsequent tool calls.

Access is governed by protocols like the Model Context Protocol (MCP), which standardizes how clients (AI apps) discover and call tools or read resources from servers. This decouples the agent from specific backend implementations.

• Process: 1. Client requests a resource URI or invokes a tool. 2. Server executes the request. 3. Structured result is returned as context.
• Benefit: Enables a pluggable architecture where new data sources and tools can be added without modifying the core agent application.

By providing the model with exact, verifiable data from authoritative systems just before it generates a response, dynamic context dramatically reduces the likelihood of the model hallucinating or relying on outdated/incorrect internal knowledge.

• Core Use Case: Foundation of Retrieval-Augmented Generation (RAG). The 'retrieval' step fetches dynamic context from a vector store or knowledge base.
• Enterprise Value: Ensures answers about business data (e.g., Q4 sales figures, ticket status) are factual and traceable to source systems.

The flow of dynamic context is managed by an orchestration layer (the agent's reasoning loop). This layer decides when to retrieve context, which tool/resource to call, and how to integrate the result into the prompt.

• Key Decisions: Determining if a user query requires external data, selecting the correct tool from a registry, handling errors, and synthesizing multiple context pieces.
• Architecture Impact: The effectiveness of dynamic context is directly tied to the quality of the agent's planning and tool selection algorithms.

The Model Context Protocol (MCP) is the foundational, open-source standard that enables the entire dynamic context system. It defines the JSON-RPC messages and communication patterns that allow AI clients to connect to external data sources and tools. Without this protocol, there is no standardized method for a model to request and receive dynamic information.

• Standardized Interface: Provides a uniform way for any AI application to discover and interact with servers.
• Transport Agnostic: Can operate over stdio, Server-Sent Events (SSE), or other transports.
• Core of the Ecosystem: All dynamic context flows are built upon MCP's request/response lifecycle.

Context Injection is the specific action performed by the MCP client after retrieving dynamic context. It is the process of inserting the fetched resource contents or tool results directly into the model's current session or context window.

• Final Step in the Loop: This is where retrieved data becomes usable by the model for reasoning.
• Session-Based: The injected information is typically scoped to a single conversation or task session.
• Contrast with Static Knowledge: Differentiates on-demand, session-specific data from the model's internal, pre-trained weights.

An MCP Resource is a primary source of read-only dynamic context. It represents a discrete piece of data—like a file, database record, or API response—that a client can fetch on demand. Resources are identified by a URI and described by metadata.

• Data Objects: Examples include a file:///reports/q3_summary.md, a sql://row/12345, or a rest://api/weather/current.
• Described by Metadata: Each resource has a name, description, and MIME type (e.g., text/markdown, application/json).
• Client-Triggered Retrieval: The model or user request prompts the client to fetch the resource's contents, which then become dynamic context.

An MCP Tool is a source of dynamic context generated through computation or action. It is an executable function exposed by a server that a client invokes. The tool's result is then injected as context.

• Executable Functions: Tools perform actions like querying a database, calling a REST API, or running a script.
• Defined by Schema: Each tool has a strict input JSON Schema, ensuring structured, validated calls.
• Generates Context: Unlike a static resource, a tool's output is computed at the moment of invocation, providing fresh, actionable data (e.g., the result of get_stock_price('AAPL') or run_sql_query('SELECT * FROM logs')).

Tool Invocation is the event that triggers the creation of new dynamic context from a tool. It is the act of an MCP client sending a request to a server to execute a defined tool with specific arguments.

• Request-Response Cycle: The client sends an invocation request with parameters; the server executes the handler and returns a result.
• Schema-Validated: Input arguments are validated against the tool's definition before execution.
• Produces Result Context: The successful result (or error) of this invocation becomes the dynamic context to be injected. This process is fundamental for agents taking action in the world.

The MCP Client is the intelligent component that orchestrates dynamic context retrieval. It is the application (e.g., an AI assistant interface) that decides when to fetch resources or invoke tools based on the model's needs and manages the connections to servers.

• Orchestrator: Determines which resource URI to fetch or which tool to invoke based on the conversation.
• Manages Connections: Handles the transport layer communication with one or more MCP servers.
• Performs Injection: Responsible for taking the retrieved data and injecting it into the model's prompt or session state. The client is the active manager of the dynamic context lifecycle.