yujunjun/claude-task-master
1
0
Fork 0
mirror of https://github.com/eyaltoledano/claude-task-master.git synced 2025-07-07 00:51:54 +00:00
Code Issues Packages Projects Releases Wiki Activity
claude-task-master/context/mcp-protocol-spec.txt
Ralph Khreish 47b79c0e29
chore: revamp README (#126)
2025-04-09 00:16:43 +02:00

9590 lines
322 KiB
Plaintext
Raw Permalink Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

Directory Structure:
└── ./
├── docs
│ ├── resources
│ │ └── _index.md
│ └── specification
│ ├── 2024-11-05
│ │ ├── architecture
│ │ │ └── _index.md
│ │ ├── basic
│ │ │ ├── utilities
│ │ │ │ ├── _index.md
│ │ │ │ ├── cancellation.md
│ │ │ │ ├── ping.md
│ │ │ │ └── progress.md
│ │ │ ├── _index.md
│ │ │ ├── lifecycle.md
│ │ │ ├── messages.md
│ │ │ └── transports.md
│ │ ├── client
│ │ │ ├── _index.md
│ │ │ ├── roots.md
│ │ │ └── sampling.md
│ │ ├── server
│ │ │ ├── utilities
│ │ │ │ ├── _index.md
│ │ │ │ ├── completion.md
│ │ │ │ ├── logging.md
│ │ │ │ └── pagination.md
│ │ │ ├── _index.md
│ │ │ ├── prompts.md
│ │ │ ├── resource-picker.png
│ │ │ ├── resources.md
│ │ │ ├── slash-command.png
│ │ │ └── tools.md
│ │ └── _index.md
│ ├── 2025-03-26
│ │ ├── architecture
│ │ │ └── _index.md
│ │ ├── basic
│ │ │ ├── utilities
│ │ │ │ ├── _index.md
│ │ │ │ ├── cancellation.md
│ │ │ │ ├── ping.md
│ │ │ │ └── progress.md
│ │ │ ├── _index.md
│ │ │ ├── authorization.md
│ │ │ ├── lifecycle.md
│ │ │ └── transports.md
│ │ ├── client
│ │ │ ├── _index.md
│ │ │ ├── roots.md
│ │ │ └── sampling.md
│ │ ├── server
│ │ │ ├── utilities
│ │ │ │ ├── _index.md
│ │ │ │ ├── completion.md
│ │ │ │ ├── logging.md
│ │ │ │ └── pagination.md
│ │ │ ├── _index.md
│ │ │ ├── prompts.md
│ │ │ ├── resource-picker.png
│ │ │ ├── resources.md
│ │ │ ├── slash-command.png
│ │ │ └── tools.md
│ │ ├── _index.md
│ │ └── changelog.md
│ ├── _index.md
│ ├── contributing.md
│ └── versioning.md
├── schema
│ ├── 2024-11-05
│ │ └── schema.ts
│ └── 2025-03-26
│ └── schema.ts
├── scripts
│ └── validate_examples.ts
├── site
│ └── layouts
│ └── index.html
└── README.md
---
File: /docs/resources/_index.md
---
---
title: "Additional Resources"
weight: 20
breadcrumbs: false
sidebar:
exclude: true
---
The Model Context Protocol (MCP) provides multiple resources for documentation and
implementation:
- **User Documentation**: Visit
[modelcontextprotocol.io](https://modelcontextprotocol.io) for comprehensive
user-facing documentation
- **Python SDK**: The Python implementation is available at
[github.com/modelcontextprotocol/python-sdk](https://github.com/modelcontextprotocol/python-sdk) -
[Issues](https://github.com/modelcontextprotocol/python-sdk/issues)
- **Specification**: The core specification is available at
[github.com/modelcontextprotocol/specification](https://github.com/modelcontextprotocol/specification) -
[Discussions](https://github.com/modelcontextprotocol/specification/discussions)
- **TypeScript SDK**: The TypeScript implementation can be found at
[github.com/modelcontextprotocol/typescript-sdk](https://github.com/modelcontextprotocol/typescript-sdk) -
[Issues](https://github.com/modelcontextprotocol/typescript-sdk/issues)
For questions or discussions, please open a discussion in the appropriate GitHub
repository based on your implementation or use case. You can also visit the
[Model Context Protocol organization on GitHub](https://github.com/modelcontextprotocol)
to see all repositories and ongoing development.
---
File: /docs/specification/2024-11-05/architecture/_index.md
---
---
title: Architecture
cascade:
type: docs
weight: 1
---
The Model Context Protocol (MCP) follows a client-host-server architecture where each
host can run multiple client instances. This architecture enables users to integrate AI
capabilities across applications while maintaining clear security boundaries and
isolating concerns. Built on JSON-RPC, MCP provides a stateful session protocol focused
on context exchange and sampling coordination between clients and servers.
## Core Components
```mermaid
graph LR
subgraph "Application Host Process"
H[Host]
C1[Client 1]
C2[Client 2]
C3[Client 3]
H --> C1
H --> C2
H --> C3
end
subgraph "Local machine"
S1[Server 1<br>Files & Git]
S2[Server 2<br>Database]
R1[("Local<br>Resource A")]
R2[("Local<br>Resource B")]
C1 --> S1
C2 --> S2
S1 <--> R1
S2 <--> R2
end
subgraph "Internet"
S3[Server 3<br>External APIs]
R3[("Remote<br>Resource C")]
C3 --> S3
S3 <--> R3
end
```
### Host
The host process acts as the container and coordinator:
- Creates and manages multiple client instances
- Controls client connection permissions and lifecycle
- Enforces security policies and consent requirements
- Handles user authorization decisions
- Coordinates AI/LLM integration and sampling
- Manages context aggregation across clients
### Clients
Each client is created by the host and maintains an isolated server connection:
- Establishes one stateful session per server
- Handles protocol negotiation and capability exchange
- Routes protocol messages bidirectionally
- Manages subscriptions and notifications
- Maintains security boundaries between servers
A host application creates and manages multiple clients, with each client having a 1:1
relationship with a particular server.
### Servers
Servers provide specialized context and capabilities:
- Expose resources, tools and prompts via MCP primitives
- Operate independently with focused responsibilities
- Request sampling through client interfaces
- Must respect security constraints
- Can be local processes or remote services
## Design Principles
MCP is built on several key design principles that inform its architecture and
implementation:
1. **Servers should be extremely easy to build**
- Host applications handle complex orchestration responsibilities
- Servers focus on specific, well-defined capabilities
- Simple interfaces minimize implementation overhead
- Clear separation enables maintainable code
2. **Servers should be highly composable**
- Each server provides focused functionality in isolation
- Multiple servers can be combined seamlessly
- Shared protocol enables interoperability
- Modular design supports extensibility
3. **Servers should not be able to read the whole conversation, nor "see into" other
servers**
- Servers receive only necessary contextual information
- Full conversation history stays with the host
- Each server connection maintains isolation
- Cross-server interactions are controlled by the host
- Host process enforces security boundaries
4. **Features can be added to servers and clients progressively**
- Core protocol provides minimal required functionality
- Additional capabilities can be negotiated as needed
- Servers and clients evolve independently
- Protocol designed for future extensibility
- Backwards compatibility is maintained
## Message Types
MCP defines three core message types based on
[JSON-RPC 2.0](https://www.jsonrpc.org/specification):
- **Requests**: Bidirectional messages with method and parameters expecting a response
- **Responses**: Successful results or errors matching specific request IDs
- **Notifications**: One-way messages requiring no response
Each message type follows the JSON-RPC 2.0 specification for structure and delivery
semantics.
## Capability Negotiation
The Model Context Protocol uses a capability-based negotiation system where clients and
servers explicitly declare their supported features during initialization. Capabilities
determine which protocol features and primitives are available during a session.
- Servers declare capabilities like resource subscriptions, tool support, and prompt
templates
- Clients declare capabilities like sampling support and notification handling
- Both parties must respect declared capabilities throughout the session
- Additional capabilities can be negotiated through extensions to the protocol
```mermaid
sequenceDiagram
participant Host
participant Client
participant Server
Host->>+Client: Initialize client
Client->>+Server: Initialize session with capabilities
Server-->>Client: Respond with supported capabilities
Note over Host,Server: Active Session with Negotiated Features
loop Client Requests
Host->>Client: User- or model-initiated action
Client->>Server: Request (tools/resources)
Server-->>Client: Response
Client-->>Host: Update UI or respond to model
end
loop Server Requests
Server->>Client: Request (sampling)
Client->>Host: Forward to AI
Host-->>Client: AI response
Client-->>Server: Response
end
loop Notifications
Server--)Client: Resource updates
Client--)Server: Status changes
end
Host->>Client: Terminate
Client->>-Server: End session
deactivate Server
```
Each capability unlocks specific protocol features for use during the session. For
example:
- Implemented [server features]({{< ref "/specification/2024-11-05/server" >}}) must be
advertised in the server's capabilities
- Emitting resource subscription notifications requires the server to declare
subscription support
- Tool invocation requires the server to declare tool capabilities
- [Sampling]({{< ref "/specification/2024-11-05/client" >}}) requires the client to
declare support in its capabilities
This capability negotiation ensures clients and servers have a clear understanding of
supported functionality while maintaining protocol extensibility.
---
File: /docs/specification/2024-11-05/basic/utilities/_index.md
---
---
title: Utilities
---
{{< callout type="info" >}} **Protocol Revision**: 2024-11-05 {{< /callout >}}
These optional features enhance the base protocol functionality with various utilities.
{{< cards >}} {{< card link="ping" title="Ping" icon="status-online" >}}
{{< card link="cancellation" title="Cancellation" icon="x" >}}
{{< card link="progress" title="Progress" icon="clock" >}} {{< /cards >}}
---
File: /docs/specification/2024-11-05/basic/utilities/cancellation.md
---
---
title: Cancellation
weight: 10
---
{{< callout type="info" >}} **Protocol Revision**: 2024-11-05 {{< /callout >}}
The Model Context Protocol (MCP) supports optional cancellation of in-progress requests
through notification messages. Either side can send a cancellation notification to
indicate that a previously-issued request should be terminated.
## Cancellation Flow
When a party wants to cancel an in-progress request, it sends a `notifications/cancelled`
notification containing:
- The ID of the request to cancel
- An optional reason string that can be logged or displayed
```json
{
"jsonrpc": "2.0",
"method": "notifications/cancelled",
"params": {
"requestId": "123",
"reason": "User requested cancellation"
}
}
```
## Behavior Requirements
1. Cancellation notifications **MUST** only reference requests that:
- Were previously issued in the same direction
- Are believed to still be in-progress
2. The `initialize` request **MUST NOT** be cancelled by clients
3. Receivers of cancellation notifications **SHOULD**:
- Stop processing the cancelled request
- Free associated resources
- Not send a response for the cancelled request
4. Receivers **MAY** ignore cancellation notifications if:
- The referenced request is unknown
- Processing has already completed
- The request cannot be cancelled
5. The sender of the cancellation notification **SHOULD** ignore any response to the
request that arrives afterward
## Timing Considerations
Due to network latency, cancellation notifications may arrive after request processing
has completed, and potentially after a response has already been sent.
Both parties **MUST** handle these race conditions gracefully:
```mermaid
sequenceDiagram
participant Client
participant Server
Client->>Server: Request (ID: 123)
Note over Server: Processing starts
Client--)Server: notifications/cancelled (ID: 123)
alt
Note over Server: Processing may have<br/>completed before<br/>cancellation arrives
else If not completed
Note over Server: Stop processing
end
```
## Implementation Notes
- Both parties **SHOULD** log cancellation reasons for debugging
- Application UIs **SHOULD** indicate when cancellation is requested
## Error Handling
Invalid cancellation notifications **SHOULD** be ignored:
- Unknown request IDs
- Already completed requests
- Malformed notifications
This maintains the "fire and forget" nature of notifications while allowing for race
conditions in asynchronous communication.
---
File: /docs/specification/2024-11-05/basic/utilities/ping.md
---
---
title: Ping
weight: 5
---
{{< callout type="info" >}} **Protocol Revision**: 2024-11-05 {{< /callout >}}
The Model Context Protocol includes an optional ping mechanism that allows either party
to verify that their counterpart is still responsive and the connection is alive.
## Overview
The ping functionality is implemented through a simple request/response pattern. Either
the client or server can initiate a ping by sending a `ping` request.
## Message Format
A ping request is a standard JSON-RPC request with no parameters:
```json
{
"jsonrpc": "2.0",
"id": "123",
"method": "ping"
}
```
## Behavior Requirements
1. The receiver **MUST** respond promptly with an empty response:
```json
{
"jsonrpc": "2.0",
"id": "123",
"result": {}
}
```
2. If no response is received within a reasonable timeout period, the sender **MAY**:
- Consider the connection stale
- Terminate the connection
- Attempt reconnection procedures
## Usage Patterns
```mermaid
sequenceDiagram
participant Sender
participant Receiver
Sender->>Receiver: ping request
Receiver->>Sender: empty response
```
## Implementation Considerations
- Implementations **SHOULD** periodically issue pings to detect connection health
- The frequency of pings **SHOULD** be configurable
- Timeouts **SHOULD** be appropriate for the network environment
- Excessive pinging **SHOULD** be avoided to reduce network overhead
## Error Handling
- Timeouts **SHOULD** be treated as connection failures
- Multiple failed pings **MAY** trigger connection reset
- Implementations **SHOULD** log ping failures for diagnostics
---
File: /docs/specification/2024-11-05/basic/utilities/progress.md
---
---
title: Progress
weight: 30
---
{{< callout type="info" >}} **Protocol Revision**: 2024-11-05 {{< /callout >}}
The Model Context Protocol (MCP) supports optional progress tracking for long-running
operations through notification messages. Either side can send progress notifications to
provide updates about operation status.
## Progress Flow
When a party wants to _receive_ progress updates for a request, it includes a
`progressToken` in the request metadata.
- Progress tokens **MUST** be a string or integer value
- Progress tokens can be chosen by the sender using any means, but **MUST** be unique
across all active requests.
```json
{
"jsonrpc": "2.0",
"id": 1,
"method": "some_method",
"params": {
"_meta": {
"progressToken": "abc123"
}
}
}
```
The receiver **MAY** then send progress notifications containing:
- The original progress token
- The current progress value so far
- An optional "total" value
```json
{
"jsonrpc": "2.0",
"method": "notifications/progress",
"params": {
"progressToken": "abc123",
"progress": 50,
"total": 100
}
}
```
- The `progress` value **MUST** increase with each notification, even if the total is
unknown.
- The `progress` and the `total` values **MAY** be floating point.
## Behavior Requirements
1. Progress notifications **MUST** only reference tokens that:
- Were provided in an active request
- Are associated with an in-progress operation
2. Receivers of progress requests **MAY**:
- Choose not to send any progress notifications
- Send notifications at whatever frequency they deem appropriate
- Omit the total value if unknown
```mermaid
sequenceDiagram
participant Sender
participant Receiver
Note over Sender,Receiver: Request with progress token
Sender->>Receiver: Method request with progressToken
Note over Sender,Receiver: Progress updates
loop Progress Updates
Receiver-->>Sender: Progress notification (0.2/1.0)
Receiver-->>Sender: Progress notification (0.6/1.0)
Receiver-->>Sender: Progress notification (1.0/1.0)
end
Note over Sender,Receiver: Operation complete
Receiver->>Sender: Method response
```
## Implementation Notes
- Senders and receivers **SHOULD** track active progress tokens
- Both parties **SHOULD** implement rate limiting to prevent flooding
- Progress notifications **MUST** stop after completion
---
File: /docs/specification/2024-11-05/basic/_index.md
---
---
title: Base Protocol
cascade:
type: docs
weight: 2
---
{{< callout type="info" >}} **Protocol Revision**: 2024-11-05 {{< /callout >}}
All messages between MCP clients and servers **MUST** follow the
[JSON-RPC 2.0](https://www.jsonrpc.org/specification) specification. The protocol defines
three fundamental types of messages:
| Type | Description | Requirements |
| --------------- | -------------------------------------- | -------------------------------------- |
| `Requests` | Messages sent to initiate an operation | Must include unique ID and method name |
| `Responses` | Messages sent in reply to requests | Must include same ID as request |
| `Notifications` | One-way messages with no reply | Must not include an ID |
**Responses** are further sub-categorized as either **successful results** or **errors**.
Results can follow any JSON object structure, while errors must include an error code and
message at minimum.
## Protocol Layers
The Model Context Protocol consists of several key components that work together:
- **Base Protocol**: Core JSON-RPC message types
- **Lifecycle Management**: Connection initialization, capability negotiation, and
session control
- **Server Features**: Resources, prompts, and tools exposed by servers
- **Client Features**: Sampling and root directory lists provided by clients
- **Utilities**: Cross-cutting concerns like logging and argument completion
All implementations **MUST** support the base protocol and lifecycle management
components. Other components **MAY** be implemented based on the specific needs of the
application.
These protocol layers establish clear separation of concerns while enabling rich
interactions between clients and servers. The modular design allows implementations to
support exactly the features they need.
See the following pages for more details on the different components:
{{< cards >}}
{{< card link="/specification/2024-11-05/basic/lifecycle" title="Lifecycle" icon="refresh" >}}
{{< card link="/specification/2024-11-05/server/resources" title="Resources" icon="document" >}}
{{< card link="/specification/2024-11-05/server/prompts" title="Prompts" icon="chat-alt-2" >}}
{{< card link="/specification/2024-11-05/server/tools" title="Tools" icon="adjustments" >}}
{{< card link="/specification/2024-11-05/server/utilities/logging" title="Logging" icon="annotation" >}}
{{< card link="/specification/2024-11-05/client/sampling" title="Sampling" icon="code" >}}
{{< /cards >}}
## Auth
Authentication and authorization are not currently part of the core MCP specification,
but we are considering ways to introduce them in future. Join us in
[GitHub Discussions](https://github.com/modelcontextprotocol/specification/discussions)
to help shape the future of the protocol!
Clients and servers **MAY** negotiate their own custom authentication and authorization
strategies.
## Schema
The full specification of the protocol is defined as a
[TypeScript schema](http://github.com/modelcontextprotocol/specification/tree/main/schema/2024-11-05/schema.ts).
This is the source of truth for all protocol messages and structures.
There is also a
[JSON Schema](http://github.com/modelcontextprotocol/specification/tree/main/schema/2024-11-05/schema.json),
which is automatically generated from the TypeScript source of truth, for use with
various automated tooling.
---
File: /docs/specification/2024-11-05/basic/lifecycle.md
---
---
title: Lifecycle
type: docs
weight: 30
---
{{< callout type="info" >}} **Protocol Revision**: 2024-11-05 {{< /callout >}}
The Model Context Protocol (MCP) defines a rigorous lifecycle for client-server
connections that ensures proper capability negotiation and state management.
1. **Initialization**: Capability negotiation and protocol version agreement
2. **Operation**: Normal protocol communication
3. **Shutdown**: Graceful termination of the connection
```mermaid
sequenceDiagram
participant Client
participant Server
Note over Client,Server: Initialization Phase
activate Client
Client->>+Server: initialize request
Server-->>Client: initialize response
Client--)Server: initialized notification
Note over Client,Server: Operation Phase
rect rgb(200, 220, 250)
note over Client,Server: Normal protocol operations
end
Note over Client,Server: Shutdown
Client--)-Server: Disconnect
deactivate Server
Note over Client,Server: Connection closed
```
## Lifecycle Phases
### Initialization
The initialization phase **MUST** be the first interaction between client and server.
During this phase, the client and server:
- Establish protocol version compatibility
- Exchange and negotiate capabilities
- Share implementation details
The client **MUST** initiate this phase by sending an `initialize` request containing:
- Protocol version supported
- Client capabilities
- Client implementation information
```json
{
"jsonrpc": "2.0",
"id": 1,
"method": "initialize",
"params": {
"protocolVersion": "2024-11-05",
"capabilities": {
"roots": {
"listChanged": true
},
"sampling": {}
},
"clientInfo": {
"name": "ExampleClient",
"version": "1.0.0"
}
}
}
```
The server **MUST** respond with its own capabilities and information:
```json
{
"jsonrpc": "2.0",
"id": 1,
"result": {
"protocolVersion": "2024-11-05",
"capabilities": {
"logging": {},
"prompts": {
"listChanged": true
},
"resources": {
"subscribe": true,
"listChanged": true
},
"tools": {
"listChanged": true
}
},
"serverInfo": {
"name": "ExampleServer",
"version": "1.0.0"
}
}
}
```
After successful initialization, the client **MUST** send an `initialized` notification
to indicate it is ready to begin normal operations:
```json
{
"jsonrpc": "2.0",
"method": "notifications/initialized"
}
```
- The client **SHOULD NOT** send requests other than
[pings]({{< ref "/specification/2024-11-05/basic/utilities/ping" >}}) before the server
has responded to the `initialize` request.
- The server **SHOULD NOT** send requests other than
[pings]({{< ref "/specification/2024-11-05/basic/utilities/ping" >}}) and
[logging]({{< ref "/specification/2024-11-05/server/utilities/logging" >}}) before
receiving the `initialized` notification.
#### Version Negotiation
In the `initialize` request, the client **MUST** send a protocol version it supports.
This **SHOULD** be the _latest_ version supported by the client.
If the server supports the requested protocol version, it **MUST** respond with the same
version. Otherwise, the server **MUST** respond with another protocol version it
supports. This **SHOULD** be the _latest_ version supported by the server.
If the client does not support the version in the server's response, it **SHOULD**
disconnect.
#### Capability Negotiation
Client and server capabilities establish which optional protocol features will be
available during the session.
Key capabilities include:
| Category | Capability | Description |
| -------- | -------------- | ------------------------------------------------------------------------------------------------- |
| Client | `roots` | Ability to provide filesystem [roots]({{< ref "/specification/2024-11-05/client/roots" >}}) |
| Client | `sampling` | Support for LLM [sampling]({{< ref "/specification/2024-11-05/client/sampling" >}}) requests |
| Client | `experimental` | Describes support for non-standard experimental features |
| Server | `prompts` | Offers [prompt templates]({{< ref "/specification/2024-11-05/server/prompts" >}}) |
| Server | `resources` | Provides readable [resources]({{< ref "/specification/2024-11-05/server/resources" >}}) |
| Server | `tools` | Exposes callable [tools]({{< ref "/specification/2024-11-05/server/tools" >}}) |
| Server | `logging` | Emits structured [log messages]({{< ref "/specification/2024-11-05/server/utilities/logging" >}}) |
| Server | `experimental` | Describes support for non-standard experimental features |
Capability objects can describe sub-capabilities like:
- `listChanged`: Support for list change notifications (for prompts, resources, and
tools)
- `subscribe`: Support for subscribing to individual items' changes (resources only)
### Operation
During the operation phase, the client and server exchange messages according to the
negotiated capabilities.
Both parties **SHOULD**:
- Respect the negotiated protocol version
- Only use capabilities that were successfully negotiated
### Shutdown
During the shutdown phase, one side (usually the client) cleanly terminates the protocol
connection. No specific shutdown messages are defined—instead, the underlying transport
mechanism should be used to signal connection termination:
#### stdio
For the stdio [transport]({{< ref "/specification/2024-11-05/basic/transports" >}}), the
client **SHOULD** initiate shutdown by:
1. First, closing the input stream to the child process (the server)
2. Waiting for the server to exit, or sending `SIGTERM` if the server does not exit
within a reasonable time
3. Sending `SIGKILL` if the server does not exit within a reasonable time after `SIGTERM`
The server **MAY** initiate shutdown by closing its output stream to the client and
exiting.
#### HTTP
For HTTP [transports]({{< ref "/specification/2024-11-05/basic/transports" >}}), shutdown
is indicated by closing the associated HTTP connection(s).
## Error Handling
Implementations **SHOULD** be prepared to handle these error cases:
- Protocol version mismatch
- Failure to negotiate required capabilities
- Initialize request timeout
- Shutdown timeout
Implementations **SHOULD** implement appropriate timeouts for all requests, to prevent
hung connections and resource exhaustion.
Example initialization error:
```json
{
"jsonrpc": "2.0",
"id": 1,
"error": {
"code": -32602,
"message": "Unsupported protocol version",
"data": {
"supported": ["2024-11-05"],
"requested": "1.0.0"
}
}
}
```
---
File: /docs/specification/2024-11-05/basic/messages.md
---
---
title: Messages
type: docs
weight: 20
---
{{< callout type="info" >}} **Protocol Revision**: 2024-11-05 {{< /callout >}}
All messages in MCP **MUST** follow the
[JSON-RPC 2.0](https://www.jsonrpc.org/specification) specification. The protocol defines
three types of messages:
## Requests
Requests are sent from the client to the server or vice versa.
```typescript
{
jsonrpc: "2.0";
id: string | number;
method: string;
params?: {
[key: string]: unknown;
};
}
```
- Requests **MUST** include a string or integer ID.
- Unlike base JSON-RPC, the ID **MUST NOT** be `null`.
- The request ID **MUST NOT** have been previously used by the requestor within the same
session.
## Responses
Responses are sent in reply to requests.
```typescript
{
jsonrpc: "2.0";
id: string | number;
result?: {
[key: string]: unknown;
}
error?: {
code: number;
message: string;
data?: unknown;
}
}
```
- Responses **MUST** include the same ID as the request they correspond to.
- Either a `result` or an `error` **MUST** be set. A response **MUST NOT** set both.
- Error codes **MUST** be integers.
## Notifications
Notifications are sent from the client to the server or vice versa. They do not expect a
response.
```typescript
{
jsonrpc: "2.0";
method: string;
params?: {
[key: string]: unknown;
};
}
```
- Notifications **MUST NOT** include an ID.
---
File: /docs/specification/2024-11-05/basic/transports.md
---
---
title: Transports
type: docs
weight: 40
---
{{< callout type="info" >}} **Protocol Revision**: 2024-11-05 {{< /callout >}}
MCP currently defines two standard transport mechanisms for client-server communication:
1. [stdio](#stdio), communication over standard in and standard out
2. [HTTP with Server-Sent Events](#http-with-sse) (SSE)
Clients **SHOULD** support stdio whenever possible.
It is also possible for clients and servers to implement
[custom transports](#custom-transports) in a pluggable fashion.
## stdio
In the **stdio** transport:
- The client launches the MCP server as a subprocess.
- The server receives JSON-RPC messages on its standard input (`stdin`) and writes
responses to its standard output (`stdout`).
- Messages are delimited by newlines, and **MUST NOT** contain embedded newlines.
- The server **MAY** write UTF-8 strings to its standard error (`stderr`) for logging
purposes. Clients **MAY** capture, forward, or ignore this logging.
- The server **MUST NOT** write anything to its `stdout` that is not a valid MCP message.
- The client **MUST NOT** write anything to the server's `stdin` that is not a valid MCP
message.
```mermaid
sequenceDiagram
participant Client
participant Server Process
Client->>+Server Process: Launch subprocess
loop Message Exchange
Client->>Server Process: Write to stdin
Server Process->>Client: Write to stdout
Server Process--)Client: Optional logs on stderr
end
Client->>Server Process: Close stdin, terminate subprocess
deactivate Server Process
```
## HTTP with SSE
In the **SSE** transport, the server operates as an independent process that can handle
multiple client connections.
The server **MUST** provide two endpoints:
1. An SSE endpoint, for clients to establish a connection and receive messages from the
server
2. A regular HTTP POST endpoint for clients to send messages to the server
When a client connects, the server **MUST** send an `endpoint` event containing a URI for
the client to use for sending messages. All subsequent client messages **MUST** be sent
as HTTP POST requests to this endpoint.
Server messages are sent as SSE `message` events, with the message content encoded as
JSON in the event data.
```mermaid
sequenceDiagram
participant Client
participant Server
Client->>Server: Open SSE connection
Server->>Client: endpoint event
loop Message Exchange
Client->>Server: HTTP POST messages
Server->>Client: SSE message events
end
Client->>Server: Close SSE connection
```
## Custom Transports
Clients and servers **MAY** implement additional custom transport mechanisms to suit
their specific needs. The protocol is transport-agnostic and can be implemented over any
communication channel that supports bidirectional message exchange.
Implementers who choose to support custom transports **MUST** ensure they preserve the
JSON-RPC message format and lifecycle requirements defined by MCP. Custom transports
**SHOULD** document their specific connection establishment and message exchange patterns
to aid interoperability.
---
File: /docs/specification/2024-11-05/client/_index.md
---
---
title: Client Features
cascade:
type: docs
weight: 4
---
{{< callout type="info" >}} **Protocol Revision**: 2024-11-05 {{< /callout >}}
Clients can implement additional features to enrich connected MCP servers:
{{< cards >}} {{< card link="roots" title="Roots" icon="folder" >}}
{{< card link="sampling" title="Sampling" icon="annotation" >}} {{< /cards >}}
---
File: /docs/specification/2024-11-05/client/roots.md
---
---
title: Roots
type: docs
weight: 40
---
{{< callout type="info" >}} **Protocol Revision**: 2024-11-05 {{< /callout >}}
The Model Context Protocol (MCP) provides a standardized way for clients to expose
filesystem "roots" to servers. Roots define the boundaries of where servers can operate
within the filesystem, allowing them to understand which directories and files they have
access to. Servers can request the list of roots from supporting clients and receive
notifications when that list changes.
## User Interaction Model
Roots in MCP are typically exposed through workspace or project configuration interfaces.
For example, implementations could offer a workspace/project picker that allows users to
select directories and files the server should have access to. This can be combined with
automatic workspace detection from version control systems or project files.
However, implementations are free to expose roots through any interface pattern that
suits their needs&mdash;the protocol itself does not mandate any specific user
interaction model.
## Capabilities
Clients that support roots **MUST** declare the `roots` capability during
[initialization]({{< ref "/specification/2024-11-05/basic/lifecycle#initialization" >}}):
```json
{
"capabilities": {
"roots": {
"listChanged": true
}
}
}
```
`listChanged` indicates whether the client will emit notifications when the list of roots
changes.
## Protocol Messages
### Listing Roots
To retrieve roots, servers send a `roots/list` request:
**Request:**
```json
{
"jsonrpc": "2.0",
"id": 1,
"method": "roots/list"
}
```
**Response:**
```json
{
"jsonrpc": "2.0",
"id": 1,
"result": {
"roots": [
{
"uri": "file:///home/user/projects/myproject",
"name": "My Project"
}
]
}
}
```
### Root List Changes
When roots change, clients that support `listChanged` **MUST** send a notification:
```json
{
"jsonrpc": "2.0",
"method": "notifications/roots/list_changed"
}
```
## Message Flow
```mermaid
sequenceDiagram
participant Server
participant Client
Note over Server,Client: Discovery
Server->>Client: roots/list
Client-->>Server: Available roots
Note over Server,Client: Changes
Client--)Server: notifications/roots/list_changed
Server->>Client: roots/list
Client-->>Server: Updated roots
```
## Data Types
### Root
A root definition includes:
- `uri`: Unique identifier for the root. This **MUST** be a `file://` URI in the current
specification.
- `name`: Optional human-readable name for display purposes.
Example roots for different use cases:
#### Project Directory
```json
{
"uri": "file:///home/user/projects/myproject",
"name": "My Project"
}
```
#### Multiple Repositories
```json
[
{
"uri": "file:///home/user/repos/frontend",
"name": "Frontend Repository"
},
{
"uri": "file:///home/user/repos/backend",
"name": "Backend Repository"
}
]
```
## Error Handling
Clients **SHOULD** return standard JSON-RPC errors for common failure cases:
- Client does not support roots: `-32601` (Method not found)
- Internal errors: `-32603`
Example error:
```json
{
"jsonrpc": "2.0",
"id": 1,
"error": {
"code": -32601,
"message": "Roots not supported",
"data": {
"reason": "Client does not have roots capability"
}
}
}
```
## Security Considerations
1. Clients **MUST**:
- Only expose roots with appropriate permissions
- Validate all root URIs to prevent path traversal
- Implement proper access controls
- Monitor root accessibility
2. Servers **SHOULD**:
- Handle cases where roots become unavailable
- Respect root boundaries during operations
- Validate all paths against provided roots
## Implementation Guidelines
1. Clients **SHOULD**:
- Prompt users for consent before exposing roots to servers
- Provide clear user interfaces for root management
- Validate root accessibility before exposing
- Monitor for root changes
2. Servers **SHOULD**:
- Check for roots capability before usage
- Handle root list changes gracefully
- Respect root boundaries in operations
- Cache root information appropriately
---
File: /docs/specification/2024-11-05/client/sampling.md
---
---
title: Sampling
type: docs
weight: 40
---
{{< callout type="info" >}} **Protocol Revision**: 2024-11-05 {{< /callout >}}
The Model Context Protocol (MCP) provides a standardized way for servers to request LLM
sampling ("completions" or "generations") from language models via clients. This flow
allows clients to maintain control over model access, selection, and permissions while
enabling servers to leverage AI capabilities&mdash;with no server API keys necessary.
Servers can request text or image-based interactions and optionally include context from
MCP servers in their prompts.
## User Interaction Model
Sampling in MCP allows servers to implement agentic behaviors, by enabling LLM calls to
occur _nested_ inside other MCP server features.
Implementations are free to expose sampling through any interface pattern that suits
their needs&mdash;the protocol itself does not mandate any specific user interaction
model.
{{< callout type="warning" >}} For trust & safety and security, there **SHOULD** always
be a human in the loop with the ability to deny sampling requests.
Applications **SHOULD**:
- Provide UI that makes it easy and intuitive to review sampling requests
- Allow users to view and edit prompts before sending
- Present generated responses for review before delivery {{< /callout >}}
## Capabilities
Clients that support sampling **MUST** declare the `sampling` capability during
[initialization]({{< ref "/specification/2024-11-05/basic/lifecycle#initialization" >}}):
```json
{
"capabilities": {
"sampling": {}
}
}
```
## Protocol Messages
### Creating Messages
To request a language model generation, servers send a `sampling/createMessage` request:
**Request:**
```json
{
"jsonrpc": "2.0",
"id": 1,
"method": "sampling/createMessage",
"params": {
"messages": [
{
"role": "user",
"content": {
"type": "text",
"text": "What is the capital of France?"
}
}
],
"modelPreferences": {
"hints": [
{
"name": "claude-3-sonnet"
}
],
"intelligencePriority": 0.8,
"speedPriority": 0.5
},
"systemPrompt": "You are a helpful assistant.",
"maxTokens": 100
}
}
```
**Response:**
```json
{
"jsonrpc": "2.0",
"id": 1,
"result": {
"role": "assistant",
"content": {
"type": "text",
"text": "The capital of France is Paris."
},
"model": "claude-3-sonnet-20240307",
"stopReason": "endTurn"
}
}
```
## Message Flow
```mermaid
sequenceDiagram
participant Server
participant Client
participant User
participant LLM
Note over Server,Client: Server initiates sampling
Server->>Client: sampling/createMessage
Note over Client,User: Human-in-the-loop review
Client->>User: Present request for approval
User-->>Client: Review and approve/modify
Note over Client,LLM: Model interaction
Client->>LLM: Forward approved request
LLM-->>Client: Return generation
Note over Client,User: Response review
Client->>User: Present response for approval
User-->>Client: Review and approve/modify
Note over Server,Client: Complete request
Client-->>Server: Return approved response
```
## Data Types
### Messages
Sampling messages can contain:
#### Text Content
```json
{
"type": "text",
"text": "The message content"
}
```
#### Image Content
```json
{
"type": "image",
"data": "base64-encoded-image-data",
"mimeType": "image/jpeg"
}
```
### Model Preferences
Model selection in MCP requires careful abstraction since servers and clients may use
different AI providers with distinct model offerings. A server cannot simply request a
specific model by name since the client may not have access to that exact model or may
prefer to use a different provider's equivalent model.
To solve this, MCP implements a preference system that combines abstract capability
priorities with optional model hints:
#### Capability Priorities
Servers express their needs through three normalized priority values (0-1):
- `costPriority`: How important is minimizing costs? Higher values prefer cheaper models.
- `speedPriority`: How important is low latency? Higher values prefer faster models.
- `intelligencePriority`: How important are advanced capabilities? Higher values prefer
more capable models.
#### Model Hints
While priorities help select models based on characteristics, `hints` allow servers to
suggest specific models or model families:
- Hints are treated as substrings that can match model names flexibly
- Multiple hints are evaluated in order of preference
- Clients **MAY** map hints to equivalent models from different providers
- Hints are advisory&mdash;clients make final model selection
For example:
```json
{
"hints": [
{ "name": "claude-3-sonnet" }, // Prefer Sonnet-class models
{ "name": "claude" } // Fall back to any Claude model
],
"costPriority": 0.3, // Cost is less important
"speedPriority": 0.8, // Speed is very important
"intelligencePriority": 0.5 // Moderate capability needs
}
```
The client processes these preferences to select an appropriate model from its available
options. For instance, if the client doesn't have access to Claude models but has Gemini,
it might map the sonnet hint to `gemini-1.5-pro` based on similar capabilities.
## Error Handling
Clients **SHOULD** return errors for common failure cases:
Example error:
```json
{
"jsonrpc": "2.0",
"id": 1,
"error": {
"code": -1,
"message": "User rejected sampling request"
}
}
```
## Security Considerations
1. Clients **SHOULD** implement user approval controls
2. Both parties **SHOULD** validate message content
3. Clients **SHOULD** respect model preference hints
4. Clients **SHOULD** implement rate limiting
5. Both parties **MUST** handle sensitive data appropriately
---
File: /docs/specification/2024-11-05/server/utilities/_index.md
---
---
title: Utilities
---
{{< callout type="info" >}} **Protocol Revision**: 2024-11-05 {{< /callout >}}
These optional features can be used to enhance server functionality.
{{< cards >}} {{< card link="completion" title="Completion" icon="at-symbol" >}}
{{< card link="logging" title="Logging" icon="terminal" >}}
{{< card link="pagination" title="Pagination" icon="collection" >}} {{< /cards >}}
---
File: /docs/specification/2024-11-05/server/utilities/completion.md
---
---
title: Completion
---
{{< callout type="info" >}} **Protocol Revision**: 2024-11-05 {{< /callout >}}
The Model Context Protocol (MCP) provides a standardized way for servers to offer
argument autocompletion suggestions for prompts and resource URIs. This enables rich,
IDE-like experiences where users receive contextual suggestions while entering argument
values.
## User Interaction Model
Completion in MCP is designed to support interactive user experiences similar to IDE code
completion.
For example, applications may show completion suggestions in a dropdown or popup menu as
users type, with the ability to filter and select from available options.
However, implementations are free to expose completion through any interface pattern that
suits their needs&mdash;the protocol itself does not mandate any specific user
interaction model.
## Protocol Messages
### Requesting Completions
To get completion suggestions, clients send a `completion/complete` request specifying
what is being completed through a reference type:
**Request:**
```json
{
"jsonrpc": "2.0",
"id": 1,
"method": "completion/complete",
"params": {
"ref": {
"type": "ref/prompt",
"name": "code_review"
},
"argument": {
"name": "language",
"value": "py"
}
}
}
```
**Response:**
```json
{
"jsonrpc": "2.0",
"id": 1,
"result": {
"completion": {
"values": ["python", "pytorch", "pyside"],
"total": 10,
"hasMore": true
}
}
}
```
### Reference Types
The protocol supports two types of completion references:
| Type | Description | Example |
| -------------- | --------------------------- | --------------------------------------------------- |
| `ref/prompt` | References a prompt by name | `{"type": "ref/prompt", "name": "code_review"}` |
| `ref/resource` | References a resource URI | `{"type": "ref/resource", "uri": "file:///{path}"}` |
### Completion Results
Servers return an array of completion values ranked by relevance, with:
- Maximum 100 items per response
- Optional total number of available matches
- Boolean indicating if additional results exist
## Message Flow
```mermaid
sequenceDiagram
participant Client
participant Server
Note over Client: User types argument
Client->>Server: completion/complete
Server-->>Client: Completion suggestions
Note over Client: User continues typing
Client->>Server: completion/complete
Server-->>Client: Refined suggestions
```
## Data Types
### CompleteRequest
- `ref`: A `PromptReference` or `ResourceReference`
- `argument`: Object containing:
- `name`: Argument name
- `value`: Current value
### CompleteResult
- `completion`: Object containing:
- `values`: Array of suggestions (max 100)
- `total`: Optional total matches
- `hasMore`: Additional results flag
## Implementation Considerations
1. Servers **SHOULD**:
- Return suggestions sorted by relevance
- Implement fuzzy matching where appropriate
- Rate limit completion requests
- Validate all inputs
2. Clients **SHOULD**:
- Debounce rapid completion requests
- Cache completion results where appropriate
- Handle missing or partial results gracefully
## Security
Implementations **MUST**:
- Validate all completion inputs
- Implement appropriate rate limiting
- Control access to sensitive suggestions
- Prevent completion-based information disclosure
---
File: /docs/specification/2024-11-05/server/utilities/logging.md
---
---
title: Logging
---
{{< callout type="info" >}} **Protocol Revision**: 2024-11-05 {{< /callout >}}
The Model Context Protocol (MCP) provides a standardized way for servers to send
structured log messages to clients. Clients can control logging verbosity by setting
minimum log levels, with servers sending notifications containing severity levels,
optional logger names, and arbitrary JSON-serializable data.
## User Interaction Model
Implementations are free to expose logging through any interface pattern that suits their
needs&mdash;the protocol itself does not mandate any specific user interaction model.
## Capabilities
Servers that emit log message notifications **MUST** declare the `logging` capability:
```json
{
"capabilities": {
"logging": {}
}
}
```
## Log Levels
The protocol follows the standard syslog severity levels specified in
[RFC 5424](https://datatracker.ietf.org/doc/html/rfc5424#section-6.2.1):
| Level | Description | Example Use Case |
| --------- | -------------------------------- | -------------------------- |
| debug | Detailed debugging information | Function entry/exit points |
| info | General informational messages | Operation progress updates |
| notice | Normal but significant events | Configuration changes |
| warning | Warning conditions | Deprecated feature usage |
| error | Error conditions | Operation failures |
| critical | Critical conditions | System component failures |
| alert | Action must be taken immediately | Data corruption detected |
| emergency | System is unusable | Complete system failure |
## Protocol Messages
### Setting Log Level
To configure the minimum log level, clients **MAY** send a `logging/setLevel` request:
**Request:**
```json
{
"jsonrpc": "2.0",
"id": 1,
"method": "logging/setLevel",
"params": {
"level": "info"
}
}
```
### Log Message Notifications
Servers send log messages using `notifications/message` notifications:
```json
{
"jsonrpc": "2.0",
"method": "notifications/message",
"params": {
"level": "error",
"logger": "database",
"data": {
"error": "Connection failed",
"details": {
"host": "localhost",
"port": 5432
}
}
}
}
```
## Message Flow
```mermaid
sequenceDiagram
participant Client
participant Server
Note over Client,Server: Configure Logging
Client->>Server: logging/setLevel (info)
Server-->>Client: Empty Result
Note over Client,Server: Server Activity
Server--)Client: notifications/message (info)
Server--)Client: notifications/message (warning)
Server--)Client: notifications/message (error)
Note over Client,Server: Level Change
Client->>Server: logging/setLevel (error)
Server-->>Client: Empty Result
Note over Server: Only sends error level<br/>and above
```
## Error Handling
Servers **SHOULD** return standard JSON-RPC errors for common failure cases:
- Invalid log level: `-32602` (Invalid params)
- Configuration errors: `-32603` (Internal error)
## Implementation Considerations
1. Servers **SHOULD**:
- Rate limit log messages
- Include relevant context in data field
- Use consistent logger names
- Remove sensitive information
2. Clients **MAY**:
- Present log messages in the UI
- Implement log filtering/search
- Display severity visually
- Persist log messages
## Security
1. Log messages **MUST NOT** contain:
- Credentials or secrets
- Personal identifying information
- Internal system details that could aid attacks
2. Implementations **SHOULD**:
- Rate limit messages
- Validate all data fields
- Control log access
- Monitor for sensitive content
---
File: /docs/specification/2024-11-05/server/utilities/pagination.md
---
---
title: Pagination
---
{{< callout type="info" >}} **Protocol Revision**: 2024-11-05 {{< /callout >}}
The Model Context Protocol (MCP) supports paginating list operations that may return
large result sets. Pagination allows servers to yield results in smaller chunks rather
than all at once.
Pagination is especially important when connecting to external services over the
internet, but also useful for local integrations to avoid performance issues with large
data sets.
## Pagination Model
Pagination in MCP uses an opaque cursor-based approach, instead of numbered pages.
- The **cursor** is an opaque string token, representing a position in the result set
- **Page size** is determined by the server, and **MAY NOT** be fixed
## Response Format
Pagination starts when the server sends a **response** that includes:
- The current page of results
- An optional `nextCursor` field if more results exist
```json
{
"jsonrpc": "2.0",
"id": "123",
"result": {
"resources": [...],
"nextCursor": "eyJwYWdlIjogM30="
}
}
```
## Request Format
After receiving a cursor, the client can _continue_ paginating by issuing a request
including that cursor:
```json
{
"jsonrpc": "2.0",
"method": "resources/list",
"params": {
"cursor": "eyJwYWdlIjogMn0="
}
}
```
## Pagination Flow
```mermaid
sequenceDiagram
participant Client
participant Server
Client->>Server: List Request (no cursor)
loop Pagination Loop
Server-->>Client: Page of results + nextCursor
Client->>Server: List Request (with cursor)
end
```
## Operations Supporting Pagination
The following MCP operations support pagination:
- `resources/list` - List available resources
- `resources/templates/list` - List resource templates
- `prompts/list` - List available prompts
- `tools/list` - List available tools
## Implementation Guidelines
1. Servers **SHOULD**:
- Provide stable cursors
- Handle invalid cursors gracefully
2. Clients **SHOULD**:
- Treat a missing `nextCursor` as the end of results
- Support both paginated and non-paginated flows
3. Clients **MUST** treat cursors as opaque tokens:
- Don't make assumptions about cursor format
- Don't attempt to parse or modify cursors
- Don't persist cursors across sessions
## Error Handling
Invalid cursors **SHOULD** result in an error with code -32602 (Invalid params).
---
File: /docs/specification/2024-11-05/server/_index.md
---
---
title: Server Features
cascade:
type: docs
weight: 3
---
{{< callout type="info" >}} **Protocol Revision**: 2024-11-05 {{< /callout >}}
Servers provide the fundamental building blocks for adding context to language models via
MCP. These primitives enable rich interactions between clients, servers, and language
models:
- **Prompts**: Pre-defined templates or instructions that guide language model
interactions
- **Resources**: Structured data or content that provides additional context to the model
- **Tools**: Executable functions that allow models to perform actions or retrieve
information
Each primitive can be summarized in the following control hierarchy:
| Primitive | Control | Description | Example |
| --------- | ---------------------- | -------------------------------------------------- | ------------------------------- |
| Prompts | User-controlled | Interactive templates invoked by user choice | Slash commands, menu options |
| Resources | Application-controlled | Contextual data attached and managed by the client | File contents, git history |
| Tools | Model-controlled | Functions exposed to the LLM to take actions | API POST requests, file writing |
Explore these key primitives in more detail below:
{{< cards >}} {{< card link="prompts" title="Prompts" icon="chat-alt-2" >}}
{{< card link="resources" title="Resources" icon="document" >}}
{{< card link="tools" title="Tools" icon="adjustments" >}} {{< /cards >}}
---
File: /docs/specification/2024-11-05/server/prompts.md
---
---
title: Prompts
weight: 10
---
{{< callout type="info" >}} **Protocol Revision**: 2024-11-05 {{< /callout >}}
The Model Context Protocol (MCP) provides a standardized way for servers to expose prompt
templates to clients. Prompts allow servers to provide structured messages and
instructions for interacting with language models. Clients can discover available
prompts, retrieve their contents, and provide arguments to customize them.
## User Interaction Model
Prompts are designed to be **user-controlled**, meaning they are exposed from servers to
clients with the intention of the user being able to explicitly select them for use.
Typically, prompts would be triggered through user-initiated commands in the user
interface, which allows users to naturally discover and invoke available prompts.
For example, as slash commands:
![Example of prompt exposed as slash command](slash-command.png)
However, implementors are free to expose prompts through any interface pattern that suits
their needs&mdash;the protocol itself does not mandate any specific user interaction
model.
## Capabilities
Servers that support prompts **MUST** declare the `prompts` capability during
[initialization]({{< ref "/specification/2024-11-05/basic/lifecycle#initialization" >}}):
```json
{
"capabilities": {
"prompts": {
"listChanged": true
}
}
}
```
`listChanged` indicates whether the server will emit notifications when the list of
available prompts changes.
## Protocol Messages
### Listing Prompts
To retrieve available prompts, clients send a `prompts/list` request. This operation
supports
[pagination]({{< ref "/specification/2024-11-05/server/utilities/pagination" >}}).
**Request:**
```json
{
"jsonrpc": "2.0",
"id": 1,
"method": "prompts/list",
"params": {
"cursor": "optional-cursor-value"
}
}
```
**Response:**
```json
{
"jsonrpc": "2.0",
"id": 1,
"result": {
"prompts": [
{
"name": "code_review",
"description": "Asks the LLM to analyze code quality and suggest improvements",
"arguments": [
{
"name": "code",
"description": "The code to review",
"required": true
}
]
}
],
"nextCursor": "next-page-cursor"
}
}
```
### Getting a Prompt
To retrieve a specific prompt, clients send a `prompts/get` request. Arguments may be
auto-completed through [the completion
API]({{< ref "/specification/2024-11-05/server/utilities/completion" >}}).
**Request:**
```json
{
"jsonrpc": "2.0",
"id": 2,
"method": "prompts/get",
"params": {
"name": "code_review",
"arguments": {
"code": "def hello():\n print('world')"
}
}
}
```
**Response:**
```json
{
"jsonrpc": "2.0",
"id": 2,
"result": {
"description": "Code review prompt",
"messages": [
{
"role": "user",
"content": {
"type": "text",
"text": "Please review this Python code:\ndef hello():\n print('world')"
}
}
]
}
}
```
### List Changed Notification
When the list of available prompts changes, servers that declared the `listChanged`
capability **SHOULD** send a notification:
```json
{
"jsonrpc": "2.0",
"method": "notifications/prompts/list_changed"
}
```
## Message Flow
```mermaid
sequenceDiagram
participant Client
participant Server
Note over Client,Server: Discovery
Client->>Server: prompts/list
Server-->>Client: List of prompts
Note over Client,Server: Usage
Client->>Server: prompts/get
Server-->>Client: Prompt content
opt listChanged
Note over Client,Server: Changes
Server--)Client: prompts/list_changed
Client->>Server: prompts/list
Server-->>Client: Updated prompts
end
```
## Data Types
### Prompt
A prompt definition includes:
- `name`: Unique identifier for the prompt
- `description`: Optional human-readable description
- `arguments`: Optional list of arguments for customization
### PromptMessage
Messages in a prompt can contain:
- `role`: Either "user" or "assistant" to indicate the speaker
- `content`: One of the following content types:
#### Text Content
Text content represents plain text messages:
```json
{
"type": "text",
"text": "The text content of the message"
}
```
This is the most common content type used for natural language interactions.
#### Image Content
Image content allows including visual information in messages:
```json
{
"type": "image",
"data": "base64-encoded-image-data",
"mimeType": "image/png"
}
```
The image data **MUST** be base64-encoded and include a valid MIME type. This enables
multi-modal interactions where visual context is important.
#### Embedded Resources
Embedded resources allow referencing server-side resources directly in messages:
```json
{
"type": "resource",
"resource": {
"uri": "resource://example",
"mimeType": "text/plain",
"text": "Resource content"
}
}
```
Resources can contain either text or binary (blob) data and **MUST** include:
- A valid resource URI
- The appropriate MIME type
- Either text content or base64-encoded blob data
Embedded resources enable prompts to seamlessly incorporate server-managed content like
documentation, code samples, or other reference materials directly into the conversation
flow.
## Error Handling
Servers **SHOULD** return standard JSON-RPC errors for common failure cases:
- Invalid prompt name: `-32602` (Invalid params)
- Missing required arguments: `-32602` (Invalid params)
- Internal errors: `-32603` (Internal error)
## Implementation Considerations
1. Servers **SHOULD** validate prompt arguments before processing
2. Clients **SHOULD** handle pagination for large prompt lists
3. Both parties **SHOULD** respect capability negotiation
## Security
Implementations **MUST** carefully validate all prompt inputs and outputs to prevent
injection attacks or unauthorized access to resources.
---
File: /docs/specification/2024-11-05/server/resource-picker.png
---
<EFBFBD>PNG

IHDR<00><00><00>Ķ`iCCPICC Profile(<28>u<EFBFBD>;HA<10><>h$D<><44>H!Q<>*<2A><><EFBFBD>rF,<14> XQ<><16>K<EFBFBD><08>d<EFBFBD>w<EFBFBD><77><EFBFBD><EFBFBD><EFBFBD><EFBFBD>6bci<63><69>B҉<42><D289>"<08><16>B4<><34><EFBFBD>z<EFBFBD><7A><0E><><EFBFBD><EFBFBD><EFBFBD>0 <0C><15>3<><00>%<25>g<EFBFBD> ium]<5D>!
?šn<C29A><6E><EFBFBD>.P <09><><EFBFBD><EFBFBD><1F>z7&fͤcR<63>rp68$o<><6F>?<3F><><EFBFBD><EFBFBD>x<EFBFBD><78><EFBFBD><EFBFBD><EFBFBD>~P<>t<EFBFBD>m<EFBFBD><6D><10>;6|H<1C><14>`<60><><17><>-<2D>5k<35>2I<32>{<7B>^<5E>r<EFBFBD><72>đl<C491>o<EFBFBD>q<EFBFBD><71>ֿv<10><07><>E<EFBFBD>0<EFBFBD>0R<30>ä<EFBFBD><10>
<EFBFBD>P ӟ"<22>?}J<>/<2F>2<18><><EFBFBD><05><> <09>¤<EFBFBD><12>Q<EFBFBD><51>qD<71>eLR*<2A>޿<EFBFBD><DEBF>zG<7A><47><EFBFBD><14><><EFBFBD>%P<><07>׮7z \7L<><4C><EFBFBD>u=u<><75><19>[<1C>@ϛ㼎<00>K<EFBFBD><4B><1D><><EFBFBD>q<1A>@<40>#P<>|.La<4C>vY'beXIfMM*<00>i&<03><>P<><00><><00>ASCIIScreenshot9UD=iTXtXML:com.adobe.xmp<x:xmpmeta xmlns:x="adobe:ns:meta/" x:xmptk="XMP Core 6.0.0">
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about=""
xmlns:exif="http://ns.adobe.com/exif/1.0/"
xmlns:tiff="http://ns.adobe.com/tiff/1.0/">
<exif:PixelYDimension>181</exif:PixelYDimension>
<exif:UserComment>Screenshot</exif:UserComment>
<exif:PixelXDimension>174</exif:PixelXDimension>
<tiff:Orientation>1</tiff:Orientation>
</rdf:Description>
</rdf:RDF>
</x:xmpmeta>
oP<EFBFBD>=3HIDATx<01>}<07>ՑnMM<>fA(<28>0BFH"<22>dl<64><6C><EFBFBD><EFBFBD>omd<6D><64><EFBFBD>9<EFBFBD>. <20>k<1C>g>{<7B>k<EFBFBD>
<0E>Ȁ<><C880><EFBFBD><EFBFBD><06><><EFBFBD>m<EFBFBD>EAH<><48>r<EFBFBD>H3<48>h<EFBFBD>h<EFBFBD><68><EFBFBD><EFBFBD><EFBFBD>ܾ}c<><63><EFBFBD>#<23><><EFBFBD>Vש:u<>ԩS]}<7D>oߢ<6F><DFA2>S<EFBFBD>Q<EFBFBD>r<EFBFBD>X<EFBFBD>e<EFBFBD><65>1<EFBFBD><31>ޑ<EFBFBD>ED<45>,<2C>_ <0B>RQ<11><00><><14>W<EFBFBD>Hzd<7A>L,P,N+<01>?2<><32><EFBFBD><EFBFBD>x" <0B><><02>i%<25>f
<EFBFBD><EFBFBD>P<EFBFBD>^]]M<><4D><EFBFBD>
<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>B<EFBFBD>w<EFBFBD>*%+<><1B>f<0E>L<EFBFBD><13> w<><77>i:]}<7D>Uq<02>oXO<58>><3E>;<3B><><EFBFBD>[iz<69>4<EFBFBD><34><EFBFBD>w<><77>C@<40><>;<3B><>.<2E>[<5B>>k<><6B><EFBFBD><EFBFBD><EFBFBD>O<EFBFBD><4F><EFBFBD>h<EFBFBD><68>IT\TL}<7D>i<EFBFBD>կ~<7E> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>6嗿<36>5=<3D><>v9眳隫<E79CB3><E99AAB>;v<><76>I<13><>7<EFBFBD><37>-<2D><><EFBFBD><EFBFBD>6۠cA<63><41><EFBFBD>
Z<EFBFBD>N<EFBFBD><EFBFBD><EFBFBD>k<EFBFBD><EFBFBD><EFBFBD>E<1E><><12>
<EFBFBD>暫h<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>~''<27><>UW<55>O<EFBFBD>s<EFBFBD>R<EFBFBD>-i<>%<25><><EFBFBD>!<21><><EFBFBD>XW\~-<2D>Ń<EFBFBD><EFBFBD>~<7E><>w<EFBFBD><77><EFBFBD><1D><>|9mݶ=<3D><>1c<31>ҋ/<2F>H+V<><56><EFBFBD><EFBFBD>ڽ<EFBFBD>=<3D><>ȑ#<23>c[L_<4C><5F><EFBFBD><EFBFBD><EFBFBD><EFBFBD>>!<16><><EFBFBD>]K睷<4B> w̘1<CC98><31>֛<EFBFBD>/~<7E><>=<1A><>@!<21>n<EFBFBD><6E>Ϊ<>*8<>)=D<><44>pЛn<D09B><6E>+<15>N#z<>
"<<3C>z.<05>.<0F><>Wn<57>5k<35>ҵ<<3C>C<EFBFBD><0F>uz0n<30>XZ<58><5A>
zs<EFBFBD><1A>J<EFBFBD><4A>G<EFBFBD><47>]D]]<5D>B<EFBFBD>|,<2C> <16><><EFBFBD><EFBFBD>r
}<7D><03>R<13>?<3F><18><><EFBFBD>N+J<>+.<2E><><16>K<EFBFBD><4B><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>4o<34>\ڶm<07><><EFBFBD>;w<77><06><>=W<><57>w<EFBFBD>Fw<46><77>}<7D><><EFBFBD>o<EFBFBD>)<29>N<EFBFBD><4E>o<EFBFBD>I<<3C><10><>%<25>L<EFBFBD>:E<><45><EFBFBD>H;/<2F><07><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><16><><EFBFBD><EFBFBD>/|<7C><><EFBFBD><EFBFBD><EFBFBD><1F>8p<38><70>m JF<4A>l<EFBFBD>9.<2E>ٹnΚ(^SSM<53><4D><EFBFBD><EFBFBD><EFBFBD>d<EFBFBD>-r<>WG<57><47><EFBFBD><EFBFBD><EFBFBD><EFBFBD>b֑<16>D<EFBFBD>_<EFBFBD><5F>ujDeԟw޹<12>U<06><>A<EFBFBD>m`<60><17><>ӧ<EFBFBD> /<2F><><EFBFBD>x<EFBFBD>v[<5B><><EFBFBD>aÆ<61><C386><EFBFBD>_K<5F><4B><EFBFBD><13>y<EFBFBD><04>s<EFBFBD>Cs<43>̦q<CCA6><71>q<EFBFBD><71><EFBFBD>z0<7A><30><EFBFBD><EFBFBD><EFBFBD>.<2E><><02><>|{<7B><>}<7D><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> /<2F>8Ϗ|/=<3D><><1F><><EFBFBD><EFBFBD>><3E><>O<EFBFBD>m<EFBFBD>1<EFBFBD>A<><7F>4o<34><q<>W^y<><79>{<7B>o4<6F><34>VUEXTp<54>9s<39><73><EFBFBD>ɓ%y<><79><EFBFBD>i5/<2F>k<EFBFBD><6B><EFBFBD><EFBFBD><10>hϞ<68>4f<34>h<EFBFBD><68><EFBFBD><1B><>{~(i<><69><EFBFBD><EFBFBD>yA\<5C><><EFBFBD><EFBFBD><EFBFBD>`>n<><6E>K<EFBFBD><4B>3<EFBFBD>R'<27>;ХX<D0A5>)<04><>c<EFBFBD><63>xH"ڦ+<2B>~|pz8
"3rT<14>!<21><>O<EFBFBD><4F>)?<3F><><EFBFBD><EFBFBD>Z<EFBFBD><5A><EFBFBD>A<EFBFBD>~<7E>C <0B><><EFBFBD>|<7C>
G<EFBFBD><EFBFBD><EFBFBD>4<><34><EFBFBD><EFBFBD>O[<10>DWg-<2D>?<3F>><3E><>%t<><74><EFBFBD>"Q<>bagjg<6A><67>G<>*<2A><>K_<4B><5F><EFBFBD>8<EFBFBD> <0C><>}ｒ<>x<EFBFBD>
ڷo<EFBFBD><EFBFBD>!Ү]<5D>V<EFBFBD>#<23><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>}<7D><>~{mٲ<6D>^}M<>6U<36>Q<>Z<EFBFBD><16><><EFBFBD><EFBFBD>#nٺ<6E><D9BA>0<EFBFBD>y<EFBFBD>fB<66>EyGd8<<3C><12><>_<> N<>h- |̜ٔ<CC9C><D994><EFBFBD> &<26>eBH<42><48><EFBFBD>M%W`ĆJ <07><>d#
<0E>~<7E><06>BM/<2F> t<>u<>c<EFBFBD><01>h<><1D><>N<15>o_ <0C><>:<3A>`<60><><EFBFBD>Q>]#<23><><EFBFBD><EFBFBD>K<EFBFBD><13><><EFBFBD><EFBFBD>-{<7B><><EFBFBD>ɷ<EFBFBD><C9B7><EFBFBD>/<10><><EFBFBD>.ਸ<><E0A8B8>.<2E><><EFBFBD><EFBFBD><7F>f<EFBFBD><66>ߡ/<>k4<6B><34>s<EFBFBD><73>.<2E><>|<7C><><EFBFBD><EFBFBD>>"<22>|<7C><>I<EFBFBD>"<22><19><>ΦM<CEA6>h<EFBFBD>"<22>*<><EEB8BB>JKJ<4B><4A>HwO<0F>fc<>ĉt<C489>I'<27>%l<><6C>Ŵu<C5B4>6<EFBFBD>%<25>}<7D><><EFBFBD>qMP<4D><50>9Xja师<61>,<2C>7ǵ<37><C7B5>T<EFBFBD><1D><><EFBFBD><11><><EFBFBD>:/<2F>׭[*<2A><>Q4Sm<53><6D>p|<7C><>9<EFBFBD><39>D?ɑc<C991><63>䰛<EFBFBD>wtt<74>i<EFBFBD><69>~<7E><><EFBFBD>i,粋<16><><EFBFBD><EFBFBD><00><><05>bp¦3<>Z<EFBFBD><5A>#䊽<><E48ABD><EFBFBD>^|<7C>%z<><7A><EFBFBD><EFBFBD><1C>q<EFBFBD>x<EFBFBD>ɿP
絼-<11>Q<><51>?<3F> <0B>ښZz<5A>h<EFBFBD><13><><EFBFBD><EFBFBD>>v<><76><EFBFBD>ڵ<EFBFBD>Q<>v^uZЂwWsXd<58><64>s<EFBFBD> <20>%<25><>%+<2B><>~FBJ<>
N<EFBFBD>M<EFBFBD>#k<>v<EFBFBD><07><1A>3<EFBFBD>ſ<EFBFBD><C5BF>/<2F><>n<EFBFBD><6E>tE<74>)w<><77>E<EFBFBD><45>+n\<5C><EFBFBD>?<3F><>*++]<5D>]<5D>v'<27><15>r<EFBFBD>g<EFBFBD>R<03><><EFBFBD>ߖS _<18><>WH<57>0~<7E>I<EFBFBD> 446<34><36><1D><><EFBFBD> 4<>i<EFBFBD><69>/<2F><12>ظ<EFBFBD>˦<EFBFBD>A]<5D>a9-<2D><><EFBFBD><08>l <20><>,<2C>=F<><46>g<EFBFBD>u
^8N<>p<EFBFBD>d<EFBFBD>#"2<><32><05><07>ԡ<EFBFBD>tੜ<13>6]<5D><>.*<2A><><EFBFBD>I<EFBFBD>N<EFBFBD>Yg<59><67>N*Ҁ3N<33>h<EFBFBD> <0B>;<3B><>u<EFBFBD>2<EFBFBD>Tj<54>s\<5C>O<EFBFBD>۽8mF<13>ZerRGOw7<77><37><EFBFBD><EFBFBD>d<EFBFBD>@<40>fϞ<66>g<>9<EFBFBD>=§<><C2A7>謳Β (б<10>><3E>,<2C>ӓO
;<3B><>Q<EFBFBD><51><EFBFBD>b<1C>t<EFBFBD>x<>'j<><6A><EFBFBD> <0C><>q:<3A><><EFBFBD><EFBFBD>i<EFBFBD><69>y<04>mh<18>oWK<57><4B><EFBFBD>2<EFBFBD>~<7E>@<40>7UQ<55> i<>wW<77>DZ<44><5A><12><08><>]<5D><18><><EFBFBD> mW<02>pP@<40><><EFBFBD>-<2D>ַ<EFBFBD>{<7B>q<EFBFBD>%<25>б"Z<><5A> <0B><><EFBFBD><EFBFBD><<3C><><EFBFBD>s<EFBFBD>%<25>!<13><11><>U<EFBFBD>ptе<74>қ<EFBFBD>7<EFBFBD><37>Q<EFBFBD>r
>w<><02>W<><57><17><><EFBFBD>|<7C><>v~9..~&L<>@<40><>=<3D><><EFBFBD>k<EFBFBD><6B><EFBFBD>/<2F>V<EFBFBD><56>|>u<>:<3A><><EFBFBD><EFBFBD><EFBFBD>g-_P<5F><50><11><><EFBFBD><EFBFBD>r<>f<EFBFBD>F<EFBFBD>pn<70><6E><EFBFBD><EFBFBD>0o<30>!ո<><D5B8>2i<32>Dzoo<6F><6F><EFBFBD>H
<EFBFBD>td7<EFBFBD><EFBFBD><EFBFBD><EFBFBD>><3E><>X<EFBFBD>҅.<2E>?><3E>ȯ<EFBFBD><C8AF><EFBFBD>?B<>G<EFBFBD>f<EFBFBD>C6l<14><><EFBFBD>z/<2F>u<EFBFBD>8y<0F><><EFBFBD><EFBFBD>@<40>nlh<6C><68><EFBFBD>p.<2E><>R:<3A>Ljvm<76>?Ҙ<><D298>r<EFBFBD><72>wH<77>{<7B><<3C>S<EFBFBD><53>g<EFBFBD><67>}<7D>f<EFBFBD>~8+\v<><76>4m<34>T<EFBFBD><54><EFBFBD><EFBFBD><EFBFBD>ڪ<EFBFBD><DAAA><EFBFBD><EFBFBD><EFBFBD>PGGx<47>EMM<4D>tl'MM<>%<25><><EFBFBD>apX<70><58>ξ!<01>Ӣw<D3A2><10><><EFBFBD>| <09>t<EFBFBD>S<EFBFBD><53>#<23><><EFBFBD>M<EFBFBD>L<EFBFBD><4C>c<EFBFBD><63><EFBFBD><EFBFBD>U<EFBFBD><55>m<EFBFBD><6D><EFBFBD>(<28>U:<1C><15><>QT "[]<1D><I<><49>><3E><02><>$nAba<62>p ik<69><6B>,<2C>ZQQɻ <0B>O<04><>#G<><47><14><>N<EFBFBD><4E><EFBFBD><EFBFBD>o]m$]`<60><><EFBFBD><EFBFBD><EFBFBD>F<EFBFBD>*<2A><> Y<>}V<><56><EFBFBD>q<><71><EFBFBD><EFBFBD><EFBFBD>W<>FL <0B>?<3F><>}6<><36>%<25>P<EFBFBD>L<><4C><EFBFBD># Y<><59>luN<75><1C><>o#<23>) <0B><>r<EFBFBD>`<60><><EFBFBD>?~<7E><>Q>R<>ĵ@B<><42><EFBFBD> <0B>r\l<>`<0F><>?
<EFBFBD>'<27><> <0C><>=9<><39><EFBFBD>FV<46>\<5C>;k<>@<40>Mf<4D>4r<34><72><EFBFBD><EFBFBD>W<03><><EFBFBD>N<><19><>틻s<>.<1A>`Z7<>8<EFBFBD><38>33<33>gqq 0*<2A><06><02>r<EFBFBD>Qn.<2E><><EFBFBD><0E><><EFBFBD>w0g,<2C>[,P<>h+NčǙǢ<17><>?<3F>x<EFBFBD>8<EFBFBD><38>i<EFBFBD>A<EFBFBD>i<EFBFBD>49.TK<54>};<3B>A<EFBFBD><41>r\<5C>YWo<57>9<EFBFBD><39><EFBFBD><13>츩s[?zo<7A>Q<EFBFBD>h<EFBFBD><68>/<2F>O8<4F>E. <0B><11><<3C><>O'<27><>DZ<44><5A><EFBFBD>c<17><>?ŏ<><C58F>ѷ<EFBFBD>Dh <0B>W#k6<6B>0?N<><4E>+g<>T<EFBFBD>@2<><32><EFBFBD><EFBFBD><EFBFBD>q<>r<EFBFBD>d<EFBFBD><64>&<26>=F<><46><EFBFBD>hKK<4B>\<5C><><01>D( d<><64><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><10>8<EFBFBD><38>}<7D><16>^?<3F><>*++<2B> <0B><><EFBFBD><EFBFBD><13><>b<EFBFBD>]<5D>@D^<5E><>o^<5E><>&m<><6D><EFBFBD>NpG<>σܧ<>D<EFBFBD><44>$<24><>Nj<>䆅<EFBFBD>_<>(<28><><03><>T<EFBFBD>[S<>~<7E><><04>e<>xy<78><79><EFBFBD><<3C>$yBY<42><59>y\<5C>7<EFBFBD><37>f!9D<39>p <0C>
<EFBFBD>e<EFBFBD><EFBFBD><EFBFBD>Z<EFBFBD>;W<><57><0F>>ŮC<19><>V0<56>
<EFBFBD><EFBFBD>D<08><02><>Y<EFBFBD><08><>]<5D><><EFBFBD><EFBFBD><EFBFBD>N<EFBFBD><4E>B CP<43>a됻l<EB90BB><6C><EFBFBD><EFBFBD>d#e";<3B><>S(9<><39>><3E>a<EFBFBD><61>d<EFBFBD><01><05><>`d<><64><EFBFBD> i<> 't<><74>i<>TtD\<5C><><EFBFBD><EFBFBD><EFBFBD>&<26>D8<44><38>g<0F><><EFBFBD><EFBFBD>Oz;X<><58><EFBFBD>,<2C>N<>Qm7!#<23><><EFBFBD><EFBFBD><EFBFBD>qZs!fG\G<><11><><13><>ZtE<16><>F0S X<><58>܄C"<22><><EFBFBD>A<EFBFBD><41>-<2D><><EFBFBD>;<3B><>,_<><5F>k~̫<>4
<EFBFBD><EFBFBD>Q<19>-Ǖ<18>Df$<24><>]L<>E<EFBFBD><45><EFBFBD><EFBFBD><00>Ԩ7%<16>7 <0B>Q<EFBFBD><51>⢠S<E2A2A0>uʥx&<ٴ<01><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>LxT<78><54><EFBFBD><EFBFBD>]n<>W̥zf<01>sjct<63><74>X<EFBFBD>$<24><18><1F><><EFBFBD><EFBFBD><EFBFBD>ǤaA<61>X<EFBFBD>x|<7C>Kn
6<EFBFBD>9r<EFBFBD>d/7<>>.{B'<27>r<13>?<1D><>t <09>֐|<7C>
0<EFBFBD><EFBFBD>.<2E>C Hqګ<18><>99'-^<5E>^e6ӂ<16>xTF&<f<><66><EFBFBD><EFBFBD>r<12><11><>MR<4D>,Ƥ2<C6A4><32>7<EFBFBD>><3E><>x<EFBFBD><78><EFBFBD>&<26>ѹ89>DyŅb><3E>
9<EFBFBD>IWk<EFBFBD>?<3F><><EFBFBD><EFBFBD>JJ<4A>0<EFBFBD>G<EFBFBD>L:<1E>f<>/ Q b<>R<EFBFBD><52><EFBFBD>M<EFBFBD>Dlؠ0<D8A0><30><EFBFBD>R<EFBFBD>&<26>h<EFBFBD><68><EFBFBD><EFBFBD>
<EFBFBD> <0B><>ܛ<EFBFBD><DC9B><EFBFBD>? <0B>h<><68>+'<1E> <11><><EFBFBD><EFBFBD><EFBFBD>[<5B><><13><19><>渐e<E6B890><65><EFBFBD>KPbA<62>JCnB<><42><EFBFBD><03>$<12><>J<1D>x,<2C><>a<EFBFBD>09.7:<06><><1C>L@<40><><EFBFBD><EFBFBD><12>E<15><><EFBFBD><06><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>< !+T<1A>!'<27> <0C><><04><>ar\g|<7C>8<EFBFBD>@6x<04>sS<73><53>9<EFBFBD>~<7E>|o<><6F>GWKh<4B>T<12>ɵ<EFBFBD>!#׾O<D7BE>vy<76>qu<71>`<60>xW<78>H<EFBFBD>.<2E>B<EFBFBD><17>,Y,:<3A>0d<30>Ԩ<EFBFBD> 0 }<2<><32>/<2F>H<EFBFBD>%<25><><EFBFBD>+2<7F>4a<34><61><EFBFBD><EFBFBD><02><><EFBFBD><EFBFBD><07>,z<><7A>JM CF<43>Nh<4E><68><EFBFBD><EFBFBD>L<EFBFBD><4C>q3<71><33><EFBFBD>"<22><1B><>3Xx<58> =<3D><><EFBFBD><EFBFBD>ͳ
<EFBFBD><EFBFBD> <0C>Gs7Vр<56><D180><EFBFBD><EFBFBD><EFBFBD><17><>!˲3-?E<><45>(=<3D><1C><>uţ<>d<EFBFBD>o<EFBFBD>9<EFBFBD><39><EFBFBD>B<EFBFBD> <20>8~<7E>e<15>
<EFBFBD><EFBFBD>Hן΍/<2F>ƺڼLJG}:<3A>dt<64><74><08><><02><><EFBFBD><EFBFBD>D<EFBFBD>\<5C><13>g<EFBFBD>Q<EFBFBD>-<2D>o<><6F><1D>g<EFBFBD>,Nׯ<4E>{n<>B8<10>Q$O::<3A>O<0E>8_<02>}W<>N<07><><EFBFBD>Ul<55><6C><EFBFBD>&<26><08>Qv<51><76>g<EFBFBD><67>__B<5F>^r)-<2D><19><><EFBFBD><19>/<2F>I<EFBFBD>C<>2<EFBFBD><32>3<EFBFBD>I<EFBFBD>GT<1F><02><>'<27><>B<EFBFBD>y<EFBFBD><79>;<3B>ivXr<58><72><EFBFBD>[L<><4C><EFBFBD>gM<67>E?˖-<2D><> <0C><0E><><EFBFBD>aGC<><02>?<3F><>A:<3A>p<EFBFBD><70>Œ<1E>z<EFBFBD> <17>ҥK%£%.<2E>uN^}<7D><>E<EFBFBD><45><05>}\<5C><><12>8t1<74><15><>|<7C>!<21><><EFBFBD>y<EFBFBD>v<>9s<39><73><EFBFBD>e<EFBFBD><65><EFBFBD>l<EFBFBD>Q7<51><0E><><EFBFBD>
<EFBFBD><EFBFBD><1B><><EFBFBD>]<5D><>2<EFBFBD><32><EFBFBD><EFBFBD>z<EFBFBD>QC<0F><>><3E><1C>
<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>{6\<5C>i"L9<4C><39><EFBFBD><EFBFBD>t4<74><34><EFBFBD><EFBFBD><1A>#<23><>촜<EFBFBD>"<22> <20>"ǽ<><C7BD><EFBFBD><03><07>9?)$C<>Cy<43><03>5 <0B><><EFBFBD><EFBFBD><EFBFBD>y5<79><35><EFBFBD>i莣<69>QOZp<5A><70><EFBFBD><EFBFBD>EZ8<5A>uѝ8-緈<><E7B788><EFBFBD>D<EFBFBD>0<EFBFBD>}X<>A<> <09><><EFBFBD>;<3B>b $H<><48><EFBFBD>z<EFBFBD><7A><<3C>}9<>;<3B><><EFBFBD>NΘ<4E><CE98><EFBFBD><EFBFBD>W<EFBFBD>5g<>ۑv<DB91>㴈<EFBFBD>ϝiﻟ<69>s<EFBFBD>k<EFBFBD>t<EFBFBD><74>'<07><1E><><EFBFBD>Y<17><>>S\<5C><03>q<EFBFBD>mm><3E>}9<>V{['G<>4߀0}<7D>-<2D>f<02>1<EFBFBD>Žr<00><>JN<4A>M8<><38>ϑv<CF91>w<EFBFBD>ҪU<D2AA><55>8#<23><>s<EFBFBD>tcJ<><4A>(<28><><EFBFBD><EFBFBD><EFBFBD>{qm<71><6D>K<EFBFBD><14><><EFBFBD>Ǚ<EFBFBD><C799><EFBFBD><EFBFBD>j<EFBFBD>#<23>#.Jl<4A>6(.aP<50>50 <20><><EFBFBD>V<EFBFBD> <20>E<1E><><EFBFBD>i<><69><EFBFBD>-<2D><><EFBFBD>q<EFBFBD><71><EFBFBD><EFBFBD>^c<><63><EFBFBD><EFBFBD>:"<22><>@<40>}\]&<26>dM<><4D>Vh<56><68><EFBFBD><EFBFBD><EFBFBD>\N0QW<51>Z<EFBFBD><5A>n<EFBFBD>]<5D>:i<><69> <0C>KgȱKظ-<2D>=<3D><><EFBFBD><10>z<EFBFBD><7A>m<EFBFBD>s`<60><>6v<36>W<EFBFBD><57><08>_<EFBFBD><5F><EFBFBD>Xe<58><65>Oև<4F><D687><EFBFBD>J&C<>Q<>9n<39>X<EFBFBD><58><10>w<>!;><3E>rziy<69><79><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>@<40>ȑ<EFBFBD><C891><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>P<EFBFBD>&G<Ž<>K<EFBFBD>+<2B><><EFBFBD><EFBFBD>S<18><1B><><EFBFBD>:<3A><>s<EFBFBD>﷿<EFBFBD>mN~<7E>]<1E><EFBFBD><7F><EFBFBD><EFBFBD><EFBFBD>6a<36><61><EFBFBD><EFBFBD>+^N <09><>AE<41>k/<2F>+<2B><><08><>EMM<4D>8F!L<><4C><EFBFBD>aMu5<1D>w<EFBFBD>Y<EFBFBD>& ҢHf<<3C>=<3D>%<25>z\B<><42>*<2A>n`r56<7F><36><EFBFBD>)Kw<ru\َ)<29><>>r<>f<EFBFBD><66><EFBFBD><EFBFBD>À5<C380>U<EFBFBD>;.ƅ"<22>.CI<1B>&<26><>"<22><>q<EFBFBD>YC<59><02><><EFBFBD>F<EFBFBD><46><EFBFBD>1TQ5<51><1D><>o<EFBFBD>:<3A><18><><.<2E><>.<2E>|a<>an8쓯<12>æTN-<2D>L<EFBFBD>{a0<61><30>V<EFBFBD><56><EFBFBD>ε<EFBFBD>p<>$ <0C>8<15>HQ<48><51><EFBFBD><EFBFBD>A<EFBFBD>ʲ<EFBFBD>Ök<C396><6B>~<7E><><08>o<EFBFBD><6F><EFBFBD>Ǖ <0C>گ<EFBFBD><1E>`S<>T|X<>0<EFBFBD><30>d<EFBFBD>ʬ+&><3E>*<2A>B<EFBFBD>[u4<75><13>gz <01><>ϱ<EFBFBD><CFB1>z<EFBFBD>y<EFBFBD> <0B>Q<EFBFBD><1D><>&N_[<5B>}̼<><CCBC>kZɳ<08>cP(<28>X<EFBFBD>L<EFBFBD>5<><35><EFBFBD>s<EFBFBD><73><<3C><> <0C>
<11><>u<02><06>W<EFBFBD>C<EFBFBD><04><>ぐk<E38190><6B><EFBFBD>8<EFBFBD><38>NNd
B_w<5F>8+<2B> q<><71>z+<2B><><EFBFBD>$<24>"*A,`<60>,<2C><><EFBFBD><<3C>͌.<2E><><EFBFBD>'Ӭ@<40><>N<EFBFBD><4E><EFBFBD>@<40>8<EFBFBD><38><EFBFBD><EFBFBD>]<07><>j:]D<><44><<3C>+<2B>mV<1C>(<28><>6<EFBFBD>(<28>x<EFBFBD><78><EFBFBD>f*W<>i_^\<5C>><19><>Q<EFBFBD>d}{r\g@<40>Z<EFBFBD>s<EFBFBD>4Pq/L<>K<EFBFBD><4B><EFBFBD>U <0B>A<>W"<1E><>ޚ0q<30>65<36><35>O<17>]ω3B|<7C>b1<62><31>H)1'1r
<EFBFBD>P<EFBFBD>x<EFBFBD><EFBFBD>*<2A><>Im<49><6D>%<25>X<><58><EFBFBD><EFBFBD><EFBFBD>jx<6A>i<EFBFBD>*<2A><>mk<6D><14>sf<1A>*U%w<><77>AP<41><50><EFBFBD><EFBFBD><EFBFBD>Ag-<2D>$<24>鎡<EFBFBD><E98EA1>;V>?<3F>J<EFBFBD><4A><00>Wl~<7E>m\<5C><01><><EFBFBD>ܯ<><DCAF><EFBFBD>۸걗8J&<<3C>3<EFBFBD><33><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ǔ<EFBFBD>7<><37>
c<EFBFBD>a<><61>.͘ ax6<>R<EFBFBD><52><><7F><EFBFBD>K<EFBFBD><4B><<3C><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>*<2A>p<EFBFBD>><3E><><EFBFBD>8<EFBFBD><38><EFBFBD>yp<1C><>t2<74><32>3<EFBFBD>#S<>X&<26><>v2i<32><69><00>
C<EFBFBD>IJL<EFBFBD><EFBFBD>1<EFBFBD>x)<29>x&|<7C><><EFBFBD>K<EFBFBD><4B><EFBFBD>,<2C><>
ۙV<DB99>q<EFBFBD><71><EFBFBD>v<EFBFBD>n.<07><>vC!X <20><>qӍ*vN<76><4E>l<><6C>VQm<51>Y@<40><>E|5<><35><EFBFBD> <20><19>z<EFBFBD><17><><EFBFBD><EFBFBD>G<EFBFBD><47>~<7E><><EFBFBD><EFBFBD><17><><EFBFBD><EFBFBD>Ǖ<EFBFBD>V<>+ɽ<>h<EFBFBD><68><08>K{ <0B><><EFBFBD>;U%b<><62>#<23>7<EFBFBD><37><EFBFBD><EFBFBD>j<EFBFBD>j<EFBFBD><6A>j<18>WTp<><70>G<EFBFBD>R?.<2E><><EFBFBD>Im<49><6D><08><><EFBFBD><EFBFBD><EFBFBD>3^n W<><57>n,<2C><>а<EFBFBD>g<1F>D\ <11>}C9#qx
<EFBFBD><EFBFBD>m<EFBFBD>
<EFBFBD>13<EFBFBD><EFBFBD><EFBFBD>@#F<>Soo<1F><>wRwO<07><><EFBFBD>rc"<<3C>[^VFUê<55><C3AA>!<21><><EFBFBD>Ct<43><74><EFBFBD><EFBFBD>Xf<58>ŗe <11><>Сk<D0A1>Пǭ<D09F><C7AD><EFBFBD><EFBFBD><EFBFBD>r;v4<76>tj<74>8<EFBFBD>:+<2B>5i<35><69>%<25>Ŵg<C5B4>>v|<11><><EFBFBD>@<40><>9<EFBFBD>ϒ5[N+<2B>+h<><68>qt<71><74><EFBFBD><EFBFBD><EFBFBD>a7¦3<C2A6><33><EFBFBD>i<><69><EFBFBD>,#<23>~#~<7E>z<EFBFBD><7A>K<EFBFBD><4B><EFBFBD>|<7C>ϡ<EFBFBD><CFA1> <20><15><>q<EFBFBD><71>8l<>KW\<5C><><EFBFBD><EFBFBD>c8<63>vw<76>1ۂ6h;v<>(G#[<><7F>Pk<50><6B><EFBFBD><<3C><><EFBFBD><EFBFBD>=L<><4C>S<19>Ú<EFBFBD><C39A><EFBFBD>Y<EFBFBD>u<15>A<EFBFBD>@<40>] <0C>8<EFBFBD><38><EFBFBD><EFBFBD>ќ<EFBFBD>V<EFBFBD><56>yG<79><47><EFBFBD><EFBFBD>Wr^!<21><><EFBFBD>m<EFBFBD>hcX<63>={<7B><><.b<><62>=<3D>5<EFBFBD><35><EFBFBD>-<2D><>ؾ}|<7C><15><>B<0E>ZZZ<5A>݆<EFBFBD>B<EFBFBD><42>myVA#n<><6E><EFBFBD>g>s<><73>"n<>
<EFBFBD><EFBFBD>j<EFBFBD><EFBFBD><EFBFBD>+<2B><>5<EFBFBD>^<5E>ڵ{/<2F>x<EFBFBD><78>8<EFBFBD><38>sΤ<73>ƍ<EFBFBD>G{"<22>s؉<73><D889>V<EFBFBD>m<EFBFBD><6D><EFBFBD>o<01>Yq<>d<EFBFBD><64>bv<>L<EFBFBD>*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>7<EFBFBD>C<EFBFBD>5"r<15><>
<EFBFBD><EFBFBD><EFBFBD>pڹg<EFBFBD><11>:/<2F>u+^]<5D>ӂd7bѢ<62><D1A2>m7<1F><>G<EFBFBD><47>Y@<40><><04><>S<EFBFBD><53>~p7<>ͣΟw^(z<><1C>QC<51><43>e<EFBFBD><65><EFBFBD>2<EFBFBD><32><EFBFBD><EFBFBD><EFBFBD> <0C>V(<28><10><><EFBFBD>(<28><>6<EFBFBD> 2<>Y<1D>uZ<75><5A><EFBFBD>[<5B><>o<EFBFBD><6F><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>,,<00><><EFBFBD><EFBFBD><EF9794><EFBFBD>gS1<53><31>=?<3F>ۑ`<60><11>g<EFBFBD>?z<>9n<39><6E><EFBFBD>,<01>#<23>j<EFBFBD>Vԍ<>i<><69>o <20><>%x<><78>'<27>D<EFBFBD><44><EFBFBD><EFBFBD>___o3<6F>ӿ<EFBFBD>|3N<33>t<EFBFBD>=<3D>g3p<33>X<EFBFBD>/<2F><>"<22><><EFBFBD>@<40><>s\^<5E><><EFBFBD>d1<64><31>H<EFBFBD><48><EFBFBD><13><1D><>8<EFBFBD>y<EFBFBD>9n
<EFBFBD><EFBFBD>-7<>_ޣ΋<DEA3><CE8B>n~<7E>Lw#<23><>y.<2E>ZQ<5A><51>h<EFBFBD><1C><><EFBFBD><EFBFBD>[<5B><><12><><EFBFBD><03><>Mu<>9<EFBFBD>y=l<><16>5bD<62><44> `8.<2E>G<EFBFBD>8/G^L(<28><><EFBFBD><EFBFBD><15>T<EFBFBD>n<EFBFBD><6E><EFBFBD>%<25><1A><><13>,<2C> 8h<>+<2B><>G<EFBFBD>9<EFBFBD><39><EFBFBD>t'<27>Mk;<3B><><1E>r^<<3C>0e<30><14>us<><00>֯x#<23>'<x<><78>o~M<><4D><EFBFBD>Bw#.<2E>Չ<EFBFBD><D589> <20><><19><>g"<22>F<EFBFBD><18><>k<EFBFBD><6B>:߈<>-/<2F><1E>N<EFBFBD>Ǡ%+g<>uN2RT<52><54><05>T<EFBFBD>n<16><><EFBFBD>8罛<38>#/<2F><><EFBFBD><EFBFBD>?6<>3x<33><78>J<><4A>q<EFBFBD>0<EFBFBD>jV<6A>F^ŽЗ<C5BD>M5<4D>*lE<1A><><EFBFBD>ڎ<EFBFBD><DA8E>Q
<EFBFBD><EFBFBD>w<EFBFBD>V<EFBFBD><EFBFBD>Ϋ<EFBFBD>
k<EFBFBD><EFBFBD><EFBFBD>/<2F><><EFBFBD><EFBFBD><X<>D<EFBFBD>[0ɒ6<C992>G^3ϩ<33>ߨ<16><07>^?I<>^<5E><01><>q<EFBFBD><71>B\N<><4E>+<2B>
<EFBFBD>g<1B><>#<23>j9x<39><78><EFBFBD>y?7`<60><>b<1F><>
T[[PR<50>< h<><68><EFBFBD><EFBFBD><EFBFBD>Y<EFBFBD><59><EFBFBD>u<EFBFBD>Mk<4D><6B><16><>9P<39><50> <09><><EFBFBD><EFBFBD>q|<7C><>}g<>6zyyi<79><69><EFBFBD><EFBFBD><EFBFBD>sR!]@X<>R:;;<3B>nWYi)<29><><EFBFBD><EFBFBD>n
%<25>O8-<2D><>x<EFBFBD>m_μQę<51>H<13><><EFBFBD><EFBFBD>apR<70><52><EFBFBD><EFBFBD><EFBFBD><05>wŊ<77><C58A><EFBFBD>Ͽi<CFBF><69>9<EFBFBD><39>|A<>Fq\,<01><1C><>ERWW<57><57><EFBFBD><18><><EFBFBD>Ћ<07><><EFBFBD>
<EFBFBD>TR\<5C><><EFBFBD><EFBFBD>i'L<<3C><><EFBFBD>۩<EFBFBD>~8K<38>JP d<><64>G<EFBFBD>w<EFBFBD><02>?<3F>O/<2F><><EFBFBD><EFBFBD>3<EFBFBD>Rͷw<CDB7>s<EFBFBD>%<25>"<22><><EFBFBD>b`<10><>y#9Ÿ<19>9<EFBFBD>Ñ2t<32><74><1A><><EFBFBD>i<EFBFBD><69><EFBFBD>W<1D>Ϛ5K<35>v„<76><C284><EFBFBD><EFBFBD>3<EFBFBD><05>q\3<><33><EFBFBD> <0B>G<>+^<5E><>Ἑο<E1BC99><CEBF><EFBFBD>?<3F><>Ï<EFBFBD><C38F>Tq<>p<<3C>x<EFBFBD><78>a<EFBFBD>ӏ9B<39><11><13><>(<28>f<14>x<EFBFBD> <0E><><>#<23>D<>V<EFBFBD><13>G<EFBFBD><47><EFBFBD><EFBFBD><EFBFBD>"/;<3B>D\xn<78><6E> _<><5F><EFBFBD>2ǎN<C78E>u¹8<C2B9>|<7C>F}<7D><><1C><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><10>DN<03>iV<>\<5C>>-<2D><><EFBFBD>{]<5D>ʧ<><CAA7>p<EFBFBD>=<3D>3je9<65><39>O<EFBFBD>Q<12><><EFBFBD><EFBFBD>><3E>Y<1C><><17>q<EFBFBD><71>q<EFBFBD>1<EFBFBD><31><EFBFBD>8<EFBFBD><38><EFBFBD>7<EFBFBD>G<EFBFBD><47><EFBFBD>n<03> y<>]wG͈A<07>Ü<EFBFBD>q<EFBFBD>W<EFBFBD>˼o<CBBC>m<EFBFBD><6D><EFBFBD><EFBFBD>C~<7E><>w<EFBFBD>SϿ8<CFBF>o;<3B>Jw<4A>qU9KYq<  OEW<45><57>PՊ<50><D58A>Z@<40>; <0B><>O<EFBFBD><4F>g<EFBFBD>g<EFBFBD><67>?<3F>#<23>\<5C><><EFBFBD>O{<7B>Ι<EFBFBD>n<EFBFBD><6E><EFBFBD>(Wz<57><7A>OJ7<4A>F<EFBFBD>C<EFBFBD>p<>Rޢ<52>ve/oSb{ <0C><>{#2pD\\<5C>`g<><67><17>W<1B>C<>q;4<>21<32><31>L‘<4C>-<2D>G<1A>JkuFu<46>
~! <18>j;<3B><> <20>-<2D><><05><><EFBFBD><EFBFBD>'<27>7<><37>6YN<59><4E>
M<EFBFBD><EFBFBD><EFBFBD><EFBFBD>v<EFBFBD>ce<EFBFBD><EFBFBD>4+(^hKHE<48><45><EFBFBD>ǀZN<08><><EFBFBD><EFBFBD>f<EFBFBD>h<EFBFBD>?D^L<>w<EFBFBD><15>t<EFBFBD><74><EFBFBD> <0B><<3C>`<60>d<EFBFBD><1D><>$#3<>iiV<69>i[<5B><><EFBFBD><EFBFBD><17><><EFBFBD><00>N
<EFBFBD>Q=<3D>s\<5C>=ֈ<><D688>;8(<28>F\㜈<><E39C88><14>P#<23><>^<5E>HW<48> ԕ<><D495><EFBFBD><EFBFBD><EFBFBD>.<2E>gu:<3A>G<EFBFBD>:<3A><>=V<>l<EFBFBD>;S<><<3C><><06>mV<6D> W<>k<EFBFBD>8 `<60>r<EFBFBD>S-<2D><><EFBFBD><7F><EFBFBD><EFBFBD>q<EFBFBD>Gܓ<>"<22><>+IO9<4F><39>j<EFBFBD>M d;ߙ<>;<3B><><EFBFBD><08>QqR<71>r<EFBFBD><72>ڊ<EFBFBD>"-w\<5C>EC<><02>6<EFBFBD>x<><78>r\<5C>l<EFBFBD><6C>IqI<71>%(>dg,R\,t<><74><EFBFBD>yTFw<><77><EFBFBD> <<3C><>!m<01>8<03><>\<5C>?<3F><>8<11><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>T<EFBFBD>69ᬤ<39>ur['<27><1A>H<EFBFBD>,<2C><>7<><37><EFBFBD><10><>x<EFBFBD>q<EFBFBD><71><EFBFBD>?I<><49>s\<5C>,.r5<72><35><18>k0 :<3A>Ee<45>Z<00>?<3F><><EFBFBD><EFBFBD><7F><EFBFBD>縺<EFBFBD><E7B8BA>F\'v<><76><EFBFBD><08>z<EFBFBD><7A><1B>=<3D><>;o'<27><><EFBFBD><EFBFBD>7<EFBFBD><37>&<26><>g<EFBFBD><67><EFBFBD>}s\^'<27>Z<EFBFBD>yaJ<61>Qu栴<75><<3C>e<EFBFBD><65><EFBFBD>- <0B>g;ߙ<>{r\d<><64>Eq/T.o=:EQ<45><51>9<EFBFBD><39><EFBFBD><EFBFBD>$<24><>:2MQ<19>jF3ah̛<><03>1<EFBFBD><0F>;<3B>*8ΠNaC5<11>c<EFBFBD>+<2B>GG<47>҃B<D283>B<EFBFBD>v<EFBFBD>p<EFBFBD><1A>m<EFBFBD><6D><EFBFBD>}b<><62><EFBFBD><EFBFBD>
<EFBFBD><15><><04>cSu<53>@ץ*ru:o<><6F><EFBFBD>;g~L<>S<EFBFBD><53><EFBFBD><EFBFBD>Z7<5A><37><EFBFBD>q<EFBFBD><71>C<EFBFBD><43>?<3F> <20>
<EFBFBD>Ÿ<19> <0C><>8<EFBFBD><00><><EFBFBD><EFBFBD>ן<EFBFBD><D79F>><3E>z<><7A>MCB_qԐ<71>+<2B><14>$<24><>4<EFBFBD>5<EFBFBD><35>x<EFBFBD><78><EFBFBD><EFBFBD>Q<EFBFBD><51>H<<3C><>K<EFBFBD>T&i<><69><EFBFBD>:<3A>B
<EFBFBD><05>;CV3<14><><EFBFBD><EFBFBD>F<EFBFBD><46><EFBFBD><EFBFBD><03><><EFBFBD><EFBFBD><EFBFBD>Z<EFBFBD><5A><EFBFBD>w>\<5C><==ր;u<1B>x<EFBFBD>\<5C><01><><EFBFBD><EFBFBD><EFBFBD>;<3B>QGW<47>w<EFBFBD>Zںiˮ6<CBAE><1A><>~<7E>jHv<>k<EFBFBD><6B>f<><66>w<1E>^<5E><>7-x<>Qgwu<><75><EFBFBD>|<<3C><1D>/<2F><><<3C><>Gڐ<47><DA90><EFBFBD>N<EFBFBD><4E><EFBFBD><EFBFBD><EFBFBD>H<EFBFBD>st<>S<EFBFBD>O<EFBFBD>q<EFBFBD><71>x4<><34><16><><EFBFBD>ϡ1<1E>ɐ.<2E><>Th<54><05><06><1C>Ap凾<70><E587BE><03><><EFBFBD>VӺ<56><D3BA>,<2C>e~<7E>E<EFBFBD><45>-9<>ڏ<EFBFBD><DA8F>?{<7B><>_<EFBFBD><5F><EFBFBD>'<27>V&<26>W.<2E>(8>^Y<>L?|x
:<3A>C#<23>W<EFBFBD><57>[ϣ)'<27>S[g}<7D>g<EFBFBD>ѳ<EFBFBD><D1B3>ފ<><12><><EFBFBD>x}𲩴|<7C><1E><><EFBFBD>^<5E><11>t<><74><11>|<7C><1E><>#W6<57><36>t<><EFBFBD><7F><EFBFBD><EFBFBD>^<1A>0<EFBFBD><30>e!<21>zR<1D><>v<EFBFBD>n<EFBFBD><6E>
ں<EFBFBD>|<7C><><EFBFBD><EFBFBD><EFBFBD>_<>D<1F>f<06>+<>1<EFBFBD><31>/_<>6Hޒ<48><DE92>{<7B>
<EFBFBD>w"<22><><EFBFBD>&ƚO<C69A>
q3<71><33>vfW<66>
& ]ze
<EFBFBD><EFBFBD><EFBFBD>ы<EFBFBD><16>x<EFBFBD>{<7B><><EFBFBD>}p<15><><EFBFBD><EFBFBD>.<2E>?<3F>>{<7B><1C>3}$;q <0B>^<><7F><EFBFBD><EFBFBD>ⴥ%<25><>`<1D>C<EFBFBD><43><EFBFBD><EFBFBD>k<EFBFBD>y<EFBFBD>aw4~i;ճ<03><>[<5B><><EFBFBD>?<3F>#z<><7A><EFBFBD><1B>g<EFBFBD>E<>`<60><>d<EFBFBD><64>?<3F>@^{<7B>Y<EFBFBD><10>H<EFBFBD><48><EFBFBD><03><><EFBFBD><EFBFBD><EFBFBD><><7F>><3E><><1A>+<2B>k1E<31><45>`'=<3D><>&^<5E>E<EFBFBD><45><1F>,N;w<>h<EFBFBD><68><EFBFBD><EFBFBD><EFBFBD>Vӽ<56>YK+<2B>5 }0짱<30>5<EFBFBD>d1<64><31>$:<3A><>W<>^<5E><><EFBFBD><08><><19>-<2D>+WQ<>O<1A>Ŋ<1E>`<60><>}<7D>)|ͦ<16>8<EFBFBD><38><EFBFBD><EFBFBD>h2<68>=sUU<55>ѿ<EFBFBD><D1BF><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>\<5C><><EFBFBD><EFBFBD><EFBFBD>5<EFBFBD><35>0Gֲ2^Q<>j<EFBFBD>\0<>><3E>x=<3D><>V<EFBFBD><56><EFBFBD>_<EFBFBD>g^<5E>E<EFBFBD><45><EFBFBD>l<EFBFBD><6C>Kۤ<4B><DBA4><EFBFBD>
ǟ<>Qs<51><73>fzb<7A>6<EFBFBD><36>qB<71><42>?x<><78>T_SF<53>-<2D><>8<EFBFBD> '<27>W<EFBFBD><57>l<EFBFBD><6C>߶q<DFB6>~<7E><>zu<7A><75><EFBFBD><1B><><EFBFBD><EFBFBD>zs<7A>A<EFBFBD><41>o<EFBFBD><<3C><>ӗôz<C3B4><01>=<3D>qP쇈<50>y 2<>0c<30><63><EFBFBD>r<EFBFBD><72>p<18>k(<28>JW<1A>e<0E>G<>։<EFBFBD><D689><EFBFBD><EFBFBD><EFBFBD>DUfvS<04>dߠ~/<2F>:<3A>z<EFBFBD>˞<EFBFBD><CB9E>f<>w<EFBFBD>_I;<3B>!D0<14><04><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><1A>4v>D<><44><EFBFBD><EFBFBD>NK<4E><4B><EFBFBD>]<5D>̜2\<5C>o<EFBFBD>d^ȇ<>v<EFBFBD><76>.7<EFBFBD>}<7D><><1D><><EFBFBD><EFBFBD>Ά<><CE86>4<EFBFBD>F<EFBFBD><46><EFBFBD><EFBFBD>`<60>O<><4F><EFBFBD>u<EFBFBD>4}B<>țz<C89B>y<EFBFBD>*ro<72><6F>?<3F>[IX<7F>U<EFBFBD><55>|<7C>i<EFBFBD>1亃e?<3F>C<EFBFBD><43><EFBFBD><EFBFBD><EFBFBD>U<EFBFBD>;^j<06>偮B<E581AE><42>K8+Ѷ<><D1B6>zM<7A>s <0C>6<EFBFBD><36><EFBFBD>_&9<>m<EFBFBD><6D><EFBFBD>'6<>)y<><79><EFBFBD><EFBFBD><EFBFBD><EFBFBD>b<EFBFBD><62>Z<EFBFBD>a?]:b<=<3D><>nj=<3D>-N=<07>x<EFBFBD>o_H5<48><35>W<EFBFBD>9<EFBFBD><39><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <0C><><EFBFBD>|ч 2<>|<7C><>&
<EFBFBD>oAt<11><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>N|<7C>D<EFBFBD>︄&<26><><EFBFBD>/<2F><>胋<EFBFBD><E8838B><EFBFBD><EFBFBD><EFBFBD>3<16><1F>_<EFBFBD><5F><EFBFBD>0<EFBFBD>[<5B><>L<EFBFBD><4C><EFBFBD>\pcit<69><10><><00><>F>1<><03><><EFBFBD><1B><>g><05>r<>3g<33>t<EFBFBD>,<2C>r<EFBFBD>‰<EFBFBD>賛<EFBFBD>?y<>~<7E><>z<EFBFBD>Ļ<03>=<3D><>ފn6<><36>l<00><><EFBFBD><EFBFBD>ΟD<CE9F><<3C><><EFBFBD><EFBFBD><EFBFBD>iG<><47><EFBFBD><EFBFBD>/<2F><>ǯ><3E>f8<66>"<22><>L&<26>8<EFBFBD>]{<7B><><16><><EFBFBD>y<EFBFBD>w$~a<>^<5E><>=<3D>(<28><><EFBFBD><EFBFBD>b/U"6?<3F>Q<EFBFBD> <1F>!<21>źP<C5BA>7+.W<1C><>ر<EFBFBD>"
'<03><03>p0<00>Wo:<3A><>}<7D>kre<72><65>{<7B>sg<73><67>]<5D>@<1C>:<3A>{<7B>//<2F><14><><EFBFBD>)<29><><EFBFBD><EFBFBD><19> W3<17><>"3<><33>4Sw<53>><3E><><EFBFBD><EFBFBD><EFBFBD><1E><><EFBFBD>/+v<><76><EFBFBD><EFBFBD>M<><4D><EFBFBD>4ze<7A>q:<3A><>h)<29>M.<2E><><EFBFBD><EFBFBD><EFBFBD>m<EFBFBD><6D><EFBFBD>8<><38>B<EFBFBD>F <0C><><EFBFBD>?<3F>d<><64><EFBFBD><EFBFBD>`<60><0F><0F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>l?<3F>i<EFBFBD><69>
<05><><10>F<EFBFBD><46>+n<>.?uz<75>P<EFBFBD><50>Zɹ<5A>_<EFBFBD><5F>a:c<><63><EFBFBD>T<EFBFBD><54><EFBFBD><EFBFBD>G:<3A>ҁC<1D>PWE<57>U<EFBFBD><55> K<>N<EFBFBD><4E><EFBFBD><EFBFBD><EFBFBD>}4zD<7A>DHIJ-z*<2A>~<7E><><EFBFBD><EFBFBD>Ө<EFBFBD>՜&<26>B<EFBFBD><42><EFBFBD>r<EFBFBD><72>F<EFBFBD><46><EFBFBD>Y9<><1F>\<5C><>
\<5C><><15><><EFBFBD>><3E>A<EFBFBD>$<24><>J<EFBFBD><4A>}<7D>;[<5B><1C><03><>CMm<4D>c<EFBFBD>qD<71><44>ي<>b<EFBFBD>-<07>ǫ*<2A>y'<27>F<EFBFBD><46><EFBFBD>{<7B><>F<EFBFBD><46>Mt<4D>F?<3F><>eLC<15><07>0<EFBFBD><30><EFBFBD>%<25><><EFBFBD><EFBFBD>J<EFBFBD><4A><05>H<EFBFBD><07>~<7E>Y&<26><><17><><EFBFBD><EFBFBD><EFBFBD>r\6]v<>]<17>Z<EFBFBD><5A>XIJ<49><4A>$0爣w<E788A3>VsQ1<51>cs<00><14>=<3D>V<EFBFBD><56>X<08><><EFBFBD>r\<5C>$r(<28><>[i<>t6Xc<58>B<EFBFBD><42><EFBFBD>W<>
<EFBFBD><EFBFBD>WKX<><58>8<><38><EFBFBD>'<0F><>lL<6C><4C>
<EFBFBD><EFBFBD>'†<><05><><EFBFBD><7F>y<EFBFBD><79>
<EFBFBD><EFBFBD><EFBFBD><1B>x"'Kx<4B><78>PMRH<52><48><EFBFBD>M<EFBFBD> <0F>=<1F><1D>GO5#I<>o .<2E><><EFBFBD>/l{<7B><>
1y 9<>BY<42>ŵ]}K<><4B><EFBFBD>±q0<71><30>Q
<EFBFBD>>q'Jg<4A><67><04><>qC<71>P<07>0<EFBFBD>؈<EFBFBD><D888>2<EFBFBD>~<7E><>Z<EFBFBD>ܨ<EFBFBD><18>F6<46>x<EFBFBD>⹩<EFBFBD><E2B9A9><EFBFBD><EFBFBD>Y<EFBFBD>p<EFBFBD><70><EFBFBD><EFBFBD>j<0F>^<5E>ZŜ<1C>lhn+y/<>'(<28><><EFBFBD><EFBFBD>,q<>1<EFBFBD>۟<EFBFBD>n,Y<><59>p<EFBFBD>|<7C><>iO:<><7F><EFBFBD>מ<03><><1D>B<EFBFBD><42>H?<3F><>".`<60>S<EFBFBD><53>C<EFBFBD>+ <09>,<1C><05>+<14><>><3E>d<05><>H<EFBFBD>k
9fxB<78><42>O<EFBFBD>7<EFBFBD>>.k):<3A>ޟ<EFBFBD><11>f*. (<28><>Y-<16><><EFBFBD>;<3B><>C<EFBFBD><08>{<7B><><EFBFBD>VB"Nb<4E>u<EFBFBD><75>!]<5D><>`<60>Å.,
<EFBFBD>j<EFBFBD>Gp(ف<>
3h<EFBFBD>Q<EFBFBD>3<<18>q<EFBFBD><13><>Y*<0E><08>a<12>I<14><>-s<><73>q<EFBFBD>3<EFBFBD><33>a<><15><>U<EFBFBD><55><EFBFBD><EFBFBD>C<EFBFBD>EW<>}<7D><><EFBFBD><EFBFBD><EFBFBD>/v<02><><EFBFBD><EFBFBD>N`Qr€P<C280><50><EFBFBD><EFBFBD><EFBFBD>820<1E><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>l{
<EFBFBD>}x<>d<EFBFBD>B<EFBFBD><03>e|@<40>yr\<5C>spF<70>r<EFBFBD><72>toč<6F><<3C><11>
<EFBFBD><EFBFBD>ja<EFBFBD>/<2F>Зnx`Dw&<26>cr<><72><EFBFBD><0F>E<EFBFBD>U6<55><36><EFBFBD><19><>r\<5C>4g<34> <20>E<EFBFBD><45>Ņb><3E>Nq<4E>ˊ<10>c<EFBFBD>"<22><>R<EFBFBD> q<><71>u<><75> <0B>3<EFBFBD><33>\<5C>_<EFBFBD><5F><EFBFBD>><3E><><EFBFBD>N<EFBFBD>9<>nąs<C485>%Mua<04><>rL<02><><EFBFBD>"݇7<>a<EFBFBD>m<EFBFBD><07>*B<><42><EFBFBD>$벢<>
Y
<EFBFBD>4<>W<EFBFBD>v<EFBFBD><76>A<EFBFBD><<3C>2O<32><4F>eb»<62><C2BB>9<EFBFBD>ܐ[<11>{P<><50>dW<06><02> U<><55><EFBFBD>M<EFBFBD>I<EFBFBD>/<2F><>>T<>gf$6><3E>]<5D><>O<EFBFBD>ޓ<EFBFBD>c<EFBFBD><63><0E><>s<>p<EFBFBD><70>s<EFBFBD>h<EFBFBD>n<><6E><EFBFBD><EFBFBD><EFBFBD><EFBFBD>6<EFBFBD>Ѿ<1E><><EFBFBD><EFBFBD><EFBFBD>y5R<1F>d<EFBFBD><64><EFBFBD><EFBFBD><EFBFBD><EFBFBD>P<EFBFBD>o<EFBFBD>)<29><>r*-<2D><><EFBFBD><EFBFBD>R<EFBFBD><52><EFBFBD>1^q2<71>'<27><><EFBFBD>[h~`<60>f<EFBFBD>Q<EFBFBD>9.\ <0C>%<25><>0 <0C><>2ǡ<32><C7A1>ء1<>^v<><76>#<23><><EFBFBD>F<15><>TRZB<5A><42>m`*<2A>W*<2A>,Ǩ<><C7A8><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>N\F<>U5<55>W<EFBFBD><57>[<5B>Ca<43><18><>g<EFBFBD>~<7E><><EFBFBD><EFBFBD>s<EFBFBD>|<7C>45<34><35><EFBFBD>BÏ<42> 纺:<3A>P<EFBFBD>~~c<19><><EFBFBD>Ruu
<EFBFBD><EFBFBD><EFBFBD>qDMW<EFBFBD><EFBFBD><EFBFBD><EFBFBD>]<5D><><EFBFBD>!<21>_:<3A><>J=<3D>T];<3B>e<18><>S<14><><EFBFBD><EFBFBD>ޙ<>XN<58>
<EFBFBD><EFBFBD>q<EFBFBD><EFBFBD>].<2E>9[<1C><><EFBFBD><EFBFBD>θ<17><0F>h<EFBFBD><68><15>p<EFBFBD><70>QL<51><4C><16>A<EFBFBD><41><EFBFBD><EFBFBD><EFBFBD><EFBFBD>i[쥺<>j1<><31><EFBFBD><EFBFBD><EFBFBD>V<EFBFBD><56> &<26><>r<EFBFBD><72><EFBFBD><EFBFBD>n<EFBFBD><6E>ʨ<EFBFBD><CAA8> <20>۳<EFBFBD>F<EFBFBD>Oe⼅1<E2BC85>ب<EFBFBD><D8A8>yC<79>
0<EFBFBD><EFBFBD>#Y<><59><EFBFBD>9<EFBFBD><39>0 f<>Ŏ<EFBFBD><C58E><EFBFBD>8<EFBFBD>Mc<4D>Zh8Vfoo'<27>4<EFBFBD><34><EFBFBD><EFBFBD><EFBFBD>ШQch<18><>1<EFBFBD><31><EFBFBD>C<EFBFBD>[[WDzFӰ<46>rڷ{;Ga<47>F<EFBFBD>B<1B><>>p:Pr<50><72>T<EFBFBD>݈<EFBFBD><1F><><EFBFBD><EFBFBD>D<EFBFBD>\q<>(;Ī<><C4AA><04>2<EFBFBD><32><EFBFBD>&<26>PH<50>Qv<51><76>{wSͰa4r<34>(<28><16><><EFBFBD>yn<<3C>4<EFBFBD><34><EFBFBD>F<EFBFBD><46>]<5D>wQgG<1B>
<EFBFBD> n<>I<EFBFBD>'4?H<>_\<5C>+<2B>l<EFBFBD>E<02>3<EFBFBD><05><><EFBFBD>JI<4A>,<2C><1A>ݬh<DDAC><68>&<02><><EFBFBD><EFBFBD>*x<10>A<EFBFBD><41><EFBFBD>C<EFBFBD>|<06>-<2D>ӻ;<3B><>loo/߲<>WH<57><48>x**L<>
zG{;<3B>3<EFBFBD>u.'<27><><EFBFBD>DcC#m߹<6D>y<EFBFBD>=c<>?<3F>9<1A><>'<27>3O<33>̹<EFBFBD> <09><><EFBFBD><EFBFBD>bH<>H<EFBFBD>+<2B><08>Υ<><1B><>ZK<5A><4B><EFBFBD><EFBFBD><EFBFBD>><3E>KK=5<><1B><>8PQ<50>} <20><>|A<>s<EFBFBD>Vj^G<><47><EFBFBD>dЎz<1D><1D><><EFBFBD><EFBFBD>c;^<5E>+xf<><66>1<EFBFBD><31>/<2F><><EFBFBD>~<7E>6l<36>@---TSSM3f<33>Fg<46>9<EFBFBD>,N<> <09><><EFBFBD>j<EFBFBD>d<EFBFBD><64><EFBFBD>n<EFBFBD><6E>a^<14>WE<57>=<3D> <20>0<1D><19>1~<7E>u<EFBFBD><15><>3<7F><33>=<3D><><B7<42><37><03><>+<1A><>kĕ<6B><08>s<EFBFBD><08>eRz<52><7A>}r<><72> <16><>D<EFBFBD>E<EFBFBD>A<EFBFBD>5<>
<EFBFBD>KG<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>B<07><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>[i<>[o<><1C><><EFBFBD>fjhl<68> <0B><><EFBFBD><EFBFBD><EFBFBD>A<EFBFBD>g͢<67>~<7E><>ny<6E>N7<>֬y<D6AC>֯[O<>9<EFBFBD>=<3D><>mQ<1C>K<EFBFBD><4B>s<EFBFBD><73><EFBFBD>N<EFBFBD><4E><EFBFBD>g<1A>lg~Ǘ<><C797><EFBFBD><EFBFBD>n<EFBFBD><6E>s<EFBFBD>8<EFBFBD>p<12>M<><4D><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>iB<69><(<28><><EFBFBD>Ӥ<EFBFBD><D3A4><EFBFBD>)x]o<>_<>v
͚}6<>>9<><39>\<5C>:<3A>9w<39>\<5C><><00><<3C>_<><5F><EFBFBD> <0B>k<EFBFBD><6B>͸YS-<2D><><EFBFBD>]@3gΤu<CEA4><75>ѓO>Is<49>Υ3<CEA5><<3C>w<1C><><EFBFBD><EFBFBD><EFBFBD>6mz<6D><7A>O<EFBFBD>Ns<>=<3D><>vp<76>-<1B> <20>p<02>۾c<03>7<EFBFBD><37>G a<>P<EFBFBD>,ؘ<><D898><1F><>x<EFBFBD><1F><><EFBFBD>: <0B><0F>?<3F>帆<EFBFBD>p_<70>x1<#:4<><34><EFBFBD>8 W|<7C><><EFBFBD><EFBFBD><EFBFBD>W<EFBFBD><57>G<><47><EFBFBD><EFBFBD><04>pG9<47>C:S0<>t<EFBFBD><74>8<EFBFBD><38><EFBFBD>\<5C>J<<3C><><EFBFBD><EFBFBD><EFBFBD>)S<><53>)<29><><EFBFBD>3~ؤ<>&N<> <20><>Iݽ{7Mc<4D>mim<69><6D>W<EFBFBD><57><EFBFBD><EFBFBD><06>=<3D><><EFBFBD><EFBFBD>"<10><><1C><>!<21>~<7E><><EFBFBD>˜<EFBFBD>+uȃ0~<7E><><EFBFBD>?<3F><>r<EFBFBD>a<>b<EFBFBD><62>0)o<08><><EFBFBD>W<><57>(<28>8f8|<7C><><EFBFBD><EFBFBD><EFBFBD>?<3F><><EFBFBD>kjiܸSX<06><11>^<5E>S<EFBFBD>[<5B>|<7C><>ù0Q<30>Z<EFBFBD><5A>xX<78><07>͟T<CD9F>W]w<>u<EFBFBD>6<EFBFBD>{؉<>*<2A><><EFBFBD>kr<6B>b޼y><3E><>}<7D><><EFBFBD>[<5B><>߉s<DF89>!<21>-q<> <20>w<EFBFBD><77><EFBFBD>s<EFBFBD>8mܸA<DCB8>2<EFBFBD><32>a<EFBFBD><61>A<EFBFBD><41><EFBFBD><EFBFBD>>.[<5B>W<16>><14><01>_<EFBFBD><5F>z<>٧8:<3A><05>L<EFBFBD><4C>[<5B><>€x0;<07><><EFBFBD> N GN<47><01>?<3F><><EFBFBD><EFBFBD> .<2E>6o<36>$<<><02>><3E><><EFBFBD><EFBFBD><EFBFBD>G۷mK<6D><4B><EFBFBD><EFBFBD>n<EFBFBD>{9o<39><6F><EFBFBD> <0B><0E>gϮ<1D><>sOѲ<4F>~<7E>h|<7C><><EFBFBD><EFBFBD>quq<75>E<EFBFBD>p<EFBFBD> <09><><16>6N<36>i6<>,<2C>&r<>w~<7E>[<5B><>_vŕ|:E5<45>u<EFBFBD><16><>bWEUu!<0F>uh㼴<68><E3BCB4><EFBFBD>/<2F>pєX<D194>#;<3B>&<26>c<EFBFBD><63><EFBFBD>҆<EFBFBD>%ڎ;<3B><>S襉<53>&<26>ԩSyPbIW<49>Ѿ>v<>4~©<>9<>a<11>(<28>@C<H<> <0B>#m<><6D><EFBFBD><EFBFBD><EFBFBD><EFBFBD>$<24><1D>P(<28>|gҾh<D2BE> <0C>
<08><>q<EFBFBD><18>
/<2F>ޱ<14>Ƈ><3E><>2<EFBFBD>o@<40>8ܯ<><DCAF>755<35>E]D<><44>~:<3A><><EFBFBD>$<M5<4D>[?<1B><>L<EFBFBD>y<EFBFBD>`<60>xNg|JGם;wҪ<77>+Y<>Yt꩓<74> <0B>z+v֮<><D6AE><EFBFBD><EFBFBD><EFBFBD><1A>qq1<71><31><EFBFBD><EFBFBD>ሎ<EFBFBD>oQ1~<7E><>X<EFBFBD>|<7C><1A>*ly<6C>ݻ<EFBFBD><DDBB>|<7C>Mz<4D><7A><EFBFBD>4<><34>A<EFBFBD><41><EFBFBD>EM<45><4D>%!
<EFBFBD>
<EFBFBD><EFBFBD>Ώ<><CE8F><EFBFBD>R^<5E>`<60>L<EFBFBD>r*}<7D><>_<EFBFBD>S}հ<><D5B0><EFBFBD>CD<43><44>ZRR*<2A>^HZ[[y[m
}<7D>/<2F><><EFBFBD><EFBFBD><EFBFBD>D<EFBFBD><44><EFBFBD>be<62><1C><10>ꮝ<EFBFBD>h<EFBFBD><68>-t<>y?<3F>:<3A><><EFBFBD>vŽ<76>9<EFBFBD><39> <09>Y<><59>xZl׮<6C><D7AE><EFBFBD><03><>ü<EFBFBD>r<EFBFBD><72>5<EFBFBD><35><EFBFBD><EFBFBD>a:<3A><1A><>:<3A><><EFBFBD><EFBFBD>~z/縷H<E7B8B7>ll)[_<>a><3E>]]<5D><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>uo<75><6F>իN(<28><>t<EFBFBD><74>dԨ<64><D4A8>Ż<EFBFBD><10>>^<5E>?<3F><>=K<>y<><79><EFBFBD> <0C>`|'l떭t<EB96AD><74><EFBFBD><EFBFBD><EFBFBD><EFBFBD>JX<>]<5D><><EFBFBD>D<EFBFBD><44>
<EFBFBD>={v<><76>U<EFBFBD><55>'<27><>_<00><1C>v<EFBFBD><76>OJo<>ڪ)<1A><><EFBFBD>&<26>|<7C><><EFBFBD><<3C>
<1C><><EFBFBD><EFBFBD><EFBFBD>l<EFBFBD>L<EFBFBD>|<01>#<23><><03><>K<EFBFBD><4B>{qA<71><41><EFBFBD>f<EFBFBD><66>"8p<38><70><EFBFBD>ٴ<EFBFBD>}<7D><><EFBFBD><EFBFBD>#<23><><03>_<EFBFBD>L'<27>D<EFBFBD><44><EFBFBD>U`<13><>*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Sg쉨d<EC89A8><64><EFBFBD><EFBFBD><19><><EFBFBD>Orag<61><67> /<2F>'<27>e;<06><>뼯<>W.<2E><><EFBFBD>o<EFBFBD>m۶<6D>3|<7C><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ԟ8ǩ<>\K3>wW!,<2C>)<29>G<EFBFBD>I<EFBFBD>ÿs<C3BF><73><EFBFBD>JH<4A>1<EFBFBD><31><EFBFBD>!<21><19><>'<27>r<EFBFBD><72><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>s<EFBFBD>=<3D><><15><><EFBFBD><EFBFBD>
<EFBFBD><EFBFBD><EFBFBD>;sHR<48>D+<2B><><EFBFBD>c:<3A><>&<26>ʠ<EFBFBD>u<EFBFBD><75><EFBFBD><EFBFBD><01><12><><EFBFBD>b<EFBFBD><62><EFBFBD>Ώ<EFBFBD>EŘԜ<C598>2<EFBFBD><32>y<EFBFBD>+S<><13><><EFBFBD>Up<55><70><EFBFBD>*<2A>9<EFBFBD>ǽ<>rṆ<>ncz<>A\<5C>Z<EFBFBD><5A><EFBFBD><><1C>>.ŝ<><C59D>
<EFBFBD>[<5B>f<EFBFBD>bs<17>f.<2E><><16>#'{<7B><><EFBFBD><EFBFBD> 0<>Gd '<03> <0B><><EFBFBD><EFBFBD>AbDq<44>t<10>=<02><>qq<15> <20> A<><41><EFBFBD>h6<68>0<EFBFBD><30>:<3A>u<EFBFBD>8e<38><65><EFBFBD><07><>$<24>Fv` <0B><>ną<6E>aH<><48>8\곣<><EAB3A3>'l
<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>E\<5C>Fxd<07><>y<><79><EFBFBD><EFBFBD><07><>A3h0IEND<4E>B`<60>
---
File: /docs/specification/2024-11-05/server/resources.md
---
---
title: Resources
type: docs
weight: 20
---
{{< callout type="info" >}} **Protocol Revision**: 2024-11-05 {{< /callout >}}
The Model Context Protocol (MCP) provides a standardized way for servers to expose
resources to clients. Resources allow servers to share data that provides context to
language models, such as files, database schemas, or application-specific information.
Each resource is uniquely identified by a
[URI](https://datatracker.ietf.org/doc/html/rfc3986).
## User Interaction Model
Resources in MCP are designed to be **application-driven**, with host applications
determining how to incorporate context based on their needs.
For example, applications could:
- Expose resources through UI elements for explicit selection, in a tree or list view
- Allow the user to search through and filter available resources
- Implement automatic context inclusion, based on heuristics or the AI model's selection
![Example of resource context picker](resource-picker.png)
However, implementations are free to expose resources through any interface pattern that
suits their needs&mdash;the protocol itself does not mandate any specific user
interaction model.
## Capabilities
Servers that support resources **MUST** declare the `resources` capability:
```json
{
"capabilities": {
"resources": {
"subscribe": true,
"listChanged": true
}
}
}
```
The capability supports two optional features:
- `subscribe`: whether the client can subscribe to be notified of changes to individual
resources.
- `listChanged`: whether the server will emit notifications when the list of available
resources changes.
Both `subscribe` and `listChanged` are optional&mdash;servers can support neither,
either, or both:
```json
{
"capabilities": {
"resources": {} // Neither feature supported
}
}
```
```json
{
"capabilities": {
"resources": {
"subscribe": true // Only subscriptions supported
}
}
}
```
```json
{
"capabilities": {
"resources": {
"listChanged": true // Only list change notifications supported
}
}
}
```
## Protocol Messages
### Listing Resources
To discover available resources, clients send a `resources/list` request. This operation
supports
[pagination]({{< ref "/specification/2024-11-05/server/utilities/pagination" >}}).
**Request:**
```json
{
"jsonrpc": "2.0",
"id": 1,
"method": "resources/list",
"params": {
"cursor": "optional-cursor-value"
}
}
```
**Response:**
```json
{
"jsonrpc": "2.0",
"id": 1,
"result": {
"resources": [
{
"uri": "file:///project/src/main.rs",
"name": "main.rs",
"description": "Primary application entry point",
"mimeType": "text/x-rust"
}
],
"nextCursor": "next-page-cursor"
}
}
```
### Reading Resources
To retrieve resource contents, clients send a `resources/read` request:
**Request:**
```json
{
"jsonrpc": "2.0",
"id": 2,
"method": "resources/read",
"params": {
"uri": "file:///project/src/main.rs"
}
}
```
**Response:**
```json
{
"jsonrpc": "2.0",
"id": 2,
"result": {
"contents": [
{
"uri": "file:///project/src/main.rs",
"mimeType": "text/x-rust",
"text": "fn main() {\n println!(\"Hello world!\");\n}"
}
]
}
}
```
### Resource Templates
Resource templates allow servers to expose parameterized resources using
[URI templates](https://datatracker.ietf.org/doc/html/rfc6570). Arguments may be
auto-completed through [the completion
API]({{< ref "/specification/2024-11-05/server/utilities/completion" >}}).
**Request:**
```json
{
"jsonrpc": "2.0",
"id": 3,
"method": "resources/templates/list"
}
```
**Response:**
```json
{
"jsonrpc": "2.0",
"id": 3,
"result": {
"resourceTemplates": [
{
"uriTemplate": "file:///{path}",
"name": "Project Files",
"description": "Access files in the project directory",
"mimeType": "application/octet-stream"
}
]
}
}
```
### List Changed Notification
When the list of available resources changes, servers that declared the `listChanged`
capability **SHOULD** send a notification:
```json
{
"jsonrpc": "2.0",
"method": "notifications/resources/list_changed"
}
```
### Subscriptions
The protocol supports optional subscriptions to resource changes. Clients can subscribe
to specific resources and receive notifications when they change:
**Subscribe Request:**
```json
{
"jsonrpc": "2.0",
"id": 4,
"method": "resources/subscribe",
"params": {
"uri": "file:///project/src/main.rs"
}
}
```
**Update Notification:**
```json
{
"jsonrpc": "2.0",
"method": "notifications/resources/updated",
"params": {
"uri": "file:///project/src/main.rs"
}
}
```
## Message Flow
```mermaid
sequenceDiagram
participant Client
participant Server
Note over Client,Server: Resource Discovery
Client->>Server: resources/list
Server-->>Client: List of resources
Note over Client,Server: Resource Access
Client->>Server: resources/read
Server-->>Client: Resource contents
Note over Client,Server: Subscriptions
Client->>Server: resources/subscribe
Server-->>Client: Subscription confirmed
Note over Client,Server: Updates
Server--)Client: notifications/resources/updated
Client->>Server: resources/read
Server-->>Client: Updated contents
```
## Data Types
### Resource
A resource definition includes:
- `uri`: Unique identifier for the resource
- `name`: Human-readable name
- `description`: Optional description
- `mimeType`: Optional MIME type
### Resource Contents
Resources can contain either text or binary data:
#### Text Content
```json
{
"uri": "file:///example.txt",
"mimeType": "text/plain",
"text": "Resource content"
}
```
#### Binary Content
```json
{
"uri": "file:///example.png",
"mimeType": "image/png",
"blob": "base64-encoded-data"
}
```
## Common URI Schemes
The protocol defines several standard URI schemes. This list not
exhaustive&mdash;implementations are always free to use additional, custom URI schemes.
### https://
Used to represent a resource available on the web.
Servers **SHOULD** use this scheme only when the client is able to fetch and load the
resource directly from the web on its own—that is, it doesn’t need to read the resource
via the MCP server.
For other use cases, servers **SHOULD** prefer to use another URI scheme, or define a
custom one, even if the server will itself be downloading resource contents over the
internet.
### file://
Used to identify resources that behave like a filesystem. However, the resources do not
need to map to an actual physical filesystem.
MCP servers **MAY** identify file:// resources with an
[XDG MIME type](https://specifications.freedesktop.org/shared-mime-info-spec/0.14/ar01s02.html#id-1.3.14),
like `inode/directory`, to represent non-regular files (such as directories) that don’t
otherwise have a standard MIME type.
### git://
Git version control integration.
## Error Handling
Servers **SHOULD** return standard JSON-RPC errors for common failure cases:
- Resource not found: `-32002`
- Internal errors: `-32603`
Example error:
```json
{
"jsonrpc": "2.0",
"id": 5,
"error": {
"code": -32002,
"message": "Resource not found",
"data": {
"uri": "file:///nonexistent.txt"
}
}
}
```
## Security Considerations
1. Servers **MUST** validate all resource URIs
2. Access controls **SHOULD** be implemented for sensitive resources
3. Binary data **MUST** be properly encoded
4. Resource permissions **SHOULD** be checked before operations
---
File: /docs/specification/2024-11-05/server/slash-command.png
---
<EFBFBD>PNG

IHDR%j<00>Gz^iCCPICC Profile(<28>u<EFBFBD>;HA<10><><EFBFBD>h0<04>"<22><><EFBFBD><EFBFBD>b$<24>6"<22>"XQ<><51>es^<5E>K\7'b<><62><EFBFBD>66<36><36><EFBFBD><EFBFBD><EFBFBD><EFBFBD>+ E<>O<EFBFBD><4F>
<EFBFBD><EFBFBD>EM<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>33 <03><>u<EFBFBD>-<1F>B<EFBFBD><16>٤<EFBFBD><D9A4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><11>!<21><>Og%<25>дy*<2A><><EFBFBD><EFBFBD><EFBFBD>#<R<>G<EFBFBD><47><EFBFBD><EFBFBD>i<EFBFBD><69>W^<5E><>;#<23><><EFBFBD>-/<2F>3J<33><4A>r<EFBFBD>qa<1E>X۵<58><DBB5>∠<><E288A0><EFBFBD>%<25>u<EFBFBD><75><EFBFBD><EFBFBD>s٭Y̤<59><1F><>,<2C><>+<2B><>l<EFBFBD>o6q<36><71>a_;<3B><>Fqi<71><69><EFBFBD><EFBFBD>i<18>($<24><>8T<38><54>O<13>><3E><>Ka {؄<><lw<02><>h<EFBFBD><68>9<14>0<EFBFBD>(q 㔪<><E394AA><EFBFBD>;6<><36>;`f<>`<60><>%9p<39>t<>4<EFBFBD><34># t
܎q]<5D>?<3F><>T}<7D><>x<EFBFBD><78>A<01><>9<EFBFBD>k/<2F>j<>q<EFBFBD>O<1C>vx<><78><EFBFBD><EFBFBD>'<27>9aj<1F>J<EFBFBD>DeXIfMM*<00>i&<02>%<25>joI<6F><49>iTXtXML:com.adobe.xmp<x:xmpmeta xmlns:x="adobe:ns:meta/" x:xmptk="XMP Core 6.0.0">
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about=""
xmlns:tiff="http://ns.adobe.com/tiff/1.0/"
xmlns:exif="http://ns.adobe.com/exif/1.0/">
<tiff:Orientation>1</tiff:Orientation>
<exif:PixelXDimension>293</exif:PixelXDimension>
<exif:PixelYDimension>106</exif:PixelYDimension>
</rdf:Description>
</rdf:RDF>
</x:xmpmeta>
l0<EFBFBD>5lIDATx<01>] xUE<55>>Y YH<59><48><EFBFBD><EFBFBD>HX H<>DDdw<64>Glhm<68>lu<1C>F<EFBFBD><46><EFBFBD>vz><3E><>v<EFBFBD>[g[wT<77>%HXd<58>%a'+ [ !<10>Ad<>_<EFBFBD>.<2E><><EFBFBD>Gܼ֗w<DCBC><77><EFBFBD>Wu<57>֭[<5B>׽<EFBFBD>=uN<75>[^W<>^<5E>N"<22><> Xo<><6F>C<EFBFBD>!<02><>B@HI.A@<10>BJ<42><4A><0E><> )<29>5 <02>B@H<>R<EFBFBD>!<21>!%<25>A<>R)Y<>;<3B>2<EFBFBD><32> <20>$׀ X
!%Ku<4B>TF<04><><EFBFBD>K! <20>d<EFBFBD><64><EFBFBD><02><><EFBFBD><EFBFBD>\<03><> `)<04><>,<2C>RA@<10><><EFBFBD>+<2B><14>]<5D><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><1E>^i<> <20>PM<><4D><EFBFBD><EFBFBD><EFBFBD>[pS<04><>ܴc<DCB4>Y<EFBFBD>@CE@H<><48><EFBFBD><EFBFBD><EFBFBD>[pS<04><>ܴc<DCB4>Y<EFBFBD>@CE@H<><48><EFBFBD><EFBFBD><EFBFBD>[pS<04><>ܴc<DCB4>Y<EFBFBD>@CE<43>头n<E5A4B4>zJKK<4B>1><3E>Ν<EFBFBD><CE9D><EFBFBD><EFBFBD><1A>#<02><><EFBFBD>p))<29><><EFBFBD>ӛo<D39B>C.<2E><><08><><EFBFBD>YN<59><1F>C<EFBFBD>,<2C><><EFBFBD>r<EFBFBD><72><EFBFBD>(.n <0B><>\p<>Gv<02><><EFBFBD>p))<29>Z<EFBFBD><5A>Z<EFBFBD>jE<06>^#$<24><>5%/oo
n<EFBFBD><EFBFBD>i9<19>h<EFBFBD><68>7<EFBFBD><37><EFBFBD><EFBFBD>N<EFBFBD><4E>A@<10>><02><><EFBFBD>bAA><3E>ر<EFBFBD><1E>1<EFBFBD><31><EFBFBD>n<EFBFBD>}EE<45><45><EFBFBD>l<EFBFBD>¢+4tH <0C>nm;<3B>zܸ<7A>4f<34>h<EFBFBD><68><EFBFBD>qZ<71><5A>$<24><>9Gv
<01><>҆<EFBFBD><D286><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ə<1F><10><>G<EFBFBD>PjJ7<><37><EFBFBD><EFBFBD><EFBFBD><EFBFBD>5k<35><6B>ˋ<EFBFBD>B[)R<>p<EFBFBD>ĉ <0C>c;v<>@<40><><EFBFBD>F<EFBFBD>իW())Emo<6D><6F><EFBFBD>
<EFBFBD><EFBFBD>3(((<28><>ޑ<><DE91><03>m<EFBFBD><02><><EFBFBD>p)<29>]<5D><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>÷PJ<><4A>濼<EFBFBD><0E><>m<EFBFBD><11><>Kt<4B>:<3A><><EFBFBD>G<EFBFBD><47>Ggy<0E><><EFBFBD>wc<1B>y<EFBFBD><79>*<2A>K'<27>g<EFBFBD><67>y<7F>E<EFBFBD><45><EFBFBD>%<1F><>f<EFBFBD><66><EFBFBD><EFBFBD>ѐ!<21>m<EFBFBD>dC<04><><EFBFBD>KH)99<39>RSSi<53><69>+<2B><><EFBFBD>VҼy<D2BC><79>iS'Sn<53>eE><3E>><3E><>&M<>H<EFBFBD>o؍<0E><><EFBFBD>><3E>@<1D>ɞ<EFBFBD><C99E><EFBFBD>_-WV<57><56><EFBFBD>F<EFBFBD><46><0F>[o<>KO><3E><04> h<>
3<><01>#<23>RZ<52>z<EFBFBD>f<>9|X9<04>O<>F<EFBFBD><1A><>)<29><><EFBFBD>ǗBBB<42>^t/<1B><><EFBFBD>q<EFBFBD>3H<1D><>w<1B>k׮<6B><D7AE><EFBFBD>_<>FF<46>3gΪ]<18>Ut<55><74> <0C> <02><><EFBFBD><10><><05>u-))<29><><EFBFBD>[i<>ȑ<EFBFBD><C891>[<5B><><EFBFBD>3<EFBFBD> Oz<4F>M{Qrr<72>:S<>V-<2D>qF9D<04> <09><>Q<EFBFBD><51><EFBFBD>m<EFBFBD>F<EFBFBD><46>y<EFBFBD>8a<38>Ò<EFBFBD><C392>Z<>f<1D><><EFBFBD><EFBFBD>iP<69>@5<>i߾x<DFBE>۷/a8&"<02><>@<40>kJk؋֣{
w<>l<EFBFBD>vm<76><6D>;<3B>)<03><><EFBFBD>G<EFBFBD><47><EFBFBD><EFBFBD>f><3E> -^<5E>z<EFBFBD>S(<28><><EFBFBD> <20>VԪ<><D4AA><EFBFBD><EFBFBD>I<1D>g<EFBFBD>~<7E>)H0t<30><74><EFBFBD>H<EFBFBD>/<2F><>]<5D><>N<EFBFBD>Uu<55><75>O<EFBFBD><4F>kU<6B> <20>A<><10>URZ<52>j
<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>w;<3B><1A><><EFBFBD><EFBFBD>W<EFBFBD><57>O<EFBFBD><19><5Iٞ:w<0E>)S&Q<>.]Ա<><D4B1>}<7D>|<7C><>C<EFBFBD><43><EFBFBD><EFBFBD>n<EFBFBD>ԴT<15><EFBFBD><04>ݻ<EFBFBD><DDBB><EFBFBD>WϞl@oD˿<44><CBBF><EFBFBD><EFBFBD>T6g <09>3<EFBFBD>O3<4F>Ķ<EFBFBD> X<1B>Z#<23><><EFBFBD><EFBFBD>X<EFBFBD>09|<7C>PjҤ<6A><D2A4>V7o<1E><>G<EFBFBD><47><EFBFBD><EFBFBD>5f$<24><> iӦʹk<CDB4><1E>l<EFBFBD>ER<45>y<>t<EFBFBD>G
yz<EFBFBD>*# <20><><EFBFBD><EFBFBD><EFBFBD>dC<64>6mJ<6D>-xEM<45><s<><73><EFBFBD>~<7E>
σ<04><06>@<40><><EFBFBD>n&<26> <0B>2<EFBFBD><32><EFBFBD>9m|^<5E>ez<65><7A>͙<>=<3D><>t<EFBFBD>|q[<5B>ҢE<45>WSv<53><76>i8EFFһ<46>i<EFBFBD><69><EFBFBD>
L'<27>S
*<2A>+<2B>A<><41>Ԛ!f<><66>uԖ<75><D496>QQ<51>N[<5B><>_@׮]<5D>ݻ<DDBB><7F>'O<>|а2xz<00>f<EFBFBD><66><EFBFBD>`ʟ x&<02><>)<29><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>9<EFBFBD>M<EFBFBD>6t<36><74>hժ<68><D5AA><EFBFBD><EFBFBD>O<EFBFBD>mM<6D>е<EFBFBD>kj<6B>^9y<39>g+
<EFBFBD>3<EFBFBD>BZ-@<40>+;;<3B><>_<EFBFBD><5F>t<EFBFBD><12><><EFBFBD>F}x<>eHp0EDt<44>ƍ<EFBFBD>\<5C>+<2B><>AC<01>!Pk<50>RU<52><55><EFBFBD>ۢ<EFBFBD>k<EFBFBD><6B><EFBFBD><EFBFBD><EFBFBD>Ϝמ<CF9C><D79E><EFBFBD><EFBFBD><EFBFBD>"<22><> `ꅔ<><EA8594>L>7<>G<13><0E>>rVA@p<><70>ۓ<EFBFBD><DB93>)N<><4E><EFBFBD><EFBFBD><EFBFBD><1F><>R<EFBFBD>P:8<>#<23>$M\<5C><><><7F><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>4ɘC<C998><43>|9O<39><4F>o<>/<2F><>}<7D><><EFBFBD>F<EFBFBD>'8C<38>4<>2<EFBFBD><05>
)??_y
<EFBFBD><15><><EFBFBD><EFBFBD>'q:I<>A<><41>p[R<><52><11>Ԅ<EFBFBD>yR<79>/_<><19>M<EFBFBD>+)u<07><>I*<2A><>[<5B><>&$<24><><EFBFBD>5<EFBFBD>!5k֌?.<2E>|<01><>'<27>A<>5<08>z<EFBFBD><7A>k<EFBFBD>Y'<27>j2<6A><32><04>lHxaW<08>N<EFBFBD><4E><EFBFBD><02>F<EFBFBD><46>HIkI@q=t<><74>Ըq<D4B8>j%
<02>@<40> <20><><EFBFBD>7@<40><>I<13>ڎ ڗ.]T3<54>KJJ<4A>q9<71> <08><01>$%3!iRr<52>^^vv6]<5D>X<EFBFBD>%<25>o<EFBFBD><6F><EFBFBD><04>*#<23>v<EFBFBD>7<EFBFBD><37>&#<23><><EFBFBD><EFBFBD>>
!i$$<04><><EFBFBD>[<5B><>#<23>)Y<><1B>&<26><> <20>p+Rҍҡ&)<1D>t A<><41><08>%) Y<><59><EFBFBD><EFBFBD> !<21><><EFBFBD>dn4<6E><04><02>@<40>A<EFBFBD>mIɬ-<2D><><EFBFBD>5<EFBFBD>ya<79>%Z<7F><5A>Z<EFBFBD><5A><EFBFBD><EFBFBD><02><>{<7B><><EFBFBD><EFBFBD> <09><>SU*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Z<><5A><1F><>o<EFBFBD><6F>ʡ5Λ<35>{<7B><>|<7C><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>'q<>ܖ<>ꪯN<EAAAAF><<3C><>><3E><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>y<EFBFBD><79><EFBFBD>PRR/
q<EFBFBD><EFBFBD><EFBFBD>]'<27><>8EV<><n۾<6E><DBBE><EFBFBD><EFBFBD>~<7E><>}<7D>EE4<15>/<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>X.L<><4C>U<EFBFBD><55><EFBFBD><EFBFBD>n9O<39>f<EFBFBD>j7v<37><76>1:p<><70><EFBFBD>%<25>Ѓ<EFBFBD>啕څ<E59595>%<25><><EFBFBD><EFBFBD>"|<7C><><EFBFBD>+ԡ}{<7B>h]rb.<2E>k<EFBFBD><6B>4o<34>
<0C><> <09><00><>R%<25><><EFBFBD>sK<73>|<7C><>`<60><><EFBFBD><EFBFBD>1}<7D><>R%<25><><EFBFBD>l<EFBFBD>"<22><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>|jZ<><5A><EFBFBD> <0C>!YeoDE<44><45>lv<6C>w!%'<27>BVV6<56>Z<EFBFBD><5A>RRR)_<17><>.AH<41><48><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>`<60><><06>n<EFBFBD>A6<>R.<2E>֡4u<34>$<24>ѽ<EFBFBD><D1BD>ҝ'c<><63><EFBFBD><EFBFBD><EFBFBD>4<EFBFBD><07><15>)==<3D><><EFBFBD><0E><><EFBFBD>x<EFBFBD><78><EFBFBD>G{<7B><>5
<EFBFBD>ׯ/<2F><>I<><EFBFBD>K<EFBFBD>\<5C>^<12><>_?n<>L<04><><EFBFBD>_A<5F><41><07>
/<2F>މW;<1E><><EFBFBD><EFBFBD><EFBFBD>4Z<34>r-<2D><>?}<7D><> <0B>;<3B>4ns˖-l<>>|<7C>֭<EFBFBD><D6AD><EFBFBD><EFBFBD>s<EFBFBD>a^<5E>а0<D0B0>ݫ<07>7nL9R<39>۲]<5D><>w<EFBFBD>|6<><36><EFBFBD><EFBFBD><EFBFBD>={<7B>6뗨<36>x<18><><EFBFBD><EFBFBD>凄<><E58784><EFBFBD>͠<><CDA0>vӱ<76><D3B1>TXTHO?<3F>k<EFBFBD><1C><>Ͼ<EFBFBD>ӧNy<11>ر<03>|<7C><01><>ϖ}<7D>><3E>ݟ빉2<EBB989>f<EFBFBD>6<EFBFBD>s
`<60>!<21><>x<>Fշ<46><D5B7>A<EFBFBD><41>3C9-O>1<><31><EFBFBD>y<><79>bz<62><7A><EFBFBD><EFBFBD>dFD<46><44>)<29>'ڤa$<24><>[<5B>"<22><><EFBFBD>g<EFBFBD><15>{G<><47>I'<27>f<EFBFBD><66><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>s<EFBFBD>ԇ<EFBFBD><D487>6<EFBFBD>1<EFBFBD>`<60>F|,X<>Тu<D0A2>v<EFBFBD><76><EFBFBD><EFBFBD><EFBFBD>
<EFBFBD>R^<5E> ￙%<25><17>t$EEE<45><45>;<3B><> <09><15>9<EFBFBD>b <0B><<3C><13><><EFBFBD>bz<62><7A><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݯn<DDAF>l&<26>!<21>Q@@<00>8<EFBFBD><38> Ã
<EFBFBD><EFBFBD>Um<EFBFBD><EFBFBD>C<EFBFBD><EFBFBD>P<<1B><><EFBFBD>R<EFBFBD>{<7B><>ԡC;^)8<><38>;N%<25>%<25><>KU<>B<EFBFBD>X<1D><>-Z<><5A>C|<7C>C#X<>7z<7F>I<EFBFBD>:LP<4C>@&<26>(<28><><EFBFBD>_}<7D><><EFBFBD>n<EFBFBD>I-}3<>?<3F>Ҕ<EFBFBD>oؤ<6F>>8o<38>.᪨<>Ǔ<EFBFBD><C793>y<EFBFBD><79><EFBFBD><08><05>JH8D[<5B>m<EFBFBD>Aw<41>l3 Fr<46>`Æ
<EFBFBD><EFBFBD>o<EFBFBD>O^<5E><><EFBFBD><EFBFBD><EFBFBD>wR<77><52>Կ_<7F>j+V<>᥷<EFBFBD>(<28>:t0<74><30><EFBFBD><1D><>{<7B><>!%%<25><><EFBFBD>A<EFBFBD>O<EFBFBD>:C<><43><EFBFBD>t<1<><31><11>C<EFBFBD><01>
<EFBFBD><EFBFBD><01>U<EFBFBD><55><EFBFBD><EFBFBD><EFBFBD>ڂ<EFBFBD><14><>A<EFBFBD><41><EFBFBD>o#<23>G<EFBFBD>I9<49><39>[<5B><><EFBFBD><EFBFBD><EFBFBD><10> <09>r@8<><38>(<28>SGjժ<6A>"<22>]<5D>~V<><56><EFBFBD><EFBFBD>v<EFBFBD>Ԧ<EFBFBD><D4A6>ÇVi<56>d_<64>QuD=S<>R<EFBFBD><52><EFBFBD><EFBFBD><EFBFBD><08>a<EFBFBD>]<5D><0F>`^<5E>gȐ;<3B><><12><><EFBFBD>E<EFBFBD>|<7C><>}r<1<>j<EFBFBD>3
<EFBFBD>h<EFBFBD><EFBFBD>.<2E>h%<25>ZIɩt<C9A9>b<EFBFBD>awƌit<69><74>!<21><04>M<EFBFBD><EFBFBD><15><>P<EFBFBD>|<7C>@+<2B><><EFBFBD><EFBFBD>M<EFBFBD>?<3F><>qQB<51><42>ᇕt<E18795><74>Q:$Fg<46>R8m<38>d<EFBFBD><64><EFBFBD>S3y<33>DZ<44><5A>bڶm'<27>;F<><46><16><><16>08<><38><EFBFBD>d^6}p9<70>̉ <0B>fߵkk -<2D><>W^242ܘ<1F><>ֻ<EFBFBD><D6BB><EFBFBD>Ԋo<D48A>}᷆<>ً<>x<EFBFBD>M^6}<7D><><EFBFBD><EFBFBD>0<EFBFBD><1D><>֭[U<>!|<7C><><0E><>۵<EFBFBD>06oުHj<13><><EFBFBD><EFBFBD>N<EFBFBD><4E>i-A <0C><>N<EFBFBD>_<EFBFBD>>Ť<><C5A4><EFBFBD>L<EFBFBD><4C>~<><7F>֎<><D68E><EFBFBD>T<08><>2<EFBFBD><32> <0C><>O<EFBFBD><4F><EFBFBD><EFBFBD><EFBFBD>?<<3C>~<7E><>o<EFBFBD><6F>;DŽ<><C784>O<EFBFBD>Ic7<63>r<EFBFBD><11><>E<EFBFBD><45>?J<><EFBFBD>N-<2D>XڶmC<6D><43><EFBFBD>k<18><><EFBFBD><EFBFBD>t<1D><>o<EFBFBD>c<EFBFBD><63>&.<2E>sDD=<3D><><EFBFBD>F9+<2B><>7<EFBFBD><37> <20><><EFBFBD>_<EFBFBD>>F<>+<2B>1<EFBFBD>p<EFBFBD>E<EFBFBD><45>tH1kGZ<47>-Z<><5A>$<24>m&c<>#xJ<78>$ң<>)a];<3B><><EFBFBD><EFBFBD>Y<>I4'<27><14><><EFBFBD>1<>&
<1B>x<EFBFBD><78>/<13><>߇<EFBFBD><DF87>.<2E>6m<36><6D>.#<04><><EFBFBD>k<EFBFBD><6B>m<1F><><EFBFBD><EFBFBD>+<2B>Ϝ<EFBFBD>ҋ<EFBFBD>e<><65><<3C><>d k3<6B> BB^ y<>r<EFBFBD>
<EFBFBD>gϞ%h<>gyHf<48><00>132NImZ<6D><5A><13>7|`<60>u<EFBFBD><75>ʚG;<3B><>͂cԹ<63><D4B9>3'ӨQw<51>l<EFBFBD>o<EFBFBD><6F>&NW<><57><EFBFBD><EFBFBD>3'<27><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>}<7D>ḹ<EFBFBD>˜<EFBFBD><C298><EFBFBD>j<EFBFBD>h'<04>D<EFBFBD>@^Z<><5A>lHC<48>W6<q"]vt<76>m<EFBFBD>DG+RJMM<4D>)<29><><EFBFBD>Xe<58>o<EFBFBD>|BJz<07> \<5C><>y؇!<21>a~Re<><05><><EFBFBD>G
<EFBFBD>f$駶<>"<22>ή]<5D><><EFBFBD><EFBFBD><EFBFBD>ȇnG<><47>YBC<42>n<EFBFBD>K<EFBFBD><4B><06><><EFBFBD>w<EFBFBD><77>ټY.޷o<DEB7><6F>؝y<D89D><79>.<2E>\.D<13>9<EFBFBD>9<EFBFBD><39>]6<>Ő ?{)5}ZƄ<5A><C684>(n<>6C<36><43>a<EFBFBD><61>֭+=0c<30><1A>x=ݠ)<17>"-YW<><10>y<EFBFBD><79>Vy`<60>:}<7D><1A>;<3B>„Â<C284><C382>x!<21><><EFBFBD>;<3B><>9
<1C>rrlh6<68>x<EFBFBD><78>5f<35><66>!n )9<>5<7F><7F><EFBFBD>,<2C><>_<EFBFBD>g;<1B>!͚6S<36>M_<>Ց<EFBFBD><D591><EFBFBD><EFBFBD><EFBFBD>a<EFBFBD><18>u<05>
St<EFBFBD><EFBFBD><EFBFBD><15><>!|d<><64><EFBFBD>rq<72>r<>R9<><39>p#<01>5<EFBFBD>ر<EFBFBD><D8B1><EFBFBD><EFBFBD>F<EFBFBD><46>` <1B><><EFBFBD>aaG<61><47>;<3B>GK<47><4B>K/><3E><>
*<1B>\e{]U<><55>6W<36>,<2C><><EFBFBD><EFBFBD><1E>
B¹0M<00><>L
jA?<3F><><EFBFBD>Wu<>'<27>BJz7З_~K<><01>4{<7B><>l轪.<2E>6<<3C>0{EZkIYY<17><><EFBFBD>u<EFBFBD> <09><01><>f<EFBFBD><66><EFBFBD><EFBFBD>k<1A><>|X<>ah5<68>'<27><>f<EFBFBD>!<18><04>4M p&<26>[8<><38><EFBFBD>0CΞ=Ǟ<><<3C><>C<EFBFBD>޽z<DEBD><10><14>X<EFBFBD><58>]۶<><DBB6>0<EFBFBD><30>1<EFBFBD><31>1<EFBFBD><31><EFBFBD><EFBFBD><EFBFBD>G<18><><EFBFBD>T^br<62>'<27>Lʆ]pZ<70><5A><05><><EFBFBD>ϯ<EFBFBD> <09><><EFBFBD><EFBFBD><EFBFBD>H<EFBFBD><48>ç<EFBFBD><C3A7>N<EFBFBD><4E><EFBFBD><<3C>3 <0B>ڨQc6<63>S <09><><EFBFBD>B<1E>KULkH<6B><48><EFBFBD><EFBFBD> <0C><><EFBFBD>W<EFBFBD>/<2F>s<EFBFBD><73><EFBFBD><EFBFBD>q!%=<3D>':l <20><>K?7<m<><00>~<7E>]#x(v<>ᒃb<E19283><62>W<><57>{<7B>V<1E>={<7B><><EFBFBD><EFBFBD>,8p<38>Z
<05><>><3E><>k<08>)<29><>v<><76>
<EFBFBD>q=y{Tf'<><7F>5<EFBFBD>ɳ<>)<29><>v<><76><EFBFBD>6<EFBFBD>=<3D>^ƏK˸~<7E><EFBFBD>և<><D687>+<2B>܉<<3C>C<EFBFBD>v)}<7D><>rJIKe<4B>R <0C><>!1mHeO<65>Q&<26>^=#<23>bqCÖ<43><C396><10>d1<64><31>b<EFBFBD><62>ƍ<EFBFBD><C68D><EFBFBD>`<04><>0<EFBFBD><01><1C>Af<41><66>bڂn3
<EFBFBD>ۧ<EFBFBD>a<1B>&v<><76><EFBFBD>,<2C>-Z<>g<EFBFBD>4{<7B>L<EFBFBD>3ZŋYC<59><43><EFBFBD>?dB<64>Q<EFBFBD><51>Ν?<3F><><EFBFBD>pvp<76> <0B> <0B><><EFBFBD>+<2B><>e!ςW<57><7F> <09><><EFBFBD>}<7D>a 0<<3C>t=[3<><33>[ <09>(J<>}<7D>><3E>k d<>7v<>ޫ<w<>~z<>)9<><39><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֵ+<2B><>Sx<53><78><EFBFBD>p<06>m:<3A>޶g<DEB6>\<5C>$<24>ڂ.<2E>~[<5B>W%7v<37>zWKϋ<4B><CF8B>f<EFBFBD><66><EFBFBD>F{<7B><>c<EFBFBD><63>Vc;%5<><35><EFBFBD><EFBFBD>VUR<55>q3<1F>AE<41>E<EFBFBD><12>Z<12><><EFBFBD><EFBFBD><13><>Yf<59> <0C><>CM<43>X<EFBFBD>r5a#<04><><EFBFBD>Ӧ؜<D3A6><D89C><EFBFBD><EFBFBD><EFBFBD><EFBFBD>WP<02>{<7B><><EFBFBD> <0C>h<EFBFBD><1A>9Mfy<66><79>5b<35>nӦ͊<D3A6>:u<>D<EFBFBD>f=dxO<>e˾0f<><66>"<22>I<EFBFBD><49>WQ<1F><><EFBFBD>bR<62><52><EFBFBD><EFBFBD><EFBFBD><EFBFBD>~<7E><> <20>7j<37>H<EFBFBD>ac<61><63>L`B<><42>k<EFBFBD>f<EFBFBD>cJ<63>o<>2<EFBFBD>^'<27><>#<23>1<EFBFBD>4L<34>x<EFBFBD>I <09><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>=t<>es<65><73>!<21>%<<3C><><EFBFBD>6x#<23><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>.<2E>V+<2B>j<EFBFBD>2<EFBFBD>V<EFBFBD>a6.<2E><><EFBFBD>R<EFBFBD>T<EFBFBD>“fIJ*3^<5E><><10>+xŊUԞ<55><D49E>#G<>y<EFBFBD><79><EFBFBD>;8))٘<>.l%<25>-p<><70>[<5B><>/Z<>4 <0B><>a<EFBFBD><61><EFBFBD><EFBFBD><EFBFBD>h<>LN<4C><4E><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ub0<1C><><EFBFBD><EFBFBD><EFBFBD>ً<EFBFBD>(?<3F> e<>#<06><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><z<><7A><17><><02><>ɬ<EFBFBD>a:ڇ<>3++[<5B><><EFBFBD>uu<75><75>X<EFBFBD>hJz%!<21>J-<2D><><01> <0C><>{<7B><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>P<EFBFBD>.ęwΕ<77> j<>wE穬<45> <0B><><EFBFBD><08>6<EFBFBD>n8<6E><38><EFBFBD>\<5C><><EFBFBD>F Ma<4D>)C@H<><48><EFBFBD><EFBFBD><EFBFBD><EFBFBD>x<EFBFBD>v<1C><><EFBFBD>Ȏ<EFBFBD>ݠ;88R<38>A<><41>)9@<40><1E><>׍<EFBFBD>;<3B>H<05>j<EFBFBD>O
<EFBFBD><07>:w/7<>wPL<50><4C><EFBFBD>"<22>ȿ<EFBFBD><C8BF><EFBFBD><19>V!rP<72>5jD<6A>I<EFBFBD><49>>X2<58><01>)<29>V)T<04><><EFBFBD>M#IuK<75><4B>qfo<66>9n<39><6E>J<EFBFBD>A<>nKJ<4B><4A>o5<6F>-8<><38><EFBFBD>l:<3A><><EFBFBD><EFBFBD> P<><08><>M <09><><EFBFBD><1E><><EFBFBD>{<7B><>"1<>_>Wj<57><6A>l <02><><EFBFBD>[<5B><><EFBFBD>R<0F>b.<08>J<EFBFBD><4A><͛~"<22><> `
<04>j<EFBFBD>fO8<4F>i<>a2<61><32>w<EFBFBD><77><01><>B<04>#<23>V<EFBFBD>dn<1E><08>$MJp<4A>c<EFBFBD><63><19>"<22><> `]ܒ<>@DMH '<27><><EFBFBD>;Kx<4B>L<EFBFBD>Gֽ <20>f<EFBFBD><66><EFBFBD>ڔ@HچR<><0F>h<EFBFBD><68><18><>Ƅ<EFBFBD><C684><EFBFBD>i<12><>A<04><01>#%MF<4D>q<><11> <09>B<><42>7<EFBFBD><37><EFBFBD>4&<26><><EFBFBD><EFBFBD>3W<33>]#5<<01>#%ݍZ<DD8D>)i1iA:<3A>D<>D<>:<3A><><EFBFBD><EFBFBD> P<><08>%)imIBMH<4D><48>g&$31<33>}<17>A<><41><EFBFBD>[<5B><08>њ<EFBFBD>֊<EFBFBD>Ą}<7D><><EFBFBD><:4<>#qA@<10>{ܖ<>4<EFBFBD><34><EFBFBD><EFBFBD>mIoCS<43>i<EFBFBD>+<2B><><11>P<10>_ܚ<>4!4 <0B><>><3E>.<2E>n<EFBFBD><6E><EFBFBD><EFBFBD>@<40>"<22>֤h5!A2<><32>=)Ak<41><6B>Ƥ`<60>?A<><41>p{R<>ȚIH<13>9͜O<CD9C>%<04><>G<EFBFBD>cH <09>j2B\kD<6B>4<EFBFBD><34><02>@<40>"<22>Q<EFBFBD>d<EFBFBD>Z<EFBFBD>Ȍ<EFBFBD><C88C><01> psf<73>u<EFBFBD>$5F@HɃ;_<>.X!%+<2B><><EFBFBD>I<10>`<04><><<3C><>邀R<>b<EFBFBD>H<EFBFBD>F@HɃ;_<>.X!%+<2B><><EFBFBD>I<10>`<04><><<3C><>邀R<>b<EFBFBD>H<EFBFBD>F@HɃ;_<>.X!%+<2B><><EFBFBD>I<10>`<04><><<3C><>邀R<>b<EFBFBD>H<EFBFBD>F@HɃ;_<>.X!%+<2B><><EFBFBD>I<10>`<04>3DE<44>A<EFBFBD>XsIEND<4E>B`<60>
---
File: /docs/specification/2024-11-05/server/tools.md
---
---
title: Tools
type: docs
weight: 40
---
{{< callout type="info" >}} **Protocol Revision**: 2024-11-05 {{< /callout >}}
The Model Context Protocol (MCP) allows servers to expose tools that can be invoked by
language models. Tools enable models to interact with external systems, such as querying
databases, calling APIs, or performing computations. Each tool is uniquely identified by
a name and includes metadata describing its schema.
## User Interaction Model
Tools in MCP are designed to be **model-controlled**, meaning that the language model can
discover and invoke tools automatically based on its contextual understanding and the
user's prompts.
However, implementations are free to expose tools through any interface pattern that
suits their needs&mdash;the protocol itself does not mandate any specific user
interaction model.
{{< callout type="warning" >}} For trust & safety and security, there **SHOULD** always
be a human in the loop with the ability to deny tool invocations.
Applications **SHOULD**:
- Provide UI that makes clear which tools are being exposed to the AI model
- Insert clear visual indicators when tools are invoked
- Present confirmation prompts to the user for operations, to ensure a human is in the
loop {{< /callout >}}
## Capabilities
Servers that support tools **MUST** declare the `tools` capability:
```json
{
"capabilities": {
"tools": {
"listChanged": true
}
}
}
```
`listChanged` indicates whether the server will emit notifications when the list of
available tools changes.
## Protocol Messages
### Listing Tools
To discover available tools, clients send a `tools/list` request. This operation supports
[pagination]({{< ref "/specification/2024-11-05/server/utilities/pagination" >}}).
**Request:**
```json
{
"jsonrpc": "2.0",
"id": 1,
"method": "tools/list",
"params": {
"cursor": "optional-cursor-value"
}
}
```
**Response:**
```json
{
"jsonrpc": "2.0",
"id": 1,
"result": {
"tools": [
{
"name": "get_weather",
"description": "Get current weather information for a location",
"inputSchema": {
"type": "object",
"properties": {
"location": {
"type": "string",
"description": "City name or zip code"
}
},
"required": ["location"]
}
}
],
"nextCursor": "next-page-cursor"
}
}
```
### Calling Tools
To invoke a tool, clients send a `tools/call` request:
**Request:**
```json
{
"jsonrpc": "2.0",
"id": 2,
"method": "tools/call",
"params": {
"name": "get_weather",
"arguments": {
"location": "New York"
}
}
}
```
**Response:**
```json
{
"jsonrpc": "2.0",
"id": 2,
"result": {
"content": [
{
"type": "text",
"text": "Current weather in New York:\nTemperature: 72°F\nConditions: Partly cloudy"
}
],
"isError": false
}
}
```
### List Changed Notification
When the list of available tools changes, servers that declared the `listChanged`
capability **SHOULD** send a notification:
```json
{
"jsonrpc": "2.0",
"method": "notifications/tools/list_changed"
}
```
## Message Flow
```mermaid
sequenceDiagram
participant LLM
participant Client
participant Server
Note over Client,Server: Discovery
Client->>Server: tools/list
Server-->>Client: List of tools
Note over Client,LLM: Tool Selection
LLM->>Client: Select tool to use
Note over Client,Server: Invocation
Client->>Server: tools/call
Server-->>Client: Tool result
Client->>LLM: Process result
Note over Client,Server: Updates
Server--)Client: tools/list_changed
Client->>Server: tools/list
Server-->>Client: Updated tools
```
## Data Types
### Tool
A tool definition includes:
- `name`: Unique identifier for the tool
- `description`: Human-readable description of functionality
- `inputSchema`: JSON Schema defining expected parameters
### Tool Result
Tool results can contain multiple content items of different types:
#### Text Content
```json
{
"type": "text",
"text": "Tool result text"
}
```
#### Image Content
```json
{
"type": "image",
"data": "base64-encoded-data",
"mimeType": "image/png"
}
```
#### Embedded Resources
[Resources]({{< ref "/specification/2024-11-05/server/resources" >}}) **MAY** be
embedded, to provide additional context or data, behind a URI that can be subscribed to
or fetched again by the client later:
```json
{
"type": "resource",
"resource": {
"uri": "resource://example",
"mimeType": "text/plain",
"text": "Resource content"
}
}
```
## Error Handling
Tools use two error reporting mechanisms:
1. **Protocol Errors**: Standard JSON-RPC errors for issues like:
- Unknown tools
- Invalid arguments
- Server errors
2. **Tool Execution Errors**: Reported in tool results with `isError: true`:
- API failures
- Invalid input data
- Business logic errors
Example protocol error:
```json
{
"jsonrpc": "2.0",
"id": 3,
"error": {
"code": -32602,
"message": "Unknown tool: invalid_tool_name"
}
}
```
Example tool execution error:
```json
{
"jsonrpc": "2.0",
"id": 4,
"result": {
"content": [
{
"type": "text",
"text": "Failed to fetch weather data: API rate limit exceeded"
}
],
"isError": true
}
}
```
## Security Considerations
1. Servers **MUST**:
- Validate all tool inputs
- Implement proper access controls
- Rate limit tool invocations
- Sanitize tool outputs
2. Clients **SHOULD**:
- Prompt for user confirmation on sensitive operations
- Show tool inputs to the user before calling the server, to avoid malicious or
accidental data exfiltration
- Validate tool results before passing to LLM
- Implement timeouts for tool calls
- Log tool usage for audit purposes
---
File: /docs/specification/2024-11-05/_index.md
---
---
linkTitle: 2024-11-05 (Final)
title: Model Context Protocol specification
cascade:
type: docs
breadcrumbs: false
weight: 2
---
{{< callout type="info" >}} **Protocol Revision**: 2024-11-05 {{< /callout >}}
[Model Context Protocol](https://modelcontextprotocol.io) (MCP) is an open protocol that
enables seamless integration between LLM applications and external data sources and
tools. Whether you're building an AI-powered IDE, enhancing a chat interface, or creating
custom AI workflows, MCP provides a standardized way to connect LLMs with the context
they need.
This specification defines the authoritative protocol requirements, based on the
TypeScript schema in
[schema.ts](https://github.com/modelcontextprotocol/specification/blob/main/schema/2024-11-05/schema.ts).
For implementation guides and examples, visit
[modelcontextprotocol.io](https://modelcontextprotocol.io).
The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD
NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be
interpreted as described in [BCP 14](https://datatracker.ietf.org/doc/html/bcp14)
[[RFC2119](https://datatracker.ietf.org/doc/html/rfc2119)]
[[RFC8174](https://datatracker.ietf.org/doc/html/rfc8174)] when, and only when, they
appear in all capitals, as shown here.
## Overview
MCP provides a standardized way for applications to:
- Share contextual information with language models
- Expose tools and capabilities to AI systems
- Build composable integrations and workflows
The protocol uses [JSON-RPC](https://www.jsonrpc.org/) 2.0 messages to establish
communication between:
- **Hosts**: LLM applications that initiate connections
- **Clients**: Connectors within the host application
- **Servers**: Services that provide context and capabilities
MCP takes some inspiration from the
[Language Server Protocol](https://microsoft.github.io/language-server-protocol/), which
standardizes how to add support for programming languages across a whole ecosystem of
development tools. In a similar way, MCP standardizes how to integrate additional context
and tools into the ecosystem of AI applications.
## Key Details
### Base Protocol
- [JSON-RPC](https://www.jsonrpc.org/) message format
- Stateful connections
- Server and client capability negotiation
### Features
Servers offer any of the following features to clients:
- **Resources**: Context and data, for the user or the AI model to use
- **Prompts**: Templated messages and workflows for users
- **Tools**: Functions for the AI model to execute
Clients may offer the following feature to servers:
- **Sampling**: Server-initiated agentic behaviors and recursive LLM interactions
### Additional Utilities
- Configuration
- Progress tracking
- Cancellation
- Error reporting
- Logging
## Security and Trust & Safety
The Model Context Protocol enables powerful capabilities through arbitrary data access
and code execution paths. With this power comes important security and trust
considerations that all implementors must carefully address.
### Key Principles
1. **User Consent and Control**
- Users must explicitly consent to and understand all data access and operations
- Users must retain control over what data is shared and what actions are taken
- Implementors should provide clear UIs for reviewing and authorizing activities
2. **Data Privacy**
- Hosts must obtain explicit user consent before exposing user data to servers
- Hosts must not transmit resource data elsewhere without user consent
- User data should be protected with appropriate access controls
3. **Tool Safety**
- Tools represent arbitrary code execution and must be treated with appropriate
caution
- Hosts must obtain explicit user consent before invoking any tool
- Users should understand what each tool does before authorizing its use
4. **LLM Sampling Controls**
- Users must explicitly approve any LLM sampling requests
- Users should control:
- Whether sampling occurs at all
- The actual prompt that will be sent
- What results the server can see
- The protocol intentionally limits server visibility into prompts
### Implementation Guidelines
While MCP itself cannot enforce these security principles at the protocol level,
implementors **SHOULD**:
1. Build robust consent and authorization flows into their applications
2. Provide clear documentation of security implications
3. Implement appropriate access controls and data protections
4. Follow security best practices in their integrations
5. Consider privacy implications in their feature designs
## Learn More
Explore the detailed specification for each protocol component:
{{< cards >}} {{< card link="architecture" title="Architecture" icon="template" >}}
{{< card link="basic" title="Base Protocol" icon="code" >}}
{{< card link="server" title="Server Features" icon="server" >}}
{{< card link="client" title="Client Features" icon="user" >}}
{{< card link="contributing" title="Contributing" icon="pencil" >}} {{< /cards >}}
---
File: /docs/specification/2025-03-26/architecture/_index.md
---
---
title: Architecture
cascade:
type: docs
weight: 10
---
The Model Context Protocol (MCP) follows a client-host-server architecture where each
host can run multiple client instances. This architecture enables users to integrate AI
capabilities across applications while maintaining clear security boundaries and
isolating concerns. Built on JSON-RPC, MCP provides a stateful session protocol focused
on context exchange and sampling coordination between clients and servers.
## Core Components
```mermaid
graph LR
subgraph "Application Host Process"
H[Host]
C1[Client 1]
C2[Client 2]
C3[Client 3]
H --> C1
H --> C2
H --> C3
end
subgraph "Local machine"
S1[Server 1<br>Files & Git]
S2[Server 2<br>Database]
R1[("Local<br>Resource A")]
R2[("Local<br>Resource B")]
C1 --> S1
C2 --> S2
S1 <--> R1
S2 <--> R2
end
subgraph "Internet"
S3[Server 3<br>External APIs]
R3[("Remote<br>Resource C")]
C3 --> S3
S3 <--> R3
end
```
### Host
The host process acts as the container and coordinator:
- Creates and manages multiple client instances
- Controls client connection permissions and lifecycle
- Enforces security policies and consent requirements
- Handles user authorization decisions
- Coordinates AI/LLM integration and sampling
- Manages context aggregation across clients
### Clients
Each client is created by the host and maintains an isolated server connection:
- Establishes one stateful session per server
- Handles protocol negotiation and capability exchange
- Routes protocol messages bidirectionally
- Manages subscriptions and notifications
- Maintains security boundaries between servers
A host application creates and manages multiple clients, with each client having a 1:1
relationship with a particular server.
### Servers
Servers provide specialized context and capabilities:
- Expose resources, tools and prompts via MCP primitives
- Operate independently with focused responsibilities
- Request sampling through client interfaces
- Must respect security constraints
- Can be local processes or remote services
## Design Principles
MCP is built on several key design principles that inform its architecture and
implementation:
1. **Servers should be extremely easy to build**
- Host applications handle complex orchestration responsibilities
- Servers focus on specific, well-defined capabilities
- Simple interfaces minimize implementation overhead
- Clear separation enables maintainable code
2. **Servers should be highly composable**
- Each server provides focused functionality in isolation
- Multiple servers can be combined seamlessly
- Shared protocol enables interoperability
- Modular design supports extensibility
3. **Servers should not be able to read the whole conversation, nor "see into" other
servers**
- Servers receive only necessary contextual information
- Full conversation history stays with the host
- Each server connection maintains isolation
- Cross-server interactions are controlled by the host
- Host process enforces security boundaries
4. **Features can be added to servers and clients progressively**
- Core protocol provides minimal required functionality
- Additional capabilities can be negotiated as needed
- Servers and clients evolve independently
- Protocol designed for future extensibility
- Backwards compatibility is maintained
## Capability Negotiation
The Model Context Protocol uses a capability-based negotiation system where clients and
servers explicitly declare their supported features during initialization. Capabilities
determine which protocol features and primitives are available during a session.
- Servers declare capabilities like resource subscriptions, tool support, and prompt
templates
- Clients declare capabilities like sampling support and notification handling
- Both parties must respect declared capabilities throughout the session
- Additional capabilities can be negotiated through extensions to the protocol
```mermaid
sequenceDiagram
participant Host
participant Client
participant Server
Host->>+Client: Initialize client
Client->>+Server: Initialize session with capabilities
Server-->>Client: Respond with supported capabilities
Note over Host,Server: Active Session with Negotiated Features
loop Client Requests
Host->>Client: User- or model-initiated action
Client->>Server: Request (tools/resources)
Server-->>Client: Response
Client-->>Host: Update UI or respond to model
end
loop Server Requests
Server->>Client: Request (sampling)
Client->>Host: Forward to AI
Host-->>Client: AI response
Client-->>Server: Response
end
loop Notifications
Server--)Client: Resource updates
Client--)Server: Status changes
end
Host->>Client: Terminate
Client->>-Server: End session
deactivate Server
```
Each capability unlocks specific protocol features for use during the session. For
example:
- Implemented [server features]({{< ref "../server" >}}) must be advertised in the
server's capabilities
- Emitting resource subscription notifications requires the server to declare
subscription support
- Tool invocation requires the server to declare tool capabilities
- [Sampling]({{< ref "../client" >}}) requires the client to declare support in its
capabilities
This capability negotiation ensures clients and servers have a clear understanding of
supported functionality while maintaining protocol extensibility.
---
File: /docs/specification/2025-03-26/basic/utilities/_index.md
---
---
title: Utilities
---
{{< callout type="info" >}} **Protocol Revision**: 2025-03-26 {{< /callout >}}
These optional features enhance the base protocol functionality with various utilities.
{{< cards >}} {{< card link="ping" title="Ping" icon="status-online" >}}
{{< card link="cancellation" title="Cancellation" icon="x" >}}
{{< card link="progress" title="Progress" icon="clock" >}} {{< /cards >}}
---
File: /docs/specification/2025-03-26/basic/utilities/cancellation.md
---
---
title: Cancellation
weight: 10
---
{{< callout type="info" >}} **Protocol Revision**: 2025-03-26 {{< /callout >}}
The Model Context Protocol (MCP) supports optional cancellation of in-progress requests
through notification messages. Either side can send a cancellation notification to
indicate that a previously-issued request should be terminated.
## Cancellation Flow
When a party wants to cancel an in-progress request, it sends a `notifications/cancelled`
notification containing:
- The ID of the request to cancel
- An optional reason string that can be logged or displayed
```json
{
"jsonrpc": "2.0",
"method": "notifications/cancelled",
"params": {
"requestId": "123",
"reason": "User requested cancellation"
}
}
```
## Behavior Requirements
1. Cancellation notifications **MUST** only reference requests that:
- Were previously issued in the same direction
- Are believed to still be in-progress
2. The `initialize` request **MUST NOT** be cancelled by clients
3. Receivers of cancellation notifications **SHOULD**:
- Stop processing the cancelled request
- Free associated resources
- Not send a response for the cancelled request
4. Receivers **MAY** ignore cancellation notifications if:
- The referenced request is unknown
- Processing has already completed
- The request cannot be cancelled
5. The sender of the cancellation notification **SHOULD** ignore any response to the
request that arrives afterward
## Timing Considerations
Due to network latency, cancellation notifications may arrive after request processing
has completed, and potentially after a response has already been sent.
Both parties **MUST** handle these race conditions gracefully:
```mermaid
sequenceDiagram
participant Client
participant Server
Client->>Server: Request (ID: 123)
Note over Server: Processing starts
Client--)Server: notifications/cancelled (ID: 123)
alt
Note over Server: Processing may have<br/>completed before<br/>cancellation arrives
else If not completed
Note over Server: Stop processing
end
```
## Implementation Notes
- Both parties **SHOULD** log cancellation reasons for debugging
- Application UIs **SHOULD** indicate when cancellation is requested
## Error Handling
Invalid cancellation notifications **SHOULD** be ignored:
- Unknown request IDs
- Already completed requests
- Malformed notifications
This maintains the "fire and forget" nature of notifications while allowing for race
conditions in asynchronous communication.
---
File: /docs/specification/2025-03-26/basic/utilities/ping.md
---
---
title: Ping
weight: 5
---
{{< callout type="info" >}} **Protocol Revision**: 2025-03-26 {{< /callout >}}
The Model Context Protocol includes an optional ping mechanism that allows either party
to verify that their counterpart is still responsive and the connection is alive.
## Overview
The ping functionality is implemented through a simple request/response pattern. Either
the client or server can initiate a ping by sending a `ping` request.
## Message Format
A ping request is a standard JSON-RPC request with no parameters:
```json
{
"jsonrpc": "2.0",
"id": "123",
"method": "ping"
}
```
## Behavior Requirements
1. The receiver **MUST** respond promptly with an empty response:
```json
{
"jsonrpc": "2.0",
"id": "123",
"result": {}
}
```
2. If no response is received within a reasonable timeout period, the sender **MAY**:
- Consider the connection stale
- Terminate the connection
- Attempt reconnection procedures
## Usage Patterns
```mermaid
sequenceDiagram
participant Sender
participant Receiver
Sender->>Receiver: ping request
Receiver->>Sender: empty response
```
## Implementation Considerations
- Implementations **SHOULD** periodically issue pings to detect connection health
- The frequency of pings **SHOULD** be configurable
- Timeouts **SHOULD** be appropriate for the network environment
- Excessive pinging **SHOULD** be avoided to reduce network overhead
## Error Handling
- Timeouts **SHOULD** be treated as connection failures
- Multiple failed pings **MAY** trigger connection reset
- Implementations **SHOULD** log ping failures for diagnostics
---
File: /docs/specification/2025-03-26/basic/utilities/progress.md
---
---
title: Progress
weight: 30
---
{{< callout type="info" >}} **Protocol Revision**: 2025-03-26 {{< /callout >}}
The Model Context Protocol (MCP) supports optional progress tracking for long-running
operations through notification messages. Either side can send progress notifications to
provide updates about operation status.
## Progress Flow
When a party wants to _receive_ progress updates for a request, it includes a
`progressToken` in the request metadata.
- Progress tokens **MUST** be a string or integer value
- Progress tokens can be chosen by the sender using any means, but **MUST** be unique
across all active requests.
```json
{
"jsonrpc": "2.0",
"id": 1,
"method": "some_method",
"params": {
"_meta": {
"progressToken": "abc123"
}
}
}
```
The receiver **MAY** then send progress notifications containing:
- The original progress token
- The current progress value so far
- An optional "total" value
- An optional "message" value
```json
{
"jsonrpc": "2.0",
"method": "notifications/progress",
"params": {
"progressToken": "abc123",
"progress": 50,
"total": 100,
"message": "Reticulating splines..."
}
}
```
- The `progress` value **MUST** increase with each notification, even if the total is
unknown.
- The `progress` and the `total` values **MAY** be floating point.
- The `message` field **SHOULD** provide relevant human readable progress information.
## Behavior Requirements
1. Progress notifications **MUST** only reference tokens that:
- Were provided in an active request
- Are associated with an in-progress operation
2. Receivers of progress requests **MAY**:
- Choose not to send any progress notifications
- Send notifications at whatever frequency they deem appropriate
- Omit the total value if unknown
```mermaid
sequenceDiagram
participant Sender
participant Receiver
Note over Sender,Receiver: Request with progress token
Sender->>Receiver: Method request with progressToken
Note over Sender,Receiver: Progress updates
loop Progress Updates
Receiver-->>Sender: Progress notification (0.2/1.0)
Receiver-->>Sender: Progress notification (0.6/1.0)
Receiver-->>Sender: Progress notification (1.0/1.0)
end
Note over Sender,Receiver: Operation complete
Receiver->>Sender: Method response
```
## Implementation Notes
- Senders and receivers **SHOULD** track active progress tokens
- Both parties **SHOULD** implement rate limiting to prevent flooding
- Progress notifications **MUST** stop after completion
---
File: /docs/specification/2025-03-26/basic/_index.md
---
---
title: Base Protocol
cascade:
type: docs
weight: 20
---
{{< callout type="info" >}} **Protocol Revision**: 2025-03-26 {{< /callout >}}
The Model Context Protocol consists of several key components that work together:
- **Base Protocol**: Core JSON-RPC message types
- **Lifecycle Management**: Connection initialization, capability negotiation, and
session control
- **Server Features**: Resources, prompts, and tools exposed by servers
- **Client Features**: Sampling and root directory lists provided by clients
- **Utilities**: Cross-cutting concerns like logging and argument completion
All implementations **MUST** support the base protocol and lifecycle management
components. Other components **MAY** be implemented based on the specific needs of the
application.
These protocol layers establish clear separation of concerns while enabling rich
interactions between clients and servers. The modular design allows implementations to
support exactly the features they need.
## Messages
All messages between MCP clients and servers **MUST** follow the
[JSON-RPC 2.0](https://www.jsonrpc.org/specification) specification. The protocol defines
these types of messages:
### Requests
Requests are sent from the client to the server or vice versa, to initiate an operation.
```typescript
{
jsonrpc: "2.0";
id: string | number;
method: string;
params?: {
[key: string]: unknown;
};
}
```
- Requests **MUST** include a string or integer ID.
- Unlike base JSON-RPC, the ID **MUST NOT** be `null`.
- The request ID **MUST NOT** have been previously used by the requestor within the same
session.
### Responses
Responses are sent in reply to requests, containing the result or error of the operation.
```typescript
{
jsonrpc: "2.0";
id: string | number;
result?: {
[key: string]: unknown;
}
error?: {
code: number;
message: string;
data?: unknown;
}
}
```
- Responses **MUST** include the same ID as the request they correspond to.
- **Responses** are further sub-categorized as either **successful results** or
**errors**. Either a `result` or an `error` **MUST** be set. A response **MUST NOT**
set both.
- Results **MAY** follow any JSON object structure, while errors **MUST** include an
error code and message at minimum.
- Error codes **MUST** be integers.
### Notifications
Notifications are sent from the client to the server or vice versa, as a one-way message.
The receiver **MUST NOT** send a response.
```typescript
{
jsonrpc: "2.0";
method: string;
params?: {
[key: string]: unknown;
};
}
```
- Notifications **MUST NOT** include an ID.
### Batching
JSON-RPC also defines a means to
[batch multiple requests and notifications](https://www.jsonrpc.org/specification#batch),
by sending them in an array. MCP implementations **MAY** support sending JSON-RPC
batches, but **MUST** support receiving JSON-RPC batches.
## Auth
MCP provides an [Authorization]({{< ref "authorization" >}}) framework for use with HTTP.
Implementations using an HTTP-based transport **SHOULD** conform to this specification,
whereas implementations using STDIO transport **SHOULD NOT** follow this specification,
and instead retrieve credentials from the environment.
Additionally, clients and servers **MAY** negotiate their own custom authentication and
authorization strategies.
For further discussions and contributions to the evolution of MCP’s auth mechanisms, join
us in
[GitHub Discussions](https://github.com/modelcontextprotocol/specification/discussions)
to help shape the future of the protocol!
## Schema
The full specification of the protocol is defined as a
[TypeScript schema](https://github.com/modelcontextprotocol/specification/blob/main/schema/2025-03-26/schema.ts).
This is the source of truth for all protocol messages and structures.
There is also a
[JSON Schema](https://github.com/modelcontextprotocol/specification/blob/main/schema/2025-03-26/schema.json),
which is automatically generated from the TypeScript source of truth, for use with
various automated tooling.
---
File: /docs/specification/2025-03-26/basic/authorization.md
---
---
title: Authorization
type: docs
weight: 15
---
{{< callout type="info" >}} **Protocol Revision**: 2025-03-26 {{< /callout >}}
## 1. Introduction
### 1.1 Purpose and Scope
The Model Context Protocol provides authorization capabilities at the transport level,
enabling MCP clients to make requests to restricted MCP servers on behalf of resource
owners. This specification defines the authorization flow for HTTP-based transports.
### 1.2 Protocol Requirements
Authorization is **OPTIONAL** for MCP implementations. When supported:
- Implementations using an HTTP-based transport **SHOULD** conform to this specification.
- Implementations using an STDIO transport **SHOULD NOT** follow this specification, and
instead retrieve credentials from the environment.
- Implementations using alternative transports **MUST** follow established security best
practices for their protocol.
### 1.3 Standards Compliance
This authorization mechanism is based on established specifications listed below, but
implements a selected subset of their features to ensure security and interoperability
while maintaining simplicity:
- [OAuth 2.1 IETF DRAFT](https://datatracker.ietf.org/doc/html/draft-ietf-oauth-v2-1-12)
- OAuth 2.0 Authorization Server Metadata
([RFC8414](https://datatracker.ietf.org/doc/html/rfc8414))
- OAuth 2.0 Dynamic Client Registration Protocol
([RFC7591](https://datatracker.ietf.org/doc/html/rfc7591))
## 2. Authorization Flow
### 2.1 Overview
1. MCP auth implementations **MUST** implement OAuth 2.1 with appropriate security
measures for both confidential and public clients.
2. MCP auth implementations **SHOULD** support the OAuth 2.0 Dynamic Client Registration
Protocol ([RFC7591](https://datatracker.ietf.org/doc/html/rfc7591)).
3. MCP servers **SHOULD** and MCP clients **MUST** implement OAuth 2.0 Authorization
Server Metadata ([RFC8414](https://datatracker.ietf.org/doc/html/rfc8414)). Servers
that do not support Authorization Server Metadata **MUST** follow the default URI
schema.
### 2.2 Basic OAuth 2.1 Authorization
When authorization is required and not yet proven by the client, servers **MUST** respond
with _HTTP 401 Unauthorized_.
Clients initiate the
[OAuth 2.1 IETF DRAFT](https://datatracker.ietf.org/doc/html/draft-ietf-oauth-v2-1-12)
authorization flow after receiving the _HTTP 401 Unauthorized_.
The following demonstrates the basic OAuth 2.1 for public clients using PKCE.
```mermaid
sequenceDiagram
participant B as User-Agent (Browser)
participant C as Client
participant M as MCP Server
C->>M: MCP Request
M->>C: HTTP 401 Unauthorized
Note over C: Generate code_verifier and code_challenge
C->>B: Open browser with authorization URL + code_challenge
B->>M: GET /authorize
Note over M: User logs in and authorizes
M->>B: Redirect to callback URL with auth code
B->>C: Callback with authorization code
C->>M: Token Request with code + code_verifier
M->>C: Access Token (+ Refresh Token)
C->>M: MCP Request with Access Token
Note over C,M: Begin standard MCP message exchange
```
### 2.3 Server Metadata Discovery
For server capability discovery:
- MCP clients _MUST_ follow the OAuth 2.0 Authorization Server Metadata protocol defined
in [RFC8414](https://datatracker.ietf.org/doc/html/rfc8414).
- MCP server _SHOULD_ follow the OAuth 2.0 Authorization Server Metadata protocol.
- MCP servers that do not support the OAuth 2.0 Authorization Server Metadata protocol,
_MUST_ support fallback URLs.
The discovery flow is illustrated below:
```mermaid
sequenceDiagram
participant C as Client
participant S as Server
C->>S: GET /.well-known/oauth-authorization-server
alt Discovery Success
S->>C: 200 OK + Metadata Document
Note over C: Use endpoints from metadata
else Discovery Failed
S->>C: 404 Not Found
Note over C: Fall back to default endpoints
end
Note over C: Continue with authorization flow
```
#### 2.3.1 Server Metadata Discovery Headers
MCP clients _SHOULD_ include the header `MCP-Protocol-Version: <protocol-version>` during
Server Metadata Discovery to allow the MCP server to respond based on the MCP protocol
version.
For example: `MCP-Protocol-Version: 2024-11-05`
#### 2.3.2 Authorization Base URL
The authorization base URL **MUST** be determined from the MCP server URL by discarding
any existing `path` component. For example:
If the MCP server URL is `https://api.example.com/v1/mcp`, then:
- The authorization base URL is `https://api.example.com`
- The metadata endpoint **MUST** be at
`https://api.example.com/.well-known/oauth-authorization-server`
This ensures authorization endpoints are consistently located at the root level of the
domain hosting the MCP server, regardless of any path components in the MCP server URL.
#### 2.3.3 Fallbacks for Servers without Metadata Discovery
For servers that do not implement OAuth 2.0 Authorization Server Metadata, clients
**MUST** use the following default endpoint paths relative to the authorization base URL
(as defined in [Section 2.3.2](#232-authorization-base-url)):
| Endpoint | Default Path | Description |
| ---------------------- | ------------ | ------------------------------------ |
| Authorization Endpoint | /authorize | Used for authorization requests |
| Token Endpoint | /token | Used for token exchange & refresh |
| Registration Endpoint | /register | Used for dynamic client registration |
For example, with an MCP server hosted at `https://api.example.com/v1/mcp`, the default
endpoints would be:
- `https://api.example.com/authorize`
- `https://api.example.com/token`
- `https://api.example.com/register`
Clients **MUST** first attempt to discover endpoints via the metadata document before
falling back to default paths. When using default paths, all other protocol requirements
remain unchanged.
### 2.3 Dynamic Client Registration
MCP clients and servers **SHOULD** support the
[OAuth 2.0 Dynamic Client Registration Protocol](https://datatracker.ietf.org/doc/html/rfc7591)
to allow MCP clients to obtain OAuth client IDs without user interaction. This provides a
standardized way for clients to automatically register with new servers, which is crucial
for MCP because:
- Clients cannot know all possible servers in advance
- Manual registration would create friction for users
- It enables seamless connection to new servers
- Servers can implement their own registration policies
Any MCP servers that _do not_ support Dynamic Client Registration need to provide
alternative ways to obtain a client ID (and, if applicable, client secret). For one of
these servers, MCP clients will have to either:
1. Hardcode a client ID (and, if applicable, client secret) specifically for that MCP
server, or
2. Present a UI to users that allows them to enter these details, after registering an
OAuth client themselves (e.g., through a configuration interface hosted by the
server).
### 2.4 Authorization Flow Steps
The complete Authorization flow proceeds as follows:
```mermaid
sequenceDiagram
participant B as User-Agent (Browser)
participant C as Client
participant M as MCP Server
C->>M: GET /.well-known/oauth-authorization-server
alt Server Supports Discovery
M->>C: Authorization Server Metadata
else No Discovery
M->>C: 404 (Use default endpoints)
end
alt Dynamic Client Registration
C->>M: POST /register
M->>C: Client Credentials
end
Note over C: Generate PKCE Parameters
C->>B: Open browser with authorization URL + code_challenge
B->>M: Authorization Request
Note over M: User /authorizes
M->>B: Redirect to callback with authorization code
B->>C: Authorization code callback
C->>M: Token Request + code_verifier
M->>C: Access Token (+ Refresh Token)
C->>M: API Requests with Access Token
```
#### 2.4.1 Decision Flow Overview
```mermaid
flowchart TD
A[Start Auth Flow] --> B{Check Metadata Discovery}
B -->|Available| C[Use Metadata Endpoints]
B -->|Not Available| D[Use Default Endpoints]
C --> G{Check Registration Endpoint}
D --> G
G -->|Available| H[Perform Dynamic Registration]
G -->|Not Available| I[Alternative Registration Required]
H --> J[Start OAuth Flow]
I --> J
J --> K[Generate PKCE Parameters]
K --> L[Request Authorization]
L --> M[User Authorization]
M --> N[Exchange Code for Tokens]
N --> O[Use Access Token]
```
### 2.5 Access Token Usage
#### 2.5.1 Token Requirements
Access token handling **MUST** conform to
[OAuth 2.1 Section 5](https://datatracker.ietf.org/doc/html/draft-ietf-oauth-v2-1-12#section-5)
requirements for resource requests. Specifically:
1. MCP client **MUST** use the Authorization request header field
[Section 5.1.1](https://datatracker.ietf.org/doc/html/draft-ietf-oauth-v2-1-12#section-5.1.1):
```
Authorization: Bearer <access-token>
```
Note that authorization **MUST** be included in every HTTP request from client to server,
even if they are part of the same logical session.
2. Access tokens **MUST NOT** be included in the URI query string
Example request:
```http
GET /v1/contexts HTTP/1.1
Host: mcp.example.com
Authorization: Bearer eyJhbGciOiJIUzI1NiIs...
```
#### 2.5.2 Token Handling
Resource servers **MUST** validate access tokens as described in
[Section 5.2](https://datatracker.ietf.org/doc/html/draft-ietf-oauth-v2-1-12#section-5.2).
If validation fails, servers **MUST** respond according to
[Section 5.3](https://datatracker.ietf.org/doc/html/draft-ietf-oauth-v2-1-12#section-5.3)
error handling requirements. Invalid or expired tokens **MUST** receive a HTTP 401
response.
### 2.6 Security Considerations
The following security requirements **MUST** be implemented:
1. Clients **MUST** securely store tokens following OAuth 2.0 best practices
2. Servers **SHOULD** enforce token expiration and rotation
3. All authorization endpoints **MUST** be served over HTTPS
4. Servers **MUST** validate redirect URIs to prevent open redirect vulnerabilities
5. Redirect URIs **MUST** be either localhost URLs or HTTPS URLs
### 2.7 Error Handling
Servers **MUST** return appropriate HTTP status codes for authorization errors:
| Status Code | Description | Usage |
| ----------- | ------------ | ------------------------------------------ |
| 401 | Unauthorized | Authorization required or token invalid |
| 403 | Forbidden | Invalid scopes or insufficient permissions |
| 400 | Bad Request | Malformed authorization request |
### 2.8 Implementation Requirements
1. Implementations **MUST** follow OAuth 2.1 security best practices
2. PKCE is **REQUIRED** for all clients
3. Token rotation **SHOULD** be implemented for enhanced security
4. Token lifetimes **SHOULD** be limited based on security requirements
### 2.9 Third-Party Authorization Flow
#### 2.9.1 Overview
MCP servers **MAY** support delegated authorization through third-party authorization
servers. In this flow, the MCP server acts as both an OAuth client (to the third-party
auth server) and an OAuth authorization server (to the MCP client).
#### 2.9.2 Flow Description
The third-party authorization flow comprises these steps:
1. MCP client initiates standard OAuth flow with MCP server
2. MCP server redirects user to third-party authorization server
3. User authorizes with third-party server
4. Third-party server redirects back to MCP server with authorization code
5. MCP server exchanges code for third-party access token
6. MCP server generates its own access token bound to the third-party session
7. MCP server completes original OAuth flow with MCP client
```mermaid
sequenceDiagram
participant B as User-Agent (Browser)
participant C as MCP Client
participant M as MCP Server
participant T as Third-Party Auth Server
C->>M: Initial OAuth Request
M->>B: Redirect to Third-Party /authorize
B->>T: Authorization Request
Note over T: User authorizes
T->>B: Redirect to MCP Server callback
B->>M: Authorization code
M->>T: Exchange code for token
T->>M: Third-party access token
Note over M: Generate bound MCP token
M->>B: Redirect to MCP Client callback
B->>C: MCP authorization code
C->>M: Exchange code for token
M->>C: MCP access token
```
#### 2.9.3 Session Binding Requirements
MCP servers implementing third-party authorization **MUST**:
1. Maintain secure mapping between third-party tokens and issued MCP tokens
2. Validate third-party token status before honoring MCP tokens
3. Implement appropriate token lifecycle management
4. Handle third-party token expiration and renewal
#### 2.9.4 Security Considerations
When implementing third-party authorization, servers **MUST**:
1. Validate all redirect URIs
2. Securely store third-party credentials
3. Implement appropriate session timeout handling
4. Consider security implications of token chaining
5. Implement proper error handling for third-party auth failures
## 3. Best Practices
#### 3.1 Local clients as Public OAuth 2.1 Clients
We strongly recommend that local clients implement OAuth 2.1 as a public client:
1. Utilizing code challenges (PKCE) for authorization requests to prevent interception
attacks
2. Implementing secure token storage appropriate for the local system
3. Following token refresh best practices to maintain sessions
4. Properly handling token expiration and renewal
#### 3.2 Authorization Metadata Discovery
We strongly recommend that all clients implement metadata discovery. This reduces the
need for users to provide endpoints manually or clients to fallback to the defined
defaults.
#### 3.3 Dynamic Client Registration
Since clients do not know the set of MCP servers in advance, we strongly recommend the
implementation of dynamic client registration. This allows applications to automatically
register with the MCP server, and removes the need for users to obtain client ids
manually.
---
File: /docs/specification/2025-03-26/basic/lifecycle.md
---
---
title: Lifecycle
type: docs
weight: 30
---
{{< callout type="info" >}} **Protocol Revision**: 2025-03-26 {{< /callout >}}
The Model Context Protocol (MCP) defines a rigorous lifecycle for client-server
connections that ensures proper capability negotiation and state management.
1. **Initialization**: Capability negotiation and protocol version agreement
2. **Operation**: Normal protocol communication
3. **Shutdown**: Graceful termination of the connection
```mermaid
sequenceDiagram
participant Client
participant Server
Note over Client,Server: Initialization Phase
activate Client
Client->>+Server: initialize request
Server-->>Client: initialize response
Client--)Server: initialized notification
Note over Client,Server: Operation Phase
rect rgb(200, 220, 250)
note over Client,Server: Normal protocol operations
end
Note over Client,Server: Shutdown
Client--)-Server: Disconnect
deactivate Server
Note over Client,Server: Connection closed
```
## Lifecycle Phases
### Initialization
The initialization phase **MUST** be the first interaction between client and server.
During this phase, the client and server:
- Establish protocol version compatibility
- Exchange and negotiate capabilities
- Share implementation details
The client **MUST** initiate this phase by sending an `initialize` request containing:
- Protocol version supported
- Client capabilities
- Client implementation information
```json
{
"jsonrpc": "2.0",
"id": 1,
"method": "initialize",
"params": {
"protocolVersion": "2024-11-05",
"capabilities": {
"roots": {
"listChanged": true
},
"sampling": {}
},
"clientInfo": {
"name": "ExampleClient",
"version": "1.0.0"
}
}
}
```
The initialize request **MUST NOT** be part of a JSON-RPC
[batch](https://www.jsonrpc.org/specification#batch), as other requests and notifications
are not possible until initialization has completed. This also permits backwards
compatibility with prior protocol versions that do not explicitly support JSON-RPC
batches.
The server **MUST** respond with its own capabilities and information:
```json
{
"jsonrpc": "2.0",
"id": 1,
"result": {
"protocolVersion": "2024-11-05",
"capabilities": {
"logging": {},
"prompts": {
"listChanged": true
},
"resources": {
"subscribe": true,
"listChanged": true
},
"tools": {
"listChanged": true
}
},
"serverInfo": {
"name": "ExampleServer",
"version": "1.0.0"
}
}
}
```
After successful initialization, the client **MUST** send an `initialized` notification
to indicate it is ready to begin normal operations:
```json
{
"jsonrpc": "2.0",
"method": "notifications/initialized"
}
```
- The client **SHOULD NOT** send requests other than
[pings]({{< ref "utilities/ping" >}}) before the server has responded to the
`initialize` request.
- The server **SHOULD NOT** send requests other than
[pings]({{< ref "utilities/ping" >}}) and
[logging]({{< ref "../server/utilities/logging" >}}) before receiving the `initialized`
notification.
#### Version Negotiation
In the `initialize` request, the client **MUST** send a protocol version it supports.
This **SHOULD** be the _latest_ version supported by the client.
If the server supports the requested protocol version, it **MUST** respond with the same
version. Otherwise, the server **MUST** respond with another protocol version it
supports. This **SHOULD** be the _latest_ version supported by the server.
If the client does not support the version in the server's response, it **SHOULD**
disconnect.
#### Capability Negotiation
Client and server capabilities establish which optional protocol features will be
available during the session.
Key capabilities include:
| Category | Capability | Description |
| -------- | -------------- | -------------------------------------------------------------------------- |
| Client | `roots` | Ability to provide filesystem [roots]({{< ref "../client/roots" >}}) |
| Client | `sampling` | Support for LLM [sampling]({{< ref "../client/sampling" >}}) requests |
| Client | `experimental` | Describes support for non-standard experimental features |
| Server | `prompts` | Offers [prompt templates]({{< ref "../server/prompts" >}}) |
| Server | `resources` | Provides readable [resources]({{< ref "../server/resources" >}}) |
| Server | `tools` | Exposes callable [tools]({{< ref "../server/tools" >}}) |
| Server | `logging` | Emits structured [log messages]({{< ref "../server/utilities/logging" >}}) |
| Server | `experimental` | Describes support for non-standard experimental features |
Capability objects can describe sub-capabilities like:
- `listChanged`: Support for list change notifications (for prompts, resources, and
tools)
- `subscribe`: Support for subscribing to individual items' changes (resources only)
### Operation
During the operation phase, the client and server exchange messages according to the
negotiated capabilities.
Both parties **SHOULD**:
- Respect the negotiated protocol version
- Only use capabilities that were successfully negotiated
### Shutdown
During the shutdown phase, one side (usually the client) cleanly terminates the protocol
connection. No specific shutdown messages are defined—instead, the underlying transport
mechanism should be used to signal connection termination:
#### stdio
For the stdio [transport]({{< ref "transports" >}}), the client **SHOULD** initiate
shutdown by:
1. First, closing the input stream to the child process (the server)
2. Waiting for the server to exit, or sending `SIGTERM` if the server does not exit
within a reasonable time
3. Sending `SIGKILL` if the server does not exit within a reasonable time after `SIGTERM`
The server **MAY** initiate shutdown by closing its output stream to the client and
exiting.
#### HTTP
For HTTP [transports]({{< ref "transports" >}}), shutdown is indicated by closing the
associated HTTP connection(s).
## Timeouts
Implementations **SHOULD** establish timeouts for all sent requests, to prevent hung
connections and resource exhaustion. When the request has not received a success or error
response within the timeout period, the sender **SHOULD** issue a [cancellation
notification]({{< ref "utilities/cancellation" >}}) for that request and stop waiting for
a response.
SDKs and other middleware **SHOULD** allow these timeouts to be configured on a
per-request basis.
Implementations **MAY** choose to reset the timeout clock when receiving a [progress
notification]({{< ref "utilities/progress" >}}) corresponding to the request, as this
implies that work is actually happening. However, implementations **SHOULD** always
enforce a maximum timeout, regardless of progress notifications, to limit the impact of a
misbehaving client or server.
## Error Handling
Implementations **SHOULD** be prepared to handle these error cases:
- Protocol version mismatch
- Failure to negotiate required capabilities
- Request [timeouts](#timeouts)
Example initialization error:
```json
{
"jsonrpc": "2.0",
"id": 1,
"error": {
"code": -32602,
"message": "Unsupported protocol version",
"data": {
"supported": ["2024-11-05"],
"requested": "1.0.0"
}
}
}
```
---
File: /docs/specification/2025-03-26/basic/transports.md
---
---
title: Transports
type: docs
weight: 10
---
{{< callout type="info" >}} **Protocol Revision**: 2025-03-26 {{< /callout >}}
MCP uses JSON-RPC to encode messages. JSON-RPC messages **MUST** be UTF-8 encoded.
The protocol currently defines two standard transport mechanisms for client-server
communication:
1. [stdio](#stdio), communication over standard in and standard out
2. [Streamable HTTP](#streamable-http)
Clients **SHOULD** support stdio whenever possible.
It is also possible for clients and servers to implement
[custom transports](#custom-transports) in a pluggable fashion.
## stdio
In the **stdio** transport:
- The client launches the MCP server as a subprocess.
- The server reads JSON-RPC messages from its standard input (`stdin`) and sends messages
to its standard output (`stdout`).
- Messages may be JSON-RPC requests, notifications, responses—or a JSON-RPC
[batch](https://www.jsonrpc.org/specification#batch) containing one or more requests
and/or notifications.
- Messages are delimited by newlines, and **MUST NOT** contain embedded newlines.
- The server **MAY** write UTF-8 strings to its standard error (`stderr`) for logging
purposes. Clients **MAY** capture, forward, or ignore this logging.
- The server **MUST NOT** write anything to its `stdout` that is not a valid MCP message.
- The client **MUST NOT** write anything to the server's `stdin` that is not a valid MCP
message.
```mermaid
sequenceDiagram
participant Client
participant Server Process
Client->>+Server Process: Launch subprocess
loop Message Exchange
Client->>Server Process: Write to stdin
Server Process->>Client: Write to stdout
Server Process--)Client: Optional logs on stderr
end
Client->>Server Process: Close stdin, terminate subprocess
deactivate Server Process
```
## Streamable HTTP
{{< callout type="info" >}} This replaces the [HTTP+SSE
transport]({{< ref "/specification/2024-11-05/basic/transports#http-with-sse" >}}) from
protocol version 2024-11-05. See the [backwards compatibility](#backwards-compatibility)
guide below. {{< /callout >}}
In the **Streamable HTTP** transport, the server operates as an independent process that
can handle multiple client connections. This transport uses HTTP POST and GET requests.
Server can optionally make use of
[Server-Sent Events](https://en.wikipedia.org/wiki/Server-sent_events) (SSE) to stream
multiple server messages. This permits basic MCP servers, as well as more feature-rich
servers supporting streaming and server-to-client notifications and requests.
The server **MUST** provide a single HTTP endpoint path (hereafter referred to as the
**MCP endpoint**) that supports both POST and GET methods. For example, this could be a
URL like `https://example.com/mcp`.
### Sending Messages to the Server
Every JSON-RPC message sent from the client **MUST** be a new HTTP POST request to the
MCP endpoint.
1. The client **MUST** use HTTP POST to send JSON-RPC messages to the MCP endpoint.
2. The client **MUST** include an `Accept` header, listing both `application/json` and
`text/event-stream` as supported content types.
3. The body of the POST request **MUST** be one of the following:
- A single JSON-RPC _request_, _notification_, or _response_
- An array [batching](https://www.jsonrpc.org/specification#batch) one or more
_requests and/or notifications_
- An array [batching](https://www.jsonrpc.org/specification#batch) one or more
_responses_
4. If the input consists solely of (any number of) JSON-RPC _responses_ or
_notifications_:
- If the server accepts the input, the server **MUST** return HTTP status code 202
Accepted with no body.
- If the server cannot accept the input, it **MUST** return an HTTP error status code
(e.g., 400 Bad Request). The HTTP response body **MAY** comprise a JSON-RPC _error
response_ that has no `id`.
5. If the input contains any number of JSON-RPC _requests_, the server **MUST** either
return `Content-Type: text/event-stream`, to initiate an SSE stream, or
`Content-Type: application/json`, to return one JSON object. The client **MUST**
support both these cases.
6. If the server initiates an SSE stream:
- The SSE stream **SHOULD** eventually include one JSON-RPC _response_ per each
JSON-RPC _request_ sent in the POST body. These _responses_ **MAY** be
[batched](https://www.jsonrpc.org/specification#batch).
- The server **MAY** send JSON-RPC _requests_ and _notifications_ before sending a
JSON-RPC _response_. These messages **SHOULD** relate to the originating client
_request_. These _requests_ and _notifications_ **MAY** be
[batched](https://www.jsonrpc.org/specification#batch).
- The server **SHOULD NOT** close the SSE stream before sending a JSON-RPC _response_
per each received JSON-RPC _request_, unless the [session](#session-management)
expires.
- After all JSON-RPC _responses_ have been sent, the server **SHOULD** close the SSE
stream.
- Disconnection **MAY** occur at any time (e.g., due to network conditions).
Therefore:
- Disconnection **SHOULD NOT** be interpreted as the client cancelling its request.
- To cancel, the client **SHOULD** explicitly send an MCP `CancelledNotification`.
- To avoid message loss due to disconnection, the server **MAY** make the stream
[resumable](#resumability-and-redelivery).
### Listening for Messages from the Server
1. The client **MAY** issue an HTTP GET to the MCP endpoint. This can be used to open an
SSE stream, allowing the server to communicate to the client, without the client first
sending data via HTTP POST.
2. The client **MUST** include an `Accept` header, listing `text/event-stream` as a
supported content type.
3. The server **MUST** either return `Content-Type: text/event-stream` in response to
this HTTP GET, or else return HTTP 405 Method Not Allowed, indicating that the server
does not offer an SSE stream at this endpoint.
4. If the server initiates an SSE stream:
- The server **MAY** send JSON-RPC _requests_ and _notifications_ on the stream. These
_requests_ and _notifications_ **MAY** be
[batched](https://www.jsonrpc.org/specification#batch).
- These messages **SHOULD** be unrelated to any concurrently-running JSON-RPC
_request_ from the client.
- The server **MUST NOT** send a JSON-RPC _response_ on the stream **unless**
[resuming](#resumability-and-redelivery) a stream associated with a previous client
request.
- The server **MAY** close the SSE stream at any time.
- The client **MAY** close the SSE stream at any time.
### Multiple Connections
1. The client **MAY** remain connected to multiple SSE streams simultaneously.
2. The server **MUST** send each of its JSON-RPC messages on only one of the connected
streams; that is, it **MUST NOT** broadcast the same message across multiple streams.
- The risk of message loss **MAY** be mitigated by making the stream
[resumable](#resumability-and-redelivery).
### Resumability and Redelivery
To support resuming broken connections, and redelivering messages that might otherwise be
lost:
1. Servers **MAY** attach an `id` field to their SSE events, as described in the
[SSE standard](https://html.spec.whatwg.org/multipage/server-sent-events.html#event-stream-interpretation).
- If present, the ID **MUST** be globally unique across all streams within that
[session](#session-management)—or all streams with that specific client, if session
management is not in use.
2. If the client wishes to resume after a broken connection, it **SHOULD** issue an HTTP
GET to the MCP endpoint, and include the
[`Last-Event-ID`](https://html.spec.whatwg.org/multipage/server-sent-events.html#the-last-event-id-header)
header to indicate the last event ID it received.
- The server **MAY** use this header to replay messages that would have been sent
after the last event ID, _on the stream that was disconnected_, and to resume the
stream from that point.
- The server **MUST NOT** replay messages that would have been delivered on a
different stream.
In other words, these event IDs should be assigned by servers on a _per-stream_ basis, to
act as a cursor within that particular stream.
### Session Management
An MCP "session" consists of logically related interactions between a client and a
server, beginning with the [initialization phase]({{< ref "lifecycle" >}}). To support
servers which want to establish stateful sessions:
1. A server using the Streamable HTTP transport **MAY** assign a session ID at
initialization time, by including it in an `Mcp-Session-Id` header on the HTTP
response containing the `InitializeResult`.
- The session ID **SHOULD** be globally unique and cryptographically secure (e.g., a
securely generated UUID, a JWT, or a cryptographic hash).
- The session ID **MUST** only contain visible ASCII characters (ranging from 0x21 to
0x7E).
2. If an `Mcp-Session-Id` is returned by the server during initialization, clients using
the Streamable HTTP transport **MUST** include it in the `Mcp-Session-Id` header on
all of their subsequent HTTP requests.
- Servers that require a session ID **SHOULD** respond to requests without an
`Mcp-Session-Id` header (other than initialization) with HTTP 400 Bad Request.
3. The server **MAY** terminate the session at any time, after which it **MUST** respond
to requests containing that session ID with HTTP 404 Not Found.
4. When a client receives HTTP 404 in response to a request containing an
`Mcp-Session-Id`, it **MUST** start a new session by sending a new `InitializeRequest`
without a session ID attached.
5. Clients that no longer need a particular session (e.g., because the user is leaving
the client application) **SHOULD** send an HTTP DELETE to the MCP endpoint with the
`Mcp-Session-Id` header, to explicitly terminate the session.
- The server **MAY** respond to this request with HTTP 405 Method Not Allowed,
indicating that the server does not allow clients to terminate sessions.
### Sequence Diagram
```mermaid
sequenceDiagram
participant Client
participant Server
note over Client, Server: initialization
Client->>+Server: POST InitializeRequest
Server->>-Client: InitializeResponse<br>Mcp-Session-Id: 1868a90c...
Client->>+Server: POST InitializedNotification<br>Mcp-Session-Id: 1868a90c...
Server->>-Client: 202 Accepted
note over Client, Server: client requests
Client->>+Server: POST ... request ...<br>Mcp-Session-Id: 1868a90c...
alt single HTTP response
Server->>Client: ... response ...
else server opens SSE stream
loop while connection remains open
Server-)Client: ... SSE messages from server ...
end
Server-)Client: SSE event: ... response ...
end
deactivate Server
note over Client, Server: client notifications/responses
Client->>+Server: POST ... notification/response ...<br>Mcp-Session-Id: 1868a90c...
Server->>-Client: 202 Accepted
note over Client, Server: server requests
Client->>+Server: GET<br>Mcp-Session-Id: 1868a90c...
loop while connection remains open
Server-)Client: ... SSE messages from server ...
end
deactivate Server
```
### Backwards Compatibility
Clients and servers can maintain backwards compatibility with the deprecated [HTTP+SSE
transport]({{< ref "/specification/2024-11-05/basic/transports#http-with-sse" >}}) (from
protocol version 2024-11-05) as follows:
**Servers** wanting to support older clients should:
- Continue to host both the SSE and POST endpoints of the old transport, alongside the
new "MCP endpoint" defined for the Streamable HTTP transport.
- It is also possible to combine the old POST endpoint and the new MCP endpoint, but
this may introduce unneeded complexity.
**Clients** wanting to support older servers should:
1. Accept an MCP server URL from the user, which may point to either a server using the
old transport or the new transport.
2. Attempt to POST an `InitializeRequest` to the server URL, with an `Accept` header as
defined above:
- If it succeeds, the client can assume this is a server supporting the new Streamable
HTTP transport.
- If it fails with an HTTP 4xx status code (e.g., 405 Method Not Allowed or 404 Not
Found):
- Issue a GET request to the server URL, expecting that this will open an SSE stream
and return an `endpoint` event as the first event.
- When the `endpoint` event arrives, the client can assume this is a server running
the old HTTP+SSE transport, and should use that transport for all subsequent
communication.
## Custom Transports
Clients and servers **MAY** implement additional custom transport mechanisms to suit
their specific needs. The protocol is transport-agnostic and can be implemented over any
communication channel that supports bidirectional message exchange.
Implementers who choose to support custom transports **MUST** ensure they preserve the
JSON-RPC message format and lifecycle requirements defined by MCP. Custom transports
**SHOULD** document their specific connection establishment and message exchange patterns
to aid interoperability.
---
File: /docs/specification/2025-03-26/client/_index.md
---
---
title: Client Features
cascade:
type: docs
weight: 40
---
{{< callout type="info" >}} **Protocol Revision**: 2025-03-26 {{< /callout >}}
Clients can implement additional features to enrich connected MCP servers:
{{< cards >}} {{< card link="roots" title="Roots" icon="folder" >}}
{{< card link="sampling" title="Sampling" icon="annotation" >}} {{< /cards >}}
---
File: /docs/specification/2025-03-26/client/roots.md
---
---
title: Roots
type: docs
weight: 40
---
{{< callout type="info" >}} **Protocol Revision**: 2025-03-26 {{< /callout >}}
The Model Context Protocol (MCP) provides a standardized way for clients to expose
filesystem "roots" to servers. Roots define the boundaries of where servers can operate
within the filesystem, allowing them to understand which directories and files they have
access to. Servers can request the list of roots from supporting clients and receive
notifications when that list changes.
## User Interaction Model
Roots in MCP are typically exposed through workspace or project configuration interfaces.
For example, implementations could offer a workspace/project picker that allows users to
select directories and files the server should have access to. This can be combined with
automatic workspace detection from version control systems or project files.
However, implementations are free to expose roots through any interface pattern that
suits their needs&mdash;the protocol itself does not mandate any specific user
interaction model.
## Capabilities
Clients that support roots **MUST** declare the `roots` capability during
[initialization]({{< ref "../basic/lifecycle#initialization" >}}):
```json
{
"capabilities": {
"roots": {
"listChanged": true
}
}
}
```
`listChanged` indicates whether the client will emit notifications when the list of roots
changes.
## Protocol Messages
### Listing Roots
To retrieve roots, servers send a `roots/list` request:
**Request:**
```json
{
"jsonrpc": "2.0",
"id": 1,
"method": "roots/list"
}
```
**Response:**
```json
{
"jsonrpc": "2.0",
"id": 1,
"result": {
"roots": [
{
"uri": "file:///home/user/projects/myproject",
"name": "My Project"
}
]
}
}
```
### Root List Changes
When roots change, clients that support `listChanged` **MUST** send a notification:
```json
{
"jsonrpc": "2.0",
"method": "notifications/roots/list_changed"
}
```
## Message Flow
```mermaid
sequenceDiagram
participant Server
participant Client
Note over Server,Client: Discovery
Server->>Client: roots/list
Client-->>Server: Available roots
Note over Server,Client: Changes
Client--)Server: notifications/roots/list_changed
Server->>Client: roots/list
Client-->>Server: Updated roots
```
## Data Types
### Root
A root definition includes:
- `uri`: Unique identifier for the root. This **MUST** be a `file://` URI in the current
specification.
- `name`: Optional human-readable name for display purposes.
Example roots for different use cases:
#### Project Directory
```json
{
"uri": "file:///home/user/projects/myproject",
"name": "My Project"
}
```
#### Multiple Repositories
```json
[
{
"uri": "file:///home/user/repos/frontend",
"name": "Frontend Repository"
},
{
"uri": "file:///home/user/repos/backend",
"name": "Backend Repository"
}
]
```
## Error Handling
Clients **SHOULD** return standard JSON-RPC errors for common failure cases:
- Client does not support roots: `-32601` (Method not found)
- Internal errors: `-32603`
Example error:
```json
{
"jsonrpc": "2.0",
"id": 1,
"error": {
"code": -32601,
"message": "Roots not supported",
"data": {
"reason": "Client does not have roots capability"
}
}
}
```
## Security Considerations
1. Clients **MUST**:
- Only expose roots with appropriate permissions
- Validate all root URIs to prevent path traversal
- Implement proper access controls
- Monitor root accessibility
2. Servers **SHOULD**:
- Handle cases where roots become unavailable
- Respect root boundaries during operations
- Validate all paths against provided roots
## Implementation Guidelines
1. Clients **SHOULD**:
- Prompt users for consent before exposing roots to servers
- Provide clear user interfaces for root management
- Validate root accessibility before exposing
- Monitor for root changes
2. Servers **SHOULD**:
- Check for roots capability before usage
- Handle root list changes gracefully
- Respect root boundaries in operations
- Cache root information appropriately
---
File: /docs/specification/2025-03-26/client/sampling.md
---
---
title: Sampling
type: docs
weight: 40
---
{{< callout type="info" >}} **Protocol Revision**: 2025-03-26 {{< /callout >}}
The Model Context Protocol (MCP) provides a standardized way for servers to request LLM
sampling ("completions" or "generations") from language models via clients. This flow
allows clients to maintain control over model access, selection, and permissions while
enabling servers to leverage AI capabilities&mdash;with no server API keys necessary.
Servers can request text, audio, or image-based interactions and optionally include
context from MCP servers in their prompts.
## User Interaction Model
Sampling in MCP allows servers to implement agentic behaviors, by enabling LLM calls to
occur _nested_ inside other MCP server features.
Implementations are free to expose sampling through any interface pattern that suits
their needs&mdash;the protocol itself does not mandate any specific user interaction
model.
{{< callout type="warning" >}} For trust & safety and security, there **SHOULD** always
be a human in the loop with the ability to deny sampling requests.
Applications **SHOULD**:
- Provide UI that makes it easy and intuitive to review sampling requests
- Allow users to view and edit prompts before sending
- Present generated responses for review before delivery {{< /callout >}}
## Capabilities
Clients that support sampling **MUST** declare the `sampling` capability during
[initialization]({{< ref "../basic/lifecycle#initialization" >}}):
```json
{
"capabilities": {
"sampling": {}
}
}
```
## Protocol Messages
### Creating Messages
To request a language model generation, servers send a `sampling/createMessage` request:
**Request:**
```json
{
"jsonrpc": "2.0",
"id": 1,
"method": "sampling/createMessage",
"params": {
"messages": [
{
"role": "user",
"content": {
"type": "text",
"text": "What is the capital of France?"
}
}
],
"modelPreferences": {
"hints": [
{
"name": "claude-3-sonnet"
}
],
"intelligencePriority": 0.8,
"speedPriority": 0.5
},
"systemPrompt": "You are a helpful assistant.",
"maxTokens": 100
}
}
```
**Response:**
```json
{
"jsonrpc": "2.0",
"id": 1,
"result": {
"role": "assistant",
"content": {
"type": "text",
"text": "The capital of France is Paris."
},
"model": "claude-3-sonnet-20240307",
"stopReason": "endTurn"
}
}
```
## Message Flow
```mermaid
sequenceDiagram
participant Server
participant Client
participant User
participant LLM
Note over Server,Client: Server initiates sampling
Server->>Client: sampling/createMessage
Note over Client,User: Human-in-the-loop review
Client->>User: Present request for approval
User-->>Client: Review and approve/modify
Note over Client,LLM: Model interaction
Client->>LLM: Forward approved request
LLM-->>Client: Return generation
Note over Client,User: Response review
Client->>User: Present response for approval
User-->>Client: Review and approve/modify
Note over Server,Client: Complete request
Client-->>Server: Return approved response
```
## Data Types
### Messages
Sampling messages can contain:
#### Text Content
```json
{
"type": "text",
"text": "The message content"
}
```
#### Image Content
```json
{
"type": "image",
"data": "base64-encoded-image-data",
"mimeType": "image/jpeg"
}
```
#### Audio Content
```json
{
"type": "audio",
"data": "base64-encoded-audio-data",
"mimeType": "audio/wav"
}
```
### Model Preferences
Model selection in MCP requires careful abstraction since servers and clients may use
different AI providers with distinct model offerings. A server cannot simply request a
specific model by name since the client may not have access to that exact model or may
prefer to use a different provider's equivalent model.
To solve this, MCP implements a preference system that combines abstract capability
priorities with optional model hints:
#### Capability Priorities
Servers express their needs through three normalized priority values (0-1):
- `costPriority`: How important is minimizing costs? Higher values prefer cheaper models.
- `speedPriority`: How important is low latency? Higher values prefer faster models.
- `intelligencePriority`: How important are advanced capabilities? Higher values prefer
more capable models.
#### Model Hints
While priorities help select models based on characteristics, `hints` allow servers to
suggest specific models or model families:
- Hints are treated as substrings that can match model names flexibly
- Multiple hints are evaluated in order of preference
- Clients **MAY** map hints to equivalent models from different providers
- Hints are advisory&mdash;clients make final model selection
For example:
```json
{
"hints": [
{ "name": "claude-3-sonnet" }, // Prefer Sonnet-class models
{ "name": "claude" } // Fall back to any Claude model
],
"costPriority": 0.3, // Cost is less important
"speedPriority": 0.8, // Speed is very important
"intelligencePriority": 0.5 // Moderate capability needs
}
```
The client processes these preferences to select an appropriate model from its available
options. For instance, if the client doesn't have access to Claude models but has Gemini,
it might map the sonnet hint to `gemini-1.5-pro` based on similar capabilities.
## Error Handling
Clients **SHOULD** return errors for common failure cases:
Example error:
```json
{
"jsonrpc": "2.0",
"id": 1,
"error": {
"code": -1,
"message": "User rejected sampling request"
}
}
```
## Security Considerations
1. Clients **SHOULD** implement user approval controls
2. Both parties **SHOULD** validate message content
3. Clients **SHOULD** respect model preference hints
4. Clients **SHOULD** implement rate limiting
5. Both parties **MUST** handle sensitive data appropriately
---
File: /docs/specification/2025-03-26/server/utilities/_index.md
---
---
title: Utilities
---
{{< callout type="info" >}} **Protocol Revision**: 2025-03-26 {{< /callout >}}
These optional features can be used to enhance server functionality.
{{< cards >}} {{< card link="completion" title="Completion" icon="at-symbol" >}}
{{< card link="logging" title="Logging" icon="terminal" >}}
{{< card link="pagination" title="Pagination" icon="collection" >}} {{< /cards >}}
---
File: /docs/specification/2025-03-26/server/utilities/completion.md
---
---
title: Completion
---
{{< callout type="info" >}} **Protocol Revision**: 2025-03-26 {{< /callout >}}
The Model Context Protocol (MCP) provides a standardized way for servers to offer
argument autocompletion suggestions for prompts and resource URIs. This enables rich,
IDE-like experiences where users receive contextual suggestions while entering argument
values.
## User Interaction Model
Completion in MCP is designed to support interactive user experiences similar to IDE code
completion.
For example, applications may show completion suggestions in a dropdown or popup menu as
users type, with the ability to filter and select from available options.
However, implementations are free to expose completion through any interface pattern that
suits their needs&mdash;the protocol itself does not mandate any specific user
interaction model.
## Capabilities
Servers that support completions **MUST** declare the `completions` capability:
```json
{
"capabilities": {
"completions": {}
}
}
```
## Protocol Messages
### Requesting Completions
To get completion suggestions, clients send a `completion/complete` request specifying
what is being completed through a reference type:
**Request:**
```json
{
"jsonrpc": "2.0",
"id": 1,
"method": "completion/complete",
"params": {
"ref": {
"type": "ref/prompt",
"name": "code_review"
},
"argument": {
"name": "language",
"value": "py"
}
}
}
```
**Response:**
```json
{
"jsonrpc": "2.0",
"id": 1,
"result": {
"completion": {
"values": ["python", "pytorch", "pyside"],
"total": 10,
"hasMore": true
}
}
}
```
### Reference Types
The protocol supports two types of completion references:
| Type | Description | Example |
| -------------- | --------------------------- | --------------------------------------------------- |
| `ref/prompt` | References a prompt by name | `{"type": "ref/prompt", "name": "code_review"}` |
| `ref/resource` | References a resource URI | `{"type": "ref/resource", "uri": "file:///{path}"}` |
### Completion Results
Servers return an array of completion values ranked by relevance, with:
- Maximum 100 items per response
- Optional total number of available matches
- Boolean indicating if additional results exist
## Message Flow
```mermaid
sequenceDiagram
participant Client
participant Server
Note over Client: User types argument
Client->>Server: completion/complete
Server-->>Client: Completion suggestions
Note over Client: User continues typing
Client->>Server: completion/complete
Server-->>Client: Refined suggestions
```
## Data Types
### CompleteRequest
- `ref`: A `PromptReference` or `ResourceReference`
- `argument`: Object containing:
- `name`: Argument name
- `value`: Current value
### CompleteResult
- `completion`: Object containing:
- `values`: Array of suggestions (max 100)
- `total`: Optional total matches
- `hasMore`: Additional results flag
## Error Handling
Servers **SHOULD** return standard JSON-RPC errors for common failure cases:
- Method not found: `-32601` (Capability not supported)
- Invalid prompt name: `-32602` (Invalid params)
- Missing required arguments: `-32602` (Invalid params)
- Internal errors: `-32603` (Internal error)
## Implementation Considerations
1. Servers **SHOULD**:
- Return suggestions sorted by relevance
- Implement fuzzy matching where appropriate
- Rate limit completion requests
- Validate all inputs
2. Clients **SHOULD**:
- Debounce rapid completion requests
- Cache completion results where appropriate
- Handle missing or partial results gracefully
## Security
Implementations **MUST**:
- Validate all completion inputs
- Implement appropriate rate limiting
- Control access to sensitive suggestions
- Prevent completion-based information disclosure
---
File: /docs/specification/2025-03-26/server/utilities/logging.md
---
---
title: Logging
---
{{< callout type="info" >}} **Protocol Revision**: 2025-03-26 {{< /callout >}}
The Model Context Protocol (MCP) provides a standardized way for servers to send
structured log messages to clients. Clients can control logging verbosity by setting
minimum log levels, with servers sending notifications containing severity levels,
optional logger names, and arbitrary JSON-serializable data.
## User Interaction Model
Implementations are free to expose logging through any interface pattern that suits their
needs&mdash;the protocol itself does not mandate any specific user interaction model.
## Capabilities
Servers that emit log message notifications **MUST** declare the `logging` capability:
```json
{
"capabilities": {
"logging": {}
}
}
```
## Log Levels
The protocol follows the standard syslog severity levels specified in
[RFC 5424](https://datatracker.ietf.org/doc/html/rfc5424#section-6.2.1):
| Level | Description | Example Use Case |
| --------- | -------------------------------- | -------------------------- |
| debug | Detailed debugging information | Function entry/exit points |
| info | General informational messages | Operation progress updates |
| notice | Normal but significant events | Configuration changes |
| warning | Warning conditions | Deprecated feature usage |
| error | Error conditions | Operation failures |
| critical | Critical conditions | System component failures |
| alert | Action must be taken immediately | Data corruption detected |
| emergency | System is unusable | Complete system failure |
## Protocol Messages
### Setting Log Level
To configure the minimum log level, clients **MAY** send a `logging/setLevel` request:
**Request:**
```json
{
"jsonrpc": "2.0",
"id": 1,
"method": "logging/setLevel",
"params": {
"level": "info"
}
}
```
### Log Message Notifications
Servers send log messages using `notifications/message` notifications:
```json
{
"jsonrpc": "2.0",
"method": "notifications/message",
"params": {
"level": "error",
"logger": "database",
"data": {
"error": "Connection failed",
"details": {
"host": "localhost",
"port": 5432
}
}
}
}
```
## Message Flow
```mermaid
sequenceDiagram
participant Client
participant Server
Note over Client,Server: Configure Logging
Client->>Server: logging/setLevel (info)
Server-->>Client: Empty Result
Note over Client,Server: Server Activity
Server--)Client: notifications/message (info)
Server--)Client: notifications/message (warning)
Server--)Client: notifications/message (error)
Note over Client,Server: Level Change
Client->>Server: logging/setLevel (error)
Server-->>Client: Empty Result
Note over Server: Only sends error level<br/>and above
```
## Error Handling
Servers **SHOULD** return standard JSON-RPC errors for common failure cases:
- Invalid log level: `-32602` (Invalid params)
- Configuration errors: `-32603` (Internal error)
## Implementation Considerations
1. Servers **SHOULD**:
- Rate limit log messages
- Include relevant context in data field
- Use consistent logger names
- Remove sensitive information
2. Clients **MAY**:
- Present log messages in the UI
- Implement log filtering/search
- Display severity visually
- Persist log messages
## Security
1. Log messages **MUST NOT** contain:
- Credentials or secrets
- Personal identifying information
- Internal system details that could aid attacks
2. Implementations **SHOULD**:
- Rate limit messages
- Validate all data fields
- Control log access
- Monitor for sensitive content
---
File: /docs/specification/2025-03-26/server/utilities/pagination.md
---
---
title: Pagination
---
{{< callout type="info" >}} **Protocol Revision**: 2025-03-26 {{< /callout >}}
The Model Context Protocol (MCP) supports paginating list operations that may return
large result sets. Pagination allows servers to yield results in smaller chunks rather
than all at once.
Pagination is especially important when connecting to external services over the
internet, but also useful for local integrations to avoid performance issues with large
data sets.
## Pagination Model
Pagination in MCP uses an opaque cursor-based approach, instead of numbered pages.
- The **cursor** is an opaque string token, representing a position in the result set
- **Page size** is determined by the server, and **MAY NOT** be fixed
## Response Format
Pagination starts when the server sends a **response** that includes:
- The current page of results
- An optional `nextCursor` field if more results exist
```json
{
"jsonrpc": "2.0",
"id": "123",
"result": {
"resources": [...],
"nextCursor": "eyJwYWdlIjogM30="
}
}
```
## Request Format
After receiving a cursor, the client can _continue_ paginating by issuing a request
including that cursor:
```json
{
"jsonrpc": "2.0",
"method": "resources/list",
"params": {
"cursor": "eyJwYWdlIjogMn0="
}
}
```
## Pagination Flow
```mermaid
sequenceDiagram
participant Client
participant Server
Client->>Server: List Request (no cursor)
loop Pagination Loop
Server-->>Client: Page of results + nextCursor
Client->>Server: List Request (with cursor)
end
```
## Operations Supporting Pagination
The following MCP operations support pagination:
- `resources/list` - List available resources
- `resources/templates/list` - List resource templates
- `prompts/list` - List available prompts
- `tools/list` - List available tools
## Implementation Guidelines
1. Servers **SHOULD**:
- Provide stable cursors
- Handle invalid cursors gracefully
2. Clients **SHOULD**:
- Treat a missing `nextCursor` as the end of results
- Support both paginated and non-paginated flows
3. Clients **MUST** treat cursors as opaque tokens:
- Don't make assumptions about cursor format
- Don't attempt to parse or modify cursors
- Don't persist cursors across sessions
## Error Handling
Invalid cursors **SHOULD** result in an error with code -32602 (Invalid params).
---
File: /docs/specification/2025-03-26/server/_index.md
---
---
title: Server Features
cascade:
type: docs
weight: 30
---
{{< callout type="info" >}} **Protocol Revision**: 2025-03-26 {{< /callout >}}
Servers provide the fundamental building blocks for adding context to language models via
MCP. These primitives enable rich interactions between clients, servers, and language
models:
- **Prompts**: Pre-defined templates or instructions that guide language model
interactions
- **Resources**: Structured data or content that provides additional context to the model
- **Tools**: Executable functions that allow models to perform actions or retrieve
information
Each primitive can be summarized in the following control hierarchy:
| Primitive | Control | Description | Example |
| --------- | ---------------------- | -------------------------------------------------- | ------------------------------- |
| Prompts | User-controlled | Interactive templates invoked by user choice | Slash commands, menu options |
| Resources | Application-controlled | Contextual data attached and managed by the client | File contents, git history |
| Tools | Model-controlled | Functions exposed to the LLM to take actions | API POST requests, file writing |
Explore these key primitives in more detail below:
{{< cards >}} {{< card link="prompts" title="Prompts" icon="chat-alt-2" >}}
{{< card link="resources" title="Resources" icon="document" >}}
{{< card link="tools" title="Tools" icon="adjustments" >}} {{< /cards >}}
---
File: /docs/specification/2025-03-26/server/prompts.md
---
---
title: Prompts
weight: 10
---
{{< callout type="info" >}} **Protocol Revision**: 2025-03-26 {{< /callout >}}
The Model Context Protocol (MCP) provides a standardized way for servers to expose prompt
templates to clients. Prompts allow servers to provide structured messages and
instructions for interacting with language models. Clients can discover available
prompts, retrieve their contents, and provide arguments to customize them.
## User Interaction Model
Prompts are designed to be **user-controlled**, meaning they are exposed from servers to
clients with the intention of the user being able to explicitly select them for use.
Typically, prompts would be triggered through user-initiated commands in the user
interface, which allows users to naturally discover and invoke available prompts.
For example, as slash commands:
![Example of prompt exposed as slash command](slash-command.png)
However, implementors are free to expose prompts through any interface pattern that suits
their needs&mdash;the protocol itself does not mandate any specific user interaction
model.
## Capabilities
Servers that support prompts **MUST** declare the `prompts` capability during
[initialization]({{< ref "../basic/lifecycle#initialization" >}}):
/draft`json { "capabilities": { "prompts": { "listChanged": true } } }
````
`listChanged` indicates whether the server will emit notifications when the list of
available prompts changes.
## Protocol Messages
### Listing Prompts
To retrieve available prompts, clients send a `prompts/list` request. This operation
supports [pagination]({{< ref "utilities/pagination" >}}).
**Request:**
```json
{
"jsonrpc": "2.0",
"id": 1,
"method": "prompts/list",
"params": {
"cursor": "optional-cursor-value"
}
}
````
**Response:**
```json
{
"jsonrpc": "2.0",
"id": 1,
"result": {
"prompts": [
{
"name": "code_review",
"description": "Asks the LLM to analyze code quality and suggest improvements",
"arguments": [
{
"name": "code",
"description": "The code to review",
"required": true
}
]
}
],
"nextCursor": "next-page-cursor"
}
}
```
### Getting a Prompt
To retrieve a specific prompt, clients send a `prompts/get` request. Arguments may be
auto-completed through [the completion API]({{< ref "utilities/completion" >}}).
**Request:**
```json
{
"jsonrpc": "2.0",
"id": 2,
"method": "prompts/get",
"params": {
"name": "code_review",
"arguments": {
"code": "def hello():\n print('world')"
}
}
}
```
**Response:**
```json
{
"jsonrpc": "2.0",
"id": 2,
"result": {
"description": "Code review prompt",
"messages": [
{
"role": "user",
"content": {
"type": "text",
"text": "Please review this Python code:\ndef hello():\n print('world')"
}
}
]
}
}
```
### List Changed Notification
When the list of available prompts changes, servers that declared the `listChanged`
capability **SHOULD** send a notification:
```json
{
"jsonrpc": "2.0",
"method": "notifications/prompts/list_changed"
}
```
## Message Flow
```mermaid
sequenceDiagram
participant Client
participant Server
Note over Client,Server: Discovery
Client->>Server: prompts/list
Server-->>Client: List of prompts
Note over Client,Server: Usage
Client->>Server: prompts/get
Server-->>Client: Prompt content
opt listChanged
Note over Client,Server: Changes
Server--)Client: prompts/list_changed
Client->>Server: prompts/list
Server-->>Client: Updated prompts
end
```
## Data Types
### Prompt
A prompt definition includes:
- `name`: Unique identifier for the prompt
- `description`: Optional human-readable description
- `arguments`: Optional list of arguments for customization
### PromptMessage
Messages in a prompt can contain:
- `role`: Either "user" or "assistant" to indicate the speaker
- `content`: One of the following content types:
#### Text Content
Text content represents plain text messages:
```json
{
"type": "text",
"text": "The text content of the message"
}
```
This is the most common content type used for natural language interactions.
#### Image Content
Image content allows including visual information in messages:
```json
{
"type": "image",
"data": "base64-encoded-image-data",
"mimeType": "image/png"
}
```
The image data **MUST** be base64-encoded and include a valid MIME type. This enables
multi-modal interactions where visual context is important.
#### Audio Content
Audio content allows including audio information in messages:
```json
{
"type": "audio",
"data": "base64-encoded-audio-data",
"mimeType": "audio/wav"
}
```
The audio data MUST be base64-encoded and include a valid MIME type. This enables
multi-modal interactions where audio context is important.
#### Embedded Resources
Embedded resources allow referencing server-side resources directly in messages:
```json
{
"type": "resource",
"resource": {
"uri": "resource://example",
"mimeType": "text/plain",
"text": "Resource content"
}
}
```
Resources can contain either text or binary (blob) data and **MUST** include:
- A valid resource URI
- The appropriate MIME type
- Either text content or base64-encoded blob data
Embedded resources enable prompts to seamlessly incorporate server-managed content like
documentation, code samples, or other reference materials directly into the conversation
flow.
## Error Handling
Servers **SHOULD** return standard JSON-RPC errors for common failure cases:
- Invalid prompt name: `-32602` (Invalid params)
- Missing required arguments: `-32602` (Invalid params)
- Internal errors: `-32603` (Internal error)
## Implementation Considerations
1. Servers **SHOULD** validate prompt arguments before processing
2. Clients **SHOULD** handle pagination for large prompt lists
3. Both parties **SHOULD** respect capability negotiation
## Security
Implementations **MUST** carefully validate all prompt inputs and outputs to prevent
injection attacks or unauthorized access to resources.
---
File: /docs/specification/2025-03-26/server/resource-picker.png
---
<EFBFBD>PNG

IHDR<00><00><00>Ķ`iCCPICC Profile(<28>u<EFBFBD>;HA<10><>h$D<><44>H!Q<>*<2A><><EFBFBD>rF,<14> XQ<><16>K<EFBFBD><08>d<EFBFBD>w<EFBFBD><77><EFBFBD><EFBFBD><EFBFBD><EFBFBD>6bci<63><69>B҉<42><D289>"<08><16>B4<><34><EFBFBD>z<EFBFBD><7A><0E><><EFBFBD><EFBFBD><EFBFBD>0 <0C><15>3<><00>%<25>g<EFBFBD> ium]<5D>!
?šn<C29A><6E><EFBFBD>.P <09><><EFBFBD><EFBFBD><1F>z7&fͤcR<63>rp68$o<><6F>?<3F><><EFBFBD><EFBFBD>x<EFBFBD><78><EFBFBD><EFBFBD><EFBFBD>~P<>t<EFBFBD>m<EFBFBD><6D><10>;6|H<1C><14>`<60><><17><>-<2D>5k<35>2I<32>{<7B>^<5E>r<EFBFBD><72>đl<C491>o<EFBFBD>q<EFBFBD><71>ֿv<10><07><>E<EFBFBD>0<EFBFBD>0R<30>ä<EFBFBD><10>
<EFBFBD>P ӟ"<22>?}J<>/<2F>2<18><><EFBFBD><05><> <09>¤<EFBFBD><12>Q<EFBFBD><51>qD<71>eLR*<2A>޿<EFBFBD><DEBF>zG<7A><47><EFBFBD><14><><EFBFBD>%P<><07>׮7z \7L<><4C><EFBFBD>u=u<><75><19>[<1C>@ϛ㼎<00>K<EFBFBD><4B><1D><><EFBFBD>q<1A>@<40>#P<>|.La<4C>vY'beXIfMM*<00>i&<03><>P<><00><><00>ASCIIScreenshot9UD=iTXtXML:com.adobe.xmp<x:xmpmeta xmlns:x="adobe:ns:meta/" x:xmptk="XMP Core 6.0.0">
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about=""
xmlns:exif="http://ns.adobe.com/exif/1.0/"
xmlns:tiff="http://ns.adobe.com/tiff/1.0/">
<exif:PixelYDimension>181</exif:PixelYDimension>
<exif:UserComment>Screenshot</exif:UserComment>
<exif:PixelXDimension>174</exif:PixelXDimension>
<tiff:Orientation>1</tiff:Orientation>
</rdf:Description>
</rdf:RDF>
</x:xmpmeta>
oP<EFBFBD>=3HIDATx<01>}<07>ՑnMM<>fA(<28>0BFH"<22>dl<64><6C><EFBFBD><EFBFBD>omd<6D><64><EFBFBD>9<EFBFBD>. <20>k<1C>g>{<7B>k<EFBFBD>
<0E>Ȁ<><C880><EFBFBD><EFBFBD><06><><EFBFBD>m<EFBFBD>EAH<><48>r<EFBFBD>H3<48>h<EFBFBD>h<EFBFBD><68><EFBFBD><EFBFBD><EFBFBD>ܾ}c<><63><EFBFBD>#<23><><EFBFBD>Vש:u<>ԩS]}<7D>oߢ<6F><DFA2>S<EFBFBD>Q<EFBFBD>r<EFBFBD>X<EFBFBD>e<EFBFBD><65>1<EFBFBD><31>ޑ<EFBFBD>ED<45>,<2C>_ <0B>RQ<11><00><><14>W<EFBFBD>Hzd<7A>L,P,N+<01>?2<><32><EFBFBD><EFBFBD>x" <0B><><02>i%<25>f
<EFBFBD><EFBFBD>P<EFBFBD>^]]M<><4D><EFBFBD>
<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>B<EFBFBD>w<EFBFBD>*%+<><1B>f<0E>L<EFBFBD><13> w<><77>i:]}<7D>Uq<02>oXO<58>><3E>;<3B><><EFBFBD>[iz<69>4<EFBFBD><34><EFBFBD>w<><77>C@<40><>;<3B><>.<2E>[<5B>>k<><6B><EFBFBD><EFBFBD><EFBFBD>O<EFBFBD><4F><EFBFBD>h<EFBFBD><68>IT\TL}<7D>i<EFBFBD>կ~<7E> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>6嗿<36>5=<3D><>v9眳隫<E79CB3><E99AAB>;v<><76>I<13><>7<EFBFBD><37>-<2D><><EFBFBD><EFBFBD>6۠cA<63><41><EFBFBD>
Z<EFBFBD>N<EFBFBD><EFBFBD><EFBFBD>k<EFBFBD><EFBFBD><EFBFBD>E<1E><><12>
<EFBFBD>暫h<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>~''<27><>UW<55>O<EFBFBD>s<EFBFBD>R<EFBFBD>-i<>%<25><><EFBFBD>!<21><><EFBFBD>XW\~-<2D>Ń<EFBFBD><EFBFBD>~<7E><>w<EFBFBD><77><EFBFBD><1D><>|9mݶ=<3D><>1c<31>ҋ/<2F>H+V<><56><EFBFBD><EFBFBD>ڽ<EFBFBD>=<3D><>ȑ#<23>c[L_<4C><5F><EFBFBD><EFBFBD><EFBFBD><EFBFBD>>!<16><><EFBFBD>]K睷<4B> w̘1<CC98><31>֛<EFBFBD>/~<7E><>=<1A><>@!<21>n<EFBFBD><6E>Ϊ<>*8<>)=D<><44>pЛn<D09B><6E>+<15>N#z<>
"<<3C>z.<05>.<0F><>Wn<57>5k<35>ҵ<<3C>C<EFBFBD><0F>uz0n<30>XZ<58><5A>
zs<EFBFBD><1A>J<EFBFBD><4A>G<EFBFBD><47>]D]]<5D>B<EFBFBD>|,<2C> <16><><EFBFBD><EFBFBD>r
}<7D><03>R<13>?<3F><18><><EFBFBD>N+J<>+.<2E><><16>K<EFBFBD><4B><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>4o<34>\ڶm<07><><EFBFBD>;w<77><06><>=W<><57>w<EFBFBD>Fw<46><77>}<7D><><EFBFBD>o<EFBFBD>)<29>N<EFBFBD><4E>o<EFBFBD>I<<3C><10><>%<25>L<EFBFBD>:E<><45><EFBFBD>H;/<2F><07><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><16><><EFBFBD><EFBFBD>/|<7C><><EFBFBD><EFBFBD><EFBFBD><1F>8p<38><70>m JF<4A>l<EFBFBD>9.<2E>ٹnΚ(^SSM<53><4D><EFBFBD><EFBFBD><EFBFBD>d<EFBFBD>-r<>WG<57><47><EFBFBD><EFBFBD><EFBFBD><EFBFBD>b֑<16>D<EFBFBD>_<EFBFBD><5F>ujDeԟw޹<12>U<06><>A<EFBFBD>m`<60><17><>ӧ<EFBFBD> /<2F><><EFBFBD>x<EFBFBD>v[<5B><><EFBFBD>aÆ<61><C386><EFBFBD>_K<5F><4B><EFBFBD><13>y<EFBFBD><04>s<EFBFBD>Cs<43>̦q<CCA6><71>q<EFBFBD><71><EFBFBD>z0<7A><30><EFBFBD><EFBFBD><EFBFBD>.<2E><><02><>|{<7B><>}<7D><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> /<2F>8Ϗ|/=<3D><><1F><><EFBFBD><EFBFBD>><3E><>O<EFBFBD>m<EFBFBD>1<EFBFBD>A<><7F>4o<34><q<>W^y<><79>{<7B>o4<6F><34>VUEXTp<54>9s<39><73><EFBFBD>ɓ%y<><79><EFBFBD>i5/<2F>k<EFBFBD><6B><EFBFBD><EFBFBD><10>hϞ<68>4f<34>h<EFBFBD><68><EFBFBD><1B><>{~(i<><69><EFBFBD><EFBFBD>yA\<5C><><EFBFBD><EFBFBD><EFBFBD>`>n<><6E>K<EFBFBD><4B>3<EFBFBD>R'<27>;ХX<D0A5>)<04><>c<EFBFBD><63>xH"ڦ+<2B>~|pz8
"3rT<14>!<21><>O<EFBFBD><4F>)?<3F><><EFBFBD><EFBFBD>Z<EFBFBD><5A><EFBFBD>A<EFBFBD>~<7E>C <0B><><EFBFBD>|<7C>
G<EFBFBD><EFBFBD><EFBFBD>4<><34><EFBFBD><EFBFBD>O[<10>DWg-<2D>?<3F>><3E><>%t<><74><EFBFBD>"Q<>bagjg<6A><67>G<>*<2A><>K_<4B><5F><EFBFBD>8<EFBFBD> <0C><>}ｒ<>x<EFBFBD>
ڷo<EFBFBD><EFBFBD>!Ү]<5D>V<EFBFBD>#<23><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>}<7D><>~{mٲ<6D>^}M<>6U<36>Q<>Z<EFBFBD><16><><EFBFBD><EFBFBD>#nٺ<6E><D9BA>0<EFBFBD>y<EFBFBD>fB<66>EyGd8<<3C><12><>_<> N<>h- |̜ٔ<CC9C><D994><EFBFBD> &<26>eBH<42><48><EFBFBD>M%W`ĆJ <07><>d#
<0E>~<7E><06>BM/<2F> t<>u<>c<EFBFBD><01>h<><1D><>N<15>o_ <0C><>:<3A>`<60><><EFBFBD>Q>]#<23><><EFBFBD><EFBFBD>K<EFBFBD><13><><EFBFBD><EFBFBD>-{<7B><><EFBFBD>ɷ<EFBFBD><C9B7><EFBFBD>/<10><><EFBFBD>.ਸ<><E0A8B8>.<2E><><EFBFBD><EFBFBD><7F>f<EFBFBD><66>ߡ/<>k4<6B><34>s<EFBFBD><73>.<2E><>|<7C><><EFBFBD><EFBFBD>>"<22>|<7C><>I<EFBFBD>"<22><19><>ΦM<CEA6>h<EFBFBD>"<22>*<><EEB8BB>JKJ<4B><4A>HwO<0F>fc<>ĉt<C489>I'<27>%l<><6C>Ŵu<C5B4>6<EFBFBD>%<25>}<7D><><EFBFBD>qMP<4D><50>9Xja师<61>,<2C>7ǵ<37><C7B5>T<EFBFBD><1D><><EFBFBD><11><><EFBFBD>:/<2F>׭[*<2A><>Q4Sm<53><6D>p|<7C><>9<EFBFBD><39>D?ɑc<C991><63>䰛<EFBFBD>wtt<74>i<EFBFBD><69>~<7E><><EFBFBD>i,粋<16><><EFBFBD><EFBFBD><00><><05>bp¦3<>Z<EFBFBD><5A>#䊽<><E48ABD><EFBFBD>^|<7C>%z<><7A><EFBFBD><EFBFBD><1C>q<EFBFBD>x<EFBFBD>ɿP
絼-<11>Q<><51>?<3F> <0B>ښZz<5A>h<EFBFBD><13><><EFBFBD><EFBFBD>>v<><76><EFBFBD>ڵ<EFBFBD>Q<>v^uZЂwWsXd<58><64>s<EFBFBD> <20>%<25><>%+<2B><>~FBJ<>
N<EFBFBD>M<EFBFBD>#k<>v<EFBFBD><07><1A>3<EFBFBD>ſ<EFBFBD><C5BF>/<2F><>n<EFBFBD><6E>tE<74>)w<><77>E<EFBFBD><45>+n\<5C><EFBFBD>?<3F><>*++]<5D>]<5D>v'<27><15>r<EFBFBD>g<EFBFBD>R<03><><EFBFBD>ߖS _<18><>WH<57>0~<7E>I<EFBFBD> 446<34><36><1D><><EFBFBD> 4<>i<EFBFBD><69>/<2F><12>ظ<EFBFBD>˦<EFBFBD>A]<5D>a9-<2D><><EFBFBD><08>l <20><>,<2C>=F<><46>g<EFBFBD>u
^8N<>p<EFBFBD>d<EFBFBD>#"2<><32><05><07>ԡ<EFBFBD>tੜ<13>6]<5D><>.*<2A><><EFBFBD>I<EFBFBD>N<EFBFBD>Yg<59><67>N*Ҁ3N<33>h<EFBFBD> <0B>;<3B><>u<EFBFBD>2<EFBFBD>Tj<54>s\<5C>O<EFBFBD>۽8mF<13>ZerRGOw7<77><37><EFBFBD><EFBFBD>d<EFBFBD>@<40>fϞ<66>g<>9<EFBFBD>=§<><C2A7>謳Β (б<10>><3E>,<2C>ӓO
;<3B><>Q<EFBFBD><51><EFBFBD>b<1C>t<EFBFBD>x<>'j<><6A><EFBFBD> <0C><>q:<3A><><EFBFBD><EFBFBD>i<EFBFBD><69>y<04>mh<18>oWK<57><4B><EFBFBD>2<EFBFBD>~<7E>@<40>7UQ<55> i<>wW<77>DZ<44><5A><12><08><>]<5D><18><><EFBFBD> mW<02>pP@<40><><EFBFBD>-<2D>ַ<EFBFBD>{<7B>q<EFBFBD>%<25>б"Z<><5A> <0B><><EFBFBD><EFBFBD><<3C><><EFBFBD>s<EFBFBD>%<25>!<13><11><>U<EFBFBD>ptе<74>қ<EFBFBD>7<EFBFBD><37>Q<EFBFBD>r
>w<><02>W<><57><17><><EFBFBD>|<7C><>v~9..~&L<>@<40><>=<3D><><EFBFBD>k<EFBFBD><6B><EFBFBD>/<2F>V<EFBFBD><56>|>u<>:<3A><><EFBFBD><EFBFBD><EFBFBD>g-_P<5F><50><11><><EFBFBD><EFBFBD>r<>f<EFBFBD>F<EFBFBD>pn<70><6E><EFBFBD><EFBFBD>0o<30>!ո<><D5B8>2i<32>Dzoo<6F><6F><EFBFBD>H
<EFBFBD>td7<EFBFBD><EFBFBD><EFBFBD><EFBFBD>><3E><>X<EFBFBD>҅.<2E>?><3E>ȯ<EFBFBD><C8AF><EFBFBD>?B<>G<EFBFBD>f<EFBFBD>C6l<14><><EFBFBD>z/<2F>u<EFBFBD>8y<0F><><EFBFBD><EFBFBD>@<40>nlh<6C><68><EFBFBD>p.<2E><>R:<3A>Ljvm<76>?Ҙ<><D298>r<EFBFBD><72>wH<77>{<7B><<3C>S<EFBFBD><53>g<EFBFBD><67>}<7D>f<EFBFBD>~8+\v<><76>4m<34>T<EFBFBD><54><EFBFBD><EFBFBD><EFBFBD>ڪ<EFBFBD><DAAA><EFBFBD><EFBFBD><EFBFBD>PGGx<47>EMM<4D>tl'MM<>%<25><><EFBFBD>apX<70><58>ξ!<01>Ӣw<D3A2><10><><EFBFBD>| <09>t<EFBFBD>S<EFBFBD><53>#<23><><EFBFBD>M<EFBFBD>L<EFBFBD><4C>c<EFBFBD><63><EFBFBD><EFBFBD>U<EFBFBD><55>m<EFBFBD><6D><EFBFBD>(<28>U:<1C><15><>QT "[]<1D><I<><49>><3E><02><>$nAba<62>p ik<69><6B>,<2C>ZQQɻ <0B>O<04><>#G<><47><14><>N<EFBFBD><4E><EFBFBD><EFBFBD>o]m$]`<60><><EFBFBD><EFBFBD><EFBFBD>F<EFBFBD>*<2A><> Y<>}V<><56><EFBFBD>q<><71><EFBFBD><EFBFBD><EFBFBD>W<>FL <0B>?<3F><>}6<><36>%<25>P<EFBFBD>L<><4C><EFBFBD># Y<><59>luN<75><1C><>o#<23>) <0B><>r<EFBFBD>`<60><><EFBFBD>?~<7E><>Q>R<>ĵ@B<><42><EFBFBD> <0B>r\l<>`<0F><>?
<EFBFBD>'<27><> <0C><>=9<><39><EFBFBD>FV<46>\<5C>;k<>@<40>Mf<4D>4r<34><72><EFBFBD><EFBFBD>W<03><><EFBFBD>N<><19><>틻s<>.<1A>`Z7<>8<EFBFBD><38>33<33>gqq 0*<2A><06><02>r<EFBFBD>Qn.<2E><><EFBFBD><0E><><EFBFBD>w0g,<2C>[,P<>h+NčǙǢ<17><>?<3F>x<EFBFBD>8<EFBFBD><38>i<EFBFBD>A<EFBFBD>i<EFBFBD>49.TK<54>};<3B>A<EFBFBD><41>r\<5C>YWo<57>9<EFBFBD><39><EFBFBD><13>츩s[?zo<7A>Q<EFBFBD>h<EFBFBD><68>/<2F>O8<4F>E. <0B><11><<3C><>O'<27><>DZ<44><5A><EFBFBD>c<17><>?ŏ<><C58F>ѷ<EFBFBD>Dh <0B>W#k6<6B>0?N<><4E>+g<>T<EFBFBD>@2<><32><EFBFBD><EFBFBD><EFBFBD>q<>r<EFBFBD>d<EFBFBD><64>&<26>=F<><46><EFBFBD>hKK<4B>\<5C><><01>D( d<><64><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><10>8<EFBFBD><38>}<7D><16>^?<3F><>*++<2B> <0B><><EFBFBD><EFBFBD><13><>b<EFBFBD>]<5D>@D^<5E><>o^<5E><>&m<><6D><EFBFBD>NpG<>σܧ<>D<EFBFBD><44>$<24><>Nj<>䆅<EFBFBD>_<>(<28><><03><>T<EFBFBD>[S<>~<7E><><04>e<>xy<78><79><EFBFBD><<3C>$yBY<42><59>y\<5C>7<EFBFBD><37>f!9D<39>p <0C>
<EFBFBD>e<EFBFBD><EFBFBD><EFBFBD>Z<EFBFBD>;W<><57><0F>>ŮC<19><>V0<56>
<EFBFBD><EFBFBD>D<08><02><>Y<EFBFBD><08><>]<5D><><EFBFBD><EFBFBD><EFBFBD>N<EFBFBD><4E>B CP<43>a됻l<EB90BB><6C><EFBFBD><EFBFBD>d#e";<3B><>S(9<><39>><3E>a<EFBFBD><61>d<EFBFBD><01><05><>`d<><64><EFBFBD> i<> 't<><74>i<>TtD\<5C><><EFBFBD><EFBFBD><EFBFBD>&<26>D8<44><38>g<0F><><EFBFBD><EFBFBD>Oz;X<><58><EFBFBD>,<2C>N<>Qm7!#<23><><EFBFBD><EFBFBD><EFBFBD>qZs!fG\G<><11><><13><>ZtE<16><>F0S X<><58>܄C"<22><><EFBFBD>A<EFBFBD><41>-<2D><><EFBFBD>;<3B><>,_<><5F>k~̫<>4
<EFBFBD><EFBFBD>Q<19>-Ǖ<18>Df$<24><>]L<>E<EFBFBD><45><EFBFBD><EFBFBD><00>Ԩ7%<16>7 <0B>Q<EFBFBD><51>⢠S<E2A2A0>uʥx&<ٴ<01><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>LxT<78><54><EFBFBD><EFBFBD>]n<>W̥zf<01>sjct<63><74>X<EFBFBD>$<24><18><1F><><EFBFBD><EFBFBD><EFBFBD>ǤaA<61>X<EFBFBD>x|<7C>Kn
6<EFBFBD>9r<EFBFBD>d/7<>>.{B'<27>r<13>?<1D><>t <09>֐|<7C>
0<EFBFBD><EFBFBD>.<2E>C Hqګ<18><>99'-^<5E>^e6ӂ<16>xTF&<f<><66><EFBFBD><EFBFBD>r<12><11><>MR<4D>,Ƥ2<C6A4><32>7<EFBFBD>><3E><>x<EFBFBD><78><EFBFBD>&<26>ѹ89>DyŅb><3E>
9<EFBFBD>IWk<EFBFBD>?<3F><><EFBFBD><EFBFBD>JJ<4A>0<EFBFBD>G<EFBFBD>L:<1E>f<>/ Q b<>R<EFBFBD><52><EFBFBD>M<EFBFBD>Dlؠ0<D8A0><30><EFBFBD>R<EFBFBD>&<26>h<EFBFBD><68><EFBFBD><EFBFBD>
<EFBFBD> <0B><>ܛ<EFBFBD><DC9B><EFBFBD>? <0B>h<><68>+'<1E> <11><><EFBFBD><EFBFBD><EFBFBD>[<5B><><13><19><>渐e<E6B890><65><EFBFBD>KPbA<62>JCnB<><42><EFBFBD><03>$<12><>J<1D>x,<2C><>a<EFBFBD>09.7:<06><><1C>L@<40><><EFBFBD><EFBFBD><12>E<15><><EFBFBD><06><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>< !+T<1A>!'<27> <0C><><04><>ar\g|<7C>8<EFBFBD>@6x<04>sS<73><53>9<EFBFBD>~<7E>|o<><6F>GWKh<4B>T<12>ɵ<EFBFBD>!#׾O<D7BE>vy<76>qu<71>`<60>xW<78>H<EFBFBD>.<2E>B<EFBFBD><17>,Y,:<3A>0d<30>Ԩ<EFBFBD> 0 }<2<><32>/<2F>H<EFBFBD>%<25><><EFBFBD>+2<7F>4a<34><61><EFBFBD><EFBFBD><02><><EFBFBD><EFBFBD><07>,z<><7A>JM CF<43>Nh<4E><68><EFBFBD><EFBFBD>L<EFBFBD><4C>q3<71><33><EFBFBD>"<22><1B><>3Xx<58> =<3D><><EFBFBD><EFBFBD>ͳ
<EFBFBD><EFBFBD> <0C>Gs7Vр<56><D180><EFBFBD><EFBFBD><EFBFBD><17><>!˲3-?E<><45>(=<3D><1C><>uţ<>d<EFBFBD>o<EFBFBD>9<EFBFBD><39><EFBFBD>B<EFBFBD> <20>8~<7E>e<15>
<EFBFBD><EFBFBD>Hן΍/<2F>ƺڼLJG}:<3A>dt<64><74><08><><02><><EFBFBD><EFBFBD>D<EFBFBD>\<5C><13>g<EFBFBD>Q<EFBFBD>-<2D>o<><6F><1D>g<EFBFBD>,Nׯ<4E>{n<>B8<10>Q$O::<3A>O<0E>8_<02>}W<>N<07><><EFBFBD>Ul<55><6C><EFBFBD>&<26><08>Qv<51><76>g<EFBFBD><67>__B<5F>^r)-<2D><19><><EFBFBD><19>/<2F>I<EFBFBD>C<>2<EFBFBD><32>3<EFBFBD>I<EFBFBD>GT<1F><02><>'<27><>B<EFBFBD>y<EFBFBD><79>;<3B>ivXr<58><72><EFBFBD>[L<><4C><EFBFBD>gM<67>E?˖-<2D><> <0C><0E><><EFBFBD>aGC<><02>?<3F><>A:<3A>p<EFBFBD><70>Œ<1E>z<EFBFBD> <17>ҥK%£%.<2E>uN^}<7D><>E<EFBFBD><45><05>}\<5C><><12>8t1<74><15><>|<7C>!<21><><EFBFBD>y<EFBFBD>v<>9s<39><73><EFBFBD>e<EFBFBD><65><EFBFBD>l<EFBFBD>Q7<51><0E><><EFBFBD>
<EFBFBD><EFBFBD><1B><><EFBFBD>]<5D><>2<EFBFBD><32><EFBFBD><EFBFBD>z<EFBFBD>QC<0F><>><3E><1C>
<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>{6\<5C>i"L9<4C><39><EFBFBD><EFBFBD>t4<74><34><EFBFBD><EFBFBD><1A>#<23><>촜<EFBFBD>"<22> <20>"ǽ<><C7BD><EFBFBD><03><07>9?)$C<>Cy<43><03>5 <0B><><EFBFBD><EFBFBD><EFBFBD>y5<79><35><EFBFBD>i莣<69>QOZp<5A><70><EFBFBD><EFBFBD>EZ8<5A>uѝ8-緈<><E7B788><EFBFBD>D<EFBFBD>0<EFBFBD>}X<>A<> <09><><EFBFBD>;<3B>b $H<><48><EFBFBD>z<EFBFBD><7A><<3C>}9<>;<3B><><EFBFBD>NΘ<4E><CE98><EFBFBD><EFBFBD>W<EFBFBD>5g<>ۑv<DB91>㴈<EFBFBD>ϝiﻟ<69>s<EFBFBD>k<EFBFBD>t<EFBFBD><74>'<07><1E><><EFBFBD>Y<17><>>S\<5C><03>q<EFBFBD>mm><3E>}9<>V{['G<>4߀0}<7D>-<2D>f<02>1<EFBFBD>Žr<00><>JN<4A>M8<><38>ϑv<CF91>w<EFBFBD>ҪU<D2AA><55>8#<23><>s<EFBFBD>tcJ<><4A>(<28><><EFBFBD><EFBFBD><EFBFBD>{qm<71><6D>K<EFBFBD><14><><EFBFBD>Ǚ<EFBFBD><C799><EFBFBD><EFBFBD>j<EFBFBD>#<23>#.Jl<4A>6(.aP<50>50 <20><><EFBFBD>V<EFBFBD> <20>E<1E><><EFBFBD>i<><69><EFBFBD>-<2D><><EFBFBD>q<EFBFBD><71><EFBFBD><EFBFBD>^c<><63><EFBFBD><EFBFBD>:"<22><>@<40>}\]&<26>dM<><4D>Vh<56><68><EFBFBD><EFBFBD><EFBFBD>\N0QW<51>Z<EFBFBD><5A>n<EFBFBD>]<5D>:i<><69> <0C>KgȱKظ-<2D>=<3D><><EFBFBD><10>z<EFBFBD><7A>m<EFBFBD>s`<60><>6v<36>W<EFBFBD><57><08>_<EFBFBD><5F><EFBFBD>Xe<58><65>Oև<4F><D687><EFBFBD>J&C<>Q<>9n<39>X<EFBFBD><58><10>w<>!;><3E>rziy<69><79><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>@<40>ȑ<EFBFBD><C891><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>P<EFBFBD>&G<Ž<>K<EFBFBD>+<2B><><EFBFBD><EFBFBD>S<18><1B><><EFBFBD>:<3A><>s<EFBFBD>﷿<EFBFBD>mN~<7E>]<1E><EFBFBD><7F><EFBFBD><EFBFBD><EFBFBD>6a<36><61><EFBFBD><EFBFBD>+^N <09><>AE<41>k/<2F>+<2B><><08><>EMM<4D>8F!L<><4C><EFBFBD>aMu5<1D>w<EFBFBD>Y<EFBFBD>& ҢHf<<3C>=<3D>%<25>z\B<><42>*<2A>n`r56<7F><36><EFBFBD>)Kw<ru\َ)<29><>>r<>f<EFBFBD><66><EFBFBD><EFBFBD>À5<C380>U<EFBFBD>;.ƅ"<22>.CI<1B>&<26><>"<22><>q<EFBFBD>YC<59><02><><EFBFBD>F<EFBFBD><46><EFBFBD>1TQ5<51><1D><>o<EFBFBD>:<3A><18><><.<2E><>.<2E>|a<>an8쓯<12>æTN-<2D>L<EFBFBD>{a0<61><30>V<EFBFBD><56><EFBFBD>ε<EFBFBD>p<>$ <0C>8<15>HQ<48><51><EFBFBD><EFBFBD>A<EFBFBD>ʲ<EFBFBD>Ök<C396><6B>~<7E><><08>o<EFBFBD><6F><EFBFBD>Ǖ <0C>گ<EFBFBD><1E>`S<>T|X<>0<EFBFBD><30>d<EFBFBD>ʬ+&><3E>*<2A>B<EFBFBD>[u4<75><13>gz <01><>ϱ<EFBFBD><CFB1>z<EFBFBD>y<EFBFBD> <0B>Q<EFBFBD><1D><>&N_[<5B>}̼<><CCBC>kZɳ<08>cP(<28>X<EFBFBD>L<EFBFBD>5<><35><EFBFBD>s<EFBFBD><73><<3C><> <0C>
<11><>u<02><06>W<EFBFBD>C<EFBFBD><04><>ぐk<E38190><6B><EFBFBD>8<EFBFBD><38>NNd
B_w<5F>8+<2B> q<><71>z+<2B><><EFBFBD>$<24>"*A,`<60>,<2C><><EFBFBD><<3C>͌.<2E><><EFBFBD>'Ӭ@<40><>N<EFBFBD><4E><EFBFBD>@<40>8<EFBFBD><38><EFBFBD><EFBFBD>]<07><>j:]D<><44><<3C>+<2B>mV<1C>(<28><>6<EFBFBD>(<28>x<EFBFBD><78><EFBFBD>f*W<>i_^\<5C>><19><>Q<EFBFBD>d}{r\g@<40>Z<EFBFBD>s<EFBFBD>4Pq/L<>K<EFBFBD><4B><EFBFBD>U <0B>A<>W"<1E><>ޚ0q<30>65<36><35>O<17>]ω3B|<7C>b1<62><31>H)1'1r
<EFBFBD>P<EFBFBD>x<EFBFBD><EFBFBD>*<2A><>Im<49><6D>%<25>X<><58><EFBFBD><EFBFBD><EFBFBD>jx<6A>i<EFBFBD>*<2A><>mk<6D><14>sf<1A>*U%w<><77>AP<41><50><EFBFBD><EFBFBD><EFBFBD>Ag-<2D>$<24>鎡<EFBFBD><E98EA1>;V>?<3F>J<EFBFBD><4A><00>Wl~<7E>m\<5C><01><><EFBFBD>ܯ<><DCAF><EFBFBD>۸걗8J&<<3C>3<EFBFBD><33><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ǔ<EFBFBD>7<><37>
c<EFBFBD>a<><61>.͘ ax6<>R<EFBFBD><52><><7F><EFBFBD>K<EFBFBD><4B><<3C><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>*<2A>p<EFBFBD>><3E><><EFBFBD>8<EFBFBD><38><EFBFBD>yp<1C><>t2<74><32>3<EFBFBD>#S<>X&<26><>v2i<32><69><00>
C<EFBFBD>IJL<EFBFBD><EFBFBD>1<EFBFBD>x)<29>x&|<7C><><EFBFBD>K<EFBFBD><4B><EFBFBD>,<2C><>
ۙV<DB99>q<EFBFBD><71><EFBFBD>v<EFBFBD>n.<07><>vC!X <20><>qӍ*vN<76><4E>l<><6C>VQm<51>Y@<40><>E|5<><35><EFBFBD> <20><19>z<EFBFBD><17><><EFBFBD><EFBFBD>G<EFBFBD><47>~<7E><><EFBFBD><EFBFBD><17><><EFBFBD><EFBFBD>Ǖ<EFBFBD>V<>+ɽ<>h<EFBFBD><68><08>K{ <0B><><EFBFBD>;U%b<><62>#<23>7<EFBFBD><37><EFBFBD><EFBFBD>j<EFBFBD>j<EFBFBD><6A>j<18>WTp<><70>G<EFBFBD>R?.<2E><><EFBFBD>Im<49><6D><08><><EFBFBD><EFBFBD><EFBFBD>3^n W<><57>n,<2C><>а<EFBFBD>g<1F>D\ <11>}C9#qx
<EFBFBD><EFBFBD>m<EFBFBD>
<EFBFBD>13<EFBFBD><EFBFBD><EFBFBD>@#F<>Soo<1F><>wRwO<07><><EFBFBD>rc"<<3C>[^VFUê<55><C3AA>!<21><><EFBFBD>Ct<43><74><EFBFBD><EFBFBD>Xf<58>ŗe <11><>Сk<D0A1>Пǭ<D09F><C7AD><EFBFBD><EFBFBD><EFBFBD>r;v4<76>tj<74>8<EFBFBD>:+<2B>5i<35><69>%<25>Ŵg<C5B4>>v|<11><><EFBFBD>@<40><>9<EFBFBD>ϒ5[N+<2B>+h<><68>qt<71><74><EFBFBD><EFBFBD><EFBFBD>a7¦3<C2A6><33><EFBFBD>i<><69><EFBFBD>,#<23>~#~<7E>z<EFBFBD><7A>K<EFBFBD><4B><EFBFBD>|<7C>ϡ<EFBFBD><CFA1> <20><15><>q<EFBFBD><71>8l<>KW\<5C><><EFBFBD><EFBFBD>c8<63>vw<76>1ۂ6h;v<>(G#[<><7F>Pk<50><6B><EFBFBD><<3C><><EFBFBD><EFBFBD>=L<><4C>S<19>Ú<EFBFBD><C39A><EFBFBD>Y<EFBFBD>u<15>A<EFBFBD>@<40>] <0C>8<EFBFBD><38><EFBFBD><EFBFBD>ќ<EFBFBD>V<EFBFBD><56>yG<79><47><EFBFBD><EFBFBD>Wr^!<21><><EFBFBD>m<EFBFBD>hcX<63>={<7B><><.b<><62>=<3D>5<EFBFBD><35><EFBFBD>-<2D><>ؾ}|<7C><15><>B<0E>ZZZ<5A>݆<EFBFBD>B<EFBFBD><42>myVA#n<><6E><EFBFBD>g>s<><73>"n<>
<EFBFBD><EFBFBD>j<EFBFBD><EFBFBD><EFBFBD>+<2B><>5<EFBFBD>^<5E>ڵ{/<2F>x<EFBFBD><78>8<EFBFBD><38>sΤ<73>ƍ<EFBFBD>G{"<22>s؉<73><D889>V<EFBFBD>m<EFBFBD><6D><EFBFBD>o<01>Yq<>d<EFBFBD><64>bv<>L<EFBFBD>*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>7<EFBFBD>C<EFBFBD>5"r<15><>
<EFBFBD><EFBFBD><EFBFBD>pڹg<EFBFBD><11>:/<2F>u+^]<5D>ӂd7bѢ<62><D1A2>m7<1F><>G<EFBFBD><47>Y@<40><><04><>S<EFBFBD><53>~p7<>ͣΟw^(z<><1C>QC<51><43>e<EFBFBD><65><EFBFBD>2<EFBFBD><32><EFBFBD><EFBFBD><EFBFBD> <0C>V(<28><10><><EFBFBD>(<28><>6<EFBFBD> 2<>Y<1D>uZ<75><5A><EFBFBD>[<5B><>o<EFBFBD><6F><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>,,<00><><EFBFBD><EFBFBD><EF9794><EFBFBD>gS1<53><31>=?<3F>ۑ`<60><11>g<EFBFBD>?z<>9n<39><6E><EFBFBD>,<01>#<23>j<EFBFBD>Vԍ<>i<><69>o <20><>%x<><78>'<27>D<EFBFBD><44><EFBFBD><EFBFBD>___o3<6F>ӿ<EFBFBD>|3N<33>t<EFBFBD>=<3D>g3p<33>X<EFBFBD>/<2F><>"<22><><EFBFBD>@<40><>s\^<5E><><EFBFBD>d1<64><31>H<EFBFBD><48><EFBFBD><13><1D><>8<EFBFBD>y<EFBFBD>9n
<EFBFBD><EFBFBD>-7<>_ޣ΋<DEA3><CE8B>n~<7E>Lw#<23><>y.<2E>ZQ<5A><51>h<EFBFBD><1C><><EFBFBD><EFBFBD>[<5B><><12><><EFBFBD><03><>Mu<>9<EFBFBD>y=l<><16>5bD<62><44> `8.<2E>G<EFBFBD>8/G^L(<28><><EFBFBD><EFBFBD><15>T<EFBFBD>n<EFBFBD><6E><EFBFBD>%<25><1A><><13>,<2C> 8h<>+<2B><>G<EFBFBD>9<EFBFBD><39><EFBFBD>t'<27>Mk;<3B><><1E>r^<<3C>0e<30><14>us<><00>֯x#<23>'<x<><78>o~M<><4D><EFBFBD>Bw#.<2E>Չ<EFBFBD><D589> <20><><19><>g"<22>F<EFBFBD><18><>k<EFBFBD><6B>:߈<>-/<2F><1E>N<EFBFBD>Ǡ%+g<>uN2RT<52><54><05>T<EFBFBD>n<16><><EFBFBD>8罛<38>#/<2F><><EFBFBD><EFBFBD>?6<>3x<33><78>J<><4A>q<EFBFBD>0<EFBFBD>jV<6A>F^ŽЗ<C5BD>M5<4D>*lE<1A><><EFBFBD>ڎ<EFBFBD><DA8E>Q
<EFBFBD><EFBFBD>w<EFBFBD>V<EFBFBD><EFBFBD>Ϋ<EFBFBD>
k<EFBFBD><EFBFBD><EFBFBD>/<2F><><EFBFBD><EFBFBD><X<>D<EFBFBD>[0ɒ6<C992>G^3ϩ<33>ߨ<16><07>^?I<>^<5E><01><>q<EFBFBD><71>B\N<><4E>+<2B>
<EFBFBD>g<1B><>#<23>j9x<39><78><EFBFBD>y?7`<60><>b<1F><>
T[[PR<50>< h<><68><EFBFBD><EFBFBD><EFBFBD>Y<EFBFBD><59><EFBFBD>u<EFBFBD>Mk<4D><6B><16><>9P<39><50> <09><><EFBFBD><EFBFBD>q|<7C><>}g<>6zyyi<79><69><EFBFBD><EFBFBD><EFBFBD>sR!]@X<>R:;;<3B>nWYi)<29><><EFBFBD><EFBFBD>n
%<25>O8-<2D><>x<EFBFBD>m_μQę<51>H<13><><EFBFBD><EFBFBD>apR<70><52><EFBFBD><EFBFBD><EFBFBD><05>wŊ<77><C58A><EFBFBD>Ͽi<CFBF><69>9<EFBFBD><39>|A<>Fq\,<01><1C><>ERWW<57><57><EFBFBD><18><><EFBFBD>Ћ<07><><EFBFBD>
<EFBFBD>TR\<5C><><EFBFBD><EFBFBD>i'L<<3C><><EFBFBD>۩<EFBFBD>~8K<38>JP d<><64>G<EFBFBD>w<EFBFBD><02>?<3F>O/<2F><><EFBFBD><EFBFBD>3<EFBFBD>Rͷw<CDB7>s<EFBFBD>%<25>"<22><><EFBFBD>b`<10><>y#9Ÿ<19>9<EFBFBD>Ñ2t<32><74><1A><><EFBFBD>i<EFBFBD><69><EFBFBD>W<1D>Ϛ5K<35>v„<76><C284><EFBFBD><EFBFBD>3<EFBFBD><05>q\3<><33><EFBFBD> <0B>G<>+^<5E><>Ἑο<E1BC99><CEBF><EFBFBD>?<3F><>Ï<EFBFBD><C38F>Tq<>p<<3C>x<EFBFBD><78>a<EFBFBD>ӏ9B<39><11><13><>(<28>f<14>x<EFBFBD> <0E><><>#<23>D<>V<EFBFBD><13>G<EFBFBD><47><EFBFBD><EFBFBD><EFBFBD>"/;<3B>D\xn<78><6E> _<><5F><EFBFBD>2ǎN<C78E>u¹8<C2B9>|<7C>F}<7D><><1C><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><10>DN<03>iV<>\<5C>>-<2D><><EFBFBD>{]<5D>ʧ<><CAA7>p<EFBFBD>=<3D>3je9<65><39>O<EFBFBD>Q<12><><EFBFBD><EFBFBD>><3E>Y<1C><><17>q<EFBFBD><71>q<EFBFBD>1<EFBFBD><31><EFBFBD>8<EFBFBD><38><EFBFBD>7<EFBFBD>G<EFBFBD><47><EFBFBD>n<03> y<>]wG͈A<07>Ü<EFBFBD>q<EFBFBD>W<EFBFBD>˼o<CBBC>m<EFBFBD><6D><EFBFBD><EFBFBD>C~<7E><>w<EFBFBD>SϿ8<CFBF>o;<3B>Jw<4A>qU9KYq<  OEW<45><57>PՊ<50><D58A>Z@<40>; <0B><>O<EFBFBD><4F>g<EFBFBD>g<EFBFBD><67>?<3F>#<23>\<5C><><EFBFBD>O{<7B>Ι<EFBFBD>n<EFBFBD><6E><EFBFBD>(Wz<57><7A>OJ7<4A>F<EFBFBD>C<EFBFBD>p<>Rޢ<52>ve/oSb{ <0C><>{#2pD\\<5C>`g<><67><17>W<1B>C<>q;4<>21<32><31>L‘<4C>-<2D>G<1A>JkuFu<46>
~! <18>j;<3B><> <20>-<2D><><05><><EFBFBD><EFBFBD>'<27>7<><37>6YN<59><4E>
M<EFBFBD><EFBFBD><EFBFBD><EFBFBD>v<EFBFBD>ce<EFBFBD><EFBFBD>4+(^hKHE<48><45><EFBFBD>ǀZN<08><><EFBFBD><EFBFBD>f<EFBFBD>h<EFBFBD>?D^L<>w<EFBFBD><15>t<EFBFBD><74><EFBFBD> <0B><<3C>`<60>d<EFBFBD><1D><>$#3<>iiV<69>i[<5B><><EFBFBD><EFBFBD><17><><EFBFBD><00>N
<EFBFBD>Q=<3D>s\<5C>=ֈ<><D688>;8(<28>F\㜈<><E39C88><14>P#<23><>^<5E>HW<48> ԕ<><D495><EFBFBD><EFBFBD><EFBFBD>.<2E>gu:<3A>G<EFBFBD>:<3A><>=V<>l<EFBFBD>;S<><<3C><><06>mV<6D> W<>k<EFBFBD>8 `<60>r<EFBFBD>S-<2D><><EFBFBD><7F><EFBFBD><EFBFBD>q<EFBFBD>Gܓ<>"<22><>+IO9<4F><39>j<EFBFBD>M d;ߙ<>;<3B><><EFBFBD><08>QqR<71>r<EFBFBD><72>ڊ<EFBFBD>"-w\<5C>EC<><02>6<EFBFBD>x<><78>r\<5C>l<EFBFBD><6C>IqI<71>%(>dg,R\,t<><74><EFBFBD>yTFw<><77><EFBFBD> <<3C><>!m<01>8<03><>\<5C>?<3F><>8<11><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>T<EFBFBD>69ᬤ<39>ur['<27><1A>H<EFBFBD>,<2C><>7<><37><EFBFBD><10><>x<EFBFBD>q<EFBFBD><71><EFBFBD>?I<><49>s\<5C>,.r5<72><35><18>k0 :<3A>Ee<45>Z<00>?<3F><><EFBFBD><EFBFBD><7F><EFBFBD>縺<EFBFBD><E7B8BA>F\'v<><76><EFBFBD><08>z<EFBFBD><7A><1B>=<3D><>;o'<27><><EFBFBD><EFBFBD>7<EFBFBD><37>&<26><>g<EFBFBD><67><EFBFBD>}s\^'<27>Z<EFBFBD>yaJ<61>Qu栴<75><<3C>e<EFBFBD><65><EFBFBD>- <0B>g;ߙ<>{r\d<><64>Eq/T.o=:EQ<45><51>9<EFBFBD><39><EFBFBD><EFBFBD>$<24><>:2MQ<19>jF3ah̛<><03>1<EFBFBD><0F>;<3B>*8ΠNaC5<11>c<EFBFBD>+<2B>GG<47>҃B<D283>B<EFBFBD>v<EFBFBD>p<EFBFBD><1A>m<EFBFBD><6D><EFBFBD>}b<><62><EFBFBD><EFBFBD>
<EFBFBD><15><><04>cSu<53>@ץ*ru:o<><6F><EFBFBD>;g~L<>S<EFBFBD><53><EFBFBD><EFBFBD>Z7<5A><37><EFBFBD>q<EFBFBD><71>C<EFBFBD><43>?<3F> <20>
<EFBFBD>Ÿ<19> <0C><>8<EFBFBD><00><><EFBFBD><EFBFBD>ן<EFBFBD><D79F>><3E>z<><7A>MCB_qԐ<71>+<2B><14>$<24><>4<EFBFBD>5<EFBFBD><35>x<EFBFBD><78><EFBFBD><EFBFBD>Q<EFBFBD><51>H<<3C><>K<EFBFBD>T&i<><69><EFBFBD>:<3A>B
<EFBFBD><05>;CV3<14><><EFBFBD><EFBFBD>F<EFBFBD><46><EFBFBD><EFBFBD><03><><EFBFBD><EFBFBD><EFBFBD>Z<EFBFBD><5A><EFBFBD>w>\<5C><==ր;u<1B>x<EFBFBD>\<5C><01><><EFBFBD><EFBFBD><EFBFBD>;<3B>QGW<47>w<EFBFBD>Zںiˮ6<CBAE><1A><>~<7E>jHv<>k<EFBFBD><6B>f<><66>w<1E>^<5E><>7-x<>Qgwu<><75><EFBFBD>|<<3C><1D>/<2F><><<3C><>Gڐ<47><DA90><EFBFBD>N<EFBFBD><4E><EFBFBD><EFBFBD><EFBFBD>H<EFBFBD>st<>S<EFBFBD>O<EFBFBD>q<EFBFBD><71>x4<><34><16><><EFBFBD>ϡ1<1E>ɐ.<2E><>Th<54><05><06><1C>Ap凾<70><E587BE><03><><EFBFBD>VӺ<56><D3BA>,<2C>e~<7E>E<EFBFBD><45>-9<>ڏ<EFBFBD><DA8F>?{<7B><>_<EFBFBD><5F><EFBFBD>'<27>V&<26>W.<2E>(8>^Y<>L?|x
:<3A>C#<23>W<EFBFBD><57>[ϣ)'<27>S[g}<7D>g<EFBFBD>ѳ<EFBFBD><D1B3>ފ<><12><><EFBFBD>x}𲩴|<7C><1E><><EFBFBD>^<5E><11>t<><74><11>|<7C><1E><>#W6<57><36>t<><EFBFBD><7F><EFBFBD><EFBFBD>^<1A>0<EFBFBD><30>e!<21>zR<1D><>v<EFBFBD>n<EFBFBD><6E>
ں<EFBFBD>|<7C><><EFBFBD><EFBFBD><EFBFBD>_<>D<1F>f<06>+<>1<EFBFBD><31>/_<>6Hޒ<48><DE92>{<7B>
<EFBFBD>w"<22><><EFBFBD>&ƚO<C69A>
q3<71><33>vfW<66>
& ]ze
<EFBFBD><EFBFBD><EFBFBD>ы<EFBFBD><16>x<EFBFBD>{<7B><><EFBFBD>}p<15><><EFBFBD><EFBFBD>.<2E>?<3F>>{<7B><1C>3}$;q <0B>^<><7F><EFBFBD><EFBFBD>ⴥ%<25><>`<1D>C<EFBFBD><43><EFBFBD><EFBFBD>k<EFBFBD>y<EFBFBD>aw4~i;ճ<03><>[<5B><><EFBFBD>?<3F>#z<><7A><EFBFBD><1B>g<EFBFBD>E<>`<60><>d<EFBFBD><64>?<3F>@^{<7B>Y<EFBFBD><10>H<EFBFBD><48><EFBFBD><03><><EFBFBD><EFBFBD><EFBFBD><><7F>><3E><><1A>+<2B>k1E<31><45>`'=<3D><>&^<5E>E<EFBFBD><45><1F>,N;w<>h<EFBFBD><68><EFBFBD><EFBFBD><EFBFBD>Vӽ<56>YK+<2B>5 }0짱<30>5<EFBFBD>d1<64><31>$:<3A><>W<>^<5E><><EFBFBD><08><><19>-<2D>+WQ<>O<1A>Ŋ<1E>`<60><>}<7D>)|ͦ<16>8<EFBFBD><38><EFBFBD><EFBFBD>h2<68>=sUU<55>ѿ<EFBFBD><D1BF><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>\<5C><><EFBFBD><EFBFBD><EFBFBD>5<EFBFBD><35>0Gֲ2^Q<>j<EFBFBD>\0<>><3E>x=<3D><>V<EFBFBD><56><EFBFBD>_<EFBFBD>g^<5E>E<EFBFBD><45><EFBFBD>l<EFBFBD><6C>Kۤ<4B><DBA4><EFBFBD>
ǟ<>Qs<51><73>fzb<7A>6<EFBFBD><36>qB<71><42>?x<><78>T_SF<53>-<2D><>8<EFBFBD> '<27>W<EFBFBD><57>l<EFBFBD><6C>߶q<DFB6>~<7E><>zu<7A><75><EFBFBD><1B><><EFBFBD><EFBFBD>zs<7A>A<EFBFBD><41>o<EFBFBD><<3C><>ӗôz<C3B4><01>=<3D>qP쇈<50>y 2<>0c<30><63><EFBFBD>r<EFBFBD><72>p<18>k(<28>JW<1A>e<0E>G<>։<EFBFBD><D689><EFBFBD><EFBFBD><EFBFBD>DUfvS<04>dߠ~/<2F>:<3A>z<EFBFBD>˞<EFBFBD><CB9E>f<>w<EFBFBD>_I;<3B>!D0<14><04><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><1A>4v>D<><44><EFBFBD><EFBFBD>NK<4E><4B><EFBFBD>]<5D>̜2\<5C>o<EFBFBD>d^ȇ<>v<EFBFBD><76>.7<EFBFBD>}<7D><><1D><><EFBFBD><EFBFBD>Ά<><CE86>4<EFBFBD>F<EFBFBD><46><EFBFBD><EFBFBD>`<60>O<><4F><EFBFBD>u<EFBFBD>4}B<>țz<C89B>y<EFBFBD>*ro<72><6F>?<3F>[IX<7F>U<EFBFBD><55>|<7C>i<EFBFBD>1亃e?<3F>C<EFBFBD><43><EFBFBD><EFBFBD><EFBFBD>U<EFBFBD>;^j<06>偮B<E581AE><42>K8+Ѷ<><D1B6>zM<7A>s <0C>6<EFBFBD><36><EFBFBD>_&9<>m<EFBFBD><6D><EFBFBD>'6<>)y<><79><EFBFBD><EFBFBD><EFBFBD><EFBFBD>b<EFBFBD><62>Z<EFBFBD>a?]:b<=<3D><>nj=<3D>-N=<07>x<EFBFBD>o_H5<48><35>W<EFBFBD>9<EFBFBD><39><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <0C><><EFBFBD>|ч 2<>|<7C><>&
<EFBFBD>oAt<11><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>N|<7C>D<EFBFBD>︄&<26><><EFBFBD>/<2F><>胋<EFBFBD><E8838B><EFBFBD><EFBFBD><EFBFBD>3<16><1F>_<EFBFBD><5F><EFBFBD>0<EFBFBD>[<5B><>L<EFBFBD><4C><EFBFBD>\pcit<69><10><><00><>F>1<><03><><EFBFBD><1B><>g><05>r<>3g<33>t<EFBFBD>,<2C>r<EFBFBD>‰<EFBFBD>賛<EFBFBD>?y<>~<7E><>z<EFBFBD>Ļ<03>=<3D><>ފn6<><36>l<00><><EFBFBD><EFBFBD>ΟD<CE9F><<3C><><EFBFBD><EFBFBD><EFBFBD>iG<><47><EFBFBD><EFBFBD>/<2F><>ǯ><3E>f8<66>"<22><>L&<26>8<EFBFBD>]{<7B><><16><><EFBFBD>y<EFBFBD>w$~a<>^<5E><>=<3D>(<28><><EFBFBD><EFBFBD>b/U"6?<3F>Q<EFBFBD> <1F>!<21>źP<C5BA>7+.W<1C><>ر<EFBFBD>"
'<03><03>p0<00>Wo:<3A><>}<7D>kre<72><65>{<7B>sg<73><67>]<5D>@<1C>:<3A>{<7B>//<2F><14><><EFBFBD>)<29><><EFBFBD><EFBFBD><19> W3<17><>"3<><33>4Sw<53>><3E><><EFBFBD><EFBFBD><EFBFBD><1E><><EFBFBD>/+v<><76><EFBFBD><EFBFBD>M<><4D><EFBFBD>4ze<7A>q:<3A><>h)<29>M.<2E><><EFBFBD><EFBFBD><EFBFBD>m<EFBFBD><6D><EFBFBD>8<><38>B<EFBFBD>F <0C><><EFBFBD>?<3F>d<><64><EFBFBD><EFBFBD>`<60><0F><0F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>l?<3F>i<EFBFBD><69>
<05><><10>F<EFBFBD><46>+n<>.?uz<75>P<EFBFBD><50>Zɹ<5A>_<EFBFBD><5F>a:c<><63><EFBFBD>T<EFBFBD><54><EFBFBD><EFBFBD>G:<3A>ҁC<1D>PWE<57>U<EFBFBD><55> K<>N<EFBFBD><4E><EFBFBD><EFBFBD><EFBFBD>}4zD<7A>DHIJ-z*<2A>~<7E><><EFBFBD><EFBFBD>Ө<EFBFBD>՜&<26>B<EFBFBD><42><EFBFBD>r<EFBFBD><72>F<EFBFBD><46><EFBFBD>Y9<><1F>\<5C><>
\<5C><><15><><EFBFBD>><3E>A<EFBFBD>$<24><>J<EFBFBD><4A>}<7D>;[<5B><1C><03><>CMm<4D>c<EFBFBD>qD<71><44>ي<>b<EFBFBD>-<07>ǫ*<2A>y'<27>F<EFBFBD><46><EFBFBD>{<7B><>F<EFBFBD><46>Mt<4D>F?<3F><>eLC<15><07>0<EFBFBD><30><EFBFBD>%<25><><EFBFBD><EFBFBD>J<EFBFBD><4A><05>H<EFBFBD><07>~<7E>Y&<26><><17><><EFBFBD><EFBFBD><EFBFBD>r\6]v<>]<17>Z<EFBFBD><5A>XIJ<49><4A>$0爣w<E788A3>VsQ1<51>cs<00><14>=<3D>V<EFBFBD><56>X<08><><EFBFBD>r\<5C>$r(<28><>[i<>t6Xc<58>B<EFBFBD><42><EFBFBD>W<>
<EFBFBD><EFBFBD>WKX<><58>8<><38><EFBFBD>'<0F><>lL<6C><4C>
<EFBFBD><EFBFBD>'†<><05><><EFBFBD><7F>y<EFBFBD><79>
<EFBFBD><EFBFBD><EFBFBD><1B>x"'Kx<4B><78>PMRH<52><48><EFBFBD>M<EFBFBD> <0F>=<1F><1D>GO5#I<>o .<2E><><EFBFBD>/l{<7B><>
1y 9<>BY<42>ŵ]}K<><4B><EFBFBD>±q0<71><30>Q
<EFBFBD>>q'Jg<4A><67><04><>qC<71>P<07>0<EFBFBD>؈<EFBFBD><D888>2<EFBFBD>~<7E><>Z<EFBFBD>ܨ<EFBFBD><18>F6<46>x<EFBFBD>⹩<EFBFBD><E2B9A9><EFBFBD><EFBFBD>Y<EFBFBD>p<EFBFBD><70><EFBFBD><EFBFBD>j<0F>^<5E>ZŜ<1C>lhn+y/<>'(<28><><EFBFBD><EFBFBD>,q<>1<EFBFBD>۟<EFBFBD>n,Y<><59>p<EFBFBD>|<7C><>iO:<><7F><EFBFBD>מ<03><><1D>B<EFBFBD><42>H?<3F><>".`<60>S<EFBFBD><53>C<EFBFBD>+ <09>,<1C><05>+<14><>><3E>d<05><>H<EFBFBD>k
9fxB<78><42>O<EFBFBD>7<EFBFBD>>.k):<3A>ޟ<EFBFBD><11>f*. (<28><>Y-<16><><EFBFBD>;<3B><>C<EFBFBD><08>{<7B><><EFBFBD>VB"Nb<4E>u<EFBFBD><75>!]<5D><>`<60>Å.,
<EFBFBD>j<EFBFBD>Gp(ف<>
3h<EFBFBD>Q<EFBFBD>3<<18>q<EFBFBD><13><>Y*<0E><08>a<12>I<14><>-s<><73>q<EFBFBD>3<EFBFBD><33>a<><15><>U<EFBFBD><55><EFBFBD><EFBFBD>C<EFBFBD>EW<>}<7D><><EFBFBD><EFBFBD><EFBFBD>/v<02><><EFBFBD><EFBFBD>N`Qr€P<C280><50><EFBFBD><EFBFBD><EFBFBD>820<1E><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>l{
<EFBFBD>}x<>d<EFBFBD>B<EFBFBD><03>e|@<40>yr\<5C>spF<70>r<EFBFBD><72>toč<6F><<3C><11>
<EFBFBD><EFBFBD>ja<EFBFBD>/<2F>Зnx`Dw&<26>cr<><72><EFBFBD><0F>E<EFBFBD>U6<55><36><EFBFBD><19><>r\<5C>4g<34> <20>E<EFBFBD><45>Ņb><3E>Nq<4E>ˊ<10>c<EFBFBD>"<22><>R<EFBFBD> q<><71>u<><75> <0B>3<EFBFBD><33>\<5C>_<EFBFBD><5F><EFBFBD>><3E><><EFBFBD>N<EFBFBD>9<>nąs<C485>%Mua<04><>rL<02><><EFBFBD>"݇7<>a<EFBFBD>m<EFBFBD><07>*B<><42><EFBFBD>$벢<>
Y
<EFBFBD>4<>W<EFBFBD>v<EFBFBD><76>A<EFBFBD><<3C>2O<32><4F>eb»<62><C2BB>9<EFBFBD>ܐ[<11>{P<><50>dW<06><02> U<><55><EFBFBD>M<EFBFBD>I<EFBFBD>/<2F><>>T<>gf$6><3E>]<5D><>O<EFBFBD>ޓ<EFBFBD>c<EFBFBD><63><0E><>s<>p<EFBFBD><70>s<EFBFBD>h<EFBFBD>n<><6E><EFBFBD><EFBFBD><EFBFBD><EFBFBD>6<EFBFBD>Ѿ<1E><><EFBFBD><EFBFBD><EFBFBD>y5R<1F>d<EFBFBD><64><EFBFBD><EFBFBD><EFBFBD><EFBFBD>P<EFBFBD>o<EFBFBD>)<29><>r*-<2D><><EFBFBD><EFBFBD>R<EFBFBD><52><EFBFBD>1^q2<71>'<27><><EFBFBD>[h~`<60>f<EFBFBD>Q<EFBFBD>9.\ <0C>%<25><>0 <0C><>2ǡ<32><C7A1>ء1<>^v<><76>#<23><><EFBFBD>F<15><>TRZB<5A><42>m`*<2A>W*<2A>,Ǩ<><C7A8><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>N\F<>U5<55>W<EFBFBD><57>[<5B>Ca<43><18><>g<EFBFBD>~<7E><><EFBFBD><EFBFBD>s<EFBFBD>|<7C>45<34><35><EFBFBD>BÏ<42> 纺:<3A>P<EFBFBD>~~c<19><><EFBFBD>Ruu
<EFBFBD><EFBFBD><EFBFBD>qDMW<EFBFBD><EFBFBD><EFBFBD><EFBFBD>]<5D><><EFBFBD>!<21>_:<3A><>J=<3D>T];<3B>e<18><>S<14><><EFBFBD><EFBFBD>ޙ<>XN<58>
<EFBFBD><EFBFBD>q<EFBFBD><EFBFBD>].<2E>9[<1C><><EFBFBD><EFBFBD>θ<17><0F>h<EFBFBD><68><15>p<EFBFBD><70>QL<51><4C><16>A<EFBFBD><41><EFBFBD><EFBFBD><EFBFBD><EFBFBD>i[쥺<>j1<><31><EFBFBD><EFBFBD><EFBFBD>V<EFBFBD><56> &<26><>r<EFBFBD><72><EFBFBD><EFBFBD>n<EFBFBD><6E>ʨ<EFBFBD><CAA8> <20>۳<EFBFBD>F<EFBFBD>Oe⼅1<E2BC85>ب<EFBFBD><D8A8>yC<79>
0<EFBFBD><EFBFBD>#Y<><59><EFBFBD>9<EFBFBD><39>0 f<>Ŏ<EFBFBD><C58E><EFBFBD>8<EFBFBD>Mc<4D>Zh8Vfoo'<27>4<EFBFBD><34><EFBFBD><EFBFBD><EFBFBD>ШQch<18><>1<EFBFBD><31><EFBFBD>C<EFBFBD>[[WDzFӰ<46>rڷ{;Ga<47>F<EFBFBD>B<1B><>>p:Pr<50><72>T<EFBFBD>݈<EFBFBD><1F><><EFBFBD><EFBFBD>D<EFBFBD>\q<>(;Ī<><C4AA><04>2<EFBFBD><32><EFBFBD>&<26>PH<50>Qv<51><76>{wSͰa4r<34>(<28><16><><EFBFBD>yn<<3C>4<EFBFBD><34><EFBFBD>F<EFBFBD><46>]<5D>wQgG<1B>
<EFBFBD> n<>I<EFBFBD>'4?H<>_\<5C>+<2B>l<EFBFBD>E<02>3<EFBFBD><05><><EFBFBD>JI<4A>,<2C><1A>ݬh<DDAC><68>&<02><><EFBFBD><EFBFBD>*x<10>A<EFBFBD><41><EFBFBD>C<EFBFBD>|<06>-<2D>ӻ;<3B><>loo/߲<>WH<57><48>x**L<>
zG{;<3B>3<EFBFBD>u.'<27><><EFBFBD>DcC#m߹<6D>y<EFBFBD>=c<>?<3F>9<1A><>'<27>3O<33>̹<EFBFBD> <09><><EFBFBD><EFBFBD>bH<>H<EFBFBD>+<2B><08>Υ<><1B><>ZK<5A><4B><EFBFBD><EFBFBD><EFBFBD>><3E>KK=5<><1B><>8PQ<50>} <20><>|A<>s<EFBFBD>Vj^G<><47><EFBFBD>dЎz<1D><1D><><EFBFBD><EFBFBD>c;^<5E>+xf<><66>1<EFBFBD><31>/<2F><><EFBFBD>~<7E>6l<36>@---TSSM3f<33>Fg<46>9<EFBFBD>,N<> <09><><EFBFBD>j<EFBFBD>d<EFBFBD><64><EFBFBD>n<EFBFBD><6E>a^<14>WE<57>=<3D> <20>0<1D><19>1~<7E>u<EFBFBD><15><>3<7F><33>=<3D><><B7<42><37><03><>+<1A><>kĕ<6B><08>s<EFBFBD><08>eRz<52><7A>}r<><72> <16><>D<EFBFBD>E<EFBFBD>A<EFBFBD>5<>
<EFBFBD>KG<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>B<07><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>[i<>[o<><1C><><EFBFBD>fjhl<68> <0B><><EFBFBD><EFBFBD><EFBFBD>A<EFBFBD>g͢<67>~<7E><>ny<6E>N7<>֬y<D6AC>֯[O<>9<EFBFBD>=<3D><>mQ<1C>K<EFBFBD><4B>s<EFBFBD><73><EFBFBD>N<EFBFBD><4E><EFBFBD>g<1A>lg~Ǘ<><C797><EFBFBD><EFBFBD>n<EFBFBD><6E>s<EFBFBD>8<EFBFBD>p<12>M<><4D><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>iB<69><(<28><><EFBFBD>Ӥ<EFBFBD><D3A4><EFBFBD>)x]o<>_<>v
͚}6<>>9<><39>\<5C>:<3A>9w<39>\<5C><><00><<3C>_<><5F><EFBFBD> <0B>k<EFBFBD><6B>͸YS-<2D><><EFBFBD>]@3gΤu<CEA4><75>ѓO>Is<49>Υ3<CEA5><<3C>w<1C><><EFBFBD><EFBFBD><EFBFBD>6mz<6D><7A>O<EFBFBD>Ns<>=<3D><>vp<76>-<1B> <20>p<02>۾c<03>7<EFBFBD><37>G a<>P<EFBFBD>,ؘ<><D898><1F><>x<EFBFBD><1F><><EFBFBD>: <0B><0F>?<3F>帆<EFBFBD>p_<70>x1<#:4<><34><EFBFBD>8 W|<7C><><EFBFBD><EFBFBD><EFBFBD>W<EFBFBD><57>G<><47><EFBFBD><EFBFBD><04>pG9<47>C:S0<>t<EFBFBD><74>8<EFBFBD><38><EFBFBD>\<5C>J<<3C><><EFBFBD><EFBFBD><EFBFBD>)S<><53>)<29><><EFBFBD>3~ؤ<>&N<> <20><>Iݽ{7Mc<4D>mim<69><6D>W<EFBFBD><57><EFBFBD><EFBFBD><06>=<3D><><EFBFBD><EFBFBD>"<10><><1C><>!<21>~<7E><><EFBFBD>˜<EFBFBD>+uȃ0~<7E><><EFBFBD>?<3F><>r<EFBFBD>a<>b<EFBFBD><62>0)o<08><><EFBFBD>W<><57>(<28>8f8|<7C><><EFBFBD><EFBFBD><EFBFBD>?<3F><><EFBFBD>kjiܸSX<06><11>^<5E>S<EFBFBD>[<5B>|<7C><>ù0Q<30>Z<EFBFBD><5A>xX<78><07>͟T<CD9F>W]w<>u<EFBFBD>6<EFBFBD>{؉<>*<2A><><EFBFBD>kr<6B>b޼y><3E><>}<7D><><EFBFBD>[<5B><>߉s<DF89>!<21>-q<> <20>w<EFBFBD><77><EFBFBD>s<EFBFBD>8mܸA<DCB8>2<EFBFBD><32>a<EFBFBD><61>A<EFBFBD><41><EFBFBD><EFBFBD>>.[<5B>W<16>><14><01>_<EFBFBD><5F>z<>٧8:<3A><05>L<EFBFBD><4C>[<5B><>€x0;<07><><EFBFBD> N GN<47><01>?<3F><><EFBFBD><EFBFBD> .<2E>6o<36>$<<><02>><3E><><EFBFBD><EFBFBD><EFBFBD>G۷mK<6D><4B><EFBFBD><EFBFBD>n<EFBFBD>{9o<39><6F><EFBFBD> <0B><0E>gϮ<1D><>sOѲ<4F>~<7E>h|<7C><><EFBFBD><EFBFBD>quq<75>E<EFBFBD>p<EFBFBD> <09><><16>6N<36>i6<>,<2C>&r<>w~<7E>[<5B><>_vŕ|:E5<45>u<EFBFBD><16><>bWEUu!<0F>uh㼴<68><E3BCB4><EFBFBD>/<2F>pєX<D194>#;<3B>&<26>c<EFBFBD><63><EFBFBD>҆<EFBFBD>%ڎ;<3B><>S襉<53>&<26>ԩSyPbIW<49>Ѿ>v<>4~©<>9<>a<11>(<28>@C<H<> <0B>#m<><6D><EFBFBD><EFBFBD><EFBFBD><EFBFBD>$<24><1D>P(<28>|gҾh<D2BE> <0C>
<08><>q<EFBFBD><18>
/<2F>ޱ<14>Ƈ><3E><>2<EFBFBD>o@<40>8ܯ<><DCAF>755<35>E]D<><44>~:<3A><><EFBFBD>$<M5<4D>[?<1B><>L<EFBFBD>y<EFBFBD>`<60>xNg|JGם;wҪ<77>+Y<>Yt꩓<74> <0B>z+v֮<><D6AE><EFBFBD><EFBFBD><EFBFBD><1A>qq1<71><31><EFBFBD><EFBFBD>ሎ<EFBFBD>oQ1~<7E><>X<EFBFBD>|<7C><1A>*ly<6C>ݻ<EFBFBD><DDBB>|<7C>Mz<4D><7A><EFBFBD>4<><34>A<EFBFBD><41><EFBFBD>EM<45><4D>%!
<EFBFBD>
<EFBFBD><EFBFBD>Ώ<><CE8F><EFBFBD>R^<5E>`<60>L<EFBFBD>r*}<7D><>_<EFBFBD>S}հ<><D5B0><EFBFBD>CD<43><44>ZRR*<2A>^HZ[[y[m
}<7D>/<2F><><EFBFBD><EFBFBD><EFBFBD>D<EFBFBD><44><EFBFBD>be<62><1C><10>ꮝ<EFBFBD>h<EFBFBD><68>-t<>y?<3F>:<3A><><EFBFBD>vŽ<76>9<EFBFBD><39> <09>Y<><59>xZl׮<6C><D7AE><EFBFBD><03><>ü<EFBFBD>r<EFBFBD><72>5<EFBFBD><35><EFBFBD><EFBFBD>a:<3A><1A><>:<3A><><EFBFBD><EFBFBD>~z/縷H<E7B8B7>ll)[_<>a><3E>]]<5D><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>uo<75><6F>իN(<28><>t<EFBFBD><74>dԨ<64><D4A8>Ż<EFBFBD><10>>^<5E>?<3F><>=K<>y<><79><EFBFBD> <0C>`|'l떭t<EB96AD><74><EFBFBD><EFBFBD><EFBFBD><EFBFBD>JX<>]<5D><><EFBFBD>D<EFBFBD><44>
<EFBFBD>={v<><76>U<EFBFBD><55>'<27><>_<00><1C>v<EFBFBD><76>OJo<>ڪ)<1A><><EFBFBD>&<26>|<7C><><EFBFBD><<3C>
<1C><><EFBFBD><EFBFBD><EFBFBD>l<EFBFBD>L<EFBFBD>|<01>#<23><><03><>K<EFBFBD><4B>{qA<71><41><EFBFBD>f<EFBFBD><66>"8p<38><70><EFBFBD>ٴ<EFBFBD>}<7D><><EFBFBD><EFBFBD>#<23><><03>_<EFBFBD>L'<27>D<EFBFBD><44><EFBFBD>U`<13><>*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Sg쉨d<EC89A8><64><EFBFBD><EFBFBD><19><><EFBFBD>Orag<61><67> /<2F>'<27>e;<06><>뼯<>W.<2E><><EFBFBD>o<EFBFBD>m۶<6D>3|<7C><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ԟ8ǩ<>\K3>wW!,<2C>)<29>G<EFBFBD>I<EFBFBD>ÿs<C3BF><73><EFBFBD>JH<4A>1<EFBFBD><31><EFBFBD>!<21><19><>'<27>r<EFBFBD><72><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>s<EFBFBD>=<3D><><15><><EFBFBD><EFBFBD>
<EFBFBD><EFBFBD><EFBFBD>;sHR<48>D+<2B><><EFBFBD>c:<3A><>&<26>ʠ<EFBFBD>u<EFBFBD><75><EFBFBD><EFBFBD><01><12><><EFBFBD>b<EFBFBD><62><EFBFBD>Ώ<EFBFBD>EŘԜ<C598>2<EFBFBD><32>y<EFBFBD>+S<><13><><EFBFBD>Up<55><70><EFBFBD>*<2A>9<EFBFBD>ǽ<>rṆ<>ncz<>A\<5C>Z<EFBFBD><5A><EFBFBD><><1C>>.ŝ<><C59D>
<EFBFBD>[<5B>f<EFBFBD>bs<17>f.<2E><><16>#'{<7B><><EFBFBD><EFBFBD> 0<>Gd '<03> <0B><><EFBFBD><EFBFBD>AbDq<44>t<10>=<02><>qq<15> <20> A<><41><EFBFBD>h6<68>0<EFBFBD><30>:<3A>u<EFBFBD>8e<38><65><EFBFBD><07><>$<24>Fv` <0B><>ną<6E>aH<><48>8\곣<><EAB3A3>'l
<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>E\<5C>Fxd<07><>y<><79><EFBFBD><EFBFBD><07><>A3h0IEND<4E>B`<60>
---
File: /docs/specification/2025-03-26/server/resources.md
---
---
title: Resources
type: docs
weight: 20
---
{{< callout type="info" >}} **Protocol Revision**: 2025-03-26 {{< /callout >}}
The Model Context Protocol (MCP) provides a standardized way for servers to expose
resources to clients. Resources allow servers to share data that provides context to
language models, such as files, database schemas, or application-specific information.
Each resource is uniquely identified by a
[URI](https://datatracker.ietf.org/doc/html/rfc3986).
## User Interaction Model
Resources in MCP are designed to be **application-driven**, with host applications
determining how to incorporate context based on their needs.
For example, applications could:
- Expose resources through UI elements for explicit selection, in a tree or list view
- Allow the user to search through and filter available resources
- Implement automatic context inclusion, based on heuristics or the AI model's selection
![Example of resource context picker](resource-picker.png)
However, implementations are free to expose resources through any interface pattern that
suits their needs&mdash;the protocol itself does not mandate any specific user
interaction model.
## Capabilities
Servers that support resources **MUST** declare the `resources` capability:
```json
{
"capabilities": {
"resources": {
"subscribe": true,
"listChanged": true
}
}
}
```
The capability supports two optional features:
- `subscribe`: whether the client can subscribe to be notified of changes to individual
resources.
- `listChanged`: whether the server will emit notifications when the list of available
resources changes.
Both `subscribe` and `listChanged` are optional&mdash;servers can support neither,
either, or both:
```json
{
"capabilities": {
"resources": {} // Neither feature supported
}
}
```
```json
{
"capabilities": {
"resources": {
"subscribe": true // Only subscriptions supported
}
}
}
```
```json
{
"capabilities": {
"resources": {
"listChanged": true // Only list change notifications supported
}
}
}
```
## Protocol Messages
### Listing Resources
To discover available resources, clients send a `resources/list` request. This operation
supports [pagination]({{< ref "utilities/pagination" >}}).
**Request:**
```json
{
"jsonrpc": "2.0",
"id": 1,
"method": "resources/list",
"params": {
"cursor": "optional-cursor-value"
}
}
```
**Response:**
```json
{
"jsonrpc": "2.0",
"id": 1,
"result": {
"resources": [
{
"uri": "file:///project/src/main.rs",
"name": "main.rs",
"description": "Primary application entry point",
"mimeType": "text/x-rust"
}
],
"nextCursor": "next-page-cursor"
}
}
```
### Reading Resources
To retrieve resource contents, clients send a `resources/read` request:
**Request:**
```json
{
"jsonrpc": "2.0",
"id": 2,
"method": "resources/read",
"params": {
"uri": "file:///project/src/main.rs"
}
}
```
**Response:**
```json
{
"jsonrpc": "2.0",
"id": 2,
"result": {
"contents": [
{
"uri": "file:///project/src/main.rs",
"mimeType": "text/x-rust",
"text": "fn main() {\n println!(\"Hello world!\");\n}"
}
]
}
}
```
### Resource Templates
Resource templates allow servers to expose parameterized resources using
[URI templates](https://datatracker.ietf.org/doc/html/rfc6570). Arguments may be
auto-completed through [the completion API]({{< ref "utilities/completion" >}}).
**Request:**
```json
{
"jsonrpc": "2.0",
"id": 3,
"method": "resources/templates/list"
}
```
**Response:**
```json
{
"jsonrpc": "2.0",
"id": 3,
"result": {
"resourceTemplates": [
{
"uriTemplate": "file:///{path}",
"name": "Project Files",
"description": "Access files in the project directory",
"mimeType": "application/octet-stream"
}
]
}
}
```
### List Changed Notification
When the list of available resources changes, servers that declared the `listChanged`
capability **SHOULD** send a notification:
```json
{
"jsonrpc": "2.0",
"method": "notifications/resources/list_changed"
}
```
### Subscriptions
The protocol supports optional subscriptions to resource changes. Clients can subscribe
to specific resources and receive notifications when they change:
**Subscribe Request:**
```json
{
"jsonrpc": "2.0",
"id": 4,
"method": "resources/subscribe",
"params": {
"uri": "file:///project/src/main.rs"
}
}
```
**Update Notification:**
```json
{
"jsonrpc": "2.0",
"method": "notifications/resources/updated",
"params": {
"uri": "file:///project/src/main.rs"
}
}
```
## Message Flow
```mermaid
sequenceDiagram
participant Client
participant Server
Note over Client,Server: Resource Discovery
Client->>Server: resources/list
Server-->>Client: List of resources
Note over Client,Server: Resource Access
Client->>Server: resources/read
Server-->>Client: Resource contents
Note over Client,Server: Subscriptions
Client->>Server: resources/subscribe
Server-->>Client: Subscription confirmed
Note over Client,Server: Updates
Server--)Client: notifications/resources/updated
Client->>Server: resources/read
Server-->>Client: Updated contents
```
## Data Types
### Resource
A resource definition includes:
- `uri`: Unique identifier for the resource
- `name`: Human-readable name
- `description`: Optional description
- `mimeType`: Optional MIME type
- `size`: Optional size in bytes
### Resource Contents
Resources can contain either text or binary data:
#### Text Content
```json
{
"uri": "file:///example.txt",
"mimeType": "text/plain",
"text": "Resource content"
}
```
#### Binary Content
```json
{
"uri": "file:///example.png",
"mimeType": "image/png",
"blob": "base64-encoded-data"
}
```
## Common URI Schemes
The protocol defines several standard URI schemes. This list not
exhaustive&mdash;implementations are always free to use additional, custom URI schemes.
### https://
Used to represent a resource available on the web.
Servers **SHOULD** use this scheme only when the client is able to fetch and load the
resource directly from the web on its own—that is, it doesn’t need to read the resource
via the MCP server.
For other use cases, servers **SHOULD** prefer to use another URI scheme, or define a
custom one, even if the server will itself be downloading resource contents over the
internet.
### file://
Used to identify resources that behave like a filesystem. However, the resources do not
need to map to an actual physical filesystem.
MCP servers **MAY** identify file:// resources with an
[XDG MIME type](https://specifications.freedesktop.org/shared-mime-info-spec/0.14/ar01s02.html#id-1.3.14),
like `inode/directory`, to represent non-regular files (such as directories) that don’t
otherwise have a standard MIME type.
### git://
Git version control integration.
## Error Handling
Servers **SHOULD** return standard JSON-RPC errors for common failure cases:
- Resource not found: `-32002`
- Internal errors: `-32603`
Example error:
```json
{
"jsonrpc": "2.0",
"id": 5,
"error": {
"code": -32002,
"message": "Resource not found",
"data": {
"uri": "file:///nonexistent.txt"
}
}
}
```
## Security Considerations
1. Servers **MUST** validate all resource URIs
2. Access controls **SHOULD** be implemented for sensitive resources
3. Binary data **MUST** be properly encoded
4. Resource permissions **SHOULD** be checked before operations
---
File: /docs/specification/2025-03-26/server/slash-command.png
---
<EFBFBD>PNG

IHDR%j<00>Gz^iCCPICC Profile(<28>u<EFBFBD>;HA<10><><EFBFBD>h0<04>"<22><><EFBFBD><EFBFBD>b$<24>6"<22>"XQ<><51>es^<5E>K\7'b<><62><EFBFBD>66<36><36><EFBFBD><EFBFBD><EFBFBD><EFBFBD>+ E<>O<EFBFBD><4F>
<EFBFBD><EFBFBD>EM<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>33 <03><>u<EFBFBD>-<1F>B<EFBFBD><16>٤<EFBFBD><D9A4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><11>!<21><>Og%<25>дy*<2A><><EFBFBD><EFBFBD><EFBFBD>#<R<>G<EFBFBD><47><EFBFBD><EFBFBD>i<EFBFBD><69>W^<5E><>;#<23><><EFBFBD>-/<2F>3J<33><4A>r<EFBFBD>qa<1E>X۵<58><DBB5>∠<><E288A0><EFBFBD>%<25>u<EFBFBD><75><EFBFBD><EFBFBD>s٭Y̤<59><1F><>,<2C><>+<2B><>l<EFBFBD>o6q<36><71>a_;<3B><>Fqi<71><69><EFBFBD><EFBFBD>i<18>($<24><>8T<38><54>O<13>><3E><>Ka {؄<><lw<02><>h<EFBFBD><68>9<14>0<EFBFBD>(q 㔪<><E394AA><EFBFBD>;6<><36>;`f<>`<60><>%9p<39>t<>4<EFBFBD><34># t
܎q]<5D>?<3F><>T}<7D><>x<EFBFBD><78>A<01><>9<EFBFBD>k/<2F>j<>q<EFBFBD>O<1C>vx<><78><EFBFBD><EFBFBD>'<27>9aj<1F>J<EFBFBD>DeXIfMM*<00>i&<02>%<25>joI<6F><49>iTXtXML:com.adobe.xmp<x:xmpmeta xmlns:x="adobe:ns:meta/" x:xmptk="XMP Core 6.0.0">
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about=""
xmlns:tiff="http://ns.adobe.com/tiff/1.0/"
xmlns:exif="http://ns.adobe.com/exif/1.0/">
<tiff:Orientation>1</tiff:Orientation>
<exif:PixelXDimension>293</exif:PixelXDimension>
<exif:PixelYDimension>106</exif:PixelYDimension>
</rdf:Description>
</rdf:RDF>
</x:xmpmeta>
l0<EFBFBD>5lIDATx<01>] xUE<55>>Y YH<59><48><EFBFBD><EFBFBD>HX H<>DDdw<64>Glhm<68>lu<1C>F<EFBFBD><46><EFBFBD>vz><3E><>v<EFBFBD>[g[wT<77>%HXd<58>%a'+ [ !<10>Ad<>_<EFBFBD>.<2E><><EFBFBD>Gܼ֗w<DCBC><77><EFBFBD>Wu<57>֭[<5B>׽<EFBFBD>=uN<75>[^W<>^<5E>N"<22><> Xo<><6F>C<EFBFBD>!<02><>B@HI.A@<10>BJ<42><4A><0E><> )<29>5 <02>B@H<>R<EFBFBD>!<21>!%<25>A<>R)Y<>;<3B>2<EFBFBD><32> <20>$׀ X
!%Ku<4B>TF<04><><EFBFBD>K! <20>d<EFBFBD><64><EFBFBD><02><><EFBFBD><EFBFBD>\<03><> `)<04><>,<2C>RA@<10><><EFBFBD>+<2B><14>]<5D><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><1E>^i<> <20>PM<><4D><EFBFBD><EFBFBD><EFBFBD>[pS<04><>ܴc<DCB4>Y<EFBFBD>@CE@H<><48><EFBFBD><EFBFBD><EFBFBD>[pS<04><>ܴc<DCB4>Y<EFBFBD>@CE@H<><48><EFBFBD><EFBFBD><EFBFBD>[pS<04><>ܴc<DCB4>Y<EFBFBD>@CE<43>头n<E5A4B4>zJKK<4B>1><3E>Ν<EFBFBD><CE9D><EFBFBD><EFBFBD><1A>#<02><><EFBFBD>p))<29><><EFBFBD>ӛo<D39B>C.<2E><><08><><EFBFBD>YN<59><1F>C<EFBFBD>,<2C><><EFBFBD>r<EFBFBD><72><EFBFBD>(.n <0B><>\p<>Gv<02><><EFBFBD>p))<29>Z<EFBFBD><5A>Z<EFBFBD>jE<06>^#$<24><>5%/oo
n<EFBFBD><EFBFBD>i9<19>h<EFBFBD><68>7<EFBFBD><37><EFBFBD><EFBFBD>N<EFBFBD><4E>A@<10>><02><><EFBFBD>bAA><3E>ر<EFBFBD><1E>1<EFBFBD><31><EFBFBD>n<EFBFBD>}EE<45><45><EFBFBD>l<EFBFBD>¢+4tH <0C>nm;<3B>zܸ<7A>4f<34>h<EFBFBD><68><EFBFBD>qZ<71><5A>$<24><>9Gv
<01><>҆<EFBFBD><D286><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ə<1F><10><>G<EFBFBD>PjJ7<><37><EFBFBD><EFBFBD><EFBFBD><EFBFBD>5k<35><6B>ˋ<EFBFBD>B[)R<>p<EFBFBD>ĉ <0C>c;v<>@<40><><EFBFBD>F<EFBFBD>իW())Emo<6D><6F><EFBFBD>
<EFBFBD><EFBFBD>3(((<28><>ޑ<><DE91><03>m<EFBFBD><02><><EFBFBD>p)<29>]<5D><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>÷PJ<><4A>濼<EFBFBD><0E><>m<EFBFBD><11><>Kt<4B>:<3A><><EFBFBD>G<EFBFBD><47>Ggy<0E><><EFBFBD>wc<1B>y<EFBFBD><79>*<2A>K'<27>g<EFBFBD><67>y<7F>E<EFBFBD><45><EFBFBD>%<1F><>f<EFBFBD><66><EFBFBD><EFBFBD>ѐ!<21>m<EFBFBD>dC<04><><EFBFBD>KH)99<39>RSSi<53><69>+<2B><><EFBFBD>VҼy<D2BC><79>iS'Sn<53>eE><3E>><3E><>&M<>H<EFBFBD>o؍<0E><><EFBFBD>><3E>@<1D>ɞ<EFBFBD><C99E><EFBFBD>_-WV<57><56><EFBFBD>F<EFBFBD><46><0F>[o<>KO><3E><04> h<>
3<><01>#<23>RZ<52>z<EFBFBD>f<>9|X9<04>O<>F<EFBFBD><1A><>)<29><><EFBFBD>ǗBBB<42>^t/<1B><><EFBFBD>q<EFBFBD>3H<1D><>w<1B>k׮<6B><D7AE><EFBFBD>_<>FF<46>3gΪ]<18>Ut<55><74> <0C> <02><><EFBFBD><10><><05>u-))<29><><EFBFBD>[i<>ȑ<EFBFBD><C891>[<5B><><EFBFBD>3<EFBFBD> Oz<4F>M{Qrr<72>:S<>V-<2D>qF9D<04> <09><>Q<EFBFBD><51><EFBFBD>m<EFBFBD>F<EFBFBD><46>y<EFBFBD>8a<38>Ò<EFBFBD><C392>Z<>f<1D><><EFBFBD><EFBFBD>iP<69>@5<>i߾x<DFBE>۷/a8&"<02><>@<40>kJk؋֣{
w<>l<EFBFBD>vm<76><6D>;<3B>)<03><><EFBFBD>G<EFBFBD><47><EFBFBD><EFBFBD>f><3E> -^<5E>z<EFBFBD>S(<28><><EFBFBD> <20>VԪ<><D4AA><EFBFBD><EFBFBD>I<1D>g<EFBFBD>~<7E>)H0t<30><74><EFBFBD>H<EFBFBD>/<2F><>]<5D><>N<EFBFBD>Uu<55><75>O<EFBFBD><4F>kU<6B> <20>A<><10>URZ<52>j
<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>w;<3B><1A><><EFBFBD><EFBFBD>W<EFBFBD><57>O<EFBFBD><19><5Iٞ:w<0E>)S&Q<>.]Ա<><D4B1>}<7D>|<7C><>C<EFBFBD><43><EFBFBD><EFBFBD>n<EFBFBD>ԴT<15><EFBFBD><04>ݻ<EFBFBD><DDBB><EFBFBD>WϞl@oD˿<44><CBBF><EFBFBD><EFBFBD>T6g <09>3<EFBFBD>O3<4F>Ķ<EFBFBD> X<1B>Z#<23><><EFBFBD><EFBFBD>X<EFBFBD>09|<7C>PjҤ<6A><D2A4>V7o<1E><>G<EFBFBD><47><EFBFBD><EFBFBD>5f$<24><> iӦʹk<CDB4><1E>l<EFBFBD>ER<45>y<>t<EFBFBD>G
yz<EFBFBD>*# <20><><EFBFBD><EFBFBD><EFBFBD>dC<64>6mJ<6D>-xEM<45><s<><73><EFBFBD>~<7E>
σ<04><06>@<40><><EFBFBD>n&<26> <0B>2<EFBFBD><32><EFBFBD>9m|^<5E>ez<65><7A>͙<>=<3D><>t<EFBFBD>|q[<5B>ҢE<45>WSv<53><76>i8EFFһ<46>i<EFBFBD><69><EFBFBD>
L'<27>S
*<2A>+<2B>A<><41>Ԛ!f<><66>uԖ<75><D496>QQ<51>N[<5B><>_@׮]<5D>ݻ<DDBB><7F>'O<>|а2xz<00>f<EFBFBD><66><EFBFBD>`ʟ x&<02><>)<29><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>9<EFBFBD>M<EFBFBD>6t<36><74>hժ<68><D5AA><EFBFBD><EFBFBD>O<EFBFBD>mM<6D>е<EFBFBD>kj<6B>^9y<39>g+
<EFBFBD>3<EFBFBD>BZ-@<40>+;;<3B><>_<EFBFBD><5F>t<EFBFBD><12><><EFBFBD>F}x<>eHp0EDt<44>ƍ<EFBFBD>\<5C>+<2B><>AC<01>!Pk<50>RU<52><55><EFBFBD>ۢ<EFBFBD>k<EFBFBD><6B><EFBFBD><EFBFBD><EFBFBD>Ϝמ<CF9C><D79E><EFBFBD><EFBFBD><EFBFBD>"<22><> `ꅔ<><EA8594>L>7<>G<13><0E>>rVA@p<><70>ۓ<EFBFBD><DB93>)N<><4E><EFBFBD><EFBFBD><EFBFBD><1F><>R<EFBFBD>P:8<>#<23>$M\<5C><><><7F><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>4ɘC<C998><43>|9O<39><4F>o<>/<2F><>}<7D><><EFBFBD>F<EFBFBD>'8C<38>4<>2<EFBFBD><05>
)??_y
<EFBFBD><15><><EFBFBD><EFBFBD>'q:I<>A<><41>p[R<><52><11>Ԅ<EFBFBD>yR<79>/_<><19>M<EFBFBD>+)u<07><>I*<2A><>[<5B><>&$<24><><EFBFBD>5<EFBFBD>!5k֌?.<2E>|<01><>'<27>A<>5<08>z<EFBFBD><7A>k<EFBFBD>Y'<27>j2<6A><32><04>lHxaW<08>N<EFBFBD><4E><EFBFBD><02>F<EFBFBD><46>HIkI@q=t<><74>Ըq<D4B8>j%
<02>@<40> <20><><EFBFBD>7@<40><>I<13>ڎ ڗ.]T3<54>KJJ<4A>q9<71> <08><01>$%3!iRr<52>^^vv6]<5D>X<EFBFBD>%<25>o<EFBFBD><6F><EFBFBD><04>*#<23>v<EFBFBD>7<EFBFBD><37>&#<23><><EFBFBD><EFBFBD>>
!i$$<04><><EFBFBD>[<5B><>#<23>)Y<><1B>&<26><> <20>p+Rҍҡ&)<1D>t A<><41><08>%) Y<><59><EFBFBD><EFBFBD> !<21><><EFBFBD>dn4<6E><04><02>@<40>A<EFBFBD>mIɬ-<2D><><EFBFBD>5<EFBFBD>ya<79>%Z<7F><5A>Z<EFBFBD><5A><EFBFBD><EFBFBD><02><>{<7B><><EFBFBD><EFBFBD> <09><>SU*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Z<><5A><1F><>o<EFBFBD><6F>ʡ5Λ<35>{<7B><>|<7C><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>'q<>ܖ<>ꪯN<EAAAAF><<3C><>><3E><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>y<EFBFBD><79><EFBFBD>PRR/
q<EFBFBD><EFBFBD><EFBFBD>]'<27><>8EV<><n۾<6E><DBBE><EFBFBD><EFBFBD>~<7E><>}<7D>EE4<15>/<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>X.L<><4C>U<EFBFBD><55><EFBFBD><EFBFBD>n9O<39>f<EFBFBD>j7v<37><76>1:p<><70><EFBFBD>%<25>Ѓ<EFBFBD>啕څ<E59595>%<25><><EFBFBD><EFBFBD>"|<7C><><EFBFBD>+ԡ}{<7B>h]rb.<2E>k<EFBFBD><6B>4o<34>
<0C><> <09><00><>R%<25><><EFBFBD>sK<73>|<7C><>`<60><><EFBFBD><EFBFBD>1}<7D><>R%<25><><EFBFBD>l<EFBFBD>"<22><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>|jZ<><5A><EFBFBD> <0C>!YeoDE<44><45>lv<6C>w!%'<27>BVV6<56>Z<EFBFBD><5A>RRR)_<17><>.AH<41><48><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>`<60><><06>n<EFBFBD>A6<>R.<2E>֡4u<34>$<24>ѽ<EFBFBD><D1BD>ҝ'c<><63><EFBFBD><EFBFBD><EFBFBD>4<EFBFBD><07><15>)==<3D><><EFBFBD><0E><><EFBFBD>x<EFBFBD><78><EFBFBD>G{<7B><>5
<EFBFBD>ׯ/<2F><>I<><EFBFBD>K<EFBFBD>\<5C>^<12><>_?n<>L<04><><EFBFBD>_A<5F><41><07>
/<2F>މW;<1E><><EFBFBD><EFBFBD><EFBFBD>4Z<34>r-<2D><>?}<7D><> <0B>;<3B>4ns˖-l<>>|<7C>֭<EFBFBD><D6AD><EFBFBD><EFBFBD>s<EFBFBD>a^<5E>а0<D0B0>ݫ<07>7nL9R<39>۲]<5D><>w<EFBFBD>|6<><36><EFBFBD><EFBFBD><EFBFBD>={<7B>6뗨<36>x<18><><EFBFBD><EFBFBD>凄<><E58784><EFBFBD>͠<><CDA0>vӱ<76><D3B1>TXTHO?<3F>k<EFBFBD><1C><>Ͼ<EFBFBD>ӧNy<11>ر<03>|<7C><01><>ϖ}<7D>><3E>ݟ빉2<EBB989>f<EFBFBD>6<EFBFBD>s
`<60>!<21><>x<>Fշ<46><D5B7>A<EFBFBD><41>3C9-O>1<><31><EFBFBD>y<><79>bz<62><7A><EFBFBD><EFBFBD>dFD<46><44>)<29>'ڤa$<24><>[<5B>"<22><><EFBFBD>g<EFBFBD><15>{G<><47>I'<27>f<EFBFBD><66><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>s<EFBFBD>ԇ<EFBFBD><D487>6<EFBFBD>1<EFBFBD>`<60>F|,X<>Тu<D0A2>v<EFBFBD><76><EFBFBD><EFBFBD><EFBFBD>
<EFBFBD>R^<5E> ￙%<25><17>t$EEE<45><45>;<3B><> <09><15>9<EFBFBD>b <0B><<3C><13><><EFBFBD>bz<62><7A><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݯn<DDAF>l&<26>!<21>Q@@<00>8<EFBFBD><38> Ã
<EFBFBD><EFBFBD>Um<EFBFBD><EFBFBD>C<EFBFBD><EFBFBD>P<<1B><><EFBFBD>R<EFBFBD>{<7B><>ԡC;^)8<><38>;N%<25>%<25><>KU<>B<EFBFBD>X<1D><>-Z<><5A>C|<7C>C#X<>7z<7F>I<EFBFBD>:LP<4C>@&<26>(<28><><EFBFBD>_}<7D><><EFBFBD>n<EFBFBD>I-}3<>?<3F>Ҕ<EFBFBD>oؤ<6F>>8o<38>.᪨<>Ǔ<EFBFBD><C793>y<EFBFBD><79><EFBFBD><08><05>JH8D[<5B>m<EFBFBD>Aw<41>l3 Fr<46>`Æ
<EFBFBD><EFBFBD>o<EFBFBD>O^<5E><><EFBFBD><EFBFBD><EFBFBD>wR<77><52>Կ_<7F>j+V<>᥷<EFBFBD>(<28>:t0<74><30><EFBFBD><1D><>{<7B><>!%%<25><><EFBFBD>A<EFBFBD>O<EFBFBD>:C<><43><EFBFBD>t<1<><31><11>C<EFBFBD><01>
<EFBFBD><EFBFBD><01>U<EFBFBD><55><EFBFBD><EFBFBD><EFBFBD>ڂ<EFBFBD><14><>A<EFBFBD><41><EFBFBD>o#<23>G<EFBFBD>I9<49><39>[<5B><><EFBFBD><EFBFBD><EFBFBD><10> <09>r@8<><38>(<28>SGjժ<6A>"<22>]<5D>~V<><56><EFBFBD><EFBFBD>v<EFBFBD>Ԧ<EFBFBD><D4A6>ÇVi<56>d_<64>QuD=S<>R<EFBFBD><52><EFBFBD><EFBFBD><EFBFBD><08>a<EFBFBD>]<5D><0F>`^<5E>gȐ;<3B><><12><><EFBFBD>E<EFBFBD>|<7C><>}r<1<>j<EFBFBD>3
<EFBFBD>h<EFBFBD><EFBFBD>.<2E>h%<25>ZIɩt<C9A9>b<EFBFBD>awƌit<69><74>!<21><04>M<EFBFBD><EFBFBD><15><>P<EFBFBD>|<7C>@+<2B><><EFBFBD><EFBFBD>M<EFBFBD>?<3F><>qQB<51><42>ᇕt<E18795><74>Q:$Fg<46>R8m<38>d<EFBFBD><64><EFBFBD>S3y<33>DZ<44><5A>bڶm'<27>;F<><46><16><><16>08<><38><EFBFBD>d^6}p9<70>̉ <0B>fߵkk -<2D><>W^242ܘ<1F><>ֻ<EFBFBD><D6BB><EFBFBD>Ԋo<D48A>}᷆<>ً<>x<EFBFBD>M^6}<7D><><EFBFBD><EFBFBD>0<EFBFBD><1D><>֭[U<>!|<7C><><0E><>۵<EFBFBD>06oުHj<13><><EFBFBD><EFBFBD>N<EFBFBD><4E>i-A <0C><>N<EFBFBD>_<EFBFBD>>Ť<><C5A4><EFBFBD>L<EFBFBD><4C>~<><7F>֎<><D68E><EFBFBD>T<08><>2<EFBFBD><32> <0C><>O<EFBFBD><4F><EFBFBD><EFBFBD><EFBFBD>?<<3C>~<7E><>o<EFBFBD><6F>;DŽ<><C784>O<EFBFBD>Ic7<63>r<EFBFBD><11><>E<EFBFBD><45>?J<><EFBFBD>N-<2D>XڶmC<6D><43><EFBFBD>k<18><><EFBFBD><EFBFBD>t<1D><>o<EFBFBD>c<EFBFBD><63>&.<2E>sDD=<3D><><EFBFBD>F9+<2B><>7<EFBFBD><37> <20><><EFBFBD>_<EFBFBD>>F<>+<2B>1<EFBFBD>p<EFBFBD>E<EFBFBD><45>tH1kGZ<47>-Z<><5A>$<24>m&c<>#xJ<78>$ң<>)a];<3B><><EFBFBD><EFBFBD>Y<>I4'<27><14><><EFBFBD>1<>&
<1B>x<EFBFBD><78>/<13><>߇<EFBFBD><DF87>.<2E>6m<36><6D>.#<04><><EFBFBD>k<EFBFBD><6B>m<1F><><EFBFBD><EFBFBD>+<2B>Ϝ<EFBFBD>ҋ<EFBFBD>e<><65><<3C><>d k3<6B> BB^ y<>r<EFBFBD>
<EFBFBD>gϞ%h<>gyHf<48><00>132NImZ<6D><5A><13>7|`<60>u<EFBFBD><75>ʚG;<3B><>͂cԹ<63><D4B9>3'ӨQw<51>l<EFBFBD>o<EFBFBD><6F>&NW<><57><EFBFBD><EFBFBD>3'<27><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>}<7D>ḹ<EFBFBD>˜<EFBFBD><C298><EFBFBD>j<EFBFBD>h'<04>D<EFBFBD>@^Z<><5A>lHC<48>W6<q"]vt<76>m<EFBFBD>DG+RJMM<4D>)<29><><EFBFBD>Xe<58>o<EFBFBD>|BJz<07> \<5C><>y؇!<21>a~Re<><05><><EFBFBD>G
<EFBFBD>f$駶<>"<22>ή]<5D><><EFBFBD><EFBFBD><EFBFBD>ȇnG<><47>YBC<42>n<EFBFBD>K<EFBFBD><4B><06><><EFBFBD>w<EFBFBD><77>ټY.޷o<DEB7><6F>؝y<D89D><79>.<2E>\.D<13>9<EFBFBD>9<EFBFBD><39>]6<>Ő ?{)5}ZƄ<5A><C684>(n<>6C<36><43>a<EFBFBD><61>֭+=0c<30><1A>x=ݠ)<17>"-YW<><10>y<EFBFBD><79>Vy`<60>:}<7D><1A>;<3B>„Â<C284><C382>x!<21><><EFBFBD>;<3B><>9
<1C>rrlh6<68>x<EFBFBD><78>5f<35><66>!n )9<>5<7F><7F><EFBFBD>,<2C><>_<EFBFBD>g;<1B>!͚6S<36>M_<>Ց<EFBFBD><D591><EFBFBD><EFBFBD><EFBFBD>a<EFBFBD><18>u<05>
St<EFBFBD><EFBFBD><EFBFBD><15><>!|d<><64><EFBFBD>rq<72>r<>R9<><39>p#<01>5<EFBFBD>ر<EFBFBD><D8B1><EFBFBD><EFBFBD>F<EFBFBD><46>` <1B><><EFBFBD>aaG<61><47>;<3B>GK<47><4B>K/><3E><>
*<1B>\e{]U<><55>6W<36>,<2C><><EFBFBD><EFBFBD><1E>
B¹0M<00><>L
jA?<3F><><EFBFBD>Wu<>'<27>BJz7З_~K<><01>4{<7B><>l轪.<2E>6<<3C>0{EZkIYY<17><><EFBFBD>u<EFBFBD> <09><01><>f<EFBFBD><66><EFBFBD><EFBFBD>k<1A><>|X<>ah5<68>'<27><>f<EFBFBD>!<18><04>4M p&<26>[8<><38><EFBFBD>0CΞ=Ǟ<><<3C><>C<EFBFBD>޽z<DEBD><10><14>X<EFBFBD><58>]۶<><DBB6>0<EFBFBD><30>1<EFBFBD><31>1<EFBFBD><31><EFBFBD><EFBFBD><EFBFBD>G<18><><EFBFBD>T^br<62>'<27>Lʆ]pZ<70><5A><05><><EFBFBD>ϯ<EFBFBD> <09><><EFBFBD><EFBFBD><EFBFBD>H<EFBFBD><48>ç<EFBFBD><C3A7>N<EFBFBD><4E><EFBFBD><<3C>3 <0B>ڨQc6<63>S <09><><EFBFBD>B<1E>KULkH<6B><48><EFBFBD><EFBFBD> <0C><><EFBFBD>W<EFBFBD>/<2F>s<EFBFBD><73><EFBFBD><EFBFBD>q!%=<3D>':l <20><>K?7<m<><00>~<7E>]#x(v<>ᒃb<E19283><62>W<><57>{<7B>V<1E>={<7B><><EFBFBD><EFBFBD>,8p<38>Z
<05><>><3E><>k<08>)<29><>v<><76>
<EFBFBD>q=y{Tf'<><7F>5<EFBFBD>ɳ<>)<29><>v<><76><EFBFBD>6<EFBFBD>=<3D>^ƏK˸~<7E><EFBFBD>և<><D687>+<2B>܉<<3C>C<EFBFBD>v)}<7D><>rJIKe<4B>R <0C><>!1mHeO<65>Q&<26>^=#<23>bqCÖ<43><C396><10>d1<64><31>b<EFBFBD><62>ƍ<EFBFBD><C68D><EFBFBD>`<04><>0<EFBFBD><01><1C>Af<41><66>bڂn3
<EFBFBD>ۧ<EFBFBD>a<1B>&v<><76><EFBFBD>,<2C>-Z<>g<EFBFBD>4{<7B>L<EFBFBD>3ZŋYC<59><43><EFBFBD>?dB<64>Q<EFBFBD><51>Ν?<3F><><EFBFBD>pvp<76> <0B> <0B><><EFBFBD>+<2B><>e!ςW<57><7F> <09><><EFBFBD>}<7D>a 0<<3C>t=[3<><33>[ <09>(J<>}<7D>><3E>k d<>7v<>ޫ<w<>~z<>)9<><39><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֵ+<2B><>Sx<53><78><EFBFBD>p<06>m:<3A>޶g<DEB6>\<5C>$<24>ڂ.<2E>~[<5B>W%7v<37>zWKϋ<4B><CF8B>f<EFBFBD><66><EFBFBD>F{<7B><>c<EFBFBD><63>Vc;%5<><35><EFBFBD><EFBFBD>VUR<55>q3<1F>AE<41>E<EFBFBD><12>Z<12><><EFBFBD><EFBFBD><13><>Yf<59> <0C><>CM<43>X<EFBFBD>r5a#<04><><EFBFBD>Ӧ؜<D3A6><D89C><EFBFBD><EFBFBD><EFBFBD><EFBFBD>WP<02>{<7B><><EFBFBD> <0C>h<EFBFBD><1A>9Mfy<66><79>5b<35>nӦ͊<D3A6>:u<>D<EFBFBD>f=dxO<>e˾0f<><66>"<22>I<EFBFBD><49>WQ<1F><><EFBFBD>bR<62><52><EFBFBD><EFBFBD><EFBFBD><EFBFBD>~<7E><> <20>7j<37>H<EFBFBD>ac<61><63>L`B<><42>k<EFBFBD>f<EFBFBD>cJ<63>o<>2<EFBFBD>^'<27><>#<23>1<EFBFBD>4L<34>x<EFBFBD>I <09><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>=t<>es<65><73>!<21>%<<3C><><EFBFBD>6x#<23><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>.<2E>V+<2B>j<EFBFBD>2<EFBFBD>V<EFBFBD>a6.<2E><><EFBFBD>R<EFBFBD>T<EFBFBD>“fIJ*3^<5E><><10>+xŊUԞ<55><D49E>#G<>y<EFBFBD><79><EFBFBD>;8))٘<>.l%<25>-p<><70>[<5B><>/Z<>4 <0B><>a<EFBFBD><61><EFBFBD><EFBFBD><EFBFBD>h<>LN<4C><4E><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ub0<1C><><EFBFBD><EFBFBD><EFBFBD>ً<EFBFBD>(?<3F> e<>#<06><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><z<><7A><17><><02><>ɬ<EFBFBD>a:ڇ<>3++[<5B><><EFBFBD>uu<75><75>X<EFBFBD>hJz%!<21>J-<2D><><01> <0C><>{<7B><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>P<EFBFBD>.ęwΕ<77> j<>wE穬<45> <0B><><EFBFBD><08>6<EFBFBD>n8<6E><38><EFBFBD>\<5C><><EFBFBD>F Ma<4D>)C@H<><48><EFBFBD><EFBFBD><EFBFBD><EFBFBD>x<EFBFBD>v<1C><><EFBFBD>Ȏ<EFBFBD>ݠ;88R<38>A<><41>)9@<40><1E><>׍<EFBFBD>;<3B>H<05>j<EFBFBD>O
<EFBFBD><07>:w/7<>wPL<50><4C><EFBFBD>"<22>ȿ<EFBFBD><C8BF><EFBFBD><19>V!rP<72>5jD<6A>I<EFBFBD><49>>X2<58><01>)<29>V)T<04><><EFBFBD>M#IuK<75><4B>qfo<66>9n<39><6E>J<EFBFBD>A<>nKJ<4B><4A>o5<6F>-8<><38><EFBFBD>l:<3A><><EFBFBD><EFBFBD> P<><08><>M <09><><EFBFBD><1E><><EFBFBD>{<7B><>"1<>_>Wj<57><6A>l <02><><EFBFBD>[<5B><><EFBFBD>R<0F>b.<08>J<EFBFBD><4A><͛~"<22><> `
<04>j<EFBFBD>fO8<4F>i<>a2<61><32>w<EFBFBD><77><01><>B<04>#<23>V<EFBFBD>dn<1E><08>$MJp<4A>c<EFBFBD><63><19>"<22><> `]ܒ<>@DMH '<27><><EFBFBD>;Kx<4B>L<EFBFBD>Gֽ <20>f<EFBFBD><66><EFBFBD>ڔ@HچR<><0F>h<EFBFBD><68><18><>Ƅ<EFBFBD><C684><EFBFBD>i<12><>A<04><01>#%MF<4D>q<><11> <09>B<><42>7<EFBFBD><37><EFBFBD>4&<26><><EFBFBD><EFBFBD>3W<33>]#5<<01>#%ݍZ<DD8D>)i1iA:<3A>D<>D<>:<3A><><EFBFBD><EFBFBD> P<><08>%)imIBMH<4D><48>g&$31<33>}<17>A<><41><EFBFBD>[<5B><08>њ<EFBFBD>֊<EFBFBD>Ą}<7D><><EFBFBD><:4<>#qA@<10>{ܖ<>4<EFBFBD><34><EFBFBD><EFBFBD>mIoCS<43>i<EFBFBD>+<2B><><11>P<10>_ܚ<>4!4 <0B><>><3E>.<2E>n<EFBFBD><6E><EFBFBD><EFBFBD>@<40>"<22>֤h5!A2<><32>=)Ak<41><6B>Ƥ`<60>?A<><41>p{R<>ȚIH<13>9͜O<CD9C>%<04><>G<EFBFBD>cH <09>j2B\kD<6B>4<EFBFBD><34><02>@<40>"<22>Q<EFBFBD>d<EFBFBD>Z<EFBFBD>Ȍ<EFBFBD><C88C><01> psf<73>u<EFBFBD>$5F@HɃ;_<>.X!%+<2B><><EFBFBD>I<10>`<04><><<3C><>邀R<>b<EFBFBD>H<EFBFBD>F@HɃ;_<>.X!%+<2B><><EFBFBD>I<10>`<04><><<3C><>邀R<>b<EFBFBD>H<EFBFBD>F@HɃ;_<>.X!%+<2B><><EFBFBD>I<10>`<04><><<3C><>邀R<>b<EFBFBD>H<EFBFBD>F@HɃ;_<>.X!%+<2B><><EFBFBD>I<10>`<04>3DE<44>A<EFBFBD>XsIEND<4E>B`<60>
---
File: /docs/specification/2025-03-26/server/tools.md
---
---
title: Tools
type: docs
weight: 40
---
{{< callout type="info" >}} **Protocol Revision**: 2025-03-26 {{< /callout >}}
The Model Context Protocol (MCP) allows servers to expose tools that can be invoked by
language models. Tools enable models to interact with external systems, such as querying
databases, calling APIs, or performing computations. Each tool is uniquely identified by
a name and includes metadata describing its schema.
## User Interaction Model
Tools in MCP are designed to be **model-controlled**, meaning that the language model can
discover and invoke tools automatically based on its contextual understanding and the
user's prompts.
However, implementations are free to expose tools through any interface pattern that
suits their needs&mdash;the protocol itself does not mandate any specific user
interaction model.
{{< callout type="warning" >}} For trust & safety and security, there **SHOULD** always
be a human in the loop with the ability to deny tool invocations.
Applications **SHOULD**:
- Provide UI that makes clear which tools are being exposed to the AI model
- Insert clear visual indicators when tools are invoked
- Present confirmation prompts to the user for operations, to ensure a human is in the
loop {{< /callout >}}
## Capabilities
Servers that support tools **MUST** declare the `tools` capability:
```json
{
"capabilities": {
"tools": {
"listChanged": true
}
}
}
```
`listChanged` indicates whether the server will emit notifications when the list of
available tools changes.
## Protocol Messages
### Listing Tools
To discover available tools, clients send a `tools/list` request. This operation supports
[pagination]({{< ref "utilities/pagination" >}}).
**Request:**
```json
{
"jsonrpc": "2.0",
"id": 1,
"method": "tools/list",
"params": {
"cursor": "optional-cursor-value"
}
}
```
**Response:**
```json
{
"jsonrpc": "2.0",
"id": 1,
"result": {
"tools": [
{
"name": "get_weather",
"description": "Get current weather information for a location",
"inputSchema": {
"type": "object",
"properties": {
"location": {
"type": "string",
"description": "City name or zip code"
}
},
"required": ["location"]
}
}
],
"nextCursor": "next-page-cursor"
}
}
```
### Calling Tools
To invoke a tool, clients send a `tools/call` request:
**Request:**
```json
{
"jsonrpc": "2.0",
"id": 2,
"method": "tools/call",
"params": {
"name": "get_weather",
"arguments": {
"location": "New York"
}
}
}
```
**Response:**
```json
{
"jsonrpc": "2.0",
"id": 2,
"result": {
"content": [
{
"type": "text",
"text": "Current weather in New York:\nTemperature: 72°F\nConditions: Partly cloudy"
}
],
"isError": false
}
}
```
### List Changed Notification
When the list of available tools changes, servers that declared the `listChanged`
capability **SHOULD** send a notification:
```json
{
"jsonrpc": "2.0",
"method": "notifications/tools/list_changed"
}
```
## Message Flow
```mermaid
sequenceDiagram
participant LLM
participant Client
participant Server
Note over Client,Server: Discovery
Client->>Server: tools/list
Server-->>Client: List of tools
Note over Client,LLM: Tool Selection
LLM->>Client: Select tool to use
Note over Client,Server: Invocation
Client->>Server: tools/call
Server-->>Client: Tool result
Client->>LLM: Process result
Note over Client,Server: Updates
Server--)Client: tools/list_changed
Client->>Server: tools/list
Server-->>Client: Updated tools
```
## Data Types
### Tool
A tool definition includes:
- `name`: Unique identifier for the tool
- `description`: Human-readable description of functionality
- `inputSchema`: JSON Schema defining expected parameters
- `annotations`: optional properties describing tool behavior
{{< callout type="warning" >}} For trust & safety and security, clients **MUST** consider
tool annotations to be untrusted unless they come from trusted servers. {{< /callout >}}
### Tool Result
Tool results can contain multiple content items of different types:
#### Text Content
```json
{
"type": "text",
"text": "Tool result text"
}
```
#### Image Content
```json
{
"type": "image",
"data": "base64-encoded-data",
"mimeType": "image/png"
}
```
#### Audio Content
```json
{
"type": "audio",
"data": "base64-encoded-audio-data",
"mimeType": "audio/wav"
}
```
#### Embedded Resources
[Resources]({{< ref "resources" >}}) **MAY** be embedded, to provide additional context
or data, behind a URI that can be subscribed to or fetched again by the client later:
```json
{
"type": "resource",
"resource": {
"uri": "resource://example",
"mimeType": "text/plain",
"text": "Resource content"
}
}
```
## Error Handling
Tools use two error reporting mechanisms:
1. **Protocol Errors**: Standard JSON-RPC errors for issues like:
- Unknown tools
- Invalid arguments
- Server errors
2. **Tool Execution Errors**: Reported in tool results with `isError: true`:
- API failures
- Invalid input data
- Business logic errors
Example protocol error:
```json
{
"jsonrpc": "2.0",
"id": 3,
"error": {
"code": -32602,
"message": "Unknown tool: invalid_tool_name"
}
}
```
Example tool execution error:
```json
{
"jsonrpc": "2.0",
"id": 4,
"result": {
"content": [
{
"type": "text",
"text": "Failed to fetch weather data: API rate limit exceeded"
}
],
"isError": true
}
}
```
## Security Considerations
1. Servers **MUST**:
- Validate all tool inputs
- Implement proper access controls
- Rate limit tool invocations
- Sanitize tool outputs
2. Clients **SHOULD**:
- Prompt for user confirmation on sensitive operations
- Show tool inputs to the user before calling the server, to avoid malicious or
accidental data exfiltration
- Validate tool results before passing to LLM
- Implement timeouts for tool calls
- Log tool usage for audit purposes
---
File: /docs/specification/2025-03-26/_index.md
---
---
linkTitle: 2025-03-26 (Latest)
title: Model Context Protocol specification
cascade:
type: docs
breadcrumbs: false
weight: 1
aliases:
- /latest
---
{{< callout type="info" >}} **Protocol Revision**: 2025-03-26 {{< /callout >}}
[Model Context Protocol](https://modelcontextprotocol.io) (MCP) is an open protocol that
enables seamless integration between LLM applications and external data sources and
tools. Whether you're building an AI-powered IDE, enhancing a chat interface, or creating
custom AI workflows, MCP provides a standardized way to connect LLMs with the context
they need.
This specification defines the authoritative protocol requirements, based on the
TypeScript schema in
[schema.ts](https://github.com/modelcontextprotocol/specification/blob/main/schema/2025-03-26/schema.ts).
For implementation guides and examples, visit
[modelcontextprotocol.io](https://modelcontextprotocol.io).
The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD
NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be
interpreted as described in [BCP 14](https://datatracker.ietf.org/doc/html/bcp14)
[[RFC2119](https://datatracker.ietf.org/doc/html/rfc2119)]
[[RFC8174](https://datatracker.ietf.org/doc/html/rfc8174)] when, and only when, they
appear in all capitals, as shown here.
## Overview
MCP provides a standardized way for applications to:
- Share contextual information with language models
- Expose tools and capabilities to AI systems
- Build composable integrations and workflows
The protocol uses [JSON-RPC](https://www.jsonrpc.org/) 2.0 messages to establish
communication between:
- **Hosts**: LLM applications that initiate connections
- **Clients**: Connectors within the host application
- **Servers**: Services that provide context and capabilities
MCP takes some inspiration from the
[Language Server Protocol](https://microsoft.github.io/language-server-protocol/), which
standardizes how to add support for programming languages across a whole ecosystem of
development tools. In a similar way, MCP standardizes how to integrate additional context
and tools into the ecosystem of AI applications.
## Key Details
### Base Protocol
- [JSON-RPC](https://www.jsonrpc.org/) message format
- Stateful connections
- Server and client capability negotiation
### Features
Servers offer any of the following features to clients:
- **Resources**: Context and data, for the user or the AI model to use
- **Prompts**: Templated messages and workflows for users
- **Tools**: Functions for the AI model to execute
Clients may offer the following feature to servers:
- **Sampling**: Server-initiated agentic behaviors and recursive LLM interactions
### Additional Utilities
- Configuration
- Progress tracking
- Cancellation
- Error reporting
- Logging
## Security and Trust & Safety
The Model Context Protocol enables powerful capabilities through arbitrary data access
and code execution paths. With this power comes important security and trust
considerations that all implementors must carefully address.
### Key Principles
1. **User Consent and Control**
- Users must explicitly consent to and understand all data access and operations
- Users must retain control over what data is shared and what actions are taken
- Implementors should provide clear UIs for reviewing and authorizing activities
2. **Data Privacy**
- Hosts must obtain explicit user consent before exposing user data to servers
- Hosts must not transmit resource data elsewhere without user consent
- User data should be protected with appropriate access controls
3. **Tool Safety**
- Tools represent arbitrary code execution and must be treated with appropriate
caution.
- In particular, descriptions of tool behavior such as annotations should be
considered untrusted, unless obtained from a trusted server.
- Hosts must obtain explicit user consent before invoking any tool
- Users should understand what each tool does before authorizing its use
4. **LLM Sampling Controls**
- Users must explicitly approve any LLM sampling requests
- Users should control:
- Whether sampling occurs at all
- The actual prompt that will be sent
- What results the server can see
- The protocol intentionally limits server visibility into prompts
### Implementation Guidelines
While MCP itself cannot enforce these security principles at the protocol level,
implementors **SHOULD**:
1. Build robust consent and authorization flows into their applications
2. Provide clear documentation of security implications
3. Implement appropriate access controls and data protections
4. Follow security best practices in their integrations
5. Consider privacy implications in their feature designs
## Learn More
Explore the detailed specification for each protocol component:
{{< cards >}} {{< card link="architecture" title="Architecture" icon="template" >}}
{{< card link="basic" title="Base Protocol" icon="code" >}}
{{< card link="server" title="Server Features" icon="server" >}}
{{< card link="client" title="Client Features" icon="user" >}}
{{< card link="contributing" title="Contributing" icon="pencil" >}} {{< /cards >}}
---
File: /docs/specification/2025-03-26/changelog.md
---
---
title: Key Changes
type: docs
weight: 5
---
This document lists changes made to the Model Context Protocol (MCP) specification since
the previous revision, [2024-11-05]({{< ref "../2024-11-05" >}}).
## Major changes
1. Added a comprehensive **[authorization framework]({{< ref "basic/authorization" >}})**
based on OAuth 2.1 (PR
[#133](https://github.com/modelcontextprotocol/specification/pull/133))
1. Replaced the previous HTTP+SSE transport with a more flexible **[Streamable HTTP
transport]({{< ref "basic/transports#streamable-http" >}})** (PR
[#206](https://github.com/modelcontextprotocol/specification/pull/206))
1. Added support for JSON-RPC **[batching](https://www.jsonrpc.org/specification#batch)**
(PR [#228](https://github.com/modelcontextprotocol/specification/pull/228))
1. Added comprehensive **tool annotations** for better describing tool behavior, like
whether it is read-only or destructive (PR
[#185](https://github.com/modelcontextprotocol/specification/pull/185))
## Other schema changes
- Added `message` field to `ProgressNotification` to provide descriptive status updates
- Added support for audio data, joining the existing text and image content types
- Added `completions` capability to explicitly indicate support for argument
autocompletion suggestions
See
[the updated schema](http://github.com/modelcontextprotocol/specification/tree/main/schema/2025-03-26/schema.ts)
for more details.
## Full changelog
For a complete list of all changes that have been made since the last protocol revision,
[see GitHub](https://github.com/modelcontextprotocol/specification/compare/2024-11-05...2025-03-26).
---
File: /docs/specification/_index.md
---
---
title: Specification
cascade:
type: docs
breadcrumbs: false
weight: 10
---
---
File: /docs/specification/contributing.md
---
---
title: "Contributions"
weight: 20
cascade:
type: docs
breadcrumbs: false
---
We welcome contributions from the community! Please review our
[contributing guidelines](https://github.com/modelcontextprotocol/specification/blob/main/CONTRIBUTING.md)
for details on how to submit changes.
All contributors must adhere to our
[Code of Conduct](https://github.com/modelcontextprotocol/specification/blob/main/CODE_OF_CONDUCT.md).
For questions and discussions, please use
[GitHub Discussions](https://github.com/modelcontextprotocol/specification/discussions).
---
File: /docs/specification/versioning.md
---
---
title: Versioning
type: docs
weight: 10
---
The Model Context Protocol uses string-based version identifiers following the format
`YYYY-MM-DD`, to indicate the last date backwards incompatible changes were made.
{{< callout type="info" >}} The protocol version will _not_ be incremented when the
protocol is updated, as long as the changes maintain backwards compatibility. This allows
for incremental improvements while preserving interoperability. {{< /callout >}}
## Revisions
Revisions may be marked as:
- **Draft**: in-progress specifications, not yet ready for consumption.
- **Current**: the current protocol version, which is ready for use and may continue to
receive backwards compatible changes.
- **Final**: past, complete specifications that will not be changed.
The **current** protocol version is [**2025-03-26**]({{< ref "2025-03-26" >}}).
## Negotiation
Version negotiation happens during
[initialization]({{< ref "2025-03-26/basic/lifecycle#initialization" >}}). Clients and
servers **MAY** support multiple protocol versions simultaneously, but they **MUST**
agree on a single version to use for the session.
The protocol provides appropriate error handling if version negotiation fails, allowing
clients to gracefully terminate connections when they cannot find a version compatible
with the server.
---
File: /schema/2024-11-05/schema.ts
---
/* JSON-RPC types */
export type JSONRPCMessage =
| JSONRPCRequest
| JSONRPCNotification
| JSONRPCResponse
| JSONRPCError;
export const LATEST_PROTOCOL_VERSION = "2024-11-05";
export const JSONRPC_VERSION = "2.0";
/**
* A progress token, used to associate progress notifications with the original request.
*/
export type ProgressToken = string | number;
/**
* An opaque token used to represent a cursor for pagination.
*/
export type Cursor = string;
export interface Request {
method: string;
params?: {
_meta?: {
/**
* If specified, the caller is requesting out-of-band progress notifications for this request (as represented by notifications/progress). The value of this parameter is an opaque token that will be attached to any subsequent notifications. The receiver is not obligated to provide these notifications.
*/
progressToken?: ProgressToken;
};
[key: string]: unknown;
};
}
export interface Notification {
method: string;
params?: {
/**
* This parameter name is reserved by MCP to allow clients and servers to attach additional metadata to their notifications.
*/
_meta?: { [key: string]: unknown };
[key: string]: unknown;
};
}
export interface Result {
/**
* This result property is reserved by the protocol to allow clients and servers to attach additional metadata to their responses.
*/
_meta?: { [key: string]: unknown };
[key: string]: unknown;
}
/**
* A uniquely identifying ID for a request in JSON-RPC.
*/
export type RequestId = string | number;
/**
* A request that expects a response.
*/
export interface JSONRPCRequest extends Request {
jsonrpc: typeof JSONRPC_VERSION;
id: RequestId;
}
/**
* A notification which does not expect a response.
*/
export interface JSONRPCNotification extends Notification {
jsonrpc: typeof JSONRPC_VERSION;
}
/**
* A successful (non-error) response to a request.
*/
export interface JSONRPCResponse {
jsonrpc: typeof JSONRPC_VERSION;
id: RequestId;
result: Result;
}
// Standard JSON-RPC error codes
export const PARSE_ERROR = -32700;
export const INVALID_REQUEST = -32600;
export const METHOD_NOT_FOUND = -32601;
export const INVALID_PARAMS = -32602;
export const INTERNAL_ERROR = -32603;
/**
* A response to a request that indicates an error occurred.
*/
export interface JSONRPCError {
jsonrpc: typeof JSONRPC_VERSION;
id: RequestId;
error: {
/**
* The error type that occurred.
*/
code: number;
/**
* A short description of the error. The message SHOULD be limited to a concise single sentence.
*/
message: string;
/**
* Additional information about the error. The value of this member is defined by the sender (e.g. detailed error information, nested errors etc.).
*/
data?: unknown;
};
}
/* Empty result */
/**
* A response that indicates success but carries no data.
*/
export type EmptyResult = Result;
/* Cancellation */
/**
* This notification can be sent by either side to indicate that it is cancelling a previously-issued request.
*
* The request SHOULD still be in-flight, but due to communication latency, it is always possible that this notification MAY arrive after the request has already finished.
*
* This notification indicates that the result will be unused, so any associated processing SHOULD cease.
*
* A client MUST NOT attempt to cancel its `initialize` request.
*/
export interface CancelledNotification extends Notification {
method: "notifications/cancelled";
params: {
/**
* The ID of the request to cancel.
*
* This MUST correspond to the ID of a request previously issued in the same direction.
*/
requestId: RequestId;
/**
* An optional string describing the reason for the cancellation. This MAY be logged or presented to the user.
*/
reason?: string;
};
}
/* Initialization */
/**
* This request is sent from the client to the server when it first connects, asking it to begin initialization.
*/
export interface InitializeRequest extends Request {
method: "initialize";
params: {
/**
* The latest version of the Model Context Protocol that the client supports. The client MAY decide to support older versions as well.
*/
protocolVersion: string;
capabilities: ClientCapabilities;
clientInfo: Implementation;
};
}
/**
* After receiving an initialize request from the client, the server sends this response.
*/
export interface InitializeResult extends Result {
/**
* The version of the Model Context Protocol that the server wants to use. This may not match the version that the client requested. If the client cannot support this version, it MUST disconnect.
*/
protocolVersion: string;
capabilities: ServerCapabilities;
serverInfo: Implementation;
/**
* Instructions describing how to use the server and its features.
*
* This can be used by clients to improve the LLM's understanding of available tools, resources, etc. It can be thought of like a "hint" to the model. For example, this information MAY be added to the system prompt.
*/
instructions?: string;
}
/**
* This notification is sent from the client to the server after initialization has finished.
*/
export interface InitializedNotification extends Notification {
method: "notifications/initialized";
}
/**
* Capabilities a client may support. Known capabilities are defined here, in this schema, but this is not a closed set: any client can define its own, additional capabilities.
*/
export interface ClientCapabilities {
/**
* Experimental, non-standard capabilities that the client supports.
*/
experimental?: { [key: string]: object };
/**
* Present if the client supports listing roots.
*/
roots?: {
/**
* Whether the client supports notifications for changes to the roots list.
*/
listChanged?: boolean;
};
/**
* Present if the client supports sampling from an LLM.
*/
sampling?: object;
}
/**
* Capabilities that a server may support. Known capabilities are defined here, in this schema, but this is not a closed set: any server can define its own, additional capabilities.
*/
export interface ServerCapabilities {
/**
* Experimental, non-standard capabilities that the server supports.
*/
experimental?: { [key: string]: object };
/**
* Present if the server supports sending log messages to the client.
*/
logging?: object;
/**
* Present if the server offers any prompt templates.
*/
prompts?: {
/**
* Whether this server supports notifications for changes to the prompt list.
*/
listChanged?: boolean;
};
/**
* Present if the server offers any resources to read.
*/
resources?: {
/**
* Whether this server supports subscribing to resource updates.
*/
subscribe?: boolean;
/**
* Whether this server supports notifications for changes to the resource list.
*/
listChanged?: boolean;
};
/**
* Present if the server offers any tools to call.
*/
tools?: {
/**
* Whether this server supports notifications for changes to the tool list.
*/
listChanged?: boolean;
};
}
/**
* Describes the name and version of an MCP implementation.
*/
export interface Implementation {
name: string;
version: string;
}
/* Ping */
/**
* A ping, issued by either the server or the client, to check that the other party is still alive. The receiver must promptly respond, or else may be disconnected.
*/
export interface PingRequest extends Request {
method: "ping";
}
/* Progress notifications */
/**
* An out-of-band notification used to inform the receiver of a progress update for a long-running request.
*/
export interface ProgressNotification extends Notification {
method: "notifications/progress";
params: {
/**
* The progress token which was given in the initial request, used to associate this notification with the request that is proceeding.
*/
progressToken: ProgressToken;
/**
* The progress thus far. This should increase every time progress is made, even if the total is unknown.
*
* @TJS-type number
*/
progress: number;
/**
* Total number of items to process (or total progress required), if known.
*
* @TJS-type number
*/
total?: number;
};
}
/* Pagination */
export interface PaginatedRequest extends Request {
params?: {
/**
* An opaque token representing the current pagination position.
* If provided, the server should return results starting after this cursor.
*/
cursor?: Cursor;
};
}
export interface PaginatedResult extends Result {
/**
* An opaque token representing the pagination position after the last returned result.
* If present, there may be more results available.
*/
nextCursor?: Cursor;
}
/* Resources */
/**
* Sent from the client to request a list of resources the server has.
*/
export interface ListResourcesRequest extends PaginatedRequest {
method: "resources/list";
}
/**
* The server's response to a resources/list request from the client.
*/
export interface ListResourcesResult extends PaginatedResult {
resources: Resource[];
}
/**
* Sent from the client to request a list of resource templates the server has.
*/
export interface ListResourceTemplatesRequest extends PaginatedRequest {
method: "resources/templates/list";
}
/**
* The server's response to a resources/templates/list request from the client.
*/
export interface ListResourceTemplatesResult extends PaginatedResult {
resourceTemplates: ResourceTemplate[];
}
/**
* Sent from the client to the server, to read a specific resource URI.
*/
export interface ReadResourceRequest extends Request {
method: "resources/read";
params: {
/**
* The URI of the resource to read. The URI can use any protocol; it is up to the server how to interpret it.
*
* @format uri
*/
uri: string;
};
}
/**
* The server's response to a resources/read request from the client.
*/
export interface ReadResourceResult extends Result {
contents: (TextResourceContents | BlobResourceContents)[];
}
/**
* An optional notification from the server to the client, informing it that the list of resources it can read from has changed. This may be issued by servers without any previous subscription from the client.
*/
export interface ResourceListChangedNotification extends Notification {
method: "notifications/resources/list_changed";
}
/**
* Sent from the client to request resources/updated notifications from the server whenever a particular resource changes.
*/
export interface SubscribeRequest extends Request {
method: "resources/subscribe";
params: {
/**
* The URI of the resource to subscribe to. The URI can use any protocol; it is up to the server how to interpret it.
*
* @format uri
*/
uri: string;
};
}
/**
* Sent from the client to request cancellation of resources/updated notifications from the server. This should follow a previous resources/subscribe request.
*/
export interface UnsubscribeRequest extends Request {
method: "resources/unsubscribe";
params: {
/**
* The URI of the resource to unsubscribe from.
*
* @format uri
*/
uri: string;
};
}
/**
* A notification from the server to the client, informing it that a resource has changed and may need to be read again. This should only be sent if the client previously sent a resources/subscribe request.
*/
export interface ResourceUpdatedNotification extends Notification {
method: "notifications/resources/updated";
params: {
/**
* The URI of the resource that has been updated. This might be a sub-resource of the one that the client actually subscribed to.
*
* @format uri
*/
uri: string;
};
}
/**
* A known resource that the server is capable of reading.
*/
export interface Resource extends Annotated {
/**
* The URI of this resource.
*
* @format uri
*/
uri: string;
/**
* A human-readable name for this resource.
*
* This can be used by clients to populate UI elements.
*/
name: string;
/**
* A description of what this resource represents.
*
* This can be used by clients to improve the LLM's understanding of available resources. It can be thought of like a "hint" to the model.
*/
description?: string;
/**
* The MIME type of this resource, if known.
*/
mimeType?: string;
/**
* The size of the raw resource content, in bytes (i.e., before base64 encoding or any tokenization), if known.
*
* This can be used by Hosts to display file sizes and estimate context window usage.
*/
size?: number;
}
/**
* A template description for resources available on the server.
*/
export interface ResourceTemplate extends Annotated {
/**
* A URI template (according to RFC 6570) that can be used to construct resource URIs.
*
* @format uri-template
*/
uriTemplate: string;
/**
* A human-readable name for the type of resource this template refers to.
*
* This can be used by clients to populate UI elements.
*/
name: string;
/**
* A description of what this template is for.
*
* This can be used by clients to improve the LLM's understanding of available resources. It can be thought of like a "hint" to the model.
*/
description?: string;
/**
* The MIME type for all resources that match this template. This should only be included if all resources matching this template have the same type.
*/
mimeType?: string;
}
/**
* The contents of a specific resource or sub-resource.
*/
export interface ResourceContents {
/**
* The URI of this resource.
*
* @format uri
*/
uri: string;
/**
* The MIME type of this resource, if known.
*/
mimeType?: string;
}
export interface TextResourceContents extends ResourceContents {
/**
* The text of the item. This must only be set if the item can actually be represented as text (not binary data).
*/
text: string;
}
export interface BlobResourceContents extends ResourceContents {
/**
* A base64-encoded string representing the binary data of the item.
*
* @format byte
*/
blob: string;
}
/* Prompts */
/**
* Sent from the client to request a list of prompts and prompt templates the server has.
*/
export interface ListPromptsRequest extends PaginatedRequest {
method: "prompts/list";
}
/**
* The server's response to a prompts/list request from the client.
*/
export interface ListPromptsResult extends PaginatedResult {
prompts: Prompt[];
}
/**
* Used by the client to get a prompt provided by the server.
*/
export interface GetPromptRequest extends Request {
method: "prompts/get";
params: {
/**
* The name of the prompt or prompt template.
*/
name: string;
/**
* Arguments to use for templating the prompt.
*/
arguments?: { [key: string]: string };
};
}
/**
* The server's response to a prompts/get request from the client.
*/
export interface GetPromptResult extends Result {
/**
* An optional description for the prompt.
*/
description?: string;
messages: PromptMessage[];
}
/**
* A prompt or prompt template that the server offers.
*/
export interface Prompt {
/**
* The name of the prompt or prompt template.
*/
name: string;
/**
* An optional description of what this prompt provides
*/
description?: string;
/**
* A list of arguments to use for templating the prompt.
*/
arguments?: PromptArgument[];
}
/**
* Describes an argument that a prompt can accept.
*/
export interface PromptArgument {
/**
* The name of the argument.
*/
name: string;
/**
* A human-readable description of the argument.
*/
description?: string;
/**
* Whether this argument must be provided.
*/
required?: boolean;
}
/**
* The sender or recipient of messages and data in a conversation.
*/
export type Role = "user" | "assistant";
/**
* Describes a message returned as part of a prompt.
*
* This is similar to `SamplingMessage`, but also supports the embedding of
* resources from the MCP server.
*/
export interface PromptMessage {
role: Role;
content: TextContent | ImageContent | EmbeddedResource;
}
/**
* The contents of a resource, embedded into a prompt or tool call result.
*
* It is up to the client how best to render embedded resources for the benefit
* of the LLM and/or the user.
*/
export interface EmbeddedResource extends Annotated {
type: "resource";
resource: TextResourceContents | BlobResourceContents;
}
/**
* An optional notification from the server to the client, informing it that the list of prompts it offers has changed. This may be issued by servers without any previous subscription from the client.
*/
export interface PromptListChangedNotification extends Notification {
method: "notifications/prompts/list_changed";
}
/* Tools */
/**
* Sent from the client to request a list of tools the server has.
*/
export interface ListToolsRequest extends PaginatedRequest {
method: "tools/list";
}
/**
* The server's response to a tools/list request from the client.
*/
export interface ListToolsResult extends PaginatedResult {
tools: Tool[];
}
/**
* The server's response to a tool call.
*
* Any errors that originate from the tool SHOULD be reported inside the result
* object, with `isError` set to true, _not_ as an MCP protocol-level error
* response. Otherwise, the LLM would not be able to see that an error occurred
* and self-correct.
*
* However, any errors in _finding_ the tool, an error indicating that the
* server does not support tool calls, or any other exceptional conditions,
* should be reported as an MCP error response.
*/
export interface CallToolResult extends Result {
content: (TextContent | ImageContent | EmbeddedResource)[];
/**
* Whether the tool call ended in an error.
*
* If not set, this is assumed to be false (the call was successful).
*/
isError?: boolean;
}
/**
* Used by the client to invoke a tool provided by the server.
*/
export interface CallToolRequest extends Request {
method: "tools/call";
params: {
name: string;
arguments?: { [key: string]: unknown };
};
}
/**
* An optional notification from the server to the client, informing it that the list of tools it offers has changed. This may be issued by servers without any previous subscription from the client.
*/
export interface ToolListChangedNotification extends Notification {
method: "notifications/tools/list_changed";
}
/**
* Definition for a tool the client can call.
*/
export interface Tool {
/**
* The name of the tool.
*/
name: string;
/**
* A human-readable description of the tool.
*/
description?: string;
/**
* A JSON Schema object defining the expected parameters for the tool.
*/
inputSchema: {
type: "object";
properties?: { [key: string]: object };
required?: string[];
};
}
/* Logging */
/**
* A request from the client to the server, to enable or adjust logging.
*/
export interface SetLevelRequest extends Request {
method: "logging/setLevel";
params: {
/**
* The level of logging that the client wants to receive from the server. The server should send all logs at this level and higher (i.e., more severe) to the client as notifications/message.
*/
level: LoggingLevel;
};
}
/**
* Notification of a log message passed from server to client. If no logging/setLevel request has been sent from the client, the server MAY decide which messages to send automatically.
*/
export interface LoggingMessageNotification extends Notification {
method: "notifications/message";
params: {
/**
* The severity of this log message.
*/
level: LoggingLevel;
/**
* An optional name of the logger issuing this message.
*/
logger?: string;
/**
* The data to be logged, such as a string message or an object. Any JSON serializable type is allowed here.
*/
data: unknown;
};
}
/**
* The severity of a log message.
*
* These map to syslog message severities, as specified in RFC-5424:
* https://datatracker.ietf.org/doc/html/rfc5424#section-6.2.1
*/
export type LoggingLevel =
| "debug"
| "info"
| "notice"
| "warning"
| "error"
| "critical"
| "alert"
| "emergency";
/* Sampling */
/**
* A request from the server to sample an LLM via the client. The client has full discretion over which model to select. The client should also inform the user before beginning sampling, to allow them to inspect the request (human in the loop) and decide whether to approve it.
*/
export interface CreateMessageRequest extends Request {
method: "sampling/createMessage";
params: {
messages: SamplingMessage[];
/**
* The server's preferences for which model to select. The client MAY ignore these preferences.
*/
modelPreferences?: ModelPreferences;
/**
* An optional system prompt the server wants to use for sampling. The client MAY modify or omit this prompt.
*/
systemPrompt?: string;
/**
* A request to include context from one or more MCP servers (including the caller), to be attached to the prompt. The client MAY ignore this request.
*/
includeContext?: "none" | "thisServer" | "allServers";
/**
* @TJS-type number
*/
temperature?: number;
/**
* The maximum number of tokens to sample, as requested by the server. The client MAY choose to sample fewer tokens than requested.
*/
maxTokens: number;
stopSequences?: string[];
/**
* Optional metadata to pass through to the LLM provider. The format of this metadata is provider-specific.
*/
metadata?: object;
};
}
/**
* The client's response to a sampling/create_message request from the server. The client should inform the user before returning the sampled message, to allow them to inspect the response (human in the loop) and decide whether to allow the server to see it.
*/
export interface CreateMessageResult extends Result, SamplingMessage {
/**
* The name of the model that generated the message.
*/
model: string;
/**
* The reason why sampling stopped, if known.
*/
stopReason?: "endTurn" | "stopSequence" | "maxTokens" | string;
}
/**
* Describes a message issued to or received from an LLM API.
*/
export interface SamplingMessage {
role: Role;
content: TextContent | ImageContent;
}
/**
* Base for objects that include optional annotations for the client. The client can use annotations to inform how objects are used or displayed
*/
export interface Annotated {
annotations?: {
/**
* Describes who the intended customer of this object or data is.
*
* It can include multiple entries to indicate content useful for multiple audiences (e.g., `["user", "assistant"]`).
*/
audience?: Role[];
/**
* Describes how important this data is for operating the server.
*
* A value of 1 means "most important," and indicates that the data is
* effectively required, while 0 means "least important," and indicates that
* the data is entirely optional.
*
* @TJS-type number
* @minimum 0
* @maximum 1
*/
priority?: number;
}
}
/**
* Text provided to or from an LLM.
*/
export interface TextContent extends Annotated {
type: "text";
/**
* The text content of the message.
*/
text: string;
}
/**
* An image provided to or from an LLM.
*/
export interface ImageContent extends Annotated {
type: "image";
/**
* The base64-encoded image data.
*
* @format byte
*/
data: string;
/**
* The MIME type of the image. Different providers may support different image types.
*/
mimeType: string;
}
/**
* The server's preferences for model selection, requested of the client during sampling.
*
* Because LLMs can vary along multiple dimensions, choosing the "best" model is
* rarely straightforward. Different models excel in different areas—some are
* faster but less capable, others are more capable but more expensive, and so
* on. This interface allows servers to express their priorities across multiple
* dimensions to help clients make an appropriate selection for their use case.
*
* These preferences are always advisory. The client MAY ignore them. It is also
* up to the client to decide how to interpret these preferences and how to
* balance them against other considerations.
*/
export interface ModelPreferences {
/**
* Optional hints to use for model selection.
*
* If multiple hints are specified, the client MUST evaluate them in order
* (such that the first match is taken).
*
* The client SHOULD prioritize these hints over the numeric priorities, but
* MAY still use the priorities to select from ambiguous matches.
*/
hints?: ModelHint[];
/**
* How much to prioritize cost when selecting a model. A value of 0 means cost
* is not important, while a value of 1 means cost is the most important
* factor.
*
* @TJS-type number
* @minimum 0
* @maximum 1
*/
costPriority?: number;
/**
* How much to prioritize sampling speed (latency) when selecting a model. A
* value of 0 means speed is not important, while a value of 1 means speed is
* the most important factor.
*
* @TJS-type number
* @minimum 0
* @maximum 1
*/
speedPriority?: number;
/**
* How much to prioritize intelligence and capabilities when selecting a
* model. A value of 0 means intelligence is not important, while a value of 1
* means intelligence is the most important factor.
*
* @TJS-type number
* @minimum 0
* @maximum 1
*/
intelligencePriority?: number;
}
/**
* Hints to use for model selection.
*
* Keys not declared here are currently left unspecified by the spec and are up
* to the client to interpret.
*/
export interface ModelHint {
/**
* A hint for a model name.
*
* The client SHOULD treat this as a substring of a model name; for example:
* - `claude-3-5-sonnet` should match `claude-3-5-sonnet-20241022`
* - `sonnet` should match `claude-3-5-sonnet-20241022`, `claude-3-sonnet-20240229`, etc.
* - `claude` should match any Claude model
*
* The client MAY also map the string to a different provider's model name or a different model family, as long as it fills a similar niche; for example:
* - `gemini-1.5-flash` could match `claude-3-haiku-20240307`
*/
name?: string;
}
/* Autocomplete */
/**
* A request from the client to the server, to ask for completion options.
*/
export interface CompleteRequest extends Request {
method: "completion/complete";
params: {
ref: PromptReference | ResourceReference;
/**
* The argument's information
*/
argument: {
/**
* The name of the argument
*/
name: string;
/**
* The value of the argument to use for completion matching.
*/
value: string;
};
};
}
/**
* The server's response to a completion/complete request
*/
export interface CompleteResult extends Result {
completion: {
/**
* An array of completion values. Must not exceed 100 items.
*/
values: string[];
/**
* The total number of completion options available. This can exceed the number of values actually sent in the response.
*/
total?: number;
/**
* Indicates whether there are additional completion options beyond those provided in the current response, even if the exact total is unknown.
*/
hasMore?: boolean;
};
}
/**
* A reference to a resource or resource template definition.
*/
export interface ResourceReference {
type: "ref/resource";
/**
* The URI or URI template of the resource.
*
* @format uri-template
*/
uri: string;
}
/**
* Identifies a prompt.
*/
export interface PromptReference {
type: "ref/prompt";
/**
* The name of the prompt or prompt template
*/
name: string;
}
/* Roots */
/**
* Sent from the server to request a list of root URIs from the client. Roots allow
* servers to ask for specific directories or files to operate on. A common example
* for roots is providing a set of repositories or directories a server should operate
* on.
*
* This request is typically used when the server needs to understand the file system
* structure or access specific locations that the client has permission to read from.
*/
export interface ListRootsRequest extends Request {
method: "roots/list";
}
/**
* The client's response to a roots/list request from the server.
* This result contains an array of Root objects, each representing a root directory
* or file that the server can operate on.
*/
export interface ListRootsResult extends Result {
roots: Root[];
}
/**
* Represents a root directory or file that the server can operate on.
*/
export interface Root {
/**
* The URI identifying the root. This *must* start with file:// for now.
* This restriction may be relaxed in future versions of the protocol to allow
* other URI schemes.
*
* @format uri
*/
uri: string;
/**
* An optional name for the root. This can be used to provide a human-readable
* identifier for the root, which may be useful for display purposes or for
* referencing the root in other parts of the application.
*/
name?: string;
}
/**
* A notification from the client to the server, informing it that the list of roots has changed.
* This notification should be sent whenever the client adds, removes, or modifies any root.
* The server should then request an updated list of roots using the ListRootsRequest.
*/
export interface RootsListChangedNotification extends Notification {
method: "notifications/roots/list_changed";
}
/* Client messages */
export type ClientRequest =
| PingRequest
| InitializeRequest
| CompleteRequest
| SetLevelRequest
| GetPromptRequest
| ListPromptsRequest
| ListResourcesRequest
| ListResourceTemplatesRequest
| ReadResourceRequest
| SubscribeRequest
| UnsubscribeRequest
| CallToolRequest
| ListToolsRequest;
export type ClientNotification =
| CancelledNotification
| ProgressNotification
| InitializedNotification
| RootsListChangedNotification;
export type ClientResult = EmptyResult | CreateMessageResult | ListRootsResult;
/* Server messages */
export type ServerRequest =
| PingRequest
| CreateMessageRequest
| ListRootsRequest;
export type ServerNotification =
| CancelledNotification
| ProgressNotification
| LoggingMessageNotification
| ResourceUpdatedNotification
| ResourceListChangedNotification
| ToolListChangedNotification
| PromptListChangedNotification;
export type ServerResult =
| EmptyResult
| InitializeResult
| CompleteResult
| GetPromptResult
| ListPromptsResult
| ListResourcesResult
| ListResourceTemplatesResult
| ReadResourceResult
| CallToolResult
| ListToolsResult;
---
File: /schema/2025-03-26/schema.ts
---
/* JSON-RPC types */
/**
* Refers to any valid JSON-RPC object that can be decoded off the wire, or encoded to be sent.
*/
export type JSONRPCMessage =
| JSONRPCRequest
| JSONRPCNotification
| JSONRPCBatchRequest
| JSONRPCResponse
| JSONRPCError
| JSONRPCBatchResponse;
/**
* A JSON-RPC batch request, as described in https://www.jsonrpc.org/specification#batch.
*/
export type JSONRPCBatchRequest = (JSONRPCRequest | JSONRPCNotification)[];
/**
* A JSON-RPC batch response, as described in https://www.jsonrpc.org/specification#batch.
*/
export type JSONRPCBatchResponse = (JSONRPCResponse | JSONRPCError)[];
export const LATEST_PROTOCOL_VERSION = "2025-03-26";
export const JSONRPC_VERSION = "2.0";
/**
* A progress token, used to associate progress notifications with the original request.
*/
export type ProgressToken = string | number;
/**
* An opaque token used to represent a cursor for pagination.
*/
export type Cursor = string;
export interface Request {
method: string;
params?: {
_meta?: {
/**
* If specified, the caller is requesting out-of-band progress notifications for this request (as represented by notifications/progress). The value of this parameter is an opaque token that will be attached to any subsequent notifications. The receiver is not obligated to provide these notifications.
*/
progressToken?: ProgressToken;
};
[key: string]: unknown;
};
}
export interface Notification {
method: string;
params?: {
/**
* This parameter name is reserved by MCP to allow clients and servers to attach additional metadata to their notifications.
*/
_meta?: { [key: string]: unknown };
[key: string]: unknown;
};
}
export interface Result {
/**
* This result property is reserved by the protocol to allow clients and servers to attach additional metadata to their responses.
*/
_meta?: { [key: string]: unknown };
[key: string]: unknown;
}
/**
* A uniquely identifying ID for a request in JSON-RPC.
*/
export type RequestId = string | number;
/**
* A request that expects a response.
*/
export interface JSONRPCRequest extends Request {
jsonrpc: typeof JSONRPC_VERSION;
id: RequestId;
}
/**
* A notification which does not expect a response.
*/
export interface JSONRPCNotification extends Notification {
jsonrpc: typeof JSONRPC_VERSION;
}
/**
* A successful (non-error) response to a request.
*/
export interface JSONRPCResponse {
jsonrpc: typeof JSONRPC_VERSION;
id: RequestId;
result: Result;
}
// Standard JSON-RPC error codes
export const PARSE_ERROR = -32700;
export const INVALID_REQUEST = -32600;
export const METHOD_NOT_FOUND = -32601;
export const INVALID_PARAMS = -32602;
export const INTERNAL_ERROR = -32603;
/**
* A response to a request that indicates an error occurred.
*/
export interface JSONRPCError {
jsonrpc: typeof JSONRPC_VERSION;
id: RequestId;
error: {
/**
* The error type that occurred.
*/
code: number;
/**
* A short description of the error. The message SHOULD be limited to a concise single sentence.
*/
message: string;
/**
* Additional information about the error. The value of this member is defined by the sender (e.g. detailed error information, nested errors etc.).
*/
data?: unknown;
};
}
/* Empty result */
/**
* A response that indicates success but carries no data.
*/
export type EmptyResult = Result;
/* Cancellation */
/**
* This notification can be sent by either side to indicate that it is cancelling a previously-issued request.
*
* The request SHOULD still be in-flight, but due to communication latency, it is always possible that this notification MAY arrive after the request has already finished.
*
* This notification indicates that the result will be unused, so any associated processing SHOULD cease.
*
* A client MUST NOT attempt to cancel its `initialize` request.
*/
export interface CancelledNotification extends Notification {
method: "notifications/cancelled";
params: {
/**
* The ID of the request to cancel.
*
* This MUST correspond to the ID of a request previously issued in the same direction.
*/
requestId: RequestId;
/**
* An optional string describing the reason for the cancellation. This MAY be logged or presented to the user.
*/
reason?: string;
};
}
/* Initialization */
/**
* This request is sent from the client to the server when it first connects, asking it to begin initialization.
*/
export interface InitializeRequest extends Request {
method: "initialize";
params: {
/**
* The latest version of the Model Context Protocol that the client supports. The client MAY decide to support older versions as well.
*/
protocolVersion: string;
capabilities: ClientCapabilities;
clientInfo: Implementation;
};
}
/**
* After receiving an initialize request from the client, the server sends this response.
*/
export interface InitializeResult extends Result {
/**
* The version of the Model Context Protocol that the server wants to use. This may not match the version that the client requested. If the client cannot support this version, it MUST disconnect.
*/
protocolVersion: string;
capabilities: ServerCapabilities;
serverInfo: Implementation;
/**
* Instructions describing how to use the server and its features.
*
* This can be used by clients to improve the LLM's understanding of available tools, resources, etc. It can be thought of like a "hint" to the model. For example, this information MAY be added to the system prompt.
*/
instructions?: string;
}
/**
* This notification is sent from the client to the server after initialization has finished.
*/
export interface InitializedNotification extends Notification {
method: "notifications/initialized";
}
/**
* Capabilities a client may support. Known capabilities are defined here, in this schema, but this is not a closed set: any client can define its own, additional capabilities.
*/
export interface ClientCapabilities {
/**
* Experimental, non-standard capabilities that the client supports.
*/
experimental?: { [key: string]: object };
/**
* Present if the client supports listing roots.
*/
roots?: {
/**
* Whether the client supports notifications for changes to the roots list.
*/
listChanged?: boolean;
};
/**
* Present if the client supports sampling from an LLM.
*/
sampling?: object;
}
/**
* Capabilities that a server may support. Known capabilities are defined here, in this schema, but this is not a closed set: any server can define its own, additional capabilities.
*/
export interface ServerCapabilities {
/**
* Experimental, non-standard capabilities that the server supports.
*/
experimental?: { [key: string]: object };
/**
* Present if the server supports sending log messages to the client.
*/
logging?: object;
/**
* Present if the server supports argument autocompletion suggestions.
*/
completions?: object;
/**
* Present if the server offers any prompt templates.
*/
prompts?: {
/**
* Whether this server supports notifications for changes to the prompt list.
*/
listChanged?: boolean;
};
/**
* Present if the server offers any resources to read.
*/
resources?: {
/**
* Whether this server supports subscribing to resource updates.
*/
subscribe?: boolean;
/**
* Whether this server supports notifications for changes to the resource list.
*/
listChanged?: boolean;
};
/**
* Present if the server offers any tools to call.
*/
tools?: {
/**
* Whether this server supports notifications for changes to the tool list.
*/
listChanged?: boolean;
};
}
/**
* Describes the name and version of an MCP implementation.
*/
export interface Implementation {
name: string;
version: string;
}
/* Ping */
/**
* A ping, issued by either the server or the client, to check that the other party is still alive. The receiver must promptly respond, or else may be disconnected.
*/
export interface PingRequest extends Request {
method: "ping";
}
/* Progress notifications */
/**
* An out-of-band notification used to inform the receiver of a progress update for a long-running request.
*/
export interface ProgressNotification extends Notification {
method: "notifications/progress";
params: {
/**
* The progress token which was given in the initial request, used to associate this notification with the request that is proceeding.
*/
progressToken: ProgressToken;
/**
* The progress thus far. This should increase every time progress is made, even if the total is unknown.
*
* @TJS-type number
*/
progress: number;
/**
* Total number of items to process (or total progress required), if known.
*
* @TJS-type number
*/
total?: number;
/**
* An optional message describing the current progress.
*/
message?: string;
};
}
/* Pagination */
export interface PaginatedRequest extends Request {
params?: {
/**
* An opaque token representing the current pagination position.
* If provided, the server should return results starting after this cursor.
*/
cursor?: Cursor;
};
}
export interface PaginatedResult extends Result {
/**
* An opaque token representing the pagination position after the last returned result.
* If present, there may be more results available.
*/
nextCursor?: Cursor;
}
/* Resources */
/**
* Sent from the client to request a list of resources the server has.
*/
export interface ListResourcesRequest extends PaginatedRequest {
method: "resources/list";
}
/**
* The server's response to a resources/list request from the client.
*/
export interface ListResourcesResult extends PaginatedResult {
resources: Resource[];
}
/**
* Sent from the client to request a list of resource templates the server has.
*/
export interface ListResourceTemplatesRequest extends PaginatedRequest {
method: "resources/templates/list";
}
/**
* The server's response to a resources/templates/list request from the client.
*/
export interface ListResourceTemplatesResult extends PaginatedResult {
resourceTemplates: ResourceTemplate[];
}
/**
* Sent from the client to the server, to read a specific resource URI.
*/
export interface ReadResourceRequest extends Request {
method: "resources/read";
params: {
/**
* The URI of the resource to read. The URI can use any protocol; it is up to the server how to interpret it.
*
* @format uri
*/
uri: string;
};
}
/**
* The server's response to a resources/read request from the client.
*/
export interface ReadResourceResult extends Result {
contents: (TextResourceContents | BlobResourceContents)[];
}
/**
* An optional notification from the server to the client, informing it that the list of resources it can read from has changed. This may be issued by servers without any previous subscription from the client.
*/
export interface ResourceListChangedNotification extends Notification {
method: "notifications/resources/list_changed";
}
/**
* Sent from the client to request resources/updated notifications from the server whenever a particular resource changes.
*/
export interface SubscribeRequest extends Request {
method: "resources/subscribe";
params: {
/**
* The URI of the resource to subscribe to. The URI can use any protocol; it is up to the server how to interpret it.
*
* @format uri
*/
uri: string;
};
}
/**
* Sent from the client to request cancellation of resources/updated notifications from the server. This should follow a previous resources/subscribe request.
*/
export interface UnsubscribeRequest extends Request {
method: "resources/unsubscribe";
params: {
/**
* The URI of the resource to unsubscribe from.
*
* @format uri
*/
uri: string;
};
}
/**
* A notification from the server to the client, informing it that a resource has changed and may need to be read again. This should only be sent if the client previously sent a resources/subscribe request.
*/
export interface ResourceUpdatedNotification extends Notification {
method: "notifications/resources/updated";
params: {
/**
* The URI of the resource that has been updated. This might be a sub-resource of the one that the client actually subscribed to.
*
* @format uri
*/
uri: string;
};
}
/**
* A known resource that the server is capable of reading.
*/
export interface Resource {
/**
* The URI of this resource.
*
* @format uri
*/
uri: string;
/**
* A human-readable name for this resource.
*
* This can be used by clients to populate UI elements.
*/
name: string;
/**
* A description of what this resource represents.
*
* This can be used by clients to improve the LLM's understanding of available resources. It can be thought of like a "hint" to the model.
*/
description?: string;
/**
* The MIME type of this resource, if known.
*/
mimeType?: string;
/**
* Optional annotations for the client.
*/
annotations?: Annotations;
}
/**
* A template description for resources available on the server.
*/
export interface ResourceTemplate {
/**
* A URI template (according to RFC 6570) that can be used to construct resource URIs.
*
* @format uri-template
*/
uriTemplate: string;
/**
* A human-readable name for the type of resource this template refers to.
*
* This can be used by clients to populate UI elements.
*/
name: string;
/**
* A description of what this template is for.
*
* This can be used by clients to improve the LLM's understanding of available resources. It can be thought of like a "hint" to the model.
*/
description?: string;
/**
* The MIME type for all resources that match this template. This should only be included if all resources matching this template have the same type.
*/
mimeType?: string;
/**
* Optional annotations for the client.
*/
annotations?: Annotations;
}
/**
* The contents of a specific resource or sub-resource.
*/
export interface ResourceContents {
/**
* The URI of this resource.
*
* @format uri
*/
uri: string;
/**
* The MIME type of this resource, if known.
*/
mimeType?: string;
}
export interface TextResourceContents extends ResourceContents {
/**
* The text of the item. This must only be set if the item can actually be represented as text (not binary data).
*/
text: string;
}
export interface BlobResourceContents extends ResourceContents {
/**
* A base64-encoded string representing the binary data of the item.
*
* @format byte
*/
blob: string;
}
/* Prompts */
/**
* Sent from the client to request a list of prompts and prompt templates the server has.
*/
export interface ListPromptsRequest extends PaginatedRequest {
method: "prompts/list";
}
/**
* The server's response to a prompts/list request from the client.
*/
export interface ListPromptsResult extends PaginatedResult {
prompts: Prompt[];
}
/**
* Used by the client to get a prompt provided by the server.
*/
export interface GetPromptRequest extends Request {
method: "prompts/get";
params: {
/**
* The name of the prompt or prompt template.
*/
name: string;
/**
* Arguments to use for templating the prompt.
*/
arguments?: { [key: string]: string };
};
}
/**
* The server's response to a prompts/get request from the client.
*/
export interface GetPromptResult extends Result {
/**
* An optional description for the prompt.
*/
description?: string;
messages: PromptMessage[];
}
/**
* A prompt or prompt template that the server offers.
*/
export interface Prompt {
/**
* The name of the prompt or prompt template.
*/
name: string;
/**
* An optional description of what this prompt provides
*/
description?: string;
/**
* A list of arguments to use for templating the prompt.
*/
arguments?: PromptArgument[];
}
/**
* Describes an argument that a prompt can accept.
*/
export interface PromptArgument {
/**
* The name of the argument.
*/
name: string;
/**
* A human-readable description of the argument.
*/
description?: string;
/**
* Whether this argument must be provided.
*/
required?: boolean;
}
/**
* The sender or recipient of messages and data in a conversation.
*/
export type Role = "user" | "assistant";
/**
* Describes a message returned as part of a prompt.
*
* This is similar to `SamplingMessage`, but also supports the embedding of
* resources from the MCP server.
*/
export interface PromptMessage {
role: Role;
content: TextContent | ImageContent | AudioContent | EmbeddedResource;
}
/**
* The contents of a resource, embedded into a prompt or tool call result.
*
* It is up to the client how best to render embedded resources for the benefit
* of the LLM and/or the user.
*/
export interface EmbeddedResource {
type: "resource";
resource: TextResourceContents | BlobResourceContents;
/**
* Optional annotations for the client.
*/
annotations?: Annotations;
}
/**
* An optional notification from the server to the client, informing it that the list of prompts it offers has changed. This may be issued by servers without any previous subscription from the client.
*/
export interface PromptListChangedNotification extends Notification {
method: "notifications/prompts/list_changed";
}
/* Tools */
/**
* Sent from the client to request a list of tools the server has.
*/
export interface ListToolsRequest extends PaginatedRequest {
method: "tools/list";
}
/**
* The server's response to a tools/list request from the client.
*/
export interface ListToolsResult extends PaginatedResult {
tools: Tool[];
}
/**
* The server's response to a tool call.
*
* Any errors that originate from the tool SHOULD be reported inside the result
* object, with `isError` set to true, _not_ as an MCP protocol-level error
* response. Otherwise, the LLM would not be able to see that an error occurred
* and self-correct.
*
* However, any errors in _finding_ the tool, an error indicating that the
* server does not support tool calls, or any other exceptional conditions,
* should be reported as an MCP error response.
*/
export interface CallToolResult extends Result {
content: (TextContent | ImageContent | AudioContent | EmbeddedResource)[];
/**
* Whether the tool call ended in an error.
*
* If not set, this is assumed to be false (the call was successful).
*/
isError?: boolean;
}
/**
* Used by the client to invoke a tool provided by the server.
*/
export interface CallToolRequest extends Request {
method: "tools/call";
params: {
name: string;
arguments?: { [key: string]: unknown };
};
}
/**
* An optional notification from the server to the client, informing it that the list of tools it offers has changed. This may be issued by servers without any previous subscription from the client.
*/
export interface ToolListChangedNotification extends Notification {
method: "notifications/tools/list_changed";
}
/**
* Additional properties describing a Tool to clients.
*
* NOTE: all properties in ToolAnnotations are **hints**.
* They are not guaranteed to provide a faithful description of
* tool behavior (including descriptive properties like `title`).
*
* Clients should never make tool use decisions based on ToolAnnotations
* received from untrusted servers.
*/
export interface ToolAnnotations {
/**
* A human-readable title for the tool.
*/
title?: string;
/**
* If true, the tool does not modify its environment.
*
* Default: false
*/
readOnlyHint?: boolean;
/**
* If true, the tool may perform destructive updates to its environment.
* If false, the tool performs only additive updates.
*
* (This property is meaningful only when `readOnlyHint == false`)
*
* Default: true
*/
destructiveHint?: boolean;
/**
* If true, calling the tool repeatedly with the same arguments
* will have no additional effect on the its environment.
*
* (This property is meaningful only when `readOnlyHint == false`)
*
* Default: false
*/
idempotentHint?: boolean;
/**
* If true, this tool may interact with an "open world" of external
* entities. If false, the tool's domain of interaction is closed.
* For example, the world of a web search tool is open, whereas that
* of a memory tool is not.
*
* Default: true
*/
openWorldHint?: boolean;
}
/**
* Definition for a tool the client can call.
*/
export interface Tool {
/**
* The name of the tool.
*/
name: string;
/**
* A human-readable description of the tool.
*
* This can be used by clients to improve the LLM's understanding of available tools. It can be thought of like a "hint" to the model.
*/
description?: string;
/**
* A JSON Schema object defining the expected parameters for the tool.
*/
inputSchema: {
type: "object";
properties?: { [key: string]: object };
required?: string[];
};
/**
* Optional additional tool information.
*/
annotations?: ToolAnnotations;
}
/* Logging */
/**
* A request from the client to the server, to enable or adjust logging.
*/
export interface SetLevelRequest extends Request {
method: "logging/setLevel";
params: {
/**
* The level of logging that the client wants to receive from the server. The server should send all logs at this level and higher (i.e., more severe) to the client as notifications/message.
*/
level: LoggingLevel;
};
}
/**
* Notification of a log message passed from server to client. If no logging/setLevel request has been sent from the client, the server MAY decide which messages to send automatically.
*/
export interface LoggingMessageNotification extends Notification {
method: "notifications/message";
params: {
/**
* The severity of this log message.
*/
level: LoggingLevel;
/**
* An optional name of the logger issuing this message.
*/
logger?: string;
/**
* The data to be logged, such as a string message or an object. Any JSON serializable type is allowed here.
*/
data: unknown;
};
}
/**
* The severity of a log message.
*
* These map to syslog message severities, as specified in RFC-5424:
* https://datatracker.ietf.org/doc/html/rfc5424#section-6.2.1
*/
export type LoggingLevel =
| "debug"
| "info"
| "notice"
| "warning"
| "error"
| "critical"
| "alert"
| "emergency";
/* Sampling */
/**
* A request from the server to sample an LLM via the client. The client has full discretion over which model to select. The client should also inform the user before beginning sampling, to allow them to inspect the request (human in the loop) and decide whether to approve it.
*/
export interface CreateMessageRequest extends Request {
method: "sampling/createMessage";
params: {
messages: SamplingMessage[];
/**
* The server's preferences for which model to select. The client MAY ignore these preferences.
*/
modelPreferences?: ModelPreferences;
/**
* An optional system prompt the server wants to use for sampling. The client MAY modify or omit this prompt.
*/
systemPrompt?: string;
/**
* A request to include context from one or more MCP servers (including the caller), to be attached to the prompt. The client MAY ignore this request.
*/
includeContext?: "none" | "thisServer" | "allServers";
/**
* @TJS-type number
*/
temperature?: number;
/**
* The maximum number of tokens to sample, as requested by the server. The client MAY choose to sample fewer tokens than requested.
*/
maxTokens: number;
stopSequences?: string[];
/**
* Optional metadata to pass through to the LLM provider. The format of this metadata is provider-specific.
*/
metadata?: object;
};
}
/**
* The client's response to a sampling/create_message request from the server. The client should inform the user before returning the sampled message, to allow them to inspect the response (human in the loop) and decide whether to allow the server to see it.
*/
export interface CreateMessageResult extends Result, SamplingMessage {
/**
* The name of the model that generated the message.
*/
model: string;
/**
* The reason why sampling stopped, if known.
*/
stopReason?: "endTurn" | "stopSequence" | "maxTokens" | string;
}
/**
* Describes a message issued to or received from an LLM API.
*/
export interface SamplingMessage {
role: Role;
content: TextContent | ImageContent | AudioContent;
}
/**
* Optional annotations for the client. The client can use annotations to inform how objects are used or displayed
*/
export interface Annotations {
/**
* Describes who the intended customer of this object or data is.
*
* It can include multiple entries to indicate content useful for multiple audiences (e.g., `["user", "assistant"]`).
*/
audience?: Role[];
/**
* Describes how important this data is for operating the server.
*
* A value of 1 means "most important," and indicates that the data is
* effectively required, while 0 means "least important," and indicates that
* the data is entirely optional.
*
* @TJS-type number
* @minimum 0
* @maximum 1
*/
priority?: number;
}
/**
* Text provided to or from an LLM.
*/
export interface TextContent {
type: "text";
/**
* The text content of the message.
*/
text: string;
/**
* Optional annotations for the client.
*/
annotations?: Annotations;
}
/**
* An image provided to or from an LLM.
*/
export interface ImageContent {
type: "image";
/**
* The base64-encoded image data.
*
* @format byte
*/
data: string;
/**
* The MIME type of the image. Different providers may support different image types.
*/
mimeType: string;
/**
* Optional annotations for the client.
*/
annotations?: Annotations;
}
/**
* Audio provided to or from an LLM.
*/
export interface AudioContent {
type: "audio";
/**
* The base64-encoded audio data.
*
* @format byte
*/
data: string;
/**
* The MIME type of the audio. Different providers may support different audio types.
*/
mimeType: string;
/**
* Optional annotations for the client.
*/
annotations?: Annotations;
}
/**
* The server's preferences for model selection, requested of the client during sampling.
*
* Because LLMs can vary along multiple dimensions, choosing the "best" model is
* rarely straightforward. Different models excel in different areas—some are
* faster but less capable, others are more capable but more expensive, and so
* on. This interface allows servers to express their priorities across multiple
* dimensions to help clients make an appropriate selection for their use case.
*
* These preferences are always advisory. The client MAY ignore them. It is also
* up to the client to decide how to interpret these preferences and how to
* balance them against other considerations.
*/
export interface ModelPreferences {
/**
* Optional hints to use for model selection.
*
* If multiple hints are specified, the client MUST evaluate them in order
* (such that the first match is taken).
*
* The client SHOULD prioritize these hints over the numeric priorities, but
* MAY still use the priorities to select from ambiguous matches.
*/
hints?: ModelHint[];
/**
* How much to prioritize cost when selecting a model. A value of 0 means cost
* is not important, while a value of 1 means cost is the most important
* factor.
*
* @TJS-type number
* @minimum 0
* @maximum 1
*/
costPriority?: number;
/**
* How much to prioritize sampling speed (latency) when selecting a model. A
* value of 0 means speed is not important, while a value of 1 means speed is
* the most important factor.
*
* @TJS-type number
* @minimum 0
* @maximum 1
*/
speedPriority?: number;
/**
* How much to prioritize intelligence and capabilities when selecting a
* model. A value of 0 means intelligence is not important, while a value of 1
* means intelligence is the most important factor.
*
* @TJS-type number
* @minimum 0
* @maximum 1
*/
intelligencePriority?: number;
}
/**
* Hints to use for model selection.
*
* Keys not declared here are currently left unspecified by the spec and are up
* to the client to interpret.
*/
export interface ModelHint {
/**
* A hint for a model name.
*
* The client SHOULD treat this as a substring of a model name; for example:
* - `claude-3-5-sonnet` should match `claude-3-5-sonnet-20241022`
* - `sonnet` should match `claude-3-5-sonnet-20241022`, `claude-3-sonnet-20240229`, etc.
* - `claude` should match any Claude model
*
* The client MAY also map the string to a different provider's model name or a different model family, as long as it fills a similar niche; for example:
* - `gemini-1.5-flash` could match `claude-3-haiku-20240307`
*/
name?: string;
}
/* Autocomplete */
/**
* A request from the client to the server, to ask for completion options.
*/
export interface CompleteRequest extends Request {
method: "completion/complete";
params: {
ref: PromptReference | ResourceReference;
/**
* The argument's information
*/
argument: {
/**
* The name of the argument
*/
name: string;
/**
* The value of the argument to use for completion matching.
*/
value: string;
};
};
}
/**
* The server's response to a completion/complete request
*/
export interface CompleteResult extends Result {
completion: {
/**
* An array of completion values. Must not exceed 100 items.
*/
values: string[];
/**
* The total number of completion options available. This can exceed the number of values actually sent in the response.
*/
total?: number;
/**
* Indicates whether there are additional completion options beyond those provided in the current response, even if the exact total is unknown.
*/
hasMore?: boolean;
};
}
/**
* A reference to a resource or resource template definition.
*/
export interface ResourceReference {
type: "ref/resource";
/**
* The URI or URI template of the resource.
*
* @format uri-template
*/
uri: string;
}
/**
* Identifies a prompt.
*/
export interface PromptReference {
type: "ref/prompt";
/**
* The name of the prompt or prompt template
*/
name: string;
}
/* Roots */
/**
* Sent from the server to request a list of root URIs from the client. Roots allow
* servers to ask for specific directories or files to operate on. A common example
* for roots is providing a set of repositories or directories a server should operate
* on.
*
* This request is typically used when the server needs to understand the file system
* structure or access specific locations that the client has permission to read from.
*/
export interface ListRootsRequest extends Request {
method: "roots/list";
}
/**
* The client's response to a roots/list request from the server.
* This result contains an array of Root objects, each representing a root directory
* or file that the server can operate on.
*/
export interface ListRootsResult extends Result {
roots: Root[];
}
/**
* Represents a root directory or file that the server can operate on.
*/
export interface Root {
/**
* The URI identifying the root. This *must* start with file:// for now.
* This restriction may be relaxed in future versions of the protocol to allow
* other URI schemes.
*
* @format uri
*/
uri: string;
/**
* An optional name for the root. This can be used to provide a human-readable
* identifier for the root, which may be useful for display purposes or for
* referencing the root in other parts of the application.
*/
name?: string;
}
/**
* A notification from the client to the server, informing it that the list of roots has changed.
* This notification should be sent whenever the client adds, removes, or modifies any root.
* The server should then request an updated list of roots using the ListRootsRequest.
*/
export interface RootsListChangedNotification extends Notification {
method: "notifications/roots/list_changed";
}
/* Client messages */
export type ClientRequest =
| PingRequest
| InitializeRequest
| CompleteRequest
| SetLevelRequest
| GetPromptRequest
| ListPromptsRequest
| ListResourcesRequest
| ReadResourceRequest
| SubscribeRequest
| UnsubscribeRequest
| CallToolRequest
| ListToolsRequest;
export type ClientNotification =
| CancelledNotification
| ProgressNotification
| InitializedNotification
| RootsListChangedNotification;
export type ClientResult = EmptyResult | CreateMessageResult | ListRootsResult;
/* Server messages */
export type ServerRequest =
| PingRequest
| CreateMessageRequest
| ListRootsRequest;
export type ServerNotification =
| CancelledNotification
| ProgressNotification
| LoggingMessageNotification
| ResourceUpdatedNotification
| ResourceListChangedNotification
| ToolListChangedNotification
| PromptListChangedNotification;
export type ServerResult =
| EmptyResult
| InitializeResult
| CompleteResult
| GetPromptResult
| ListPromptsResult
| ListResourcesResult
| ReadResourceResult
| CallToolResult
| ListToolsResult;
---
File: /scripts/validate_examples.ts
---
import * as fs from "fs";
import Ajv, { ValidateFunction } from "ajv";
import { globSync } from "glob";
import addFormats from "ajv-formats";
import { readFileSync } from "node:fs";
function createAjvInstance(): { ajv: Ajv; validate: ValidateFunction } {
const ajv = new Ajv({
// strict: true,
allowUnionTypes: true,
});
addFormats(ajv);
const schema = JSON.parse(readFileSync("schema/schema.json", "utf8"));
const validate = ajv.compile(schema);
return { ajv, validate };
}
function validateJsonBlocks(
validate: ValidateFunction,
filePath: string,
): void {
const content = fs.readFileSync(filePath, "utf8");
const jsonBlocks = content.match(/```json\s*\n([\s\S]*?)\n\s*```/g);
if (!jsonBlocks) {
console.log("No JSON blocks found in the file.");
return;
}
jsonBlocks.forEach((block, index) => {
try {
const jsonContent = block.replace(/```json\s*\n|\n\s*```/g, "");
const parsedJson = JSON.parse(jsonContent);
const valid = validate(parsedJson);
if (valid) {
console.log(`JSON block ${index + 1} is valid.`);
} else {
console.log(`JSON block ${index + 1} is invalid:`);
console.log(parsedJson);
console.log(validate.errors);
}
} catch (error) {
console.error(
`Error parsing JSON block ${index + 1}:`,
(error as Error).message,
);
}
});
}
const { validate } = createAjvInstance();
// Usage
const mdFiles = globSync("examples/**/*.md", {});
mdFiles.forEach((filePath) => {
console.log(`Validating JSON blocks in ${filePath}:`);
validateJsonBlocks(validate, filePath);
console.log("\n"); // Add a newline for separation between files
});
---
File: /site/layouts/index.html
---
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>Model Context Protocol Specification</title>
<script>window.location.replace("/latest");</script>
<meta http-equiv="refresh" content="0; url=/latest">
<link rel="canonical" href="/latest">
</head>
<body>
<h1>Model Context Protocol Specification</h1>
<p>Redirecting to <a href="/latest">specification</a>...</p>
</body>
</html>
---
File: /README.md
---
# Model Context Protocol specification
This repo contains the specification and protocol schema for the Model Context Protocol.
The schema is [defined in TypeScript](schema/2024-11-05/schema.ts) first, but
[made available as JSON Schema](schema/2024-11-05/schema.json) as well, for wider
compatibility.
## Contributing
Please see [CONTRIBUTING.md](CONTRIBUTING.md) for details on how to contribute to this
project.
## License
This project is licensed under the MIT License—see the [LICENSE](LICENSE) file for
details.
Reference in New Issue View Git Blame Copy Permalink