Tool Invocation

The Tool Definition is the formal contract published by an MCP server, specifying exactly how a tool can be called. It consists of three core parts:

• Name: A unique identifier for the tool (e.g., get_weather).
• Description: A natural language explanation of the tool's purpose, used by the LLM to decide when to call it.
• Input Schema: A JSON Schema object that defines the required and optional parameters, their data types, and validation rules (e.g., {"type": "object", "properties": {"city": {"type": "string"}}}).

The Invocation Request is the JSON-RPC message sent by the MCP client to the server. It contains the actionable instruction derived from the tool definition and the user's query. Key elements include:

• Method: Always tools/call.
• Params: An object containing:
  • name: The tool's identifier.
  • arguments: A JSON object matching the input schema (e.g., {"city": "London"}).
• Call ID: A unique string for tracking this specific request and its corresponding response.

The Tool Handler is the server-side function that contains the business logic executed when a request is received. It is the implementation of the tool definition. Its responsibilities are:

• Parse Arguments: Receive and validate the arguments object against the input schema.
• Execute Core Logic: Perform the intended action, such as calling a REST API, querying a database, or running a local script.
• Generate Result: Package the outcome into a structured format for the response.
• Handle Errors: Catch exceptions and return appropriate error messages if execution fails.

The Invocation Result is the JSON-RPC response sent from the MCP server back to the client. It conveys the outcome of the tool execution. It has two primary forms:

• Success Result: Contains a content array, where each item provides the result data, often as text for the LLM's context (e.g., [{"type": "text", "text": "The weather in London is 12°C and cloudy."}]).
• Error Result: Returned if the handler fails or validation errors occur. It includes an error object with a code and descriptive message, allowing the client or agent to attempt recovery or inform the user.

Schema Validation is the critical safety and correctness check that occurs both before and during a tool invocation. It ensures deterministic behavior.

• Client-Side (Pre-flight): The client's orchestration layer validates that the arguments it intends to send conform to the tool's published JSON Schema.
• Server-Side (Pre-execution): The MCP server validates the received arguments object against the same schema before passing it to the handler. This prevents malformed data from reaching business logic.
• This dual-layer validation is a core reliability feature of MCP, guaranteeing that tools receive inputs in the exact format they expect.

Context Injection is the final step where the tool's result is integrated back into the AI's reasoning flow. It is not part of the invocation itself but is its essential purpose.

• The MCP client receives the successful invocation result.
• The textual content from the result is injected into the language model's context window.
• The model then generates its final user-facing response, augmented by the fresh, external data (e.g., "Based on the weather data I retrieved, you should bring a jacket.").
• This closes the loop, transforming a raw API call into informed, contextual AI behavior.

A Tool Definition is the formal specification of an executable function exposed by an MCP server. It acts as the contract for invocation, containing:

• Name: A unique identifier for the tool.
• Description: A natural language explanation of the tool's purpose.
• Input Schema: A JSON Schema object that defines the exact structure, data types, and validation rules for the arguments the client must provide.

This definition is advertised by the server during capability negotiation, allowing the client to understand what can be called and how to call it.

The Tool Handler is the server-side implementation function that contains the business logic executed when an MCP client invokes a tool. It is the counterpart to the tool definition.

Key Responsibilities:

• Receives and parses the validated input arguments from the client's invocation request.
• Executes the intended action, such as querying a database, calling a third-party API, or running a local script.
• Formats the result into a structured response (often with content and mimeType fields) to be sent back to the client.
• Manages errors and returns appropriate error messages if the execution fails.

Schema Validation is the critical safety check that occurs both before and after a tool invocation. It ensures data integrity and prevents malformed calls.

Process:

1. Pre-invocation: The MCP client (or orchestration layer) validates that the arguments it intends to send conform to the tool's declared input JSON Schema.
2. Post-execution: The server may validate its own output, and the client can validate the structure of the result against an expected schema.

This validation is enforced by JSON Schema libraries, guaranteeing that the tool handler receives well-typed, expected parameters, drastically reducing runtime errors.

JSON-RPC (JavaScript Object Notation Remote Procedure Call) is the lightweight messaging protocol that underpins all MCP communication, including tool invocation.

Structure of an Invocation Request:

jsonCopy
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "get_weather",
    "arguments": {
      "location": "London",
      "unit": "celsius"
    }
  }
}

The server responds with a corresponding JSON-RPC response containing the result or an error object. This standardized envelope ensures reliable, parseable communication between client and server.

The Orchestration Layer is the middleware or control plane software that manages the sequencing, routing, and monitoring of tool calls within an AI agent's workflow. It sits between the reasoning agent and the MCP clients/servers.

Functions include:

• Sequencing: Determining the order of tool calls based on dependencies and agent reasoning.
• Parallelization: Managing concurrent tool invocations where possible.
• State Management: Maintaining context and partial results between successive tool calls.
• Fallback & Retry: Implementing retry logic (e.g., exponential backoff) for failed invocations.
• Audit Logging: Recording all invocations, parameters, and outcomes for compliance and debugging.

Structured Output Guarantees are techniques used to ensure the arguments generated by a language model for a tool invocation strictly conform to the required Tool Definition schema.

Common Implementation Methods:

• Function Calling: Native LLM APIs (e.g., OpenAI, Anthropic) that are trained to output a specific JSON structure matching a provided function signature.
• Grammar-Constrained Decoding: Using formal grammars (e.g., JSON Schema compiled to a grammar) to restrict the model's token-by-token output, making invalid JSON impossible.
• Validation & Re-prompting: Parsing the model's raw output, validating it against the schema, and automatically re-prompting the model with error details if validation fails.

This is essential for reliable, automated tool use without manual intervention.