About MCP

The MCP is an open standard for creating and consuming tools and services in a model-driven way. It provides a standardized protocol that enables AI applications to discover and interact with external systems, APIs, and data sources. MCP standardizes how your AI agents and apps call internal systems and SaaS APIs, making it easier to build AI-powered applications that can perform actions, access resources, and leverage prompts.

For more information about MCP, see the official MCP documentation.

MCP architecture consists of three key participants that work together to enable seamless communication between AI applications and external systems:

1. MCP Host

The MCP host is the AI application that coordinates and manages one or more MCP clients. It provides the user interface and oversees the overall user experience. Examples include AI-powered IDEs such as Cursor, AI assistants like Claude Desktop, or custom AI applications built on platforms like Boltic. The host manages multiple clients, user interactions, and presents results through a unified interface.

2. Servers

MCP servers are programs that expose specific capabilities to AI applications through standardized protocol interfaces. They act as intermediaries between AI applications and external systems, providing a consistent way to access various services and data sources.

Servers use the MCP protocol to expose their capabilities as primitives (tools). Common examples include:

• File system servers for document access and file operations
• Database servers for data queries and manipulation
• GitHub servers for code management and repository operations
• Slack servers for team communication and messaging
• Calendar servers for scheduling and event management
• Custom business logic servers that wrap internal APIs and Workflows

Each server specializes in a specific domain, enabling AI applications to interact with diverse systems through a unified protocol.

Tools

Tools allow AI models to perform actions and interact with external systems. Each tool defines a specific operation with typed inputs and outputs, enabling AI models to execute functions programmatically based on user context and requirements.
MCP uses JSON Schema for input validation, ensuring type safety and providing clear documentation about required and optional parameters. Each tool performs a single, well-defined operation with clearly specified inputs and outputs. This modular design helps AI models determine when and how to use each tool.

Security and User Control: Tools may require user consent before execution, ensuring users maintain control over model actions. This consent is especially important for operations that modify data, perform transactions, or access sensitive information.

Protocol Operations:

Method	Purpose	Returns
tools/list	Discover available tools	Array of tool definitions with schemas
tools/call	Execute a specific tool	Tool execution result with structured output

3. Clients

MCP clients are launched by host applications to communicate with specific MCP servers. The host application, such as Claude.ai, Cursor IDE, or Boltic, manages the user experience and coordinates multiple clients. Each client maintains a direct communication channel with one server, handling the connection lifecycle and protocol-level interactions.
The host is the application users interact with, providing the UI and user experience. Clients are protocol-level components that enable server connections and manage the technical aspects of communication.

Key Characteristics:

• One-to-one relationship: Each client connects to a single MCP server
• Protocol implementation: Clients handle JSON-RPC 2.0 message formatting, transport management, and error handling
• Lifecycle management: Clients manage connection establishment, initialization, and graceful shutdown
• Capability negotiation: Clients negotiate supported protocol versions and features during initialization

Elicitation

Elicitation enables servers to request specific information from users during interactions, resulting in more dynamic, responsive workflows. This bidirectional communication lets servers gather information as needed instead of requiring all inputs upfront.

How Elicitation Works:

• Servers can pause their operations when they need additional information
• They send structured requests to the client, which present them to the user
• Users provide the requested information, which is then passed back to the server
• The server continues processing with the complete information

---

Layers

MCP consists of two layers:

1. Data layer: Defines the JSON-RPC protocol for client-server communication, including lifecycle management, and core primitives, such as tools, resources, prompts and notifications.
2. Transport layer: Defines the communication mechanisms and channels for data exchange between clients and servers, including transport-specific connection establishment, message framing, and authorization.

Transport layer

note

Boltic MCP supports Streamable HTTP transport mechanisms, which provide reliable, scalable communication suitable for production environments.

The transport layer manages communication channels and authentication between clients and servers. It handles connection establishment, message framing, and secure communication. Abstracting low-level networking details from the protocol layer allows the same JSON-RPC 2.0 message format to function across different transport mechanisms.

Key Responsibilities

• Connection management: Establishing and maintaining connections between clients and servers
• Message framing: Packaging JSON-RPC messages for transmission over the transport mechanism
• Authentication: Handling secure authentication and authorization
• Error handling: Managing transport-level errors and connection failures

Streamable HTTP transport

Streamable HTTP transport uses HTTP POST for client-to-server messages and optional Server-Sent Events (SSE) for streaming. This mechanism enables communication with remote servers over standard HTTP or HTTPS, making it suitable for cloud- and distributed-based systems.

Key Features:

• HTTP POST requests: Standard HTTP POST requests carry JSON-RPC 2.0 messages from clients to servers
• Server-Sent Events (SSE): Optional streaming support for real-time updates and progress notifications
• Remote communication: Enables communication with servers hosted on different machines or networks
• Standard authentication: Supports standard HTTP authentication methods, including:
  • Bearer tokens
  • API keys
  • Custom headers
  • OAuth 2.0 (recommended for production deployments)

Security Best Practices: MCP recommends OAuth 2.0 to obtain authentication tokens in production environments. This approach provides secure, token-based authentication with support for token refresh and revocation.
The transport layer abstracts communication details from the protocol layer, allowing the JSON-RPC 2.0 message format to work consistently across all transport mechanisms, including HTTP, WebSockets, and others.

Primitives

MCP primitives are the most important concept within MCP. They define what clients and servers can offer each other, specifying the types of contextual information that can be shared and the actions that can be performed. Primitives standardize capability exposure, making it easy for AI applications to discover and use server functionality.

Discovery and Usage

Each primitive type has associated methods for discovery (*/list), retrieval (*/get), and in some cases, execution (tools/call). MCP clients use the */list methods to discover available primitives dynamically. For example, a client can first list all available tools (tools/list) and then execute them as needed. This design allows listings to be dynamic, meaning servers can expose different primitives based on configuration, user permissions, or runtime conditions.

Example

Consider an MCP server that provides context about a database. It can expose:

• Tools for querying the database (e.g., execute_query, insert_record)

This approach allows AI applications to understand the database structure, see examples of proper usage, and execute queries safely.

Client Primitives

MCP also defines primitives that clients can expose to servers. These primitives allow MCP server authors to build richer, more interactive experiences by leveraging capabilities of the host AI application.

1. Elicitation: Allows servers to request additional information from users during operation. This enables interactive workflows in which servers can gather information incrementally.
   • Servers use the elicitation/request method to request additional information from users
   • Useful for gathering missing parameters, requesting confirmations, or collecting user preferences
   • Enables servers to adapt their behavior based on user input instead of failing when information is incomplete

Notifications

The protocol supports real-time notifications for dynamic updates between servers and clients. Notifications let servers proactively inform clients about changes without requiring polling.

How Notifications Work

• Notifications are sent as JSON-RPC 2.0 notification messages
• Servers can send notifications at any time after initialization
• Clients receive and process notifications asynchronously
• Notifications enable real-time updates without blocking request/response cycles

Example

• Tool updates: When a server's available tools change (new functionality added, tools modified, or tools removed)
• Resource updates: When resources are added, modified, or deleted, servers can notify clients
• Status changes: Servers can notify clients about state changes, errors, or important events
• Progress updates: Long-running operations can send progress notifications