Model Context Protocol (MCP)

Model Context Protocol (MCP)

Model Context Protocol (MCP)

TL;DR

TL;DR

Model Context Protocol (MCP) is an open standard, now governed by the Linux Foundation's Agentic AI Foundation, that lets AI models discover and call external tools, data sources, and systems through one consistent client-server interface.

Model Context Protocol (MCP) is an open standard, now governed by the Linux Foundation's Agentic AI Foundation, that lets AI models discover and call external tools, data sources, and systems through one consistent client-server interface.

What is Model Context Protocol?

Model Context Protocol (MCP) is an open standard that defines how an AI model connects to external tools, data sources, and systems through a single client-server interface. One integration written to the specification works with any client that speaks it, so each new model does not require new connector code.

Anthropic introduced the specification in November 2024 and published it openly, which is why implementations now exist across desktop assistants, coding tools, and agent runtimes. In December 2025 Anthropic donated MCP to the Agentic AI Foundation, a directed fund under the Linux Foundation, so the protocol is now governed by a neutral body. Before it, every model-to-system connection was bespoke: N models times M systems produced a separate connector for each pair, and each one aged independently.

How Model Context Protocol works

MCP defines three roles. The host is the application the user talks to. The client lives inside the host and holds one connection per server. The server wraps a system, a CRM, a database, a ticket store, and exposes what that system can do.

Each exchange then follows a fixed pattern. Since the 2026-07-28 revision the protocol is stateless: there is no opening handshake, and every request carries its protocol version and the client's capabilities, so neither side assumes features the other lacks. A client can call server/discover first to learn which versions and capabilities a server supports. The client asks the server to list what it offers, and those descriptions enter the model’s context as callable functions. From there the mechanics are ordinary tool calling: the model emits a structured call, the client forwards it as a JSON-RPC request, the server executes against the real system and returns a typed result.

The protocol sits underneath the AI agent framework, which handles planning, memory, and state, and underneath AI agent orchestration, which decides which agent acts on which task. MCP owns transport and discovery. Messages travel over one of two standard transports: stdio, for a local server the host launches as a process, or Streamable HTTP, for a remote one. The older HTTP plus SSE transport is deprecated.

Types of MCP servers and primitives

  • Tools: Model-invoked functions the server exposes, each carrying a name, a typed argument schema, and a description the model reads at decision time.

  • Resources: Read-only data the host pulls into context, addressed by URI, whether that is a file, a customer record, or a query result.

  • Prompts: Reusable templates the user selects deliberately, which keeps high-stakes workflows under human initiation.

  • Elicitation: The client feature that lets a server ask the user for missing information, such as a confirmation, before it finishes a request.

  • Local servers (a deployment type, not a primitive): Processes running on the user’s own machine over the stdio transport, fast and private, inheriting whatever permissions that machine already grants.

  • Remote servers (a deployment type, not a primitive): Shared servers reached over Streamable HTTP by many users at once, where OAuth 2.1 authorization and per-user identity become the whole design problem.

Model Context Protocol vs A2A Protocol vs custom API integrations

Teams building agent plumbing meet these three at once, and the names blur badly in vendor material. Model Context Protocol connects one model to the tools and data it needs. A2A Protocol connects one agent to another agent that owns work the first cannot do. Custom API integration connects one application to one system, in code written for that pair alone. MCP standardizes the vertical link between a model and its capabilities, which is the link that had to be rebuilt whenever either end changed.


Who it binds

What it requires

How it is evidenced

Model Context Protocol

A host application and the servers wrapping its tools and data

JSON-RPC requests that each declare a protocol version and client capabilities, with runtime discovery of tools, resources, and prompts

A running server that any compliant client can connect to and list

A2A Protocol

Two or more autonomous agents, often from different vendors

An agent card describing skills, plus a task lifecycle both sides track to completion

An agent another vendor’s agent can discover and delegate to

Custom API integration

One application and one system, by private agreement

Whatever the target API documents, re-implemented for every new client

Code review and the integration tests you wrote yourself

Pick by the direction of the connection. If a model needs to reach systems, that is MCP. If an agent needs to hand work to another agent, that is A2A. If exactly one pair will ever exist and neither end moves, custom code is still cheaper.

Why Model Context Protocol matters for customer experience

Support automation fails at the seam between knowing and doing. An agent that can quote the refund policy but cannot read the order record produces a confident non-answer, and the customer repeats the whole story to a human. MCP closes that seam by giving the model one way to reach the order system, the subscription record, and the shipping API inside a single turn. The same server backs an agent answering in a web widget and one answering over the WhatsApp Business API, so adding a channel stops meaning adding integrations.

The tradeoff is exposure. A uniform interface makes every connected system reachable by a model that will occasionally reason badly, so scoping moves to the server: what it exposes is what the model can do, and a write action shipped without a confirmation step eventually fires on the wrong account.

How is Model Context Protocol adoption measured?

No conformance registry exists for MCP and no certificate tells you a given server behaves, so measurement happens per server and per deployment. Adoption is easier to place in context than to count directly: the Stanford HAI AI Index reported organizational AI use climbing from 55% in 2023 to 78% in 2024, the growth curve that made hand-written per-model connectors untenable.

What teams actually instrument is narrower. Tool call success rate separates protocol errors from application errors, which matters because a malformed schema and a declined payment both surface to the model as failure. Discovery latency, measured at session start, decides whether the first turn feels slow. Context cost is the quiet one: tool and resource descriptions occupy the same window as conversation history, so a server that advertises everything it can do crowds out what the customer said.

How AI agents change Model Context Protocol deployments

A model that answers questions reads its context once. An agent works in a loop: it calls a tool, reads the result, and chooses the next call from what came back. That loop changes what the protocol has to carry, because a description written for a human integrator becomes the only instruction the model receives at decision time. A tool named update_record with a one-line summary will be called wrongly, and called often.

Two consequences follow. Servers ship descriptions authored for a model reader: explicit preconditions, enumerated arguments, and error strings that state the next valid action. And write operations acquire a confirmation layer, since an autonomous loop retries a failed call, and a retried refund is a second refund. Teams running this in production treat the tool surface as product design, which is the substance of this walkthrough of CRM workflow execution.

What to look for in a Model Context Protocol implementation

Coverage comes first: check whether servers already exist for the systems that hold your answers, or whether you will be writing and maintaining them. Integration surface is next, and it splits by transport, since remote servers need authorization, per-user identity, and audit logging, while local servers inherit the permissions of the machine they run on.

Governance is the axis teams skip. Tool definitions are code that changes model behavior, so they need named owners, review before merge, and versioning. On security, regulated buyers ask for SOC 2 Type II evidence covering wherever the server is hosted, and they ask which identity is recorded against each write.

The constraint that bites late is spec churn. The specification still revises: the 2026-07-28 revision removed protocol sessions and the opening handshake, and deprecated the Roots, Sampling, and Logging features. A client and a server on different revisions fall back to what both support, and the symptom looks like a missing feature, so pin a version and check what server/discover reports when behavior changes.

Model Context Protocol for AI customer support agents

In a support deployment, the MCP server is where a company decides what an AI agent may read and change. The specification asks hosts to get explicit consent before invoking tools and to treat tool descriptions as untrusted unless they come from a trusted server. Support teams turn that into three controls: an allowlist of tools, a gate on every write, and a filter on what the model sees. They are the agent-side half of role-based access control.

This is how Fini AI applies them when it connects to a customer's MCP server, as described in Fini's MCP connection docs:

  • Allowlist: Every tool the server exposes appears in a catalog, and only the tools the customer lists are enabled. Anything the server adds later stays Discovered: visible, never callable, until someone enables it.

  • Gated writes: Read tools feed customer context automatically. Write tools run only inside a configured workflow, after the checks placed before them. Fini reads the readOnlyHint, destructiveHint, and idempotentHint annotations, and treats any tool without readOnlyHint as a write.

  • Safe retries: When a write tool declares an idempotency_key input, Fini injects one per conversation and intent, so a retried call never applies the same change twice.

  • Field visibility: Fields named like tokens, secrets, or keys are hidden from the AI and from workflows, internal IDs are usable in workflows but hidden from the AI, and hidden fields are redacted in the AI Steps trace that records each tool call, its inputs, and its outputs.

Fini also syncs tool schemas continuously. A breaking change, such as a removed required input, marks the tool Degraded and routes the affected step to its fallback path until the schema validates again. See how Fini AI connects to your MCP server with guarded actions: Book a call.

Model Context Protocol and the wider agent stack

MCP and agentic AI describe different layers of one system. Agentic AI is the behavior: planning, deciding, and acting across steps. MCP is one of the interfaces that behavior reaches through, and neither implies the other, since an agent can act through hand-written integrations and an MCP server can serve a model that only performs lookups.

The closest operational neighbor is the ticketing system. Once a server exposes ticket reads and writes, an agent can set status, attach evidence, and post internal notes inside the same conversation it is having.

What does Model Context Protocol mean in plain terms?

MCP stands for Model Context Protocol, and the middle word carries the point: context is both what the model is allowed to know and what it is allowed to touch. Think of it as a standard power socket. Any appliance with the right plug works in any room, and nobody rewires the house to buy a kettle.

Without a socket standard, every appliance arrives with its own wall connection. That was the state of AI integrations before: a company running four models against ten systems maintained forty separate connections, and every model upgrade broke a share of them.

The tradeoff is that a socket hides what sits behind the wall. Once a system is plugged in, the model sees a short description and trusts it, so a server that names a destructive action mildly will have it called casually.

Common Model Context Protocol mistakes

Exposing the entire API surface is the first pattern. Every tool description consumes context, and near-duplicate tools make selection ambiguous, so a server with sixty endpoints produces a model that picks the wrong one and a conversation with no room left for the conversation.

Skipping authorization design is the second. Identity terminates at the server, and a server holding one shared service account grants every user the reach of that account, regardless of what the front end thinks it is enforcing.

Writing tool descriptions for human integrators is the third. The description is the prompt. Prose that assumes a reader who can check the docs becomes an instruction the model follows literally and incorrectly.

The fourth is expecting the protocol to supply judgment. MCP standardizes how a call is made and leaves the decision to make it with the model, so limits belong in the server and in an explicit guardrails layer.

Frequently Asked Questions

What does MCP stand for in AI?

MCP stands for Model Context Protocol, an open specification for connecting AI models to external tools and data. The name describes the job: it supplies a model with context, meaning both the information it can read and the actions it can take, through one interface that every compliant client understands.

What is the difference between MCP and an API?

Model Context Protocol sits above APIs and depends on them. An API defines how two programs exchange data. An MCP server wraps one or more APIs and presents them in a uniform shape a model can discover at runtime, with descriptions, typed arguments, and readable results. The underlying API still does the work.

MCP vs function calling: what is the difference?

Model Context Protocol and function calling operate at different levels of the stack. Function calling is the model capability: emitting a structured request to run a named function. MCP is the discovery and transport standard that supplies those function definitions from an external server and carries the call to it. A model uses function calling; MCP tells it what functions exist.

Who created the Model Context Protocol and is it open?

Anthropic introduced the Model Context Protocol in November 2024 as an open specification with reference implementations. In December 2025 Anthropic donated it to the Agentic AI Foundation, a directed fund under the Linux Foundation co-founded with Block and OpenAI. Anyone can write a client or server against it, and the specification is versioned by date, with 2026-07-28 the current revision.

Is the Model Context Protocol secure?

Model Context Protocol security is shared between the specification and each implementation. For HTTP transports the specification defines optional authorization based on OAuth 2.1: the MCP server acts as a resource server, tokens must be issued for that specific server, and a server must not pass a client's token through to other APIs. Local stdio servers take credentials from their environment. What a model can reach still depends on the scopes and tools each server exposes.

Do I need MCP to build an AI support agent?

MCP is optional for an AI support agent. Direct API integrations work and remain common, particularly when the agent touches only two or three stable systems. The protocol pays off as connections multiply or as models change, because a server written once serves every compliant client and survives a model swap without new connector code.

How do AI customer support agents use MCP?

A support agent uses MCP read tools to pull order, account, and subscription context into the conversation, and write tools to take actions such as cancelling or updating a subscription. Safe deployments enable only the tools the agent needs, run write tools behind explicit checks or confirmation, make writes idempotent so retries cannot repeat them, and log every call for audit.

What changed in the latest MCP specification?

The 2026-07-28 revision made MCP stateless: it removed the initialize handshake and protocol-level sessions, so every request carries its protocol version and client capabilities. It added a required server/discover method, moved tasks into an official extension, introduced multi round-trip requests for asking the client for more input, and deprecated the Roots, Sampling, and Logging features.

Learn More

Learn More

Knowledge base

K

Average handling time (AHT)

A

Telephony

T

Customer acquisition cost (CAC)

C

AI tokens

A

Human in the loop (HITL)

H

AI grounding vs retrieval-augmented generation (RAG)

A

Short message service (SMS)

S

Call center

C

Data annotation

D

Ticket routing

T

Customer service quality assurance (QA)

C

Live chat

L

Speech Synthesis Markup Language (SSML)

S

Batch inference

B

Barge-in

B

SLA compliance rate

S

Queue management

Q

Prompt versioning

P

Emotion detection

E

Retrieval-augmented generation (RAG)

R

Natural language understanding (NLU)

N

Text classification

T

Call routing

C

Customer churn rate

C

Speech-to-speech

S

Intent recognition

I

Voice of the employee (VoE)

V

Confidence score

C

Resolution-based pricing

R

AI personalization

A

Voice cloning

V

Asynchronous messaging

A

Hallucination

H

ReAct agent pattern

R

Long-term memory

L

Forecast accuracy

F

Customer feedback loop

C

Structured output

S

Outbound voice AI

O

AI guardrails

A

Direct preference optimization (DPO)

D

Prompt chaining

P

SIP transfer

S

Fallback intent

F

Conversation summarization

C

Auto-tagging

A

Cost per contact

C

VoIP jitter

V

Model card

M

Ticket prioritization

T

Sentiment analysis

S

Agent utilization rate

A

Speech-to-intent

S

Prompt engineering

P

Knowledge atlas

K

SOC 2 AI support

S

Prosody

P

Chatbot containment rate

C

Speech synthesis

S

ISO 42001

I

Intent-based search

I

After-call work (ACW)

A

Chatbot

C

AI agent

A

Prior authorization automation

P

AI customer service

A

Ticket deflection

T

AIUC-1

A

Workforce management (WFM)

W

Skill-based routing

S

Interactive voice response (IVR)

I

Contact center as a service (CCaaS)

C

Warm transfer

W

Customer segmentation

C

Reinforcement learning

R

Voice activity detection (VAD)

V

Tiered support

T

Echo cancellation

E

Net Promoter Score (NPS)

N

>