cómo conectarse a mcp usando la api de qwen - Alibaba Cloud Model Studio

El Protocolo de Contexto de Modelo (MCP) permite a los modelos de lenguaje grandes utilizar herramientas y datos externos. Este tema describe cómo conectarse a MCP mediante la API de Responses.

Uso

Agregue la información del servidor MCP en el parámetro tools cuando utilice la API de Responses.

Obtenga el endpoint de Server-Sent Events (SSE) y la información de autenticación para el servicio MCP desde plataformas como ModelScope.

Admite servidores MCP que utilizan el protocolo SSE.

Máximo de 10 servidores MCP.

# 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)

Modelos admitidos

Qwen-Max: serie Qwen3.8-Max, serie Qwen3.7-Max
Qwen-Plus: serie Qwen3.7-Plus, serie Qwen3.6-Plus, serie Qwen3.5-Plus
Qwen-Flash: serie Qwen3.7-Flash, serie Qwen3.6-Flash, serie Qwen3.5-Flash
Serie de código abierto Qwen3.8
Serie de código abierto Qwen3.6 (excepto qwen3.6-27b)
Serie de código abierto Qwen3.5

Disponible únicamente a través de la API de Responses.

Introducción

Este ejemplo utiliza el servicio MCP Fetch web scraping de ModelScope. Puede obtener el Endpoint SSE y la información de autenticación del servicio en la sección Service configuration a la derecha.

Obtenga una clave de API y configúrela como variable de entorno.

Reemplace server_url con el endpoint SSE de la plataforma de servicios MCP. Reemplace la autenticación en headers con el token proporcionado por dicha plataforma.

python

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

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

// 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"
        }
    ]
}'

Después de ejecutar el código, se devuelve la siguiente respuesta:

[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

Salida por secuencias

Las llamadas a herramientas MCP pueden implicar múltiples interacciones con servicios externos. Habilite la transmisión por secuencias para obtener resultados intermedios en tiempo real.

python

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

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

// 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
}'

Después de ejecutar el código, se devuelve la siguiente respuesta:

[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

Parámetros

La herramienta mcp admite los siguientes parámetros:

Parámetro	Obligatorio	Descripción
`type`	Sí	Establecido en `"mcp"`.
`server_protocol`	Sí	El protocolo de comunicación con el servidor MCP. Actualmente, solo se admite `"sse"`.
`server_label`	Sí	El nombre de etiqueta del servidor MCP, utilizado para identificar el servicio.
`server_description`	No	Una descripción de las funciones del servidor MCP. Esto ayuda al modelo a comprender las capacidades y los escenarios del servicio. Se recomienda completar este parámetro para mejorar la precisión de las llamadas al modelo.
`server_url`	Sí	La URL del endpoint del servidor MCP.
`headers`	No	Los encabezados de solicitud que se deben incluir al conectarse al servidor MCP, como información de autenticación tipo `Authorization`.

Ejemplo:

{
    "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"
}

Facturación

La facturación incluye:

Tarifas de inferencia del modelo: Se facturan según el uso de tokens del modelo.
Tarifas del servidor MCP: Sujetas a las reglas de facturación de cada servidor MCP.