Criar uma resposta

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