Alibaba Cloud Model Studio:Criar uma resposta

import os
    from openai import OpenAI

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

    response = client.responses.create(
        model="qwen3.8-max",
        input="What can you do?"
    )

    # Get the model's response
    print(response.output_text)

import OpenAI from "openai";

    const openai = new OpenAI({
        // If the environment variable is not set, replace with: apiKey: "sk-xxx"
        apiKey: process.env.DASHSCOPE_API_KEY,
        // 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() {
        const response = await openai.responses.create({
            model: "qwen3.8-max",
            input: "What can you do?"
        });

        // Get the model's response
        console.log(response.output_text);
    }

    main();

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": "What can you do?"
    }'

import os
    from openai import OpenAI

    client = OpenAI(
        api_key=os.getenv("DASHSCOPE_API_KEY"),
        # Replace {WorkspaceId} with your actual workspace ID. URLs vary by region.
        base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1",
    )

    stream = client.responses.create(
        model="qwen3.8-max",
        input="Briefly introduce artificial intelligence.",
        stream=True
    )

    print("Receiving stream output:")
    for event in stream:
        if event.type == 'response.output_text.delta':
            print(event.delta, end='', flush=True)
        elif event.type == 'response.completed':
            print("\nStream completed")
            print(f"Total tokens: {event.response.usage.total_tokens}")

import OpenAI from "openai";

    const openai = new OpenAI({
        apiKey: process.env.DASHSCOPE_API_KEY,
        // 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() {
        const stream = await openai.responses.create({
            model: "qwen3.8-max",
            input: "Briefly introduce artificial intelligence.",
            stream: true
        });

        console.log("Receiving stream output:");
        for await (const event of stream) {
            if (event.type === 'response.output_text.delta') {
                process.stdout.write(event.delta);
            } else if (event.type === 'response.completed') {
                console.log("\nStream completed");
                console.log(`Total tokens: ${event.response.usage.total_tokens}`);
            }
        }
    }

    main();

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" \
    --no-buffer \
    -d '{
        "model": "qwen3.8-max",
        "input": "Briefly introduce artificial intelligence.",
        "stream": true
    }'

import os
    from openai import OpenAI

    client = OpenAI(
        api_key=os.getenv("DASHSCOPE_API_KEY"),
        # Replace {WorkspaceId} with your actual workspace ID. URLs vary by region.
        base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1",
    )

    # First turn
    response1 = client.responses.create(
        model="qwen3.8-max",
        input="My name is John. Please remember it."
    )
    print(f"First response: {response1.output_text}")

    # Second turn - use previous_response_id to link context. The response ID is valid for 7 days.
    response2 = client.responses.create(
        model="qwen3.8-max",
        input="Do you remember my name?",
        previous_response_id=response1.id
    )
    print(f"Second response: {response2.output_text}")

import OpenAI from "openai";

    const openai = new OpenAI({
        apiKey: process.env.DASHSCOPE_API_KEY,
        // 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() {
        // First turn
        const response1 = await openai.responses.create({
            model: "qwen3.8-max",
            input: "My name is John. Please remember it."
        });
        console.log(`First response: ${response1.output_text}`);

        // Second turn - use previous_response_id to link context. The response ID is valid for 7 days.
        const response2 = await openai.responses.create({
            model: "qwen3.8-max",
            input: "Do you remember my name?",
            previous_response_id: response1.id
        });
        console.log(`Second response: ${response2.output_text}`);
    }

    main();

import os
    from openai import OpenAI

    client = OpenAI(
        api_key=os.getenv("DASHSCOPE_API_KEY"),
        # Replace {WorkspaceId} with your actual workspace ID. URLs vary by region.
        base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1",
    )

    response = client.responses.create(
        model="qwen3.8-max",
        input="Find the Alibaba Cloud official website and extract key information from its homepage.",
        # For best results, we recommend enabling the built-in tools.
        tools=[
            {"type": "web_search"},
            {"type": "code_interpreter"},
            {"type": "web_extractor"}
        ],
    )

    # Uncomment the following line to view the intermediate output.
    # print(response.output)
    print(response.output_text)

import OpenAI from "openai";

    const openai = new OpenAI({
        apiKey: process.env.DASHSCOPE_API_KEY,
        // 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() {
        const response = await openai.responses.create({
            model: "qwen3.8-max",
            input: "Find the Alibaba Cloud official website and extract key information from its homepage.",
            tools: [
                { type: "web_search" },
                { type: "code_interpreter" },
                { type: "web_extractor" }
            ]
        });

        for (const item of response.output) {
            if (item.type === "reasoning") {
                console.log("Model is thinking...");
            } else if (item.type === "web_search_call") {
                console.log(`Search query: ${item.action.query}`);
            } else if (item.type === "web_extractor_call") {
                console.log("Extracting web content...");
            } else if (item.type === "message") {
                console.log(`Response content: ${item.content[0].text}`);
            }
        }
    }

    main();

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": "Find the Alibaba Cloud official website and extract key information from its homepage.",
        "tools": [
            {
                "type": "web_search"
            },
            {
                "type": "code_interpreter"
            },
            {
                "type": "web_extractor"
            }
        ]
    }'

from openai import OpenAI
    import json
    import os
    import random

    # Initialize the client.
    client = OpenAI(
        # If the environment variable is not set, replace with: api_key="sk-xxx"
        api_key=os.getenv("DASHSCOPE_API_KEY"),
        # Replace {WorkspaceId} with your actual workspace ID. URLs vary by region.
        base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1",
    )
    # Simulate a user question.
    USER_QUESTION = "What's the weather like in Beijing?"
    # Define the list of tools.
    tools = [
        {
            "type": "function",
            "name": "get_current_weather",
            "description": "Useful for getting the weather in a specific city.",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "The city or district, such as Beijing or Hangzhou.",
                    }
                },
                "required": ["location"],
            },
        }
    ]

    # Simulate the weather query tool.
    def get_current_weather(arguments):
        weather_conditions = ["sunny", "cloudy", "rainy"]
        random_weather = random.choice(weather_conditions)
        location = arguments["location"]
        return f"Today in {location} it is {random_weather}."

    # Wrap the model response function.
    def get_response(input_data):
        response = client.responses.create(
            model="qwen3.8-max",
            input=input_data,
            tools=tools,
        )
        return response

    # Maintain the conversation context.
    conversation = [{"role": "user", "content": USER_QUESTION}]

    response = get_response(conversation)
    function_calls = [item for item in response.output if item.type == "function_call"]
    # If no tool call is needed, output the content directly.
    if not function_calls:
        print(f"Final assistant response: {response.output_text}")
    else:
        # Enter the tool-calling loop.
        while function_calls:
            for fc in function_calls:
                func_name = fc.name
                arguments = json.loads(fc.arguments)
                print(f"Calling tool [{func_name}] with arguments: {arguments}")
                # Execute the tool.
                tool_result = get_current_weather(arguments)
                print(f"Tool returned: {tool_result}")
                # Append the tool call and its result to the context as a pair.
                conversation.append(
                    {
                        "type": "function_call",
                        "name": fc.name,
                        "arguments": fc.arguments,
                        "call_id": fc.call_id,
                    }
                )
                conversation.append(
                    {
                        "type": "function_call_output",
                        "call_id": fc.call_id,
                        "output": tool_result,
                    }
                )
            # Call the model again with the full context.
            response = get_response(conversation)
            function_calls = [
                item for item in response.output if item.type == "function_call"
            ]
        print(f"Final assistant response: {response.output_text}")

import OpenAI from "openai";

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

    // Define the list of tools.
    const tools = [
      {
        type: "function",
        name: "get_current_weather",
        description: "Useful for getting the weather in a specific city.",
        parameters: {
          type: "object",
          properties: {
            location: {
              type: "string",
              description: "The city or district, such as Beijing or Hangzhou.",
            },
          },
          required: ["location"],
        },
      },
    ];

    // Simulate the weather query tool.
    const getCurrentWeather = (args) => {
      const weatherConditions = ["sunny", "cloudy", "rainy"];
      const randomWeather =
        weatherConditions[Math.floor(Math.random() * weatherConditions.length)];
      const location = args.location;
      return `Today in ${location} it is ${randomWeather}.`;
    };

    // Wrap the model response function.
    const getResponse = async (inputData) => {
      const response = await openai.responses.create({
        model: "qwen3.8-max",
        input: inputData,
        tools: tools,
      });
      return response;
    };

    const main = async () => {
      const userQuestion = "What's the weather like in Beijing?";

      // Maintain the conversation context.
      const conversation = [{ role: "user", content: userQuestion }];

      let response = await getResponse(conversation);
      let functionCalls = response.output.filter(
        (item) => item.type === "function_call"
      );
      // If no tool call is needed, output the content directly.
      if (functionCalls.length === 0) {
        console.log(`Final assistant response: ${response.output_text}`);
      } else {
        // Enter the tool-calling loop.
        while (functionCalls.length > 0) {
          for (const fc of functionCalls) {
            const funcName = fc.name;
            const args = JSON.parse(fc.arguments);
            console.log(`Calling tool [${funcName}] with arguments:`, args);
            // Execute the tool.
            const toolResult = getCurrentWeather(args);
            console.log(`Tool returned: ${toolResult}`);
            // Append the tool call and its result to the context as a pair.
            conversation.push({
              type: "function_call",
              name: fc.name,
              arguments: fc.arguments,
              call_id: fc.call_id,
            });
            conversation.push({
              type: "function_call_output",
              call_id: fc.call_id,
              output: toolResult,
            });
          }
          // Call the model again with the full context.
          response = await getResponse(conversation);
          functionCalls = response.output.filter(
            (item) => item.type === "function_call"
          );
        }
        console.log(`Final assistant response: ${response.output_text}`);
      }
    };

    // Start the program.
    main().catch(console.error);

import os
from openai import OpenAI

client = OpenAI(
    # If you have not configured an environment variable, replace the next line with: api_key="sk-xxx"
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url="https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1",
)

response = client.responses.create(
    model="qwen3.5-ocr",
    input=[
        {
            "role": "user",
            "content": [
                {
                    "type": "input_file",
                    "file_url": "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20260616/qmycjl/1506.02640v5.pdf",
                },
                {
                    "type": "input_text",
                    "text": "Read all the text in the file.",
                },
            ],
        }
    ],
    extra_body={
        "ocr_options": {"task": "document_parsing"}
    },
)

print(response.output_text)

import OpenAI from 'openai';

const client = new OpenAI({
    // If you have not configured an environment variable, replace the next line with: apiKey: "sk-xxx"
    apiKey: process.env.DASHSCOPE_API_KEY,
    baseURL: "https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1",
});

async function main() {
    const response = await client.responses.create({
        model: "qwen3.5-ocr",
        input: [{
            role: "user",
            content: [{
                type: "input_file",
                file_url: "https://example.com/your-document.pdf"
            }]
        }],
        ocr_options: { task: "document_parsing" }
    });

    // Get the custom task result
    console.log(response.output[0].content[0].ocr_result);
}

main();

curl -X POST https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1/responses \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
    "model": "qwen3.5-ocr",
    "input": [
        {
            "role": "user",
            "content": [
                {
                    "type": "input_file",
                    "file_url": "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20260616/qmycjl/1506.02640v5.pdf"
                },
                {
                    "type": "input_text",
                    "text": "Read all the text in the file."
                }
            ]
        }
    ],
    "ocr_options": {"task": "document_parsing"}
}'

import os
    from openai import OpenAI

    client = OpenAI(
        api_key=os.getenv("DASHSCOPE_API_KEY"),
        # Replace {WorkspaceId} with your actual workspace ID. URLs vary by region.
        base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1",
        # Enable the session cache via default_headers.
        default_headers={"x-dashscope-session-cache": "enable"}
    )

    # Construct a long text over 1024 tokens to trigger cache creation.
    # If not, caching is triggered when the cumulative context exceeds 1024 tokens.
    long_context = "Artificial intelligence (AI) is a major branch of computer science, dedicated to researching and developing theories, methods, technologies, and application systems that can simulate, extend, and expand human intelligence." * 50

    # First turn
    response1 = client.responses.create(
        model="qwen3.8-max",
        input=long_context + "\n\nBased on this context, briefly introduce the Random Forest algorithm in machine learning.",
    )
    print(f"First response: {response1.output_text}")

    # Second turn: Link context using previous_response_id. The cache is handled automatically by the server.
    response2 = client.responses.create(
        model="qwen3.8-max",
        input="What are the main differences between it and GBDT?",
        extra_body={"previous_response_id": response1.id}
    )
    print(f"Second response: {response2.output_text}")

    # Check the cache hit status.
    usage = response2.usage
    print(f"Input tokens: {usage.input_tokens}")
    print(f"Cached tokens: {usage.prompt_tokens_details.cached_tokens}")

import OpenAI from "openai";

    const openai = new OpenAI({
        apiKey: process.env.DASHSCOPE_API_KEY,
        // Replace {WorkspaceId} with your actual workspace ID. URLs vary by region.
        baseURL: "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1",
        // Enable the session cache via defaultHeaders.
        defaultHeaders: {"x-dashscope-session-cache": "enable"}
    });

    // Construct a long text over 1024 tokens to trigger cache creation.
    // If not, caching is triggered when the cumulative context exceeds 1024 tokens.
    const longContext = "Artificial intelligence (AI) is a major branch of computer science, dedicated to researching and developing theories, methods, technologies, and application systems that can simulate, extend, and expand human intelligence.".repeat(50);

    async function main() {
        // First turn
        const response1 = await openai.responses.create({
            model: "qwen3.8-max",
            input: longContext + "\n\nBased on this context, briefly introduce the Random Forest algorithm in machine learning, including its basic principles and applications."
        });
        console.log(`First response: ${response1.output_text}`);

        // Second turn: Link context using previous_response_id. The cache is handled automatically by the server.
        const response2 = await openai.responses.create({
            model: "qwen3.8-max",
            input: "What are the main differences between it and GBDT?",
            extra_body: { previous_response_id: response1.id }
        } as any);
        console.log(`Second response: ${response2.output_text}`);

        // Check the cache hit status.
        console.log(`Input tokens: ${response2.usage.input_tokens}`);
        console.log(`Cached tokens: ${response2.usage.prompt_tokens_details.cached_tokens}`);
    }

    main();

# First turn
    # Repeat the long text 50 times to ensure it exceeds 1024 tokens and triggers cache creation.
    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" \
    -H "x-dashscope-session-cache: enable" \
    -d '{
        "model": "qwen3.8-max",
        "input": "Artificial intelligence (AI) is a major branch of computer science..."
    }'

    # Second turn - use the ID from the previous response as previous_response_id.
    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" \
    -H "x-dashscope-session-cache: enable" \
    -d '{
        "model": "qwen3.8-max",
        "input": "What are the main differences between it and GBDT?",
        "previous_response_id": ""
    }'