{
  "openapi": "3.1.0",
  "info": {
    "title": "Geoapify MCP API",
    "version": "0.1.0",
    "description": "OpenAPI specification for the Geoapify Model Context Protocol JSON-RPC endpoint."
  },
  "servers": [
    {
      "url": "https://api.geoapify.com/v1"
    }
  ],
  "tags": [
    {
      "name": "MCP",
      "description": "Model Context Protocol JSON-RPC endpoint."
    }
  ],
  "paths": {
    "/mcp": {
      "post": {
        "tags": [
          "MCP"
        ],
        "operationId": "callMcpJsonRpc",
        "summary": "Call the Geoapify MCP JSON-RPC endpoint",
        "description": "Send MCP initialize, tools/list, tools/call, or notification JSON-RPC requests.",
        "parameters": [
          {
            "name": "apiKey",
            "in": "query",
            "required": true,
            "description": "Geoapify API key.",
            "schema": {
              "type": "string"
            },
            "example": "YOUR_API_KEY"
          }
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "oneOf": [
                  {
                    "$ref": "#/components/schemas/InitializeRequest"
                  },
                  {
                    "$ref": "#/components/schemas/ToolsListRequest"
                  },
                  {
                    "$ref": "#/components/schemas/NotificationRequest"
                  },
                  {
                    "$ref": "#/components/schemas/GeocodeAddressToolCallRequest"
                  },
                  {
                    "$ref": "#/components/schemas/GeocodeStructuredAddressToolCallRequest"
                  },
                  {
                    "$ref": "#/components/schemas/ReverseGeocodeCoordinatesToolCallRequest"
                  },
                  {
                    "$ref": "#/components/schemas/SearchPlacesToolCallRequest"
                  },
                  {
                    "$ref": "#/components/schemas/ListPlaceCategoriesToolCallRequest"
                  },
                  {
                    "$ref": "#/components/schemas/CalculateRouteToolCallRequest"
                  },
                  {
                    "$ref": "#/components/schemas/CalculateRouteMatrixToolCallRequest"
                  }
                ]
              },
              "example": {
                "jsonrpc": "2.0",
                "id": 1,
                "method": "tools/list"
              },
              "examples": {
                "toolsList": {
                  "summary": "List MCP tools",
                  "description": "Default request body. Returns the tools and input schemas exposed by the Geoapify MCP endpoint.",
                  "value": {
                    "jsonrpc": "2.0",
                    "id": 1,
                    "method": "tools/list"
                  }
                },
                "initialize": {
                  "summary": "Initialize MCP session",
                  "description": "Initialize an MCP client session and read server capabilities.",
                  "value": {
                    "jsonrpc": "2.0",
                    "id": 1,
                    "method": "initialize",
                    "params": {
                      "protocolVersion": "2025-06-18",
                      "capabilities": {},
                      "clientInfo": {
                        "name": "swagger-ui",
                        "version": "1.0.0"
                      }
                    }
                  }
                },
                "geocodeAddress": {
                  "summary": "Geocode address",
                  "description": "Convert a free-text address or place query into coordinates and structured address data.",
                  "value": {
                    "jsonrpc": "2.0",
                    "id": 1,
                    "method": "tools/call",
                    "params": {
                      "name": "geocode_address",
                      "arguments": {
                        "query": "Berlin",
                        "limit": 5,
                        "lang": "en"
                      }
                    }
                  }
                },
                "geocodeStructuredAddress": {
                  "summary": "Geocode structured address",
                  "description": "Geocode structured address fields into coordinates and normalized address data.",
                  "value": {
                    "jsonrpc": "2.0",
                    "id": 1,
                    "method": "tools/call",
                    "params": {
                      "name": "geocode_structured_address",
                      "arguments": {
                        "street": "Unter den Linden",
                        "city": "Berlin",
                        "country": "Germany",
                        "limit": 5,
                        "lang": "en"
                      }
                    }
                  }
                },
                "reverseGeocodeCoordinates": {
                  "summary": "Reverse geocode coordinates",
                  "description": "Convert latitude and longitude coordinates into nearby address or place data.",
                  "value": {
                    "jsonrpc": "2.0",
                    "id": 1,
                    "method": "tools/call",
                    "params": {
                      "name": "reverse_geocode_coordinates",
                      "arguments": {
                        "lat": 52.52,
                        "lon": 13.405,
                        "limit": 1,
                        "lang": "en"
                      }
                    }
                  }
                },
                "searchPlaces": {
                  "summary": "Search places",
                  "description": "Find places and points of interest by category near geographic coordinates.",
                  "value": {
                    "jsonrpc": "2.0",
                    "id": 1,
                    "method": "tools/call",
                    "params": {
                      "name": "search_places",
                      "arguments": {
                        "category": "catering.restaurant",
                        "lat": 52.52,
                        "lon": 13.405,
                        "radius_meters": 2000,
                        "limit": 20,
                        "lang": "en"
                      }
                    }
                  }
                },
                "listPlaceCategories": {
                  "summary": "List place categories",
                  "description": "List the category values accepted by search_places.",
                  "value": {
                    "jsonrpc": "2.0",
                    "id": 1,
                    "method": "tools/call",
                    "params": {
                      "name": "list_place_categories",
                      "arguments": {}
                    }
                  }
                },
                "calculateRoute": {
                  "summary": "Calculate route",
                  "description": "Calculate a route between geographic waypoints for a supported travel mode.",
                  "value": {
                    "jsonrpc": "2.0",
                    "id": 1,
                    "method": "tools/call",
                    "params": {
                      "name": "calculate_route",
                      "arguments": {
                        "waypoints": [
                          {
                            "lat": 52.52,
                            "lon": 13.405
                          },
                          {
                            "lat": 52.51,
                            "lon": 13.39
                          }
                        ],
                        "mode": "drive",
                        "geometry_scope": "route",
                        "geometry_format": "geojson",
                        "include_instructions": false
                      }
                    }
                  }
                },
                "calculateRouteMatrix": {
                  "summary": "Calculate route matrix",
                  "description": "Calculate travel times and distances between source and target locations.",
                  "value": {
                    "jsonrpc": "2.0",
                    "id": 1,
                    "method": "tools/call",
                    "params": {
                      "name": "calculate_route_matrix",
                      "arguments": {
                        "sources": [
                          {
                            "lat": 52.52,
                            "lon": 13.405
                          },
                          {
                            "lat": 52.51,
                            "lon": 13.39
                          }
                        ],
                        "mode": "drive"
                      }
                    }
                  }
                },
                "notificationsInitialized": {
                  "summary": "Initialized notification",
                  "description": "Send an MCP initialized notification. Notifications do not include a JSON-RPC id.",
                  "value": {
                    "jsonrpc": "2.0",
                    "method": "notifications/initialized"
                  }
                }
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "JSON-RPC response for initialize, tools/list, and tools/call requests.",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/McpResponse"
                }
              }
            }
          },
          "202": {
            "description": "Accepted notification request with no JSON-RPC response body."
          },
          "400": {
            "description": "Invalid request payload or tool arguments."
          },
          "401": {
            "description": "Missing or invalid Geoapify API key."
          },
          "429": {
            "description": "Rate limit or quota exceeded."
          },
          "500": {
            "description": "Internal gateway error."
          }
        }
      }
    }
  },
  "components": {
    "schemas": {
      "JsonRpcId": {
        "description": "JSON-RPC request identifier. The server echoes this value in the response.",
        "oneOf": [
          {
            "type": "string"
          },
          {
            "type": "integer"
          },
          {
            "type": "null"
          }
        ]
      },
      "InitializeRequest": {
        "type": "object",
        "description": "JSON-RPC request that initializes an MCP client session.",
        "additionalProperties": false,
        "required": [
          "jsonrpc",
          "id",
          "method"
        ],
        "properties": {
          "jsonrpc": {
            "description": "JSON-RPC protocol version.",
            "const": "2.0"
          },
          "id": {
            "description": "Client-supplied JSON-RPC request id echoed in the response.",
            "$ref": "#/components/schemas/JsonRpcId"
          },
          "method": {
            "description": "MCP initialize method.",
            "const": "initialize"
          },
          "params": {
            "description": "Optional MCP initialize parameters supplied by the client.",
            "type": "object",
            "additionalProperties": true
          }
        }
      },
      "ToolsListRequest": {
        "type": "object",
        "description": "JSON-RPC request that lists available MCP tools and their input schemas.",
        "additionalProperties": false,
        "required": [
          "jsonrpc",
          "id",
          "method"
        ],
        "properties": {
          "jsonrpc": {
            "description": "JSON-RPC protocol version.",
            "const": "2.0"
          },
          "id": {
            "description": "Client-supplied JSON-RPC request id echoed in the response.",
            "$ref": "#/components/schemas/JsonRpcId"
          },
          "method": {
            "description": "MCP method that lists tools.",
            "const": "tools/list"
          },
          "params": {
            "description": "Optional tools/list parameters.",
            "type": "object",
            "additionalProperties": true
          }
        }
      },
      "NotificationRequest": {
        "type": "object",
        "description": "JSON-RPC notification request. Notifications do not receive a JSON-RPC response and must not include id.",
        "additionalProperties": false,
        "required": [
          "jsonrpc",
          "method"
        ],
        "properties": {
          "jsonrpc": {
            "description": "JSON-RPC protocol version.",
            "const": "2.0"
          },
          "method": {
            "description": "MCP notification method name.",
            "type": "string",
            "pattern": "^notifications/"
          },
          "params": {
            "description": "Optional notification parameters.",
            "type": "object",
            "additionalProperties": true
          }
        },
        "not": {
          "required": [
            "id"
          ]
        }
      },
      "JsonRpcError": {
        "type": "object",
        "description": "JSON-RPC error object.",
        "additionalProperties": false,
        "required": [
          "code",
          "message"
        ],
        "properties": {
          "code": {
            "type": "integer"
          },
          "message": {
            "type": "string"
          },
          "data": true
        }
      },
      "JsonRpcErrorResponse": {
        "type": "object",
        "description": "JSON-RPC error response returned for invalid requests or unknown methods.",
        "additionalProperties": false,
        "required": [
          "jsonrpc",
          "id",
          "error"
        ],
        "properties": {
          "jsonrpc": {
            "const": "2.0"
          },
          "id": {
            "$ref": "#/components/schemas/JsonRpcId"
          },
          "error": {
            "$ref": "#/components/schemas/JsonRpcError"
          }
        }
      },
      "InitializeResponse": {
        "type": "object",
        "description": "Successful JSON-RPC response for initialize.",
        "additionalProperties": false,
        "required": [
          "jsonrpc",
          "id",
          "result"
        ],
        "properties": {
          "jsonrpc": {
            "const": "2.0"
          },
          "id": {
            "$ref": "#/components/schemas/JsonRpcId"
          },
          "result": {
            "type": "object",
            "additionalProperties": false,
            "required": [
              "protocolVersion",
              "serverInfo",
              "capabilities"
            ],
            "properties": {
              "protocolVersion": {
                "type": "string"
              },
              "serverInfo": {
                "type": "object",
                "additionalProperties": false,
                "required": [
                  "name",
                  "version"
                ],
                "properties": {
                  "name": {
                    "type": "string"
                  },
                  "version": {
                    "type": "string"
                  }
                }
              },
              "capabilities": {
                "type": "object",
                "additionalProperties": true
              }
            }
          }
        }
      },
      "ToolMetadata": {
        "type": "object",
        "description": "MCP tool metadata returned by tools/list.",
        "additionalProperties": false,
        "required": [
          "name",
          "description",
          "inputSchema",
          "outputSchema",
          "_meta"
        ],
        "properties": {
          "name": {
            "type": "string"
          },
          "title": {
            "type": "string"
          },
          "description": {
            "type": "string"
          },
          "inputSchema": {
            "type": "object",
            "additionalProperties": true
          },
          "outputSchema": {
            "type": "object",
            "additionalProperties": true
          },
          "_meta": {
            "type": "object",
            "additionalProperties": true,
            "required": [
              "geoapify/category"
            ],
            "properties": {
              "geoapify/category": {
                "type": "string"
              }
            }
          }
        }
      },
      "ToolsListResponse": {
        "type": "object",
        "description": "Successful JSON-RPC response for tools/list.",
        "additionalProperties": false,
        "required": [
          "jsonrpc",
          "id",
          "result"
        ],
        "properties": {
          "jsonrpc": {
            "const": "2.0"
          },
          "id": {
            "$ref": "#/components/schemas/JsonRpcId"
          },
          "result": {
            "type": "object",
            "additionalProperties": false,
            "required": [
              "tools"
            ],
            "properties": {
              "tools": {
                "type": "array",
                "items": {
                  "$ref": "#/components/schemas/ToolMetadata"
                }
              }
            }
          }
        }
      },
      "ToolCallResponse": {
        "type": "object",
        "description": "Successful JSON-RPC response for tools/call. Tool failures are returned with isError set to true.",
        "additionalProperties": false,
        "required": [
          "jsonrpc",
          "id",
          "result"
        ],
        "properties": {
          "jsonrpc": {
            "const": "2.0"
          },
          "id": {
            "$ref": "#/components/schemas/JsonRpcId"
          },
          "result": {
            "type": "object",
            "additionalProperties": false,
            "required": [
              "content",
              "isError"
            ],
            "properties": {
              "content": {
                "type": "array",
                "items": {
                  "type": "object",
                  "additionalProperties": false,
                  "required": [
                    "type",
                    "text"
                  ],
                  "properties": {
                    "type": {
                      "const": "text"
                    },
                    "text": {
                      "type": "string"
                    }
                  }
                }
              },
              "structuredContent": true,
              "isError": {
                "type": "boolean"
              }
            }
          }
        }
      },
      "McpResponse": {
        "oneOf": [
          {
            "$ref": "#/components/schemas/InitializeResponse"
          },
          {
            "$ref": "#/components/schemas/ToolsListResponse"
          },
          {
            "$ref": "#/components/schemas/ToolCallResponse"
          },
          {
            "$ref": "#/components/schemas/JsonRpcErrorResponse"
          }
        ]
      },
      "GeocodeAddressInput": {
        "type": "object",
        "additionalProperties": false,
        "required": [
          "query"
        ],
        "properties": {
          "query": {
            "type": "string",
            "minLength": 1,
            "maxLength": 1024,
            "description": "Street address or free-text location query to geocode."
          },
          "limit": {
            "type": "integer",
            "minimum": 1,
            "maximum": 10,
            "default": 5,
            "description": "Maximum number of results to return."
          },
          "lang": {
            "type": "string",
            "default": "en",
            "description": "Result language as a supported two-letter language code."
          },
          "country_codes": {
            "type": "array",
            "maxItems": 10,
            "items": {
              "type": "string"
            },
            "description": "Optional ISO 3166-1 alpha-2 country code filters, for example \"de\" or \"us\". Values are case-insensitive and normalized to lowercase."
          }
        }
      },
      "GeocodeAddressOutput": {
        "type": "object",
        "additionalProperties": false,
        "required": [
          "query",
          "count",
          "results"
        ],
        "properties": {
          "query": {
            "type": "string"
          },
          "count": {
            "type": "integer",
            "minimum": 0
          },
          "results": {
            "type": "array",
            "items": {
              "type": "object",
              "additionalProperties": true,
              "description": "Geocoding result with common address and location properties. Additional fields may be returned depending on the result type and available source data.",
              "properties": {
                "formatted": {
                  "type": "string"
                },
                "address_line1": {
                  "type": "string"
                },
                "address_line2": {
                  "type": "string"
                },
                "lon": {
                  "type": "number",
                  "minimum": -180,
                  "maximum": 180
                },
                "lat": {
                  "type": "number",
                  "minimum": -90,
                  "maximum": 90
                },
                "confidence": {
                  "type": "number",
                  "minimum": 0,
                  "maximum": 1,
                  "description": "Confidence score for the matched result."
                },
                "housenumber": {
                  "type": "string"
                },
                "street": {
                  "type": "string"
                },
                "postcode": {
                  "type": "string"
                },
                "city": {
                  "type": "string"
                },
                "county": {
                  "type": "string"
                },
                "state": {
                  "type": "string"
                },
                "country": {
                  "type": "string"
                },
                "country_code": {
                  "type": "string"
                },
                "timezone": {
                  "type": "object",
                  "additionalProperties": true,
                  "description": "Timezone information for the result location."
                }
              }
            }
          }
        }
      },
      "GeocodeAddressToolCallParams": {
        "type": "object",
        "description": "MCP tools/call params for geocode_address.",
        "additionalProperties": false,
        "required": [
          "name",
          "arguments"
        ],
        "properties": {
          "name": {
            "description": "Registered MCP tool name.",
            "const": "geocode_address"
          },
          "arguments": {
            "description": "Arguments validated by the geocode_address input schema.",
            "$ref": "#/components/schemas/GeocodeAddressInput"
          }
        }
      },
      "GeocodeAddressToolCallRequest": {
        "type": "object",
        "description": "JSON-RPC tools/call request for the geocode_address MCP tool.",
        "additionalProperties": false,
        "required": [
          "jsonrpc",
          "id",
          "method",
          "params"
        ],
        "properties": {
          "jsonrpc": {
            "description": "JSON-RPC protocol version.",
            "const": "2.0"
          },
          "id": {
            "description": "Client-supplied JSON-RPC request id echoed in the response.",
            "$ref": "#/components/schemas/JsonRpcId"
          },
          "method": {
            "description": "MCP method used to call a tool.",
            "const": "tools/call"
          },
          "params": {
            "description": "Tool call parameters for geocode_address.",
            "$ref": "#/components/schemas/GeocodeAddressToolCallParams"
          }
        },
        "examples": [
          {
            "jsonrpc": "2.0",
            "id": 1,
            "method": "tools/call",
            "params": {
              "name": "geocode_address",
              "arguments": {
                "query": "Berlin"
              }
            }
          }
        ],
        "x-geoapify-mcp-tool": "geocode_address",
        "x-geoapify-mcp-category": "Geocoding",
        "x-geoapify-mcp-input-schema": "#/components/schemas/GeocodeAddressInput",
        "x-geoapify-mcp-output-schema": "#/components/schemas/GeocodeAddressOutput"
      },
      "GeocodeStructuredAddressInput": {
        "type": "object",
        "additionalProperties": false,
        "properties": {
          "name": {
            "type": "string",
            "minLength": 1,
            "maxLength": 1024,
            "description": "Place or venue name, for example \"Central Station\"."
          },
          "housenumber": {
            "type": "string",
            "minLength": 1,
            "maxLength": 1024,
            "description": "House or building number. Use together with street."
          },
          "street": {
            "type": "string",
            "minLength": 1,
            "maxLength": 1024,
            "description": "Street name without city, state, or country."
          },
          "postcode": {
            "type": "string",
            "minLength": 1,
            "maxLength": 1024,
            "description": "Postal or ZIP code."
          },
          "city": {
            "type": "string",
            "minLength": 1,
            "maxLength": 1024,
            "description": "City, town, village, or locality."
          },
          "state": {
            "type": "string",
            "minLength": 1,
            "maxLength": 1024,
            "description": "State, region, province, or administrative area."
          },
          "country": {
            "type": "string",
            "minLength": 1,
            "maxLength": 1024,
            "description": "Country name."
          },
          "country_codes": {
            "type": "array",
            "maxItems": 10,
            "items": {
              "type": "string"
            },
            "description": "Optional ISO 3166-1 alpha-2 country code filters, for example \"de\" or \"us\". Values are case-insensitive and normalized to lowercase."
          },
          "limit": {
            "type": "integer",
            "minimum": 1,
            "maximum": 10,
            "default": 5,
            "description": "Maximum number of results to return."
          },
          "lang": {
            "type": "string",
            "default": "en",
            "description": "Result language as a supported two-letter language code."
          }
        },
        "anyOf": [
          {
            "required": [
              "name"
            ]
          },
          {
            "required": [
              "street"
            ]
          },
          {
            "required": [
              "postcode"
            ]
          },
          {
            "required": [
              "city"
            ]
          },
          {
            "required": [
              "state"
            ]
          },
          {
            "required": [
              "country"
            ]
          }
        ]
      },
      "GeocodeStructuredAddressOutput": {
        "type": "object",
        "additionalProperties": false,
        "required": [
          "address",
          "count",
          "results"
        ],
        "properties": {
          "address": {
            "type": "object",
            "additionalProperties": false,
            "properties": {
              "name": {
                "type": "string"
              },
              "housenumber": {
                "type": "string"
              },
              "street": {
                "type": "string"
              },
              "postcode": {
                "type": "string"
              },
              "city": {
                "type": "string"
              },
              "state": {
                "type": "string"
              },
              "country": {
                "type": "string"
              },
              "country_codes": {
                "type": "array",
                "items": {
                  "type": "string"
                }
              }
            }
          },
          "count": {
            "type": "integer",
            "minimum": 0
          },
          "results": {
            "type": "array",
            "items": {
              "type": "object",
              "additionalProperties": true,
              "description": "Geocoding result with common address and location properties. Additional fields may be returned depending on the result type and available source data.",
              "properties": {
                "formatted": {
                  "type": "string"
                },
                "address_line1": {
                  "type": "string"
                },
                "address_line2": {
                  "type": "string"
                },
                "lon": {
                  "type": "number",
                  "minimum": -180,
                  "maximum": 180
                },
                "lat": {
                  "type": "number",
                  "minimum": -90,
                  "maximum": 90
                },
                "confidence": {
                  "type": "number",
                  "minimum": 0,
                  "maximum": 1,
                  "description": "Confidence score for the matched result."
                },
                "housenumber": {
                  "type": "string"
                },
                "street": {
                  "type": "string"
                },
                "postcode": {
                  "type": "string"
                },
                "city": {
                  "type": "string"
                },
                "county": {
                  "type": "string"
                },
                "state": {
                  "type": "string"
                },
                "country": {
                  "type": "string"
                },
                "country_code": {
                  "type": "string"
                },
                "timezone": {
                  "type": "object",
                  "additionalProperties": true,
                  "description": "Timezone information for the result location."
                }
              }
            }
          }
        }
      },
      "GeocodeStructuredAddressToolCallParams": {
        "type": "object",
        "description": "MCP tools/call params for geocode_structured_address.",
        "additionalProperties": false,
        "required": [
          "name",
          "arguments"
        ],
        "properties": {
          "name": {
            "description": "Registered MCP tool name.",
            "const": "geocode_structured_address"
          },
          "arguments": {
            "description": "Arguments validated by the geocode_structured_address input schema.",
            "$ref": "#/components/schemas/GeocodeStructuredAddressInput"
          }
        }
      },
      "GeocodeStructuredAddressToolCallRequest": {
        "type": "object",
        "description": "JSON-RPC tools/call request for the geocode_structured_address MCP tool.",
        "additionalProperties": false,
        "required": [
          "jsonrpc",
          "id",
          "method",
          "params"
        ],
        "properties": {
          "jsonrpc": {
            "description": "JSON-RPC protocol version.",
            "const": "2.0"
          },
          "id": {
            "description": "Client-supplied JSON-RPC request id echoed in the response.",
            "$ref": "#/components/schemas/JsonRpcId"
          },
          "method": {
            "description": "MCP method used to call a tool.",
            "const": "tools/call"
          },
          "params": {
            "description": "Tool call parameters for geocode_structured_address.",
            "$ref": "#/components/schemas/GeocodeStructuredAddressToolCallParams"
          }
        },
        "examples": [
          {
            "jsonrpc": "2.0",
            "id": 1,
            "method": "tools/call",
            "params": {
              "name": "geocode_structured_address",
              "arguments": {
                "name": "example",
                "street": "example",
                "postcode": "example",
                "city": "example",
                "state": "example",
                "country": "example"
              }
            }
          }
        ],
        "x-geoapify-mcp-tool": "geocode_structured_address",
        "x-geoapify-mcp-category": "Geocoding",
        "x-geoapify-mcp-input-schema": "#/components/schemas/GeocodeStructuredAddressInput",
        "x-geoapify-mcp-output-schema": "#/components/schemas/GeocodeStructuredAddressOutput"
      },
      "ReverseGeocodeCoordinatesInput": {
        "type": "object",
        "additionalProperties": false,
        "required": [
          "lat",
          "lon"
        ],
        "properties": {
          "lat": {
            "type": "number",
            "minimum": -90,
            "maximum": 90,
            "description": "Latitude of the coordinate to reverse geocode."
          },
          "lon": {
            "type": "number",
            "minimum": -180,
            "maximum": 180,
            "description": "Longitude of the coordinate to reverse geocode."
          },
          "limit": {
            "type": "integer",
            "minimum": 1,
            "maximum": 10,
            "default": 1,
            "description": "Maximum number of nearby address or place results to return."
          },
          "lang": {
            "type": "string",
            "default": "en",
            "description": "Result language as a supported two-letter language code."
          },
          "type": {
            "type": "string",
            "enum": [
              "country",
              "state",
              "city",
              "postcode",
              "street",
              "amenity",
              "locality",
              "building"
            ],
            "description": "Optional result granularity, for example building for address-level results, city for city-level results, or postcode for postal-code results."
          },
          "country_codes": {
            "type": "array",
            "maxItems": 10,
            "items": {
              "type": "string"
            },
            "description": "Optional ISO 3166-1 alpha-2 country code filters, for example \"de\" or \"us\". Values are case-insensitive and normalized to lowercase."
          }
        }
      },
      "ReverseGeocodeCoordinatesOutput": {
        "type": "object",
        "additionalProperties": false,
        "required": [
          "coordinates",
          "count",
          "results"
        ],
        "properties": {
          "coordinates": {
            "type": "object",
            "additionalProperties": false,
            "required": [
              "lat",
              "lon"
            ],
            "properties": {
              "lat": {
                "type": "number"
              },
              "lon": {
                "type": "number"
              }
            }
          },
          "type": {
            "type": "string"
          },
          "count": {
            "type": "integer",
            "minimum": 0
          },
          "results": {
            "type": "array",
            "items": {
              "type": "object",
              "additionalProperties": true,
              "description": "Geocoding result with common address and location properties. Additional fields may be returned depending on the result type and available source data.",
              "properties": {
                "formatted": {
                  "type": "string"
                },
                "address_line1": {
                  "type": "string"
                },
                "address_line2": {
                  "type": "string"
                },
                "lon": {
                  "type": "number",
                  "minimum": -180,
                  "maximum": 180
                },
                "lat": {
                  "type": "number",
                  "minimum": -90,
                  "maximum": 90
                },
                "confidence": {
                  "type": "number",
                  "minimum": 0,
                  "maximum": 1,
                  "description": "Confidence score for the matched result."
                },
                "housenumber": {
                  "type": "string"
                },
                "street": {
                  "type": "string"
                },
                "postcode": {
                  "type": "string"
                },
                "city": {
                  "type": "string"
                },
                "county": {
                  "type": "string"
                },
                "state": {
                  "type": "string"
                },
                "country": {
                  "type": "string"
                },
                "country_code": {
                  "type": "string"
                },
                "timezone": {
                  "type": "object",
                  "additionalProperties": true,
                  "description": "Timezone information for the result location."
                }
              }
            }
          }
        }
      },
      "ReverseGeocodeCoordinatesToolCallParams": {
        "type": "object",
        "description": "MCP tools/call params for reverse_geocode_coordinates.",
        "additionalProperties": false,
        "required": [
          "name",
          "arguments"
        ],
        "properties": {
          "name": {
            "description": "Registered MCP tool name.",
            "const": "reverse_geocode_coordinates"
          },
          "arguments": {
            "description": "Arguments validated by the reverse_geocode_coordinates input schema.",
            "$ref": "#/components/schemas/ReverseGeocodeCoordinatesInput"
          }
        }
      },
      "ReverseGeocodeCoordinatesToolCallRequest": {
        "type": "object",
        "description": "JSON-RPC tools/call request for the reverse_geocode_coordinates MCP tool.",
        "additionalProperties": false,
        "required": [
          "jsonrpc",
          "id",
          "method",
          "params"
        ],
        "properties": {
          "jsonrpc": {
            "description": "JSON-RPC protocol version.",
            "const": "2.0"
          },
          "id": {
            "description": "Client-supplied JSON-RPC request id echoed in the response.",
            "$ref": "#/components/schemas/JsonRpcId"
          },
          "method": {
            "description": "MCP method used to call a tool.",
            "const": "tools/call"
          },
          "params": {
            "description": "Tool call parameters for reverse_geocode_coordinates.",
            "$ref": "#/components/schemas/ReverseGeocodeCoordinatesToolCallParams"
          }
        },
        "examples": [
          {
            "jsonrpc": "2.0",
            "id": 1,
            "method": "tools/call",
            "params": {
              "name": "reverse_geocode_coordinates",
              "arguments": {
                "lat": 52.52,
                "lon": 13.405
              }
            }
          }
        ],
        "x-geoapify-mcp-tool": "reverse_geocode_coordinates",
        "x-geoapify-mcp-category": "Geocoding",
        "x-geoapify-mcp-input-schema": "#/components/schemas/ReverseGeocodeCoordinatesInput",
        "x-geoapify-mcp-output-schema": "#/components/schemas/ReverseGeocodeCoordinatesOutput"
      },
      "SearchPlacesInput": {
        "type": "object",
        "additionalProperties": false,
        "required": [
          "category",
          "lat",
          "lon"
        ],
        "properties": {
          "category": {
            "type": "string",
            "minLength": 3,
            "maxLength": 64,
            "pattern": "^[a-z0-9_-]+(?:\\.[a-z0-9_-]+)*$",
            "description": "Place category to find. Call list_place_categories first to get the supported category values."
          },
          "lat": {
            "type": "number",
            "minimum": -90,
            "maximum": 90,
            "description": "Latitude of the search center."
          },
          "lon": {
            "type": "number",
            "minimum": -180,
            "maximum": 180,
            "description": "Longitude of the search center."
          },
          "radius_meters": {
            "type": "number",
            "minimum": 1,
            "description": "Optional search radius in meters. When omitted, returns the nearest matching places without a hard distance limit."
          },
          "limit": {
            "type": "integer",
            "minimum": 1,
            "maximum": 100,
            "default": 20,
            "description": "Maximum number of places to return."
          },
          "lang": {
            "type": "string",
            "default": "en",
            "description": "Result language as a supported two-letter language code."
          }
        }
      },
      "SearchPlacesOutput": {
        "type": "object",
        "additionalProperties": false,
        "required": [
          "category",
          "coordinates",
          "count",
          "results"
        ],
        "properties": {
          "category": {
            "type": "string",
            "description": "The supported place category used for this search."
          },
          "coordinates": {
            "type": "object",
            "additionalProperties": false,
            "required": [
              "lat",
              "lon"
            ],
            "properties": {
              "lat": {
                "type": "number"
              },
              "lon": {
                "type": "number"
              }
            }
          },
          "radius_meters": {
            "type": "number"
          },
          "count": {
            "type": "integer",
            "minimum": 0
          },
          "results": {
            "type": "array",
            "items": {
              "type": "object",
              "additionalProperties": true,
              "description": "Place result with common address and location properties. Additional fields may be returned depending on the place category and available source data.",
              "properties": {
                "name": {
                  "type": "string"
                },
                "formatted": {
                  "type": "string",
                  "description": "Formatted address or place label."
                },
                "lat": {
                  "type": "number",
                  "minimum": -90,
                  "maximum": 90
                },
                "lon": {
                  "type": "number",
                  "minimum": -180,
                  "maximum": 180
                },
                "categories": {
                  "type": "array",
                  "items": {
                    "type": "string"
                  },
                  "description": "Supported place categories assigned to the result."
                },
                "housenumber": {
                  "type": "string"
                },
                "street": {
                  "type": "string"
                },
                "neighbourhood": {
                  "type": "string"
                },
                "suburb": {
                  "type": "string"
                },
                "district": {
                  "type": "string"
                },
                "city": {
                  "type": "string"
                },
                "county": {
                  "type": "string"
                },
                "postcode": {
                  "type": "string"
                },
                "state": {
                  "type": "string"
                },
                "state_code": {
                  "type": "string"
                },
                "country": {
                  "type": "string"
                },
                "country_code": {
                  "type": "string"
                }
              }
            }
          }
        }
      },
      "SearchPlacesToolCallParams": {
        "type": "object",
        "description": "MCP tools/call params for search_places.",
        "additionalProperties": false,
        "required": [
          "name",
          "arguments"
        ],
        "properties": {
          "name": {
            "description": "Registered MCP tool name.",
            "const": "search_places"
          },
          "arguments": {
            "description": "Arguments validated by the search_places input schema.",
            "$ref": "#/components/schemas/SearchPlacesInput"
          }
        }
      },
      "SearchPlacesToolCallRequest": {
        "type": "object",
        "description": "JSON-RPC tools/call request for the search_places MCP tool.",
        "additionalProperties": false,
        "required": [
          "jsonrpc",
          "id",
          "method",
          "params"
        ],
        "properties": {
          "jsonrpc": {
            "description": "JSON-RPC protocol version.",
            "const": "2.0"
          },
          "id": {
            "description": "Client-supplied JSON-RPC request id echoed in the response.",
            "$ref": "#/components/schemas/JsonRpcId"
          },
          "method": {
            "description": "MCP method used to call a tool.",
            "const": "tools/call"
          },
          "params": {
            "description": "Tool call parameters for search_places.",
            "$ref": "#/components/schemas/SearchPlacesToolCallParams"
          }
        },
        "examples": [
          {
            "jsonrpc": "2.0",
            "id": 1,
            "method": "tools/call",
            "params": {
              "name": "search_places",
              "arguments": {
                "category": "catering.restaurant",
                "lat": 52.52,
                "lon": 13.405
              }
            }
          }
        ],
        "x-geoapify-mcp-tool": "search_places",
        "x-geoapify-mcp-category": "Places",
        "x-geoapify-mcp-input-schema": "#/components/schemas/SearchPlacesInput",
        "x-geoapify-mcp-output-schema": "#/components/schemas/SearchPlacesOutput"
      },
      "ListPlaceCategoriesInput": {
        "type": "object",
        "additionalProperties": false,
        "properties": {}
      },
      "ListPlaceCategoriesOutput": {
        "type": "object",
        "additionalProperties": false,
        "required": [
          "count",
          "categories"
        ],
        "properties": {
          "count": {
            "type": "integer",
            "minimum": 0
          },
          "categories": {
            "type": "array",
            "items": {
              "type": "string"
            }
          }
        }
      },
      "ListPlaceCategoriesToolCallParams": {
        "type": "object",
        "description": "MCP tools/call params for list_place_categories.",
        "additionalProperties": false,
        "required": [
          "name",
          "arguments"
        ],
        "properties": {
          "name": {
            "description": "Registered MCP tool name.",
            "const": "list_place_categories"
          },
          "arguments": {
            "description": "Arguments validated by the list_place_categories input schema.",
            "$ref": "#/components/schemas/ListPlaceCategoriesInput"
          }
        }
      },
      "ListPlaceCategoriesToolCallRequest": {
        "type": "object",
        "description": "JSON-RPC tools/call request for the list_place_categories MCP tool.",
        "additionalProperties": false,
        "required": [
          "jsonrpc",
          "id",
          "method",
          "params"
        ],
        "properties": {
          "jsonrpc": {
            "description": "JSON-RPC protocol version.",
            "const": "2.0"
          },
          "id": {
            "description": "Client-supplied JSON-RPC request id echoed in the response.",
            "$ref": "#/components/schemas/JsonRpcId"
          },
          "method": {
            "description": "MCP method used to call a tool.",
            "const": "tools/call"
          },
          "params": {
            "description": "Tool call parameters for list_place_categories.",
            "$ref": "#/components/schemas/ListPlaceCategoriesToolCallParams"
          }
        },
        "examples": [
          {
            "jsonrpc": "2.0",
            "id": 1,
            "method": "tools/call",
            "params": {
              "name": "list_place_categories",
              "arguments": {}
            }
          }
        ],
        "x-geoapify-mcp-tool": "list_place_categories",
        "x-geoapify-mcp-category": "Places",
        "x-geoapify-mcp-input-schema": "#/components/schemas/ListPlaceCategoriesInput",
        "x-geoapify-mcp-output-schema": "#/components/schemas/ListPlaceCategoriesOutput"
      },
      "CalculateRouteInput": {
        "type": "object",
        "additionalProperties": false,
        "required": [
          "waypoints"
        ],
        "properties": {
          "waypoints": {
            "type": "array",
            "minItems": 2,
            "items": {
              "type": "object",
              "additionalProperties": false,
              "required": [
                "lat",
                "lon"
              ],
              "properties": {
                "lat": {
                  "type": "number",
                  "minimum": -90,
                  "maximum": 90,
                  "description": "Waypoint latitude."
                },
                "lon": {
                  "type": "number",
                  "minimum": -180,
                  "maximum": 180,
                  "description": "Waypoint longitude."
                }
              }
            },
            "description": "Ordered route waypoints. Provide at least an origin and destination."
          },
          "mode": {
            "type": "string",
            "enum": [
              "drive",
              "light_truck",
              "medium_truck",
              "truck",
              "heavy_truck",
              "truck_dangerous_goods",
              "long_truck",
              "bus",
              "scooter",
              "motorcycle",
              "bicycle",
              "mountain_bike",
              "road_bike",
              "walk",
              "hike",
              "transit",
              "approximated_transit"
            ],
            "default": "drive",
            "description": "Travel or vehicle mode used to calculate the route."
          },
          "waypoint_mode": {
            "type": "string",
            "enum": [
              "stopover",
              "through_stop",
              "pass_through"
            ],
            "default": "stopover",
            "description": "How intermediate waypoints are treated."
          },
          "type": {
            "type": "string",
            "enum": [
              "balanced",
              "short",
              "less_maneuvers"
            ],
            "default": "balanced",
            "description": "Route optimization preference."
          },
          "avoid": {
            "type": "array",
            "maxItems": 3,
            "uniqueItems": true,
            "items": {
              "type": "string",
              "enum": [
                "tolls",
                "ferries",
                "highways"
              ]
            },
            "description": "Route features to avoid. Supported values are \"tolls\", \"ferries\", and \"highways\"."
          },
          "geometry_scope": {
            "type": "string",
            "enum": [
              "none",
              "route",
              "legs",
              "steps"
            ],
            "default": "route",
            "description": "Geometry detail to return: none, route only, route and legs, or route, legs, and instruction steps."
          },
          "geometry_format": {
            "type": "string",
            "enum": [
              "geojson",
              "polyline"
            ],
            "default": "geojson",
            "description": "Return geometry as a GeoJSON geometry object or an encoded precision-5 polyline."
          },
          "include_instructions": {
            "type": "boolean",
            "default": false,
            "description": "Include detailed turn-by-turn instruction steps."
          },
          "optimize_stops": {
            "type": "boolean",
            "default": false,
            "description": "Optimize the order of intermediate stops while preserving the first and last waypoint."
          },
          "units": {
            "type": "string",
            "enum": [
              "metric",
              "imperial"
            ],
            "default": "metric",
            "description": "Distance and speed units."
          },
          "lang": {
            "type": "string",
            "enum": [
              "bg",
              "ca",
              "cs",
              "da",
              "de",
              "el",
              "en-GB",
              "en",
              "es",
              "et",
              "fi",
              "fr",
              "hi",
              "hu",
              "it",
              "ja",
              "nb-NO",
              "nl",
              "pl",
              "pt-BR",
              "pt",
              "ro",
              "ru",
              "sk",
              "sl",
              "sv",
              "tr",
              "uk"
            ],
            "default": "en",
            "description": "Language used for turn-by-turn instructions."
          },
          "traffic": {
            "type": "string",
            "enum": [
              "free_flow",
              "approximated"
            ],
            "default": "free_flow",
            "description": "Traffic model used for motorized routing."
          }
        }
      },
      "CalculateRouteOutput": {
        "type": "object",
        "additionalProperties": false,
        "required": [
          "units",
          "distance_units",
          "time_units",
          "waypoints",
          "legs"
        ],
        "properties": {
          "distance": {
            "type": "number"
          },
          "units": {
            "type": "string",
            "enum": [
              "metric",
              "imperial"
            ]
          },
          "distance_units": {
            "type": "string",
            "enum": [
              "meters",
              "miles"
            ]
          },
          "time": {
            "type": "number"
          },
          "time_units": {
            "type": "string",
            "enum": [
              "seconds"
            ]
          },
          "waypoints": {
            "type": "array",
            "items": {
              "type": "object",
              "additionalProperties": false,
              "required": [
                "lat",
                "lon"
              ],
              "properties": {
                "lat": {
                  "type": "number"
                },
                "lon": {
                  "type": "number"
                }
              }
            }
          },
          "legs": {
            "type": "array",
            "items": {
              "type": "object",
              "additionalProperties": true,
              "properties": {
                "geometry": {
                  "oneOf": [
                    {
                      "type": "object",
                      "additionalProperties": false,
                      "required": [
                        "type",
                        "coordinates"
                      ],
                      "properties": {
                        "type": {
                          "type": "string",
                          "enum": [
                            "LineString",
                            "MultiLineString"
                          ]
                        },
                        "coordinates": {
                          "type": "array"
                        }
                      }
                    },
                    {
                      "type": "string",
                      "description": "Precision-5 encoded polyline."
                    }
                  ]
                },
                "steps": {
                  "type": "array",
                  "items": {
                    "type": "object",
                    "additionalProperties": true,
                    "properties": {
                      "geometry": {
                        "oneOf": [
                          {
                            "type": "object",
                            "additionalProperties": false,
                            "required": [
                              "type",
                              "coordinates"
                            ],
                            "properties": {
                              "type": {
                                "type": "string",
                                "enum": [
                                  "LineString",
                                  "MultiLineString"
                                ]
                              },
                              "coordinates": {
                                "type": "array"
                              }
                            }
                          },
                          {
                            "type": "string",
                            "description": "Precision-5 encoded polyline."
                          }
                        ]
                      }
                    }
                  }
                }
              }
            }
          },
          "geometry": {
            "oneOf": [
              {
                "type": "object",
                "additionalProperties": false,
                "required": [
                  "type",
                  "coordinates"
                ],
                "properties": {
                  "type": {
                    "type": "string",
                    "enum": [
                      "LineString",
                      "MultiLineString"
                    ]
                  },
                  "coordinates": {
                    "type": "array"
                  }
                }
              },
              {
                "type": "string",
                "description": "Precision-5 encoded polyline."
              }
            ]
          }
        }
      },
      "CalculateRouteToolCallParams": {
        "type": "object",
        "description": "MCP tools/call params for calculate_route.",
        "additionalProperties": false,
        "required": [
          "name",
          "arguments"
        ],
        "properties": {
          "name": {
            "description": "Registered MCP tool name.",
            "const": "calculate_route"
          },
          "arguments": {
            "description": "Arguments validated by the calculate_route input schema.",
            "$ref": "#/components/schemas/CalculateRouteInput"
          }
        }
      },
      "CalculateRouteToolCallRequest": {
        "type": "object",
        "description": "JSON-RPC tools/call request for the calculate_route MCP tool.",
        "additionalProperties": false,
        "required": [
          "jsonrpc",
          "id",
          "method",
          "params"
        ],
        "properties": {
          "jsonrpc": {
            "description": "JSON-RPC protocol version.",
            "const": "2.0"
          },
          "id": {
            "description": "Client-supplied JSON-RPC request id echoed in the response.",
            "$ref": "#/components/schemas/JsonRpcId"
          },
          "method": {
            "description": "MCP method used to call a tool.",
            "const": "tools/call"
          },
          "params": {
            "description": "Tool call parameters for calculate_route.",
            "$ref": "#/components/schemas/CalculateRouteToolCallParams"
          }
        },
        "examples": [
          {
            "jsonrpc": "2.0",
            "id": 1,
            "method": "tools/call",
            "params": {
              "name": "calculate_route",
              "arguments": {
                "waypoints": [
                  {
                    "lat": 52.52,
                    "lon": 13.405
                  },
                  {
                    "lat": 52.52,
                    "lon": 13.405
                  }
                ]
              }
            }
          }
        ],
        "x-geoapify-mcp-tool": "calculate_route",
        "x-geoapify-mcp-category": "Routing",
        "x-geoapify-mcp-input-schema": "#/components/schemas/CalculateRouteInput",
        "x-geoapify-mcp-output-schema": "#/components/schemas/CalculateRouteOutput"
      },
      "CalculateRouteMatrixInput": {
        "type": "object",
        "additionalProperties": false,
        "required": [
          "sources"
        ],
        "properties": {
          "sources": {
            "type": "array",
            "minItems": 1,
            "maxItems": 1000,
            "items": {
              "type": "object",
              "additionalProperties": false,
              "required": [
                "lat",
                "lon"
              ],
              "properties": {
                "lat": {
                  "type": "number",
                  "minimum": -90,
                  "maximum": 90,
                  "description": "Location latitude."
                },
                "lon": {
                  "type": "number",
                  "minimum": -180,
                  "maximum": 180,
                  "description": "Location longitude."
                }
              }
            },
            "description": "Matrix source locations. sources.length multiplied by targets.length must not exceed 1000."
          },
          "targets": {
            "type": "array",
            "minItems": 1,
            "maxItems": 1000,
            "items": {
              "type": "object",
              "additionalProperties": false,
              "required": [
                "lat",
                "lon"
              ],
              "properties": {
                "lat": {
                  "type": "number",
                  "minimum": -90,
                  "maximum": 90,
                  "description": "Location latitude."
                },
                "lon": {
                  "type": "number",
                  "minimum": -180,
                  "maximum": 180,
                  "description": "Location longitude."
                }
              }
            },
            "description": "Matrix target locations. Defaults to the source locations when omitted. sources.length multiplied by targets.length must not exceed 1000."
          },
          "mode": {
            "type": "string",
            "enum": [
              "drive",
              "truck",
              "light_truck",
              "medium_truck",
              "bus",
              "motorcycle",
              "scooter",
              "bicycle",
              "walk",
              "hike"
            ],
            "default": "drive",
            "description": "Travel or vehicle mode used to calculate the matrix."
          },
          "type": {
            "type": "string",
            "enum": [
              "balanced",
              "short",
              "less_maneuvers"
            ],
            "default": "balanced",
            "description": "Route optimization preference."
          },
          "traffic": {
            "type": "string",
            "enum": [
              "free_flow",
              "approximated"
            ],
            "default": "free_flow",
            "description": "Traffic model used for motorized routing."
          },
          "avoid": {
            "type": "array",
            "maxItems": 3,
            "uniqueItems": true,
            "items": {
              "type": "string",
              "enum": [
                "tolls",
                "highways",
                "ferries"
              ]
            },
            "description": "Route features to avoid. Supported values are \"tolls\", \"highways\", and \"ferries\"."
          },
          "units": {
            "type": "string",
            "enum": [
              "metric",
              "imperial"
            ],
            "default": "metric",
            "description": "Distance and speed units."
          }
        }
      },
      "CalculateRouteMatrixOutput": {
        "type": "object",
        "additionalProperties": false,
        "required": [
          "sources",
          "targets",
          "sources_to_targets",
          "units",
          "distance_units",
          "time_units"
        ],
        "properties": {
          "sources": {
            "type": "array",
            "items": {
              "type": "object",
              "additionalProperties": false,
              "required": [
                "lat",
                "lon"
              ],
              "properties": {
                "lat": {
                  "type": "number"
                },
                "lon": {
                  "type": "number"
                }
              }
            }
          },
          "targets": {
            "type": "array",
            "items": {
              "type": "object",
              "additionalProperties": false,
              "required": [
                "lat",
                "lon"
              ],
              "properties": {
                "lat": {
                  "type": "number"
                },
                "lon": {
                  "type": "number"
                }
              }
            }
          },
          "sources_to_targets": {
            "type": "array",
            "items": {
              "type": "array",
              "items": {
                "type": "object",
                "additionalProperties": true,
                "properties": {
                  "distance": {
                    "type": "number"
                  },
                  "time": {
                    "type": "number"
                  }
                }
              }
            }
          },
          "units": {
            "type": "string",
            "enum": [
              "metric",
              "imperial"
            ]
          },
          "distance_units": {
            "type": "string",
            "enum": [
              "meters",
              "miles"
            ]
          },
          "time_units": {
            "type": "string",
            "enum": [
              "seconds"
            ]
          }
        }
      },
      "CalculateRouteMatrixToolCallParams": {
        "type": "object",
        "description": "MCP tools/call params for calculate_route_matrix.",
        "additionalProperties": false,
        "required": [
          "name",
          "arguments"
        ],
        "properties": {
          "name": {
            "description": "Registered MCP tool name.",
            "const": "calculate_route_matrix"
          },
          "arguments": {
            "description": "Arguments validated by the calculate_route_matrix input schema.",
            "$ref": "#/components/schemas/CalculateRouteMatrixInput"
          }
        }
      },
      "CalculateRouteMatrixToolCallRequest": {
        "type": "object",
        "description": "JSON-RPC tools/call request for the calculate_route_matrix MCP tool.",
        "additionalProperties": false,
        "required": [
          "jsonrpc",
          "id",
          "method",
          "params"
        ],
        "properties": {
          "jsonrpc": {
            "description": "JSON-RPC protocol version.",
            "const": "2.0"
          },
          "id": {
            "description": "Client-supplied JSON-RPC request id echoed in the response.",
            "$ref": "#/components/schemas/JsonRpcId"
          },
          "method": {
            "description": "MCP method used to call a tool.",
            "const": "tools/call"
          },
          "params": {
            "description": "Tool call parameters for calculate_route_matrix.",
            "$ref": "#/components/schemas/CalculateRouteMatrixToolCallParams"
          }
        },
        "examples": [
          {
            "jsonrpc": "2.0",
            "id": 1,
            "method": "tools/call",
            "params": {
              "name": "calculate_route_matrix",
              "arguments": {
                "sources": [
                  {
                    "lat": 52.52,
                    "lon": 13.405
                  }
                ]
              }
            }
          }
        ],
        "x-geoapify-mcp-tool": "calculate_route_matrix",
        "x-geoapify-mcp-category": "Routing",
        "x-geoapify-mcp-input-schema": "#/components/schemas/CalculateRouteMatrixInput",
        "x-geoapify-mcp-output-schema": "#/components/schemas/CalculateRouteMatrixOutput"
      }
    }
  }
}
