> ## Documentation Index
> Fetch the complete documentation index at: https://docs.getmcp.com/llms.txt
> Use this file to discover all available pages before exploring further.

# tools/list

> Retrieve the list of all tools available on the MCP server.

The `tools/list` method returns all active tools configured for the server, including their names, descriptions, and input schemas. AI clients call this to discover what capabilities are available.

## MCP Endpoint

```
POST https://yoursite.com/mcp/{slug}
Content-Type: application/json
```

## Request

<ParamField body="jsonrpc" type="string" required>
  Must be `"2.0"`.
</ParamField>

<ParamField body="id" type="integer | string" required>
  Arbitrary request identifier echoed back unchanged in the response.
</ParamField>

<ParamField body="method" type="string" required>
  Must be `"tools/list"`.
</ParamField>

<ParamField body="params" type="object">
  Empty object `{}`. No parameters accepted.
</ParamField>

<RequestExample>
  ```bash cURL theme={null}
  curl --request POST \
       --url https://yoursite.com/mcp/my-weather-tools \
       --header 'content-type: application/json' \
       --header 'Mcp-Session-Id: your_session_id' \
       --data '
  {
    "jsonrpc": "2.0",
    "id": 3,
    "method": "tools/list",
    "params": {}
  }
  '
  ```

  ```go Go theme={null}
  package main
  import (
  	"fmt"
  	"io"
  	"net/http"
  	"strings"
  )

  func main() {
  	body := strings.NewReader(`{
    "jsonrpc": "2.0",
    "id": 3,
    "method": "tools/list",
    "params": {}
  }`)

  	req, _ := http.NewRequest("POST", "https://yoursite.com/mcp/my-weather-tools", body)
  	req.Header.Set("Content-Type", "application/json")

  	client := &http.Client{}
  	resp, _ := client.Do(req)
  	defer resp.Body.Close()
  	data, _ := io.ReadAll(resp.Body)
  	fmt.Println(string(data))
  }
  ```

  ```java Java theme={null}
  import java.net.URI;
  import java.net.http.HttpClient;
  import java.net.http.HttpRequest;
  import java.net.http.HttpResponse;

  public class Main {
      public static void main(String[] args) throws Exception {
          String json = "{\n  \"jsonrpc\": \"2.0\",\n  \"id\": 3,\n  \"method\": \"tools/list\",\n  \"params\": {}\n}";

          HttpRequest request = HttpRequest.newBuilder()
              .uri(URI.create("https://yoursite.com/mcp/my-weather-tools"))
              .header("Content-Type", "application/json")
              .POST(HttpRequest.BodyPublishers.ofString(json))
              .build();

          HttpClient client = HttpClient.newHttpClient();
          HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
          System.out.println(response.body());
      }
  }
  ```

  ```ruby Ruby theme={null}
  require 'net/http'
  require 'json'
  require 'uri'

  uri = URI('https://yoursite.com/mcp/my-weather-tools')
  http = Net::HTTP.new(uri.host, uri.port)
  http.use_ssl = uri.scheme == 'https'

  request = Net::HTTP::Post.new(uri)
  request['Content-Type'] = 'application/json'
  request.body = '{
    "jsonrpc": "2.0",
    "id": 3,
    "method": "tools/list",
    "params": {}
  }'

  response = http.request(request)
  puts JSON.parse(response.body)
  ```
</RequestExample>

## Response

<ResponseField name="result.tools" type="array">
  Array of tool objects. Only `active` tools are included, returned in their configured sort order.

  Each tool object contains:

  * `name` — Machine-readable tool identifier
  * `description` — Human-readable description used by AI for decision making
  * `inputSchema` — JSON Schema defining accepted parameters
</ResponseField>

<ResponseExample>
  ```json 200 OK theme={null}
  {
    "jsonrpc": "2.0",
    "id": 3,
    "result": {
      "tools": [
        {
          "name": "get_weather",
          "description": "Get current weather conditions for a city",
          "inputSchema": {
            "type": "object",
            "properties": {
              "city": {
                "type": "string",
                "description": "The city name to get weather for"
              }
            },
            "required": ["city"]
          }
        },
        {
          "name": "get_forecast",
          "description": "Get a 5-day weather forecast for a city",
          "inputSchema": {
            "type": "object",
            "properties": {
              "city": {
                "type": "string",
                "description": "The city name"
              },
              "units": {
                "type": "string",
                "enum": ["metric", "imperial"],
                "default": "metric",
                "description": "Temperature units"
              }
            },
            "required": ["city"]
          }
        }
      ]
    }
  }
  ```
</ResponseExample>

<Note>
  Only tools with `status: active` are included in `tools/list`. Paused tools are hidden from AI clients.
</Note>