What Is an MCP Server?
MCP servers expose tools, data, and prompts to AI agents and models
SUMMARY
An MCP server is a service that exposes tools, data, and prompt templates to AI models through the Model Context Protocol. It acts as a governed interface between an AI agent and the external systems it needs to interact with, whether that’s a database, an API, a file system, or a SaaS platform. The model discovers what the server offers at runtime and invokes capabilities as needed without any prior hardcoded knowledge of the server’s interface.
What is an MCP server?
An MCP server is a service that implements the Model Context Protocol on the provider side and exposes a set of capabilities to any compliant AI model or agent framework that connects to it. Sitting between the AI model and the external system it needs to access, the server translates model requests into actions and returns structured results the model can reason over.
The term “server” in MCP follows the standard client-server computing model. The MCP server provides capabilities. The MCP client is the consumer, the AI application is the host, and the host creates one client for each server it connects to. A single AI agent can connect to multiple MCP servers simultaneously, combining capabilities from a database server, a calendar server, and a web search server in a single inference session without any of those servers needing to know about each other.
Before MCP, connecting an AI model to an external system required a custom integration for every model-tool combination. Each pair would have different APIs, schemas, error handling, and authentication. An MCP server standardizes the interface so any model that speaks MCP can use any MCP server, and any MCP server can serve any compliant model.
The content below covers what an MCP server exposes, how it works at the protocol level, what makes an enterprise MCP server well-governed, how MCP servers differ from traditional APIs, and how Couchbase implements its MCP Server as part of the AI Data Plane.
What an MCP server exposes: Tools, resources, and prompts
What makes an enterprise MCP server well governed
MCP server vs. traditional API
How Couchbase implements an MCP server
Key takeaways and related resources
What an MCP server exposes: Tools, resources, and prompts
An MCP server exposes three types of capabilities to connected AI models. Each type serves a different purpose in the agent’s workflow.
Tools
Tools are executable functions the model can invoke to take action or retrieve information. Examples of MCP tools include database query tools, web search tools, file write tools, and calendar event creation tools. When a model determines it needs a tool to complete a task, it sends a structured invocation request to the MCP server specifying the tool name and required input parameters. The server executes the operation and returns the result.
Tools are the primary action mechanism in MCP. They’re what give AI agents the ability to do things beyond simply generating text.
Resources
Resources are data objects the model can read to gather context. For example, files, database records, documents, webpages, and structured data streams can all be exposed as MCP resources. Tools require the model to invoke a function, while resources provide context the model can read passively. A resource might be the current contents of a database table, a configuration file, or a reference document the model needs to produce an accurate response.
The distinction between tools and resources is important for governance. Tools can take action, such as writing a record, sending a message, or triggering a workflow. Resources are read-only and simply return information without changing anything. A well-governed MCP server can apply different access controls to each, with tighter restrictions on tools that can modify data or take action.
Prompts
Prompts are reusable prompt templates the server exposes for common tasks. An organization can define a standard prompt for tasks such as summarizing a database record, generating a SQL++ query from a natural language description, or formatting a support response according to company guidelines. When a model invokes a prompt, the server returns the template populated with the relevant data, and the model uses it as the basis for its response.
Prompts are the governance mechanism for standardizing model behavior across an organization. Rather than letting each application or agent define its own instructions for a given task, the MCP server provides a vetted, versioned template that produces consistent, compliant output.
How an MCP server works
An MCP server operates in four steps for each client session. Messages travel over JSON-RPC 2.0, carried either by stdio when the server runs locally or by streamable HTTP when it runs remotely.
Connection and capability advertisement
When an MCP client connects to a server, the server advertises its capabilities, including the list of tools it exposes (tools/list), the resources it makes available (resources/list), and any prompt templates it provides (prompts/list). Each capability includes a name, a plain-language description the model uses to decide whether to invoke it, and a schema defining the inputs it accepts and the outputs it returns.
This advertisement step is what makes MCP dynamic. The model doesn’t need prior knowledge of the server’s capabilities before connecting. It reads the descriptions at runtime and decides how to use them based on the task at hand.
Invocation
When the model determines that a tool or resource is relevant to the current task, it sends a structured invocation request to the MCP server. The request includes the capability name and the input parameters formatted according to the schema the server advertised. The server then validates the request against its access control policies before executing anything.
Execution
The MCP server executes the requested operation against the underlying system it’s connected to. It can run a database query, call an API, read a file, or perform any other action the server is configured to do. The server handles authentication with the underlying system, manages errors, and transforms data as needed so the model can use the result.
Response
The server returns a structured result to the client using the schema defined for that capability. This gives the model the context it needs to interpret the result without additional configuration. The model can then use the information to complete the task or call another tool if needed.
What makes an enterprise MCP server well governed
MCP defines an optional authorization framework based on OAuth 2.1 for servers exposed over HTTP, but it does not determine how a server handles access control, logging, or compliance. Those capabilities depend on how the MCP server is designed and deployed. An MCP server that exposes sensitive tools or data without appropriate access controls, auditing, or other safeguards can create security and compliance risks. In an enterprise environment, a well-governed MCP server typically meets four key requirements that help organizations control access, protect data, and monitor server use.
Access control at the tool level
Role-based access control enforced 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. Server-level access control is more reliable than application-level access control because the server enforces it consistently, regardless of which application or agent makes the request.
Audit logging of all invocations
The MCP server should log every tool invocation, resource read, and prompt request with the capability name, timestamp, and identity of the requesting agent or session, plus enough detail about inputs and results to reconstruct what happened without writing sensitive values into the log. This log is the record compliance teams need to verify that agents are operating within their authorized scope. An MCP server that doesn’t log invocations makes it impossible to audit agent behavior after the fact.
Data filtering and redaction before results reach the model
An MCP server connected to a database or document store may have access to sensitive information that shouldn’t be passed directly to an LLM. A governed MCP server filters or redacts sensitive fields before returning data to the model, ensuring personal information, financial records, and other regulated data are handled according to policy rather than passed wholesale into the inference context.
Observability across multi-agent systems
In a system where multiple agents invoke multiple MCP servers across a single user request, understanding what happened requires end-to-end tracing. A governed MCP server contributes structured trace data to the observability layer so that engineers and compliance teams can reconstruct the full sequence of tool calls for debugging, auditing, and performance analysis.
MCP server vs. traditional API
An MCP server and a traditional REST API both give an AI model access to external systems, but they work differently in ways that matter for agent development at scale.
| Traditional API | MCP server | |
|---|---|---|
| How the model learns what it can do | Hardcoded at development time | Dynamic discovery at runtime |
| Adding a new capability | New integration required | New tool added to existing server |
| Authentication and error handling | Per integration | Standardized by the protocol |
| Access control | Application level | Enforced at the server layer |
| Audit logging | Custom per integration | Built into governed MCP servers |
| Cross-model compatibility | Model-specific integration | Any compliant MCP client |
The practical consequence of dynamic discovery with an MCP server is significant for teams managing many tools across many agents. With a traditional API, every new tool requires a new integration. When an MCP server adds new tools, connected agents can use them immediately. The agent discovers them at runtime without changing the application or the agent framework.
How Couchbase implements an MCP server
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 Couchbase Server deployments. It’s part of the Couchbase AI Data Plane™ and is published on GitHub under the Apache 2.0 license.
The Couchbase MCP Server exposes tools to query Couchbase collections using SQL++, retrieve and write documents by key, inspect schemas and indexes, and analyze query performance. The model discovers these tools at runtime through MCP’s standard capability advertisement and invokes them as needed without any prior knowledge of the Couchbase schema or query language.
From a governance standpoint, the Couchbase MCP Server connects to the cluster as a Couchbase database user, so Couchbase’s existing role-based access control bounds what data any connected agent can reach, down to individual buckets, scopes, and collections. The server also 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 Agent Catalog covers the other half of governance, keeping tools, prompts, and end-to-end traces of agent activity in the database where teams can query them with SQL++.
| Capability | What it does |
|---|---|
| SQL++ query tool | Queries any Couchbase collection using SQL++ |
| Key-value access tool | Retrieves 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 | Role-based, enforced at the server layer using Couchbase’s access control system |
| Read-only mode | On by default: write tools are not loaded and data-modifying SQL++ is blocked until an operator opts in |
| Agent Catalog integration | Integration with AI Data Plane component that versions tools and prompts and records agent traces, queryable with SQL++ |
The Agent Catalog complements the Couchbase MCP Server by providing a centralized, versioned registry of tools, prompts, and agent functions. Where the Couchbase MCP Server handles the runtime protocol (receiving invocations, executing them, returning results), the Agent Catalog handles governance and lifecycle management for the tools and prompts agents use, and records end-to-end traces of what they did. Together they form the governed tool layer of the Couchbase AI Data Plane.
Key takeaways and related resources
An MCP server is the infrastructure layer that connects AI agents to the external systems they need to act in the world. As agent deployments scale across tools, teams, and organizations, the MCP server is what makes that scale manageable. It provides a single governed interface that any compliant model can use, with access control, audit logging, and observability built in at the server layer rather than reconstructed per integration.
Key takeaways:
- An MCP server is a service that exposes tools, resources, and prompt templates to AI models through the Model Context Protocol. It sits between the AI model and whatever external system it needs to access.
- MCP servers expose three types of capabilities: tools (executable functions), resources (data the model can read), and prompts (reusable prompt templates for standardizing model behavior).
- The discovery step is what makes MCP servers different from traditional APIs. The model discovers what a server can do at runtime rather than relying on integrations built at development time.
- A well-governed enterprise MCP server enforces four requirements: 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.
- MCP servers are cross-model compatible. Any compliant MCP client can use any MCP server, regardless of who built either one.
- The Couchbase MCP Server exposes SQL++ queries, key-value access, schema and index inspection, and query performance analysis as MCP tools. 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 Agent Catalog complements the Couchbase 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:
- What Is the Model Context Protocol (MCP)?
- Introducing Model Context Protocol (MCP) Server for Couchbase
- What Is an Agent Database?
- What Is an Agentic AI Data Foundation?
- Couchbase MCP Server on GitHub
FAQs
What is an MCP server? An MCP server is a service that exposes tools, resources, and prompt templates 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 through a capability advertisement step, then invokes the tools or resources it needs to complete a task.
What does an MCP server expose to AI models? An MCP server exposes three types of capabilities. Tools are executable functions the model can invoke to take action or retrieve information. Resources are data objects the model can read passively to gather context. Prompts are reusable prompt templates for common tasks that standardize model behavior across an organization. A single MCP server can expose any combination of all three types.
How does an MCP server differ from a traditional API? A traditional API is a static contract defined at development time. With a traditional API, the endpoints, input schemas, and output formats are fixed, and a model needs a specific integration for each API it uses. An MCP server uses dynamic discovery. With MCP, the model asks the server what it can do at runtime, and the server responds with structured descriptions of its capabilities. Adding a new tool to an MCP server makes it available to all connected agents immediately without any changes to the application or agent framework.
What makes an enterprise MCP server well governed? A well-governed enterprise MCP server enforces four requirements: role-based access control at the tool level so agents can only invoke what they are authorized to use, audit logging of every invocation with enough detail to reconstruct agent behavior after the fact, data filtering and redaction before results reach the model so sensitive information is handled according to policy, and structured observability that contributes trace data to the broader system for debugging and compliance review.
Can multiple AI agents share the same MCP server? Yes. An MCP server can serve multiple agents simultaneously, with access control enforced per session or per agent identity. This is one governance advantage of centralizing tools in an MCP server rather than defining them per agent or per application. The same access policies, audit logs, and observability apply to every agent that connects, regardless of who built the agent or which model it runs on.
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. It gives AI agents the ability 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. Couchbase MCP Server is published on GitHub under the Apache 2.0 license.
How does the Couchbase MCP Server relate to the Agent Catalog? The Couchbase MCP Server handles the runtime protocol. It receives invocation requests from AI agents, executes them against the Couchbase database, and returns structured results. The Agent Catalog handles the governance and lifecycle management layer. It versions the tools and prompts agents use, records tool calls, tool results, agent handoffs, and LLM generations as end-to-end traces that teams can query with SQL++, and provides a centralized registry that teams across the organization can use to discover and reuse existing capabilities. Together, they form the governed tool layer of the Couchbase AI Data Plane.