# MCP

> The Model Context Protocol (MCP) enables large language models to use external tools and data. This topic describes how to connect to MCP using the Responses API.

## Usage <span id="rs2b3c4d5e6f7" /> <span id="8c7222cb4bg7i" />

Add MCP server information in the `tools` parameter when using the Responses API.

> Get the Server-Sent Events (SSE) endpoint and authentication information for the MCP service from platforms such as [ModelScope](https://modelscope.ai/mcp/servers).

> Supports MCP servers using the SSE protocol.

> Maximum 10 MCP servers.

```python
# Import dependencies and create a client...
mcp_tool = {
    "type": "mcp",
    "server_protocol": "sse",
    "server_label": "my-mcp-service",
    "server_description": "A description of the MCP server's features to help the model understand its use cases.",
    "server_url": "https://your-mcp-server-endpoint/sse",
    "headers": {
        "Authorization": "Bearer YOUR_TOKEN"
    }
}

response = client.responses.create(
    model="qwen3.8-max",
    input="Your question...",
    tools=[mcp_tool]
)

print(response.output_text)
```

## Supported models <span id="rs9i0j1k2l3m4" /> <span id="rs8h9i0j1k2l3" />

- Qwen-Max: Qwen3.8-Max series, Qwen3.7-Max series
- Qwen-Plus: Qwen3.7-Plus series, Qwen3.6-Plus series, Qwen3.5-Plus series
- Qwen-Flash: Qwen3.7-Flash series, Qwen3.6-Flash series, Qwen3.5-Flash series
- Qwen3.8 open-source series
- Qwen3.6 open-source series (except qwen3.6-27b)
- Qwen3.5 open-source series

Available through the Responses API only.

## Getting started <span id="rsi8r9s0t1u2v3" /> <span id="rsh7q8r9s0t1u2" />

This example uses the [Fetch web scraping](https://modelscope.ai/mcp/servers/@modelcontextprotocol/fetch) MCP service from ModelScope. You can get the SSE Endpoint and authentication information for the service from the Service configuration section on the right.

Get an [API key](/help/en/model-studio/get-api-key) and [configure it as an environment variable](/help/en/model-studio/get-api-key).

> Replace `server_url` with the SSE endpoint from the MCP service platform. Replace the authentication in `headers` with the token provided by that platform.

<CodeGroup dropdown>
  ```python expandable
  import os
  from openai import OpenAI

  client = OpenAI(
      # If no environment variable, use: api_key="sk-xxx" (not recommended).
      api_key=os.getenv("DASHSCOPE_API_KEY"),
      # The following URL is for the Singapore region. Replace {WorkspaceId} with your actual workspace ID. URLs vary by region.
      base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1"
  )

  # MCP tool configuration
  # Replace server_url with the SSE Endpoint that you got from a platform such as ModelScope
  # If authentication is required, add the token from the corresponding platform to the headers
  mcp_tool = {
      "type": "mcp",
      "server_protocol": "sse",
      "server_label": "fetch",
      "server_description": "Fetch MCP Server that provides web scraping capabilities. It can scrape the content of a specified URL and return it as text.",
      "server_url": "https://mcp.api-inference.modelscope.net/xxx/sse",
  }

  response = client.responses.create(
      model="qwen3.8-max",
      input="https://news.aibase.com/news, what is the AI news today?",
      tools=[mcp_tool]
  )

  print("[Model Response]")
  print(response.output_text)
  print(f"\n[Token Usage] Input: {response.usage.input_tokens}, Output: {response.usage.output_tokens}, Total: {response.usage.total_tokens}")
  ```

  ```javascript expandable
  import OpenAI from "openai";
  import process from 'process';

  const openai = new OpenAI({
      // If no environment variable, use: apiKey: "sk-xxx" (not recommended).
      apiKey: process.env.DASHSCOPE_API_KEY,
      // The following URL is for the Singapore region. Replace {WorkspaceId} with your actual workspace ID. URLs vary by region.
      baseURL: "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1"
  });

  async function main() {
      // MCP tool configuration
      // Replace server_url with the SSE Endpoint that you got from a platform such as ModelScope
      // If authentication is required, add the token from the corresponding platform to the headers
      const mcpTool = {
          type: "mcp",
          server_protocol: "sse",
          server_label: "fetch",
          server_description: "Fetch MCP Server that provides web scraping capabilities. It can scrape the content of a specified URL and return it as text.",
          server_url: "https://mcp.api-inference.modelscope.net/xxx/sse",
      };

      const response = await openai.responses.create({
          model: "qwen3.8-max",
          input: "https://news.aibase.com/news, what is the AI news today?",
          tools: [mcpTool]
      });

      console.log("[Model Response]");
      console.log(response.output_text);
      console.log(`\n[Token Usage] Input: ${response.usage.input_tokens}, Output: ${response.usage.output_tokens}, Total: ${response.usage.total_tokens}`);
  }

  main();
  ```

  ```java expandable
  // The Bailian MCP tool requires the server_protocol field, which the official OpenAI Java SDK's
  // Tool.Mcp does not yet expose. Add it via putAdditionalProperty. JDK 8+ / Spring Boot 2.x compatible.
  // Maven dependency: com.openai:openai-java:4.67.0 (or later)
  import com.openai.client.OpenAIClient;
  import com.openai.client.okhttp.OpenAIOkHttpClient;
  import com.openai.core.JsonValue;
  import com.openai.models.responses.*;

  public class McpResponsesDemo {
      public static void main(String[] args) {
          // If no environment variable is set, replace the line below with: apiKey = "sk-xxx" (not recommended)
          String apiKey = System.getenv("DASHSCOPE_API_KEY");
          // The following URL is for the Singapore region. Replace {WorkspaceId} with your actual workspace ID. URLs vary by region.
          OpenAIClient client = OpenAIOkHttpClient.builder()
                  .apiKey(apiKey)
                  .baseUrl("https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1")
                  .build();

          // Replace server_url with the SSE Endpoint that you got from a platform such as ModelScope
          // If authentication is required, add the token from the corresponding platform to the headers
          Tool mcpTool = Tool.ofMcp(Tool.Mcp.builder()
                  .serverLabel("fetch")
                  .serverDescription("Fetch MCP Server that provides web scraping capabilities. It can scrape the content of a specified URL and return it as text.")
                  .serverUrl("https://mcp.api-inference.modelscope.net/xxx/sse")
                  .putAdditionalProperty("server_protocol", JsonValue.from("sse"))
                  .build());

          ResponseCreateParams params = ResponseCreateParams.builder()
                  .model("qwen3.8-max")
                  .input("https://news.aibase.com/news, what is the AI news today?")
                  .addTool(mcpTool)
                  .build();

          // Call the Responses API
          Response response = client.responses().create(params);

          System.out.println("[Model Response]");
          response.output().stream()
                  .flatMap(item -> item.message().stream())
                  .flatMap(message -> message.content().stream())
                  .flatMap(content -> content.outputText().stream())
                  .forEach(text -> System.out.println(text.text()));

          response.usage().ifPresent(u ->
                  System.out.println("\n[Token Usage] Input: " + u.inputTokens()
                          + ", Output: " + u.outputTokens()
                          + ", Total: " + u.totalTokens()));
      }
  }
  ```

  ```bash
  # Replace server_url with the SSE Endpoint that you got from a platform such as ModelScope
  # If authentication is required, add the token from the corresponding platform to the headers
  # The following URL is for the Singapore region. Replace {WorkspaceId} with your actual workspace ID. URLs vary by region.
  curl -X POST https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1/responses \
  -H "Authorization: Bearer $DASHSCOPE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
      "model": "qwen3.8-max",
      "input": "https://news.aibase.com/news, what is the AI news today?",
      "tools": [
          {
              "type": "mcp",
              "server_protocol": "sse",
              "server_label": "fetch",
              "server_description": "Fetch MCP Server that provides web scraping capabilities. It can scrape the content of a specified URL and return it as text.",
              "server_url": "https://mcp.api-inference.modelscope.net/xxx/sse"
          }
      ]
  }'
  ```
</CodeGroup>

After you run the code, the following response is returned:

```plaintext
[Model Response]
Based on the documentation for the Model Context Protocol (MCP) on the Alibaba Cloud Model Studio (Bailian) help center, the supported models are:

*   Qwen Max:
    *   Qwen3.8-Max series
    *   Qwen3.7-Max series
*   Qwen Plus:
    *   Qwen3.7-Plus series
    *   Qwen3.6-Plus series
    *   Qwen3.5-Plus series
*   Qwen Flash:
    *   Qwen3.7-Flash series
    *   Qwen3.6-Flash series
    *   Qwen3.5-Flash series
*   Qwen3.6 Open Source Series (excluding qwen3.6-27b)
*   Qwen3.5 Open Source Series

Note: The documentation specifies that MCP is only supported via the Responses API (client.responses.create) and not the standard Chat Completions API.

[Token Usage] Input: 20583, Output: 1638, Total: 22221
```

## Streaming output <span id="rsw2f3g4h5i6j7" /> <span id="rsv1e2f3g4h5i6" />

MCP tool calls may involve multiple interactions with external services. Enable streaming for real-time intermediate results.

<CodeGroup dropdown>
  ```python expandable
  import os
  from openai import OpenAI

  client = OpenAI(
      # If no environment variable, use: api_key="sk-xxx" (not recommended).
      api_key=os.getenv("DASHSCOPE_API_KEY"),
      # The following URL is for the Singapore region. Replace {WorkspaceId} with your actual workspace ID. URLs vary by region.
      base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1"
  )

  # Replace server_url with the SSE Endpoint that you got from a platform such as ModelScope
  # If authentication is required, add the token from the corresponding platform to the headers
  mcp_tool = {
      "type": "mcp",
      "server_protocol": "sse",
      "server_label": "fetch",
      "server_description": "Fetch MCP Server that provides web scraping capabilities. It can scrape the content of a specified URL and return it as text.",
      "server_url": "https://mcp.api-inference.modelscope.net/xxx/sse",
  }

  stream = client.responses.create(
      model="qwen3.8-max",
      input="https://news.aibase.com/news, what is the AI news today?",
      tools=[mcp_tool],
      stream=True
  )

  for event in stream:
      # The model response starts
      if event.type == "response.content_part.added":
          print("[Model Response]")
      # Streaming text output
      elif event.type == "response.output_text.delta":
          print(event.delta, end="", flush=True)
      # The response is complete, output the usage
      elif event.type == "response.completed":
          usage = event.response.usage
          print(f"\n\n[Token Usage] Input: {usage.input_tokens}, Output: {usage.output_tokens}, Total: {usage.total_tokens}")
  ```

  ```javascript expandable
  import OpenAI from "openai";
  import process from 'process';

  const openai = new OpenAI({
      // If no environment variable, use: apiKey: "sk-xxx" (not recommended).
      apiKey: process.env.DASHSCOPE_API_KEY,
      // The following URL is for the Singapore region. Replace {WorkspaceId} with your actual workspace ID. URLs vary by region.
      baseURL: "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1"
  });

  async function main() {
      // Replace server_url with the SSE Endpoint that you got from a platform such as ModelScope
      // If authentication is required, add the token from the corresponding platform to the headers
      const mcpTool = {
          type: "mcp",
          server_protocol: "sse",
          server_label: "fetch",
          server_description": "Fetch MCP Server that provides web scraping capabilities. It can scrape the content of a specified URL and return it as text.",
          server_url": "https://mcp.api-inference.modelscope.net/xxx/sse",
      };

      const stream = await openai.responses.create({
          model: "qwen3.8-max",
          input: "https://news.aibase.com/news, what is the AI news today?",
          tools: [mcpTool],
          stream: true
      });

      for await (const event of stream) {
          // The model response starts
          if (event.type === "response.content_part.added") {
              console.log("[Model Response]");
          }
          // Streaming text output
          else if (event.type === "response.output_text.delta") {
              process.stdout.write(event.delta);
          }
          // The response is complete, output the usage
          else if (event.type === "response.completed") {
              const usage = event.response.usage;
              console.log(`\n\n[Token Usage] Input: ${usage.input_tokens}, Output: ${usage.output_tokens}, Total: ${usage.total_tokens}`);
          }
      }
  }

  main();
  ```

  ```java expandable
  // The Bailian MCP tool requires the server_protocol field, which the official OpenAI Java SDK's
  // Tool.Mcp does not yet expose. Add it via putAdditionalProperty. JDK 8+ / Spring Boot 2.x compatible.
  // Maven dependency: com.openai:openai-java:4.67.0 (or later)
  import com.openai.client.OpenAIClient;
  import com.openai.client.okhttp.OpenAIOkHttpClient;
  import com.openai.core.JsonValue;
  import com.openai.core.http.StreamResponse;
  import com.openai.models.responses.*;

  public class McpResponsesStreamDemo {
      public static void main(String[] args) {
          // If no environment variable is set, replace the line below with: apiKey = "sk-xxx" (not recommended)
          String apiKey = System.getenv("DASHSCOPE_API_KEY");
          // The following URL is for the Singapore region. Replace {WorkspaceId} with your actual workspace ID. URLs vary by region.
          OpenAIClient client = OpenAIOkHttpClient.builder()
                  .apiKey(apiKey)
                  .baseUrl("https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1")
                  .build();

          // Replace server_url with the SSE Endpoint that you got from a platform such as ModelScope
          // If authentication is required, add the token from the corresponding platform to the headers
          Tool mcpTool = Tool.ofMcp(Tool.Mcp.builder()
                  .serverLabel("fetch")
                  .serverDescription("Fetch MCP Server that provides web scraping capabilities. It can scrape the content of a specified URL and return it as text.")
                  .serverUrl("https://mcp.api-inference.modelscope.net/xxx/sse")
                  .putAdditionalProperty("server_protocol", JsonValue.from("sse"))
                  .build());

          ResponseCreateParams params = ResponseCreateParams.builder()
                  .model("qwen3.8-max")
                  .input("https://news.aibase.com/news, what is the AI news today?")
                  .addTool(mcpTool)
                  .build();

          // Call the Responses API (streaming output)
          System.out.println("[Model Response]");
          try (StreamResponse<ResponseStreamEvent> stream = client.responses().createStreaming(params)) {
              stream.stream().forEach(event -> {
                  // Streaming text output
                  event.outputTextDelta().ifPresent(delta -> {
                      System.out.print(delta.delta());
                      System.out.flush();
                  });
                  // Response completed, print usage
                  if (event.isCompleted()) {
                      event.completed().ifPresent(completed ->
                              completed.response().usage().ifPresent(u ->
                                      System.out.println("\n\n[Token Usage] Input: " + u.inputTokens()
                                              + ", Output: " + u.outputTokens()
                                              + ", Total: " + u.totalTokens())));
                  }
              });
          }
      }
  }
  ```

  ```bash
  # Replace server_url with the SSE Endpoint that you got from a platform such as ModelScope
  # If authentication is required, add the token from the corresponding platform to the headers
  # The following URL is for the Singapore region. Replace {WorkspaceId} with your actual workspace ID. URLs vary by region.
  curl -X POST https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1/responses \
  -H "Authorization: Bearer $DASHSCOPE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
      "model": "qwen3.8-max",
      "input": "https://news.aibase.com/news, what is the AI news today?",
      "tools": [
          {
              "type": "mcp",
              "server_protocol": "sse",
              "server_label": "fetch",
              "server_description": "Fetch MCP Server that provides web scraping capabilities. It can scrape the content of a specified URL and return it as text.",
              "server_url": "https://mcp.api-inference.modelscope.net/xxx/sse"
          }
      ],
      "stream": true
  }'
  ```
</CodeGroup>

After you run the code, the following response is returned:

```plaintext
[Model Response]
Based on the documentation page for MCP on Alibaba Cloud Model Studio, the following models are supported:

*   Qwen Max Series: Qwen3.8-Max series and Qwen3.7-Max series
*   Qwen Plus Series: Qwen3.7-Plus series, Qwen3.6-Plus series and Qwen3.5-Plus series
*   Qwen Flash Series: Qwen3.7-Flash series, Qwen3.6-Flash series and Qwen3.5-Flash series
*   Qwen3.6 Open Source Series (excluding qwen3.6-27b)
*   Qwen3.5 Open Source Series

Note: These models support MCP functionality only via the Responses API.

[Token Usage] Input: 20472, Output: 945, Total: 21417
```

## Parameters <span id="rsh3q4r5s6t7u8" /> <span id="rsg2p3q4r5s6t7" />

The `mcp` tool supports the following parameters:

<table style={{ display: "table", tableLayout: "fixed", width: "100%" }}>
  <colgroup>
    <col style={{ width: "50%" }} />

    <col style={{ width: "50%" }} />
  </colgroup>

  <tbody>
    <tr>
      <td>
        <table style={{ display: "table", tableLayout: "fixed", width: "100%" }}><colgroup><col style={{ width: "33.29%" }} /><col style={{ width: "33.29%" }} /><col style={{ width: "33.42%" }} /></colgroup><thead><tr><th><p><strong>Parameter</strong></p></th><th><p><strong>Required</strong></p></th><th><p><strong>Description</strong></p></th></tr></thead><tbody><tr><td><p><code>type</code></p></td><td><p>Yes</p></td><td><p>Set to <code>"mcp"</code>.</p></td></tr><tr><td><p><code>server\_protocol</code></p></td><td><p>Yes</p></td><td><p>The communication protocol with the MCP server. Currently, only <code>"sse"</code> is supported.</p></td></tr><tr><td><p><code>server\_label</code></p></td><td><p>Yes</p></td><td><p>The label name of the MCP server, used to identify the service.</p></td></tr><tr><td><p><code>server\_description</code></p></td><td><p>No</p></td><td><p>A description of the MCP server's features. This helps the model understand the service's capabilities and scenarios. Filling in this parameter is recommended to improve the accuracy of model calls.</p></td></tr><tr><td><p><code>server\_url</code></p></td><td><p>Yes</p></td><td><p>The endpoint URL of the MCP server.</p></td></tr><tr><td><p><code>headers</code></p></td><td><p>No</p></td><td><p>The request headers to include when connecting to the MCP server, such as authentication information like <code>Authorization</code>.</p></td></tr></tbody></table>
      </td>

      <td>
        Example:

        ```json
        {
            "type": "mcp",
            "server_protocol": "sse",
            "server_label": "fetch",
            "server_description": "Fetch MCP Server that provides web scraping capabilities. It can scrape the content of a specified URL and return it as text.",
            "server_url": "https://mcp.api-inference.modelscope.net/xxx/sse"
        }
        ```
      </td>
    </tr>
  </tbody>
</table>

## Billing <span id="rvb5k6l7m8n9o0" /> <span id="rva4j5k6l7m8n9" />

Billing includes:

- <strong>Model inference fees:</strong> Billed based on the model's token usage.
- <strong>MCP server fees:</strong> Subject to the billing rules of each MCP server.