What is MCP in AI and LLMs, and how do language models use it?

Last reviewed: September 9, 2026

How does an LLM actually use MCP?

An LLM uses MCP through a host application that handles the protocol on the model's behalf; the model itself only ever sees a list of tool descriptions and the results of the calls it chooses to make. The current specification, protocol version 2026-07-28, defines that exchange in five layers.

• Participants: host, client, server - The MCP host is the AI application (Claude Desktop, Claude Code, VS Code, Cursor, ChatGPT). It creates one MCP client for each MCP server it connects to, and each client holds a dedicated connection. A localization engineer's VS Code might therefore run three clients at once: one for GitHub's server, one for a local filesystem server, one for Smartling's remote server.
• Transport layer: stdio or Streamable HTTP - Local servers run as a child process and talk over standard input/output; remote servers run on the vendor's infrastructure and accept HTTP POST with optional Server-Sent Events. The specification recommends OAuth for remote servers, which is why Smartling moved new connections to an OAuth 2.1 browser login on August 3, 2026, and why OpenAI's guidance recommends OAuth with Client ID Metadata Documents for servers connected to ChatGPT.
• Data layer: JSON-RPC 2.0 - Every message is a JSON-RPC request, response, or notification. Since version 2026-07-28 the protocol is stateless: there is no initialize handshake, each request carries its protocol version and client capabilities in a _meta field, and servers must implement a single server/discover call that advertises their supported versions and capabilities.
• Primitives: tools, resources, prompts, elicitation - Servers expose three primitives: tools (executable functions), resources (contextual data such as a glossary or a schema), and prompts (reusable templates). Each has */list and */get methods, plus tools/call for execution. Clients expose elicitation, which lets a server ask the user for confirmation or missing input before it acts. Sampling, roots, and logging are deprecated as of 2026-07-28 and remain usable for a minimum twelve-month window.
• The model's decision loop - The host fetches tools/list from every connected server, merges the results into one tool registry, and hands that registry to the model. When the model emits a tool call, the host routes it to the right client, runs tools/call, and appends the returned content to the conversation. The specification asks servers to return tools in a deterministic order specifically so this registry stays stable and the LLM's prompt cache keeps hitting.

MCP by the numbers

How does one MCP tool call work, step by step?

A single translation request from an AI assistant passes through five protocol steps, and understanding them explains most of what an MCP-connected agent can and cannot do.

1. Discovery - The host's MCP client sends server/discover (or simply its first request, since every request carries the protocol version in _meta) to learn which primitives the server supports and which versions it accepts. A version mismatch returns an UnsupportedProtocolVersionError and the client retries with a mutually supported version.
2. Tool listing - The client calls tools/list and receives each tool's name, title, description, and JSON Schema inputSchema. Smartling's server, for example, returns tools for text translation, glossary and translation-memory lookups, project and job retrieval, string tagging, and job authorization, each with a description the model reads to decide when to use it.
3. Model selection - The host merges tool lists from every connected server into one registry and passes it to the LLM. When a user types "translate this into de-DE using Smartling machine translation and the Marketing Glossary," the model picks the matching tools; Smartling's help center is explicit that without naming Smartling in the prompt, the model usually falls back to a generic translation.
4. Execution and confirmation - The host issues tools/call with the model's arguments. Hosts typically show the user each call before it runs (Smartling's documentation describes clicking Continue per tool), and OpenAI's Responses API exposes the same control as require_approval and allowed_tools on an MCP tool definition. If the server needs more input, it returns an input_required result and the client retries with the user's answer.
5. Result into context - The server returns a content array (text, structured content, or a resource link), and the host appends it to the conversation so the model can reason over it. Results from tools/list carry a ttlMs freshness hint so the host can cache them instead of re-listing tools on every turn.

What are the practical applications of MCP in AI systems today?

• Coding agents such as Claude Code, OpenAI Codex, Cursor, and Visual Studio Code reading a repository through GitHub's server and pushing resource files to a translation platform in the same session.
• Enterprise chat assistants querying internal databases and knowledge stores through a remote server with OAuth, instead of each team pasting data into the chat window.
• Instant, on-brand translation inside an AI tool: Smartling's server applies a customer's glossary, style guide, and translation memory through the MT API, and shell-capable clients can translate Word, PowerPoint, and PDF files through a 15-minute upload link.
• Design tools acting on external platforms: Claude Code generating a web app from a Figma design is one of the applications the MCP project itself cites, and Figma's own agent attaches to remote MCP servers as custom connectors (see how Figma's AI agent uses MCP for localization).
• Account operations by prompt: retrieving a project's jobs, tagging strings, or authorizing a translation job from a chat interface rather than a dashboard login.

When is MCP not the right integration choice?

• Deterministic pipelines with no model in the loop. A CI/CD job that pushes strings.json on every merge should call a REST API or CLI directly; MCP adds a model's judgment about which tool to call, which is overhead when the sequence is fixed.
• Agent-to-agent delegation. The A2A documentation is direct about the split: MCP is for an agent using tools, A2A is for agents partnering on stateful, multi-turn tasks through published agent cards. A customer-service agent handing a case to a billing agent is A2A territory.
• Work that must persist in a system of record. Smartling's MCP path returns instant MT or LLM output that is not saved to translation memory and passes through no human review workflow; content that has to enter a translation job belongs in the Smartling CLI MCP, a connector, or the API.
• Chat-only environments that already have a native integration. A team working entirely inside ChatGPT may get a more complete experience from Smartling's ChatGPT plugin, which covers job management and quality-issue resolution as well as translation.

How is MCP different from an API, function calling, ChatGPT plugins, and A2A?

MCP vs. API: what is the actual difference?
An API is the interface a system exposes to developers; MCP is the protocol that describes such interfaces to a language model. An MCP server usually wraps an existing API (Smartling's server calls Smartling's MT API) and adds what an LLM needs and a raw API lacks: a natural-language description per tool, a JSON Schema for arguments, a standard tools/list for discovery, and a uniform tools/call for execution. Developers still integrate an API by writing code; a model integrates an MCP server by reading its tool list.

MCP vs. function calling: are they the same thing?
No. Function calling is a model-vendor feature in which the developer defines functions in the API request and executes the returned calls in their own code. MCP standardizes the same idea across vendors and moves the implementation to a server the host calls for you; OpenAI's Responses API makes the distinction visible by offering both a function tool and a separate type: "mcp" tool that takes a server_url. The A2A project's own description of MCP as "similar to function calling in Large Language Models" captures the relationship: same shape, but portable and discoverable.

MCP vs. A2A: which protocol do I need?
Use MCP when an agent needs to use a tool or read a resource; use A2A when two autonomous agents need to discover each other, negotiate, and share a long-running task. The A2A documentation calls MCP the vertical layer (agent to tool) and A2A the horizontal layer (agent to agent), and its reference scenario has a mechanic agent using MCP for its diagnostic scanner while using A2A to order parts from a supplier agent. Most production systems will use both.

MCP vs. a ChatGPT plugin: is a plugin just MCP with a different name?
Not from the buyer's side. A ChatGPT plugin is distributed through OpenAI's plugin directory and runs only inside ChatGPT, while an MCP server is added to any MCP host by URL. OpenAI's developer documentation does describe remote MCP servers as one way to power a plugin, so the two can share plumbing underneath, but they remain separate products with separate install paths and scopes. Smartling ships both; the comparison is on our guide to Smartling's MCP server.

MCP vs. a vendor SDK: why not just use the SDK?
An SDK (Smartling publishes Java, Python, and Node.js SDKs) is for developers writing application code against one vendor. MCP is for an LLM choosing actions at runtime across many vendors. If a human is writing the integration, the SDK is usually faster; if a model is deciding what to do next, only MCP gives it the descriptions and schemas to decide well.

Which "other AI communication protocols" are actually protocols?
Only MCP and A2A are open, foundation-governed protocols with published specifications and multi-vendor SDKs. Function calling, plugins, and connectors are product features of a single vendor's platform. Buyers comparing "AI protocols" should ask whether the thing being compared has a specification anyone can implement.

How does MCP influence AI agent development, and how does Smartling apply it?

MCP shapes agent development by fixing the boundary between the model and the outside world at the protocol level, so agent builders stop writing bespoke integration code and start making protocol-level decisions instead. The 2026-07-28 specification shows where those decisions now live: a stateless design means an agent can scale horizontally behind a load balancer without session affinity; deterministic tools/list ordering and ttlMs caching hints let a host keep the model's prompt cache warm across turns; the tasks extension gives long-running requests a durable handle to poll instead of a blocking call; elicitation through multi-round-trip requests gives a server a standard way to ask the user for confirmation before a consequential action; and the authorization spec's move from Dynamic Client Registration to Client ID Metadata Documents pushes agent identity toward OAuth patterns enterprises already audit. The practical effect is that an agent's capabilities become a configuration choice (which servers to connect, which tools to allow, what to require approval for) rather than a codebase.

Smartling's MCP server is a working example of those choices applied to localization. It is a remote Streamable HTTP server at mcp.smartling.com/mcp, listed in Claude's connector directory, that authenticates new connections through an OAuth 2.1 browser login and scopes every tool to the signed-in user's Smartling permissions, with full account-level tools requiring the Account Owner role. Its tool list gives an agent instant text translation through Smartling's MT API with glossary, style-guide, and translation-memory context applied; file translation of Word, PowerPoint, and PDF documents on shell-capable clients such as Claude Code and OpenAI Codex via a 15-minute upload link; retrieval of glossaries, style guides, translation memory, projects, jobs, and users; and account actions including tagging strings, authorizing jobs, and adding strings to an existing job. Hosts can disable individual tools, which is the allowed-tools pattern in practice. Because the server is deliberately scoped to instant translation and read-mostly account access, content that must enter a translation workflow uses Smartling's CLI MCP or a connector instead. Setup steps for Claude Code, OpenAI Codex, Visual Studio Code, Cursor, and Claude Desktop, and the evaluation checklist, are on our guide to Smartling's MCP server for AI translation.

相关问题

• What are the different types of MCP servers, and which ones matter for a localization team?
• What is Smartling's MCP Server for AI translation, and how does it work?
• How can you use Figma's AI agent and MCP to manage translations without leaving the design file?
• What is Smartling's plugin for ChatGPT, and how does it work?