MCP Concepts Without the Mystery

MCP, the Model Context Protocol, can sound mysterious at first. Architecturally, the core idea is simple: it defines a set of standard JSON-RPC-style messages that allow AI applications to discover available tools, understand their metadata, and invoke them in a consistent way.

MCP communication usually follows a simple sequence. First, the AI application initializes the connection. Then it asks which tools are available and what they do. Finally, it invokes the selected tool with appropriate input parameters.

Connection Initialization

This step initializes communication between the AI application and the server. It acts as a protocol handshake where the server returns protocol version, supported capabilities, and server information.

The AI application sends an initialize request to the server using the following message structure. In practice, the only value that usually changes is the request id.

{
  "jsonrpc": "2.0",
  "method": "initialize",
  "params": {},
  "id": "1"
}

The server returns protocol version, capabilities, and server information:

{
  "protocolVersion": "2025-11-25",
  "capabilities": {
    "tools": {
      "listChanged": false
    }
  },
  "serverInfo": {
    "name": "JsonRpcEndpointSample",
    "version": "1.0.0"
  }
}

• protocolVersion - specifies which version of the MCP specification the server supports. The current version is 2025-11-25.
• capabilities - describes which MCP features the server supports. The MCP specification defines different capability types, but tools are the capability type used for operation-oriented APIs.
• tools - indicates that the server exposes callable operations ("tools").
• listChanged - specifies whether the set of available tools may change during the session. In many server-side business systems the tool list remains stable, so the value is commonly set to false.
• serverInfo provides descriptive information about the server implementation, such as its name and version.
• name - is the server name.
• version - is the server version.

In practice, the initialize response is largely static for a particular API server. The server version is usually the primary value that differs between deployments.

Tool Discovery

After initialization, the AI application needs to understand which tools are available and what they do. The tools/list method is used to request the list of available tools together with their metadata. The following request asks the server to return the tools it provides. Again, the only value that usually changes is the request id:

{
  "jsonrpc": "2.0",
  "method": "tools/list",
  "params": {},
  "id": "2"
}

The server responds with the list of available tools and their metadata (tool descriptors). Each descriptor includes the tool name, a description of what it does, whether it is read-only or changes state, and an input schema that defines the expected parameters. For example, the following response describes a Bank.MakeDeposit tool that deposits money into an existing bank account and returns the new balance:

{
  "tools": [
    {
      "name": "Bank.MakeDeposit",
      "description": "Deposits money into an existing bank account.",
      "inputSchema": {
        "type": "object",
        "properties": {
          "accountNumber": {
            "type": "string"
          },
          "amount": {
            "type": "number"
          }
        }
      }
    }
  ]
}

Tool Invocation

Finally, after the AI application has discovered the available tools, it can invoke the selected operation by sending a tools/call request. The request specifies the tool name together with the input parameters.

The following example shows how to call the Bank.MakeDeposit tool to deposit 250.00 into account A-100:

{
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "name": "Bank.MakeDeposit",
    "arguments": {
      "accountNumber": "A-100",
      "amount": 250.00
    }
  },
  "id": "3"
}

 

Table of Content Operation-Oriented APIs and AI Tools Previous: AI-Friendly Operation Catalog Next: Plugin-Based Request Handler Assemblies

 

---

Business Process Programming in .Net
© 2004–2026 Laskarzhevsky Software Inc.
Unless otherwise noted, the content of this website is licensed under the Creative Commons Attribution 4.0 International License (CC BY 4.0).
Code examples are provided under the MIT License.
You are free to share and adapt the material provided that appropriate credit is given and any modifications are clearly indicated.
The information provided on this website is for educational purposes only.
The author and publisher make no warranties regarding the completeness or suitability of the information and are not responsible for any damages resulting from its use.