×

About the author

Gauraw Jumnake
Lead Engineer (AI/ML)
Gauraw Jumnake is a Lead Engineer at Nitor Infotech with over 7 years of experience in building data-driven and intelligent solutions. His ex... Read More

Artificial intelligence   |      18 Nov 2026   |     24 min  |

Highlights

Model Context Protocol (MCP) gives AI applications a standard way to connect with external tools, data sources and workflows. Connectivity alone does not guarantee better agent performance, though. Its real value depends on how organizations manage the information agents access, the actions they can perform and the context they receive.

Why Does Model Context Protocol Matter for AI Agents?

AI agents need more than a capable model. They need access to the right business data, systems and actions at the right time. Connecting every application through a separate integration can become difficult to manage as agent use cases grow.

It allows applications to discover and use tools, access data, and draw on reusable prompts without building a separate integration for every model and system combination.

MCP was introduced by Anthropic in November 2024. In December 2025, Anthropic donated it to the Agentic AI Foundation, a Linux Foundation directed fund co-founded by Anthropic, Block and OpenAI, to support the protocol’s open and vendor-neutral development.

Adoption has accelerated. In July 2026, the MCP project’s Tier 1 SDKs (its highest-support-tier software development kits) were seeing close to 500 million downloads per month. This measures SDK downloads, not unique users or deployed agents, but indicates the pace at which developers are adopting the protocol.

Research from the UK AI Security Institute (AISI), examining 177,436 agent tools created between November 2024 and February 2026, found that software development and IT accounted for 67% of agent tools and 90% of MCP server downloads. The findings highlight how strongly MCP adoption is concentrated in software development workflows.

For an AI agent, MCP can make a practical difference. Consider a development assistant investigating a production issue. It may need to retrieve a relevant incident, inspect a code repository, check a deployment record and create a ticket. MCP provides a consistent way for the assistant to access those systems through their respective servers.

The larger point is that connectivity alone is not the outcome. The agent still needs relevant, well-scoped information and clear rules about what it can do. That is where MCP intersects with context engineering.

MCP benefits for AI agents.

Fig: MCP benefits for AI agents.

How Does Model Context Protocol Work?

The protocol uses JSON-RPC 2.0 to structure messages between clients and servers. It supports two transport mechanisms: stdio, commonly used for local server connections, and Streamable HTTP, used for remote connections.

The specification dated July 28, 2026, introduces a stateless protocol core. It removes the earlier initialization handshake and makes protocol-version and client-capability metadata part of individual requests. Discovery through server/discover is optional for clients, although servers implementing this specification must support it.

This matters for context engineering. Because the protocol no longer keeps session state, information such as conversation history, selected tools and retrieved resources must be managed by the host application rather than by the connection. The host is where context is assembled, so it carries more of that responsibility.

A simplified example shows how an AI application can request a tool through MCP. Here, the assistant asks a server for a customer record.

Request

{
"jsonrpc": "2.0",
"id": 1,
"method": "tools/call",
"params": {
  "name": "get_customer_record",
  "arguments": {
  "customer_id": "C-1042"
},

"_meta": {
"io.modelcontextprotocol/protocolVersion": "2026-07-28",
"io.modelcontextprotocol/clientCapabilities": {},
"io.modelcontextprotocol/clientInfo": {
  "name": "customer-assistant",
  "version": "1.0.0"
}
}
}
}
Response
{
"jsonrpc": "2.0",
"id": 1,
"result": {
  "resultType": "complete",
  "content": [
    {
      "type": "text",
      "text": "Customer C-1042: Active account. Renewal information is available."
    }
  ]
}
}

This is a simplified JSON-RPC example. In an actual HTTP exchange, the request also carries protocol-version and routing headers.

Host-client-server architecture of MCP.

Fig: Host-client-server architecture of MCP.

What Are MCP Tools, Resources and Prompts?

MCP servers can expose three core primitives. They serve different purposes and, importantly, have different control models.

MCP primitive What it provides Control model
Tools Actions an AI application can invoke, such as searching a system, creating a ticket or updating a record. Model-controlled: The model decides when to call a tool, subject to application permissions and approval rules.
Resources Contextual information, such as files, database records, documentation or other data. Application-controlled: The host application decides which resources to retrieve and include in context.
Prompts Reusable prompt templates or workflows that guide a task. User-controlled: Users select them through the application’s interface, such as a command or menu.

This distinction matters when designing an agent. A model may decide to use a tool, but that does not mean it should have unrestricted access to every action. The host application controls which resources enter the context, while users can choose predefined prompts for repeatable tasks.

MCP also defines client-side capabilities. Elicitation allows a server to request additional information from a user through the client. Roots, Sampling and Logging are deprecated in the July 2026 specification. They remain functional during a minimum 12-month deprecation window and should not be adopted in new implementations. They may still appear in older implementations, so teams should check the version and compatibility requirements of the MCP components they use.

How Does MCP Support Context Engineering?

Context engineering is the practice of selecting, structuring and managing the information an AI model receives to complete a task. It includes instructions, conversation history, retrieved knowledge, tool definitions and tool results.

MCP contributes to this process by standardizing how an AI application accesses external context and actions. A development assistant, for example, can retrieve repository documentation as a resource, call a code-search tool when needed, and use a prompt template for a code review. The host can then assemble the information relevant to the current task.

This is different from simply giving an agent access to more systems. The quality of context depends on relevance, freshness, structure and permissions. An agent that receives a large volume of unrelated information may perform worse than one given a smaller, carefully selected context. MCP makes connections easier; context engineering determines which connections and results are useful.

Related blog: Context Engineering 101: Why It’s the Real Bottleneck for AI Agents in 2026 explores how context quality affects agent accuracy, reliability and operating costs.

MCP and RAG: How Are They Different?

MCP and retrieval-augmented generation (RAG) solve different parts of the problem.

RAG MCP
Retrieves relevant information from a knowledge source and provides it to a model. Standardizes how an AI application connects to external tools, resources and prompts.
Focuses on retrieval, grounding and bringing relevant data into the model’s context. Focuses on interoperability and access to capabilities across systems.

Related blog: Small Language Models + RAG: Building Context-Aware AI Applications looks at how retrieval and smaller models can work together to build context-aware applications.

MCP and Function Calling: When Is MCP Worth It?

For a single application connecting one model to a small number of stable functions, direct function calling or API integration may be simpler. MCP becomes more valuable when multiple AI applications need to use the same capabilities, when integrations span different systems, or when teams want a reusable interface that is not tightly coupled to one model or application.

The decision should be based on integration complexity and reuse. MCP is not automatically the right choice for every project. If a direct API integration already meets the need, adding a protocol layer may introduce unnecessary work.

Related blog: How APIs Power AI Agents, Automation and Intelligent Workflows explains how APIs enable agents to retrieve data, trigger workflows and interact with enterprise systems.

Managing Context Bloat in MCP Integrations

One of the challenges of expanding MCP integrations is context bloat. Large tool catalogs, lengthy descriptions and oversized tool responses consume the model’s available context. They can also make it harder for an agent to identify the right tool for a task.

Consider an agent connected to dozens of servers whose full tool catalog is loaded into every request. Most of those definitions are irrelevant to the task at hand, yet they still take up context and compete for the model’s attention. An agent given only the handful of tools its workflow needs has less to sift through and is more likely to choose correctly.

These practices help keep context manageable, improve tool selection and reduce unnecessary processing. Where tooling supports it, discovering tools on demand and filtering large results before they reach the model extend the same principle. The objective is not to maximize the number of integrations but to give agents access to the information and actions that help them complete a task.

Managing context bloat in MCP integrations.

Fig: Managing context bloat in MCP integrations.

What Should Organizations Consider Before Implementing MCP?

MCP can simplify integration, but it does not remove the need for sound architecture, security and operational controls. The quality of an implementation depends on how servers and their exposed capabilities are selected, governed and maintained.

collatral

Giving AI agents the right context is only the start. See how structured specifications can bring greater control and reliability to AI-assisted software development.

Security, Permissions and Human Oversight

MCP servers can expose sensitive information and actions. A compromised or poorly configured server can therefore create risks beyond an ordinary data integration. Tool descriptions and returned content must be treated as untrusted input. Malicious instructions can appear in tool outputs or be concealed in tool descriptions, a pattern often called tool poisoning.

Prompt injection can also occur when an agent retrieves untrusted content and interprets it as an instruction. Organizations should establish three safeguards:

  • Control access: Use trusted and allowlisted servers, least-privilege permissions and narrowly scoped credentials. For remote HTTP-based servers, implement appropriate OAuth-based authorization and validate tokens and access scopes. Note that the July 2026 specification deprecates OAuth Dynamic Client Registration in favor of Client ID Metadata Documents, so review how your authorization flow registers clients.
  • Validate inputs and outputs: Review tool names, descriptions and schemas; validate arguments and returned data; and treat resource content and tool results as untrusted.
  • Keep people in control: Require human approval for sensitive or irreversible actions, and maintain clear audit trails of tool calls and agent decisions.

Security must be designed into the integration, not added after agents are connected.

Related blog: Agentic AI Governance: Managing Risk When AI Agents Act Without Human Approval discusses why permissions, oversight and governance matter as agents take on more autonomous tasks.

Monitoring, Observability and Scale

Teams need visibility into which tools agents call, how often calls fail, how long they take, and whether returned information helps complete the task. Monitor latency, errors, usage and context consumption together.

As adoption grows, use appropriate server capacity, connection management and caching. Avoid exposing every available tool to every agent. Scale access around actual workflows rather than building one oversized tool catalog.

Organizations should also review server versions, dependencies and permissions regularly. An integration that works in a development environment may need additional controls before it is suitable for production. The 2026-07-28 specification also introduces breaking changes, including the removal of protocol-level sessions, so teams not ready to migrate should pin their current SDK and protocol versions and plan the upgrade deliberately.

Final Thoughts

The success of an MCP implementation depends on how effectively organizations integrate it into their broader AI architecture. Its value comes from making the right capabilities accessible, managing context carefully and ensuring agents operate within defined boundaries. Organizations that approach MCP as part of a broader context-engineering strategy will be better positioned to build agents that are useful, secure and scalable. The goal should not be to connect everything. It should be to connect the right capabilities and make them available at the right time.

Key Takeaways

  • MCP provides a standardized integration layer for AI applications, making tools and resources reusable across systems.
  • Its three core primitives have distinct control models: tools are model-controlled, resources are application-controlled, and prompts are user-controlled.
  • MCP and RAG are complementary. A RAG capability can be exposed through an MCP server.
  • Direct APIs and function calling may be sufficient for simpler integrations. MCP becomes more useful as reuse and integration complexity increase.
  • Context quality matters more than the number of available integrations. Focused tools, on-demand retrieval and filtered responses help manage context bloat.
  • Production-ready MCP implementations require access controls, validation, monitoring and human oversight.

Have an AI agent or MCP initiative in mind? Contact Nitor Infotech to discuss your requirements and explore the right approach for your product and engineering environment.

Frequently Asked Questions

subscribe image

Subscribe to our
fortnightly newsletter!

we'll keep you in the loop with everything that's trending in the tech world.

We use cookies to ensure that we give you the best experience on our website. If you continue to use this site we will assume that you are happy with it.