Agentic Ai Foundation Mcp Protocol

{
    "$schema": "https://json-schema.org/draft/2020-12/schema",
    "$defs": {
        "Annotations": {
            "description": "Optional annotations for the client. The client can use annotations to inform how objects are used or displayed",
            "properties": {
                "audience": {
                    "description": "Describes who the intended audience of this object or data is.\n\nIt can include multiple entries to indicate content useful for multiple audiences (e.g., `[\"user\", \"assistant\"]`).",
                    "items": {
                        "$ref": "#/$defs/Role"
                    },
                    "type": "array"
                },
                "lastModified": {
                    "description": "The moment the resource was last modified, as an ISO 8601 formatted string.\n\nShould be an ISO 8601 formatted string (e.g., \"2025-01-12T15:00:58Z\").\n\nExamples: last activity timestamp in an open file, timestamp when the resource\nwas attached, etc.",
                    "type": "string"
                },
                "priority": {
                    "description": "Describes how important this data is for operating the server.\n\nA value of 1 means \"most important,\" and indicates that the data is\neffectively required, while 0 means \"least important,\" and indicates that\nthe data is entirely optional.",
                    "maximum": 1,
                    "minimum": 0,
                    "type": "number"
                }
            },
            "type": "object"
        },
        "AudioContent": {
            "description": "Audio provided to or from an LLM.",
            "properties": {
                "_meta": {
                    "$ref": "#/$defs/MetaObject"
                },
                "annotations": {
                    "$ref": "#/$defs/Annotations",
                    "description": "Optional annotations for the client."
                },
                "data": {
                    "description": "The base64-encoded audio data.",
                    "format": "byte",
                    "type": "string"
                },
                "mimeType": {
                    "description": "The MIME type of the audio. Different providers may support different audio types.",
                    "type": "string"
                },
                "type": {
                    "const": "audio",
                    "type": "string"
                }
            },
            "required": [
                "data",
                "mimeType",
                "type"
            ],
            "type": "object"
        },
        "BaseMetadata": {
            "description": "Base interface for metadata with name (identifier) and title (display name) properties.",
            "properties": {
                "name": {
                    "description": "Intended for programmatic or logical use, but used as a display name in past specs or fallback (if title isn't present).",
                    "type": "string"
                },
                "title": {
                    "description": "Intended for UI and end-user contexts — optimized to be human-readable and easily understood,\neven by those unfamiliar with domain-specific terminology.\n\nIf not provided, the name should be used for display (except for {@link Tool},\nwhere `annotations.title` should be given precedence over using `name`,\nif present).",
                    "type": "string"
                }
            },
            "required": [
                "name"
            ],
            "type": "object"
        },
        "BlobResourceContents": {
            "properties": {
                "_meta": {
                    "$ref": "#/$defs/MetaObject"
                },
                "blob": {
                    "description": "A base64-encoded string representing the binary data of the item.",
                    "format": "byte",
                    "type": "string"
                },
                "mimeType": {
                    "description": "The MIME type of this resource, if known.",
                    "type": "string"
                },
                "uri": {
                    "description": "The URI of this resource.",
                    "format": "uri",
                    "type": "string"
                }
            },
            "required": [
                "blob",
                "uri"
            ],
            "type": "object"
        },
        "BooleanSchema": {
            "properties": {
                "default": {
                    "type": "boolean"
                },
                "description": {
                    "type": "string"
                },
                "title": {
                    "type": "string"
                },
                "type": {
                    "const": "boolean",
                    "type": "string"
                }
            },
            "required": [
                "type"
            ],
            "type": "object"
        },
        "CacheableResult": {
            "description": "A result that supports a time-to-live (TTL) hint for client-side caching.",
            "properties": {
                "_meta": {
                    "$ref": "#/$defs/ResultMetaObject"
                },
                "cacheScope": {
                    "description": "Indicates the intended scope of the cached response, analogous to HTTP\n`Cache-Control: public` vs `Cache-Control: private`.\n\n- `\"public\"`: The response does not contain user-specific data. Any\n  client or intermediary (e.g., shared gateway, caching proxy) MAY cache\n  the response and serve it across authorization contexts.\n- `\"private\"`: The response MAY be cached and reused only within the\n  same authorization context. Caches MUST NOT be shared across\n  authorization contexts (e.g., a different access token requires a\n  different cache).",
                    "enum": [
                        "private",
                        "public"
                    ],
                    "type": "string"
                },
                "resultType": {
                    "description": "Indicates the type of the result, which allows the client to determine\nhow to parse the result object.\n\nServers implementing this protocol version MUST include this field.\nFor backward compatibility, when a client receives a result from a\nserver implementing an earlier protocol version (which does not include\n`resultType`), the client MUST treat the absent field as `\"complete\"`.",
                    "type": "string"
                },
                "ttlMs": {
                    "description": "A hint from the server indicating how long (in milliseconds) the\nclient MAY cache this response before re-fetching. Semantics are\nanalogous to HTTP Cache-Control max-age.\n\n- If 0, The response SHOULD be considered immediately stale,\n  The client MAY re-fetch every time the result is needed.\n- If positive, the client SHOULD consider the result fresh for this many\n  milliseconds after receiving the response.",
                    "minimum": 0,
                    "type": "integer"
                }
            },
            "required": [
                "cacheScope",
                "resultType",
                "ttlMs"
            ],
            "type": "object"
        },
        "CallToolRequest": {
            "description": "Used by the client to invoke a tool provided by the server.",
            "properties": {
                "id": {
                    "$ref": "#/$defs/RequestId"
                },
                "jsonrpc": {
                    "const": "2.0",
                    "type": "string"
                },
                "method": {
                    "const": "tools/call",
                    "type": "string"
                },
                "params": {
                    "$ref": "#/$defs/CallToolRequestParams"
                }
            },
            "required": [
                "id",
                "jsonrpc",
                "method",
                "params"
            ],
            "type": "object"
        },
        "CallToolRequestParams": {
            "description": "Parameters for a `tools/call` request.",
            "properties": {
                "_meta": {
                    "$ref": "#/$defs/RequestMetaObject"
                },
                "arguments": {
                    "additionalProperties": {},
                    "description": "Arguments to use for the tool call.",
                    "type": "object"
                },
                "inputResponses": {
                    "$ref": "#/$defs/InputResponses"
                },
                "name": {
                    "description": "The name of the tool.",
                    "type": "string"
                },
                "requestState": {
                    "type": "string"
                }
            },
            "required": [
                "_meta",
                "name"
            ],
            "type": "object"
        },
        "CallToolResult": {
            "description": "The result returned by the server for a {@link CallToolRequesttools/call} request.",
            "properties": {
                "_meta": {
                    "$ref": "#/$defs/ResultMetaObject"
                },
                "content": {
                    "description": "A list of content objects that represent the unstructured result of the tool call.",
                    "items": {
                        "$ref": "#/$defs/ContentBlock"
                    },
                    "type": "array"
                },
                "isError": {
                    "description": "Whether the tool call ended in an error.\n\nIf not set, this is assumed to be false (the call was successful).\n\nAny errors that originate from the tool SHOULD be reported inside the result\nobject, with `isError` set to true, _not_ as an MCP protocol-level error\nresponse. Otherwise, the LLM would not be able to see that an error occurred\nand self-correct.\n\nHowever, any errors in _finding_ the tool, an error indicating that the\nserver does not support tool calls, or any other exceptional conditions,\nshould be reported as an MCP error response.",
                    "type": "boolean"
                },
                "resultType": {
                    "description": "Indicates the type of the result, which allows the client to determine\nhow to parse the result object.\n\nServers implementing this protocol version MUST include this field.\nFor backward compatibility, when a client receives a result from a\nserver implementing an earlier protocol version (which does not include\n`resultType`), the client MUST treat the absent field as `\"complete\"`.",
                    "type": "string"
                },
                "structuredContent": {
                    "description": "An optional JSON value that represents the structured result of the tool call.\n\nThis can be any JSON value (object, array, string, number, boolean, or null)\nthat conforms to the tool's outputSchema if one is defined."
                }
            },
            "required": [
                "content",
                "resultType"
            ],
            "type": "object"
        },
        "CallToolResultResponse": {
            "description": "A successful response from the server for a {@link CallToolRequesttools/call} request.",
            "properties": {
                "id": {
                    "$ref": "#/$defs/RequestId"
                },
                "jsonrpc": {
                    "const": "2.0",
                    "type": "string"
                },
                "result": {
                    "anyOf": [
                        {
                            "$ref": "#/$defs/InputRequiredResult"
                        },
                        {
                            "$ref": "#/$defs/CallToolResult"
                        }
                    ]
                }
            },
            "required": [
                "id",
                "jsonrpc",
                "result"
            ],
            "type": "object"
        },
        "CancelledNotification": {
            "description": "This notification is sent by the client to indicate that it is cancelling a request it previously issued.\n\nOn stdio, the server also sends this notification, solely to terminate a {@link SubscriptionsListenRequestsubscriptions/listen} stream: it references the ID of the `subscriptions/listen` request that opened the stream. Servers MUST NOT use this notification to cancel any other request.\n\nThe 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.\n\nThis notification indicates that the result will be unused, so any associated processing SHOULD cease.",
            "properties": {
                "jsonrpc": {
                    "const": "2.0",
                    "type": "string"
                },
                "method": {
                    "const": "notifications/cancelled",
                    "type": "string"
                },
                "params": {
                    "$ref": "#/$defs/CancelledNotificationParams"
                }
            },
            "required": [
                "jsonrpc",
                "method",
                "params"
            ],
            "type": "object"
        },
        "CancelledNotificationParams": {
            "description": "Parameters for a `notifications/cancelled` notification.",
            "properties": {
                "_meta": {
                    "$ref": "#/$defs/NotificationMetaObject"
                },
                "reason": {
                    "description": "An optional string describing the reason for the cancellation. This MAY be logged or presented to the user.",
                    "type": "string"
                },
                "requestId": {
                    "$ref": "#/$defs/RequestId",
                    "description": "The ID of the request to cancel.\n\nThis MUST correspond to the ID of a request the client previously issued."
                }
            },
            "required": [
                "requestId"
            ],
            "type": "object"
        },
        "ClientCapabilities": {
            "description": "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.",
            "properties": {
                "elicitation": {
                    "description": "Present if the client supports elicitation from the server.",
                    "properties": {
                        "form": {
                            "$ref": "#/$defs/JSONObject"
                        },
                        "url": {
                            "$ref": "#/$defs/JSONObject"
                        }
                    },
                    "type": "object"
                },
                "experimental": {
                    "additionalProperties": {
                        "$ref": "#/$defs/JSONObject"
                    },
                    "description": "Experimental, non-standard capabilities that the client supports.",
                    "type": "object"
                },
                "extensions": {
                    "additionalProperties": {
                        "$ref": "#/$defs/JSONObject"
                    },
                    "description": "Optional MCP extensions that the client supports. Keys are extension identifiers\n(e.g., \"io.modelcontextprotocol/oauth-client-credentials\"), and values are\nper-extension settings objects. An empty object indicates support with no settings.\n\nKeys MUST follow the {@link MetaObject`_meta` key naming rules}, with a\nmandatory prefix.",
                    "type": "object"
                },
                "roots": {
                    "description": "Present if the client supports listing roots.",
                    "properties": {},
                    "type": "object"
                },
                "sampling": {
                    "description": "Present if the client supports sampling from an LLM.",
                    "properties": {
                        "context": {
                            "$ref": "#/$defs/JSONObject",
                            "description": "Whether the client supports context inclusion via `includeContext` parameter.\nIf not declared, servers SHOULD only use `includeContext: \"none\"` (or omit it)."
                        },
                        "tools": {
                            "$ref": "#/$defs/JSONObject",
                            "description": "Whether the client supports tool use via `tools` and `toolChoice` parameters."
                        }
                    },
                    "type": "object"
                }
            },
            "type": "object"
        },
        "ClientNotification": {
            "description": "This notification is sent by the client to indicate that it is cancelling a request it previously issued.\n\nOn stdio, the server also sends this notification, solely to terminate a {@link SubscriptionsListenRequestsubscriptions/listen} stream: it references the ID of the `subscriptions/listen` request that opened the stream. Servers MUST NOT use this notification to cancel any other request.\n\nThe 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.\n\nThis notification indicates that the result will be unused, so any associated processing SHOULD cease.",
            "properties": {
                "jsonrpc": {
                    "const": "2.0",
                    "type": "string"
                },
                "method": {
                    "const": "notifications/cancelled",
                    "type": "string"
                },
                "params": {
                    "$ref": "#/$defs/CancelledNotificationParams"
                }
            },
            "required": [
                "jsonrpc",
                "method",
                "params"
            ],
            "type": "object"
        },
        "ClientRequest": {
            "anyOf": [
                {
                    "$ref": "#/$defs/DiscoverRequest"
                },
                {
                    "$ref": "#/$defs/ListResourcesRequest"
                },
                {
                    "$ref": "#/$defs/ListResourceTemplatesRequest"
                },
                {
                    "$ref": "#/$defs/ReadResourceRequest"
                },
                {
                    "$ref": "#/$defs/SubscriptionsListenRequest"
                },
                {
                    "$ref": "#/$defs/ListPromptsRequest"
                },
                {
                    "$ref": "#/$defs/GetPromptRequest"
                },
                {
                    "$ref": "#/$defs/ListToolsRequest"
                },
                {
                    "$ref": "#/$defs/CallToolRequest"
                },
                {
                    "$ref": "#/$defs/CompleteRequest"
                }
            ]
        },
        "ClientResult": {
            "$ref": "#/$defs/Result",
            "description": "Common result fields."
        },
        "CompleteRequest": {
            "description": "A request from the client to the server, to ask for completion options.",
            "properties": {
                "id": {
                    "$ref": "#/$defs/RequestId"
                },
                "jsonrpc": {
                    "const": "2.0",
                    "type": "string"
                },
                "method": {
                    "const": "completion/complete",
                    "type": "string"
                },
                "params": {
                    "$ref": "#/$defs/CompleteRequestParams"
                }
            },
            "required": [
                "id",
                "jsonrpc",
                "method",
                "params"
            ],
            "type": "object"
        },
        "CompleteRequestParams": {
            "description": "Parameters for a `completion/complete` request.",
            "properties": {
                "_meta": {
                    "$ref": "#/$defs/RequestMetaObject"
                },
                "argument": {
                    "description": "The argument's information",
                    "properties": {
                        "name": {
                            "description": "The name of the argument",
                            "type": "string"
                        },
                        "value": {
                            "description": "The value of the argument to use for completion matching.",
                            "type": "string"
                        }
                    },
                    "required": [
                        "name",
                        "value"
                    ],
                    "type": "object"
                },
                "context": {
                    "description": "Additional, optional context for completions",
                    "properties": {
                        "arguments": {
                            "additionalProperties": {
                                "type": "string"
                            },
                            "description": "Previously-resolved variables in a URI template or prompt.",
                            "type": "object"
                        }
                    },
                    "type": "object"
                },
                "ref": {
                    "anyOf": [
                        {
                            "$ref": "#/$defs/PromptReference"
                        },
                        {
                            "$ref": "#/$defs/ResourceTemplateReference"
                        }
                    ]
                }
            },
            "required": [
                "_meta",
                "argument",
                "ref"
            ],
            "type": "object"
        },
        "CompleteResult": {
            "description": "The result returned by the server for a {@link CompleteRequestcompletion/complete} request.",
            "properties": {
                "_meta": {
                    "$ref": "#/$defs/ResultMetaObject"
                },
                "completion": {
                    "properties": {
                        "hasMore": {
                            "description": "Indicates whether there are additional completion options beyond those provided in the current response, even if the exact total is unknown.",
                            "type": "boolean"
                        },
                        "total": {
                            "description": "The total number of completion options available. This can exceed the number of values actually sent in the response.",
                            "type": "integer"
                        },
                        "values": {
                            "description": "An array of completion values. Must not exceed 100 items.",
                            "items": {
                                "type": "string"
                            },
                            "maxItems": 100,
                            "type": "array"
                        }
                    },
                    "required": [
                        "values"
                    ],
                    "type": "object"
                },
                "resultType": {
                    "description": "Indicates the type of the result, which allows the client to determine\nhow to parse the result object.\n\nServers implementing this protocol version MUST include this field.\nFor backward compatibility, when a client receives a result from a\nserver implementing an earlier protocol version (which does not include\n`resultType`), the client MUST treat the absent field as `\"complete\"`.",
                    "type": "string"
                }
            },
            "required": [
                "completion",
                "resultType"
            ],
            "type": "object"
        },
        "CompleteResultResponse": {
            "description": "A successful response from the server for a {@link CompleteRequestcompletion/complete} request.",
            "properties": {
                "id": {
                    "$ref": "#/$defs/RequestId"
                },
                "jsonrpc": {
                    "const": "2.0",
                    "type": "string"
                },
                "result": {
                    "$ref": "#/$defs/CompleteResult"
                }
            },
            "required": [
                "id",
                "jsonrpc",
                "result"
            ],
            "type": "object"
        },
        "ContentBlock": {
            "anyOf": [
                {
                    "$ref": "#/$defs/TextContent"
                },
                {
                    "$ref": "#/$defs/ImageContent"
                },
                {
                    "$ref": "#/$defs/AudioContent"
                },
                {
                    "$ref": "#/$defs/ResourceLink"
                },
                {
                    "$ref": "#/$defs/EmbeddedResource"
                }
            ]
        },
        "CreateMessageRequest": {
            "description": "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.",
            "properties": {
                "method": {
                    "const": "sampling/createMessage",
                    "type": "string"
                },
                "params": {
                    "$ref": "#/$defs/CreateMessageRequestParams"
                }
            },
            "required": [
                "method",
                "params"
            ],
            "type": "object"
        },
        "CreateMessageRequestParams": {
            "description": "Parameters for a `sampling/createMessage` request.",
            "properties": {
                "includeContext": {
                    "description": "A request to include context from one or more MCP servers (including the caller), to be attached to the prompt.\nThe client MAY ignore this request.\n\nDefault is `\"none\"`. The values `\"thisServer\"` and `\"allServers\"` are deprecated (SEP-2596): servers SHOULD\nomit this field or use `\"none\"`, and SHOULD only use the deprecated values if the client declares\n{@link ClientCapabilities.sampling.context}.",
                    "enum": [
                        "allServers",
                        "none",
                        "thisServer"
                    ],
                    "type": "string"
                },
                "maxTokens": {
                    "description": "The requested maximum number of tokens to sample (to prevent runaway completions).\n\nThe client MAY choose to sample fewer tokens than the requested maximum.",
                    "type": "integer"
                },
                "messages": {
                    "items": {
                        "$ref": "#/$defs/SamplingMessage"
                    },
                    "type": "array"
                },
                "metadata": {
                    "$ref": "#/$defs/JSONObject",
                    "description": "Optional metadata to pass through to the LLM provider. The format of this metadata is provider-specific."
                },
                "modelPreferences": {
                    "$ref": "#/$defs/ModelPreferences",
                    "description": "The server's preferences for which model to select. The client MAY ignore these preferences."
                },
                "stopSequences": {
                    "items": {
                        "type": "string"
                    },
                    "type": "array"
                },
                "systemPrompt": {
                    "description": "An optional system prompt the server wants to use for sampling. The client MAY modify or omit this prompt.",
                    "type": "string"
                },
                "temperature": {
                    "type": "number"
                },
                "toolChoice": {
                    "$ref": "#/$defs/ToolChoice",
                    "description": "Controls how the model uses tools.\nThe client MUST return an error if this field is provided but {@link ClientCapabilities.sampling.tools} is not declared.\nDefault is `{ mode: \"auto\" }`."
                },
                "tools": {
                    "description": "Tools that the model may use during generation.\nThe client MUST return an error if this field is provided but {@link ClientCapabilities.sampling.tools} is not declared.",
                    "items": {
                        "$ref": "#/$defs/Tool"
                    },
                    "type": "array"
                }
            },
            "required": [
                "maxTokens",
                "messages"
            ],
            "type": "object"
        },
        "CreateMessageResult": {
            "description": "The result returned by the client for a {@link CreateMessageRequestsampling/createMessage} request.\nThe client should inform the user before returning the sampled message, to allow them\nto inspect the response (human in the loop) and decide whether to allow the server to see it.",
            "properties": {
                "_meta": {
                    "$ref": "#/$defs/MetaObject"
                },
                "content": {
                    "anyOf": [
                        {
                            "$ref": "#/$defs/TextContent"
                        },
                        {
                            "$ref": "#/$defs/ImageContent"
                        },
                        {
                            "$ref": "#/$defs/AudioContent"
                        },
                        {
                            "$ref": "#/$defs/ToolUseContent"
                        },
                        {
                            "$ref": "#/$defs/ToolResultContent"
                        },
                        {
                            "items": {
                                "$ref": "#/$defs/SamplingMessageContentBlock"
                            },
                            "type": "array"
                        }
                    ]
                },
                "model": {
                    "description": "The name of the model that generated the message.",
                    "type": "string"
                },
                "role": {
                    "$ref": "#/$defs/Role"
                },
                "stopReason": {
                    "description": "The reason why sampling stopped, if known.\n\nStandard values:\n- `\"endTurn\"`: Natural end of the assistant's turn\n- `\"stopSequence\"`: A stop sequence was encountered\n- `\"maxTokens\"`: Maximum token limit was reached\n- `\"toolUse\"`: The model wants to use one or more tools\n\nThis field is an open string to allow for provider-specific stop reasons.",
                    "type": "string"
                }
            },
            "required": [
                "content",
                "model",
                "role"
            ],
            "type": "object"
        },
        "Cursor": {
            "description": "An opaque token used to represent a cursor for pagination.",
            "type": "string"
        },
        "DiscoverRequest": {
            "description": "A request from the client asking the server to advertise its supported\nprotocol versions, capabilities, and other metadata. Servers **MUST**\nimplement `server/discover`. Clients **MAY** call it but are not required\nto — version negotiation can also happen inline via per-request `_meta`.",
            "properties": {
                "id": {
                    "$ref": "#/$defs/RequestId"
                },
                "jsonrpc": {
                    "const": "2.0",
                    "type": "string"
                },
                "method": {
      

# --- truncated at 32 KB (177 KB total) ---
# Full source: https://raw.githubusercontent.com/api-evangelist/agentic-ai-foundation/refs/heads/main/json-schema/agentic-ai-foundation-mcp-protocol-schema.json