Skip to content

Understanding Model Context Protocol (MCP) and Agentic AI

A large language model (LLM) can only respond to information available in its current input or learned during training. Giving it controlled access to files, databases, or software tools usually requires integration code for each host and service.

Model Context Protocol (MCP) defines a common way for an AI application to discover and call those resources. This post explains the client-server roles, the messages they exchange, and where MCP fits into a tool-using application. MCP standardizes the connection; it does not make a tool safe or an answer correct by itself.

Navigate this post

Why is Context Important?

Large Language Models (LLMs) do not possess human reasoning or persistent memory. Instead, an LLM relies on the context provided in its input prompt to construct every response.

Without relevant external context, an LLM must rely solely on its static training weights, leading to outdated answers or hallucinations when queried about private data, current events, or specialized domain knowledge.

LLM Context Relationship

The diagram above demonstrates how external context feeds directly into the LLM prompt window, allowing the model to ground its outputs in verifiable facts rather than unverified assumptions.

Context vs. Training Data

Context refers to dynamic, real-time information provided to the model at inference time. In contrast, training data consists of static historical datasets compiled before the model was trained.

What Constitutes Context?

Context encompasses any information provided alongside a user request that helps an LLM generate a more accurate and targeted response.

In modern AI applications, context extends far beyond simple chat history to include system instructions, user metadata, retrieved documents, database records, and active code editor state.

Elements of Context

As shown in the illustration, context can be categorized into four primary streams:

  1. System Prompts: Core behavioral rules and safety guidelines.
  2. User Instructions: Specific queries and constraints provided by the end user.
  3. Retrieved Documents: Relevant snippets retrieved from external search engines or vector databases (Retrieval-Augmented Generation).
  4. Environment State: Workspace state such as file paths, database schemas, or active API connections.

Why is Context Standardization Important?

When every application structures context differently, developers must write custom formatting logic for each AI model and data source. This fragmentation increases integration cost and introduces formatting errors that degrade model response quality.

Standardizing context structure ensures that information is delivered to the LLM in a predictable, high-density format that optimizes attention mechanisms and token usage.

Context Standardization Benefits

As highlighted in the diagram, context standardization provides three major benefits:

  • Relevance: Filters out noise so only pertinent data enters the context window.
  • Accuracy: Enforces consistent data types and schemas to reduce model confusion.
  • Structure: Formats inputs using clear delimiters (such as JSON or XML tags) for precise parsing.

What is Model Context Protocol?

Model Context Protocol (MCP) is an open specification introduced by Anthropic that standardizes how applications provide context and tools to Large Language Models.

Think of MCP as the "USB-C port" for AI applications. Just as USB-C provides a universal physical interface to connect laptops with monitors, storage drives, and peripherals, MCP provides a universal software interface to connect AI models with external tools and data stores.

Model Context Protocol Overview

Analogy: The USB-C of Artificial Intelligence

Before USB standards existed, connecting a printer, keyboard, or external drive required proprietary cables and custom hardware ports. Similarly, before MCP, connecting an AI model to Slack, GitHub, or PostgreSQL required bespoke integration code for every combination of application and model. MCP replaces N×M custom integrations with a single protocol.

MCP standardizes three key capabilities:

  • Resources: Standardized data access for reading files, database records, and API responses.
  • Prompts: Standardized prompt templates for reusable workflows.
  • Tools: Standardized tool definitions enabling LLMs to execute actions (such as committing code or executing database queries).

How MCP Enables Agentic AI

Agentic AI refers to artificial intelligence systems capable of autonomous planning, decision-making, and multi-step task execution. To understand how MCP advances agentic systems, consider our previous walkthrough on Agentic AI Chatbot Design.

While standard LLMs only generate text responses based on prompt inputs, agentic systems use external tools to read from and act upon the external environment.

Agentic AI Overview

The 3-Stage Evolution of AI Agency

The progression toward fully autonomous AI agents can be divided into three evolutionary stages based on how models interact with external tools and data.

Stage Agency Level Integration Mechanism System Coupling Tool Scope
Stage 1 0% Static Prompt & Internal Weights Hardcoded No external action
Stage 2 50% Direct Custom API Integration Tightly coupled Single specific tool
Stage 3 100% Standardized Protocol (MCP) Fully decoupled Any MCP-compliant tool

The table above summarizes how AI capability has evolved from isolated text generators to protocol-driven autonomous agents.

Stage 1: LLMs without Agency

In Stage 1, language models operate strictly on internal knowledge embedded during training. They cannot perform external actions, browse live web content, or query private databases.

Stage 1 LLM Architecture

As shown above, Stage 1 models receive text inputs and output text responses. While they can write code to solve complex problems, they cannot execute that code themselves.

Stage 2: LLMs with Limited Agency

In Stage 2, developers equip LLMs with tool-calling capabilities. The application parses model outputs and executes specific API calls based on custom integration code.

Stage 2 Custom Tool Calling

Fragility of Custom Tool Integrations

While Stage 2 allows models to perform real-world actions, every tool integration requires custom wrapper code. When an external API updates its endpoints or parameters, the application code breaks, making large-scale maintenance difficult.

Stage 3: LLMs with Full Agency via MCP

In Stage 3, MCP acts as a standardized middle layer between the AI application (client) and external tools (servers).

Stage 3 MCP Standardized Agency

As illustrated in the Stage 3 diagram, MCP decouples the host application from external tool APIs:

  • Decoupling: Host applications communicate exclusively via standard MCP protocol messages.
  • Maintainability: When an external tool API changes, only the dedicated MCP server adapter is updated.
  • Scalability: Host applications gain instant access to any new MCP server without writing new client code.

MCP Architecture Overview

The Model Context Protocol follows a client-server architecture designed to keep tool execution secure and modular.

MCP Architecture Components

The diagram above details the four primary components of the MCP architecture:

  • MCP Host: The application initiating AI interactions (such as Claude Desktop, VS Code, or custom AI agents).
  • MCP Client: The protocol client living inside the host that manages 1:1 connections with MCP servers.
  • MCP Server: A lightweight server process exposing specific capabilities (such as filesystem access, GitHub operations, or database queries) via the MCP specification.
  • Data Sources & Tools: The underlying local files, databases, or remote web services accessed by the server.

Standardized Tool Access

MCP relies on JSON-RPC 2.0 to exchange messages between clients and servers. This standard protocol ensures predictable tool discovery, parameter validation, and execution.

Standardized Tool Access Workflow

Sample MCP JSON-RPC Message Format
JSON
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "calculate_hash",
    "arguments": {
      "algorithm": "sha256",
      "input": "model-context-protocol"
    }
  }
}

As demonstrated in the interaction flow, the client sends a tools/list request to discover available capabilities, followed by a tools/call request to execute a specific action with validated arguments.

MCP Client-Server Interaction

During a typical session, the host application maintains isolated connections to multiple specialized MCP servers.

For instance, an AI coding assistant might connect simultaneously to a local File System MCP Server and a remote GitHub MCP Server. When the user asks for a code refactor, the AI client queries both servers through uniform protocol messages, aggregates the retrieved context, and presents a complete solution.

Conclusion

Model Context Protocol (MCP) establishes an essential open standard for the next generation of AI development. By replacing fragmented, custom API integrations with a standardized client-server architecture, MCP enables developers to build resilient, scalable, and fully autonomous Agentic AI systems.

  • Context Standardization
    Structures information exchange into uniform resources, prompts, and tool definitions for AI models.

  • Decoupled Architecture
    Separates host client applications from tool server implementations, eliminating custom API integration code.

  • Autonomous Agency
    Enables LLMs to discover, inspect, and invoke external tools dynamically to execute multi-step tasks.

  • Secure Access Boundaries
    Provides controlled access boundaries for local databases, local filesystems, and remote APIs.

References and further reading

Open the complete reference catalog

Primary Sources