MCP Server

A Resource Provider is the server-side component responsible for exposing static or dynamic data objects to the client. Each resource is identified by a URI and described by metadata including its name, description, and MIME type.

• Examples: A file on disk, a database record, an API response, or a real-time data stream.
• Function: Handles client requests for resource listings and contents, enabling context injection into the AI's session.
• Key Protocol: Uses the resources/list and resources/read JSON-RPC methods.

A Tool Provider defines executable functions, while a Tool Handler contains the business logic that runs upon invocation.

• Tool Definition: Specifies the tool's name, description, and a strict JSON Schema for its input parameters.
• Tool Invocation: When a client calls a tool, the handler executes—such as calling an external API, running a script, or modifying data—and returns a structured result.
• Security: This separation allows for input schema validation and secure execution within the server's environment before any external action is taken.

This capability allows an MCP server to store and serve reusable Prompt Templates for language models.

• Structure: Templates are blueprints containing placeholder variables (e.g., {{query}}, {{date}}).
• Client-Side Rendering: The client populates the variables to generate a final, contextualized instruction or system message.
• Use Case: Ensures consistent, optimized prompting strategies across different AI clients and sessions, centralizing prompt engineering.

An MCP Server must implement one or more MCP Transports—the communication layer for exchanging JSON-RPC messages with a client.

• Stdio Transport: Uses standard input/output streams. Ideal for integrating local scripts, command-line tools, and secure enclave execution where the server is a subprocess.
• SSE Transport: Uses HTTP with Server-Sent Events for long-lived, asynchronous connections. Suitable for web-based or remotely hosted servers.
• Message Framing: The server correctly delimits messages (e.g., newline-separated JSON in stdio) to ensure reliable parsing.

Upon connection, the server engages in capability negotiation, a handshake process defined by the MCP specification.

• Process: The client and server exchange initialize and initialized messages, declaring supported protocol versions and feature sets (e.g., which resource/tool/prompt methods they support).
• Purpose: Ensures compatibility and allows both parties to understand available functionalities before any requests are made.
• Foundation: This negotiation is critical for stable orchestration layer design and dynamic tool discovery.

The server enforces correctness and safety by validating all incoming requests against defined schemas and implementing robust error handling.

• Input Validation: Verifies that parameters for a tool invocation strictly conform to the declared JSON Schema in the tool definition.
• Structured Errors: Returns standardized JSON-RPC error codes and messages for invalid requests, failed executions, or internal server errors.
• Resilience: This capability is fundamental for request/response validation, audit logging, and building reliable agentic systems.

These servers provide read-only or read-write access to local or networked file systems, enabling AI agents to analyze and manipulate documents.

• Examples: A server exposing a project's code repository, a directory of markdown files, or a shared network drive.
• Key Capability: Lists files as resources and may offer tools for searching, reading, and writing file contents.
• Use Case: An AI coding assistant reading multiple source files to understand a codebase before suggesting a fix.

Servers that interface with structured data stores, allowing AI agents to query and retrieve specific records without direct database access.

• Examples: Connectors for SQL databases (PostgreSQL, MySQL), NoSQL stores (MongoDB), or knowledge graphs.
• Key Capability: Exposes database tables or query endpoints as tools. Results are returned as structured data or text resources.
• Use Case: An AI analyst querying a customer database to summarize support ticket trends, with the server handling the SQL generation and execution.

These servers wrap existing REST, GraphQL, or gRPC APIs, providing a uniform, schema-defined interface for AI agents to call external services.

• Examples: A server that wraps the GitHub API, a CRM system like Salesforce, or an internal microservice.
• Key Capability: Each API endpoint is exposed as a tool with a strict input JSON Schema, ensuring valid requests. Handles authentication, rate limiting, and error translation.
• Use Case: An AI assistant creating a support ticket in Jira by invoking the create_issue tool, with the server managing the OAuth flow and HTTP request.

Servers that allow safe execution of shell commands, scripts, or specific command-line utilities, extending an AI's ability to interact with the host system.

• Examples: A server that runs git commands, executes Python scripts in a sandbox, or interfaces with package managers like npm or pip.
• Key Capability: Exposes discrete operations (e.g., git_log, run_linter) as tools. Critical for implementing secure enclave execution to prevent arbitrary code execution.
• Use Case: An AI developer agent running unit tests or applying a code formatter across a project directory.

Servers that provide streaming or frequently updated data from live systems, such as application logs, metrics, or IoT sensor telemetry.

• Examples: Connectors for Datadog, Prometheus, Splunk, or a live market data feed.
• Key Capability: Often uses SSE Transport for push-based updates. Data can be exposed as continuously updating resources or queryable tools.
• Use Case: An AI SRE agent monitoring a dashboard resource for error spikes, then invoking a tool to fetch detailed logs for diagnosis.

Servers dedicated to managing reusable prompt templates and system instructions, enabling centralized control over AI behavior and best practices.

• Examples: A corporate server storing approved prompt templates for code review, customer email drafting, or data analysis.
• Key Capability: Exposes prompts as named templates with variables. Clients request a prompt, fill the variables, and inject the result into the model context.
• Use Case: Ensuring all AI assistants in an organization use a vetted, compliant template for generating financial reports.

An MCP Client is the application that connects to MCP Servers. It is typically an AI assistant interface or language model application that dynamically extends its capabilities by discovering and using the resources, tools, and prompts exposed by servers.

• Primary Role: Initiates connections and sends JSON-RPC requests to servers.
• Core Actions: Lists available capabilities, reads resources, invokes tools, and fetches prompt templates.
• Examples: AI coding assistants like Claude for Desktop or Cursor act as MCP clients when configured to connect to external data sources.

An MCP Transport is the underlying communication channel that carries JSON-RPC messages between a client and a server. It defines how bytes are exchanged over a network or local process boundary.

• Stdio (Standard Input/Output): Used for integrating local scripts and command-line tools. The client spawns the server as a subprocess.
• SSE (Server-Sent Events): An HTTP-based protocol where the client opens a long-lived connection to a remote server, which can push messages asynchronously.
• Named Pipes / Unix Domain Sockets: Used for efficient inter-process communication on the same host.

The transport is abstracted by the protocol, allowing the same server logic to work over different channels.

A Tool Definition is the formal schema that describes an executable function an MCP Server provides. Tool Invocation is the act of a client calling that function.

• Definition Components: Includes a unique name, a human-readable description, and an inputSchema (a JSON Schema) that strictly defines the required parameters.
• Invocation Flow: The client sends a tools/call request with the tool name and arguments. The server executes the corresponding Tool Handler (the implementation logic) and returns a result.
• Validation: The server performs Schema Validation on the incoming arguments against the inputSchema before execution, ensuring type safety and correctness.

A Resource URI is a Uniform Resource Identifier that uniquely identifies a specific data object within an MCP Server's namespace. It follows the URI standard (scheme://authority/path?query) and is used by clients to request content.

• Structure: Often uses a custom scheme like file, github, or postgres to indicate the resource type and origin.
• Example: file:///etc/config.yaml or github://owner/repo/path/to/README.md.
• Purpose: Provides a stable, addressable pointer to a resource. The client requests resources by their URI, and the server's Resource Provider resolves the URI to fetch and return the actual data (e.g., file contents, database record).

Capability Negotiation is the initial handshake process when an MCP client connects to a server. Both parties exchange their supported protocol versions and the specific features they offer or wish to use.

• Initialization: The client sends an initialize request stating the protocol version it supports and the MCP features it wants to use (e.g., resources, tools).
• Server Response: The server replies with its protocol version and the capabilities it actually provides, such as the list of resource and tool providers.
• Outcome: Establishes a shared understanding of what operations are possible for the session, enabling graceful degradation if features are unsupported.