What Is the Model Context Protocol (MCP)?
A standard protocol for connecting AI models to tools, data, and external systems
ZUSAMMENFASSUNG
The Model Context Protocol (MCP) is an open standard that defines how AI models connect to external tools, data sources, and services. It gives AI agents a consistent, governed interface to discover and invoke capabilities at runtime, without requiring hardcoded integrations for every tool the agent needs to use. Developed by Anthropic and adopted broadly across the AI tooling ecosystem, MCP is becoming the standard infrastructure layer for connecting AI models to the real world.
What is the Model Context Protocol (MCP)?
The Model Context Protocol is an open protocol that standardizes how AI models communicate with external tools, data sources, and services. Before MCP, connecting an AI agent to an external system required a custom integration for every model and every tool. Each combination used different APIs, authentication schemes, data formats, and error handling. MCP replaces that fragmented approach with a single consistent protocol that any compliant model can use to discover and invoke any compliant tool.
The protocol defines three core participants. MCP servers expose tools and data. The MCP host is the AI application, such as a chat client, an IDE, or an agent framework. The host creates one MCP client for each server it connects to, and that client maintains the connection. The request-response cycle governs how a client discovers what a server offers, invokes a capability, and receives a result. Any model that speaks MCP can use any MCP server, and any MCP server can be used by any compliant model, regardless of which company built either one.
Anthropic introduced MCP in November 2024, and a wide range of AI tools, agent frameworks, and enterprise platforms have since adopted it. In December 2025, Anthropic donated the protocol to the Agentic AI Foundation (AAIF), a directed fund under the Linux Foundation co-founded with Block and OpenAI, so MCP is now stewarded as a vendor-neutral standard rather than one company’s project. It is open source and model-agnostic. The specification defines an optional OAuth 2.1 authorization framework for servers exposed over HTTP, and leaves auditability and data handling to the server implementation.
The content below covers how MCP works architecturally, what MCP servers and clients are, how MCP differs from APIs and function calling, why governance matters for enterprise MCP deployments, and how Couchbase implements MCP as part of its AI Data Plane.
How MCP works
MCP servers and MCP clients
MCP vs. APIs and function calling
Enterprise governance and MCP
How Couchbase implements MCP
Die wichtigsten Erkenntnisse und zugehörige Ressourcen
FAQs
How MCP works
MCP follows a client-server architecture. An MCP server can run as a local subprocess on the same machine as the AI application or as a remote service, and the protocol works the same either way. An MCP server exposes a set of capabilities (tools, resources, and prompts) to any client that connects to it. The AI application acting as host connects to one or more MCP servers, one client per server, discovers what they offer, and invokes capabilities as needed to complete a task.
MCP messages are JSON-RPC 2.0. The request-response cycle works as follows:
- Discovery – The MCP client connects to an MCP server and requests a list of available tools, resources, and prompts. The server responds with structured descriptions of each capability, including what it does, what inputs it expects, and what it returns. The model reads these descriptions and uses them to decide which tool to call for a given task.
- Invocation – When the model determines it needs a tool, it sends a structured invocation request to the MCP server specifying the tool name and required input parameters.
- Execution – The MCP server executes the requested operation, which can be a database query, an API call, a file read, or any other action the server is configured to perform.
- Response – The server returns the result to the client in a structured format the model can reason over and incorporate into its response.
This cycle repeats as many times as the agent needs to finish the task, with each tool result feeding the next model turn. A single user request might trigger five or 10 MCP tool calls as the agent gathers context, queries data, and takes actions before generating a final response.
The key architectural insight is that the model doesn’t need to know how a tool works internally. It only needs the tool’s description, its input schema, and its output format. The MCP server handles everything else. This separation of concerns is what makes MCP composable. You can add a new MCP server to an agent’s environment without changing the model or the agent framework.
MCP servers and MCP clients
What is an MCP server?
An MCP server is a service that exposes tools, resources, and prompts to AI models through the Model Context Protocol. It acts as a governed interface between the AI model and whatever the server is connected to, whether that’s a database, an API, a file system, a SaaS platform, or another external system.
An MCP server exposes three types of capabilities:
- Tools are executable functions the model can invoke. Examples of MCP tools include a database query tool, a web search tool, a calendar event creation tool, and a code execution tool. Tools are the primary action mechanism in MCP.
- Ressourcen are data objects the model can read. A file, a database record, a document, or a data stream can all be exposed as MCP resources. Resources provide context without requiring the model to invoke a function.
- Prompts are reusable prompt templates the server exposes for common tasks. By standardizing the instructions given to a model for specific operations, these prompts improve consistency and make agent behavior easier to govern.
An MCP server can expose any combination of tools, resources, and prompts. For example, a database MCP server might expose query and write tools, the schema as a resource, and standard query prompt templates. A well-governed enterprise MCP server also enforces access controls, logs all invocations, and filters sensitive data before returning results to the model.
What is an MCP client?
An MCP client maintains a connection to a single MCP server. The spec calls the surrounding AI application the host, and the host creates one client per server it connects to. Claude, Cursor, Windsurf, and custom agent frameworks built on LangChain, LlamaIndex, or similar libraries all act as hosts. The model doesn’t need to know which specific MCP server it is talking to before the session starts. It discovers available tools at runtime by querying whatever servers are connected to its environment.
MCP clients and servers communicate over a transport layer. The specification defines two: stdio, used when the server runs as a local subprocess, and streamable HTTP, used for remote servers. Streamable HTTP can use Server-Sent Events (SSE) to stream messages back to the client, but the standalone HTTP+SSE transport from the original 2024-11-05 specification is deprecated and has been replaced. Enterprise deployments typically use streamable HTTP with authentication and TLS.
MCP vs. APIs and function calling
MCP vs. a traditional API
A traditional REST API is a static contract. The API’s endpoints, input schemas, and output formats are defined at build time. An AI model calling a REST API directly needs to have that API’s interface hardcoded into its integration layer, whether that’s in a system prompt, a function definition, or application code. Adding a new API requires a new integration. Changing an API requires updating the integration.
MCP is a dynamic discovery protocol. An MCP client asks the server what it can do at runtime, and the server responds with structured descriptions. The model reads those descriptions and decides how to use them without any prior hardcoded knowledge of the server’s capabilities. Adding a new MCP server to an agent’s environment does not require changing the agent. The agent discovers and uses the new server’s tools automatically.
The practical difference: a REST API integration is a point-to-point connection built at development time. An MCP integration is a runtime relationship the agent establishes dynamically.
MCP vs. function calling
Function calling, as implemented by OpenAI, Anthropic, and other model providers, allows a model to invoke predefined functions during inference. The functions are defined in the prompt or the API call, and the model outputs a structured invocation that the application layer executes. Function calling is powerful but application-scoped. The application developer defines the functions available to the model for that specific application.
MCP extends the function calling concept to a standardized, cross-application protocol. While function calling requires the application to define and manage every function the model can use, MCP lets the model discover and use tools from any connected MCP server across applications and organizations. The application developer doesn’t need to define each tool individually.
In practical terms, function calling is the mechanism, whereas MCP is the ecosystem. An MCP server typically exposes its capabilities as tools that the model invokes using its native function calling mechanism. MCP and function calling work together rather than competing.
Enterprise governance and MCP
Adopting MCP in enterprise environments introduces governance requirements beyond what the core protocol specifies. A model that can invoke any tool connected to its environment is powerful and potentially risky. Governance defines what the model can do, records what it did, and ensures it handles sensitive data appropriately throughout.
Enterprise MCP governance has four requirements:
Access control at the tool level – Not every model or agent should be able to invoke every tool on every MCP server. Role-based access control, applied at the MCP server layer, restricts which tools a given agent or user session can invoke. For instance, an agent handling customer-facing queries shouldn’t be able to invoke administrative write tools. Access control enforced at the MCP server is more reliable than access control enforced in application code because it applies consistently no matter which application or agent makes the request, and a bug in that application’s logic cannot undo it. It does not make an agent immune to prompt injection. What it does is bound the damage, because an injected instruction still cannot reach a tool the session was never authorized to call.
Audit logging of all invocations – Enterprise compliance requirements typically mandate a record of what actions were taken, when, by whom, and with what data. An MCP server that logs every tool invocation, with enough detail about inputs and results to reconstruct what happened without writing sensitive values into the log, produces the audit trail compliance teams need without requiring the application developer to implement logging separately for every tool.
Data filtering and redaction – MCP servers that connect to databases or document stores may have access to sensitive information that should not be passed directly to an LLM. A governed MCP server filters or redacts sensitive fields before returning data to the model. This ensures that personal information, financial records, and other regulated data are handled according to policy rather than passed wholesale to the inference layer.
Observability and tracing – In a multi-agent system where multiple agents invoke multiple MCP servers across a single user request, understanding what happened requires end-to-end tracing across the full invocation chain. A governed MCP server contributes structured trace data to the observability layer, making it possible to reconstruct the full sequence of tool calls for debugging, auditing, and performance analysis.
These requirements apply regardless of which MCP server implementation is used. The purpose is to enable organizations to see, control, and audit what the server does.
How Couchbase implements MCP
The Couchbase MCP Server is an enterprise-supported MCP server implementation that lets AI agents connect to and interact with data in Couchbase clusters, on Couchbase Capella or self-managed. It’s part of the Couchbase AI Data Plane™ and is published under the Apache 2.0 license as an open-source implementation on GitHub.
The Couchbase MCP Server exposes tools that let AI agents query Couchbase collections using SQL++, retrieve and write documents by key, inspect schemas and indexes, analyze query performance, and interact with the database without requiring the model to know the schema or query language in advance. The agent discovers these capabilities at runtime through MCP’s standard tool discovery mechanism.
From a governance perspective, the Couchbase MCP Server connects to the cluster as a Couchbase database user, so what any connected agent can reach is bounded by Couchbase’s existing role-based access control system down to individual buckets, scopes, and collections. The server runs in read-only mode by default: write tools are not loaded, and data-modifying SQL++ queries are blocked until an operator turns them on. Individual tools can be disabled to narrow what a deployment exposes, and a server published over HTTP acts as an OAuth 2.1 resource server with separate read and write scopes.
The Couchbase Agentenkatalog complements the MCP Server by providing a centralized, versioned registry of tools, prompts, and agent functions. Where the MCP Server handles the runtime protocol, the Agent Catalog handles governance and lifecycle management for the tools and prompts agents use, and records end-to-end traces of tool calls, tool results, agent handoffs, and LLM generations that teams can query with SQL++. Together they form the governed tool layer of the Couchbase AI Data Plane.
| Capability | What it does |
|---|---|
| SQL++ query tool | Query any Couchbase collection using SQL++. |
| Zugriff auf Schlüssel- und Werte | Retrieve documents by key; write tools load only when read-only mode is turned off. |
| Schema and index tools | Inspect buckets, scopes, collections, and indexes, and return index advisor recommendations. |
| Access control | Couchbase database role-based access control, enforced by the cluster on the user the server connects as, scoped to buckets, scopes, and collections. |
| Read-only mode | On by default: write tools are not loaded and data-modifying SQL++ is blocked until an operator opts in. |
| Agentenkatalog | Related AI Data Plane component that versions tools and prompts and records agent traces, queryable with SQL++. |
Die wichtigsten Erkenntnisse und zugehörige Ressourcen
The Model Context Protocol is the emerging standard for how AI agents connect to the external world. As enterprises move from AI pilots to production systems, MCP provides the consistent, governed interface that makes agentic AI scalable across tools, teams, and organizations.
Key takeaways:
- The Model Context Protocol is an open standard that defines how AI models connect to external tools, data sources, and services through a consistent, governed interface.
- MCP follows a client-server architecture. MCP servers expose tools, resources, and prompts. An AI application acting as a host connects through one client per server to discover and invoke those capabilities at runtime.
- MCP enables dynamic tool discovery. The model discovers what a server can do at runtime rather than requiring hardcoded integrations built at development time.
- MCP differs from traditional APIs in that it is a discovery protocol, not a static contract. It differs from function calling in that it is a cross-application ecosystem standard, not an application-scoped mechanism.
- Enterprise MCP deployments require governance. They provide access control at the tool level, audit logging of all invocations, data filtering before results reach the model, and end-to-end observability across multi-agent systems.
- The Couchbase MCP Server exposes Couchbase database capabilities (SQL++ queries, key-value access, schema and index inspection, query performance analysis) to any compliant MCP client. It runs read-only by default, and Couchbase’s database role-based access control is the authoritative boundary on what an agent can reach.
- The Couchbase Agent Catalog complements the MCP Server by providing centralized versioning for the tools and prompts agents use, plus end-to-end traces of agent activity that teams can query with SQL++.
Related resources:
- Introducing Model Context Protocol (MCP) Server for Couchbase – Blog
- What Is an MCP Server? – Concepts
- What Is an Agent Database? – Concepts
- What Is an Agentic AI Data Foundation? – Concepts
FAQs
What is the Model Context Protocol? The Model Context Protocol is an open standard that defines how AI models connect to external tools, data sources, and services. It gives AI agents a consistent interface for discovering and invoking capabilities at runtime without requiring a custom integration for every model-tool combination. Anthropic introduced MCP in November 2024, and it has been adopted broadly across AI tools, agent frameworks, and enterprise platforms.
What is an MCP server? An MCP server is a service that exposes tools, resources, and prompts to AI models through the Model Context Protocol. It acts as a governed interface between the AI model and an external system, such as a database, an API, or a file system. The model discovers what the server offers at runtime and invokes the capabilities it needs to complete a task, without any prior hardcoded knowledge of the server’s interface.
What is an MCP client? An MCP client is the component inside an AI application that maintains a connection to one MCP server. The spec calls the application itself the host, and the host creates one client for each server it connects to. Claude, Cursor, Windsurf, and custom agent frameworks built on LangChain, LlamaIndex, or similar libraries can all act as hosts. The client discovers available tools at runtime by querying connected MCP servers rather than relying on tools defined at development time.
How is MCP different from a traditional API? A traditional API is a static contract defined at build time. Endpoints, inputs, and outputs are fixed, and integrating a new API requires building a new integration. MCP is a dynamic discovery protocol. At runtime, the model asks the server what it can do, and the server responds with structured descriptions of its capabilities. Adding a new MCP server to an agent’s environment does not require changing the agent or its application code.
How is MCP different from function calling? Function calling lets a model invoke predefined functions during inference, and the application developer defines those functions for a specific application. MCP extends this capability to a standardized cross-application protocol, enabling the model to discover and use tools from any connected MCP server. It works across applications and organizations without the developer needing to define each tool individually. MCP and function calling work together. An MCP server typically exposes its capabilities as tools that the model invokes using its native function calling mechanism.
Why does MCP matter for enterprise AI? Before MCP, connecting an AI agent to multiple external systems required a custom integration for every model-tool combination. This customization created fragmented, hard-to-govern architectures. MCP standardizes those connections so that any compliant model can use any compliant tool through a single protocol. For enterprises, this means faster agent development, consistent governance across all tool integrations, and an auditable record of every action an agent takes through a governed MCP server.
What is the Couchbase MCP Server? The Couchbase MCP Server is an enterprise-supported MCP server that lets AI agents connect to and interact with data in Couchbase clusters, on Capella or self-managed Couchbase Server deployments. It allows AI agents to query Couchbase collections using SQL++, retrieve and write documents by key, inspect schemas and indexes, and analyze query performance, all without prior knowledge of the schema. The server runs in read-only mode by default, and Couchbase’s database role-based access control is the authoritative control on what data an agent can reach.