Qwen3.5-Plus API Tutorial: Build AI Agents with OpenAI SDK

# Install: pip install openai

from openai import OpenAI
import os

client = OpenAI(
    api_key=os.environ.get("DASHSCOPE_API_KEY"),
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1"
)

response = client.chat.completions.create(
    model="qwen3.5-plus",
    messages=[
        {
            "role": "system",
            "content": "You are a helpful assistant with expertise in AI and technology."
        },
        {
            "role": "user",
            "content": "Summarize the key improvements in Qwen3.5 compared to previous Qwen versions."
        }
    ],
    max_tokens=1024,
    temperature=0.7
)

print(response.choices[0].message.content)
print(f"Tokens used: {response.usage.total_tokens}")

# Tool calling example: weather lookup agent

import json
from openai import OpenAI

client = OpenAI(
    api_key=os.environ.get("DASHSCOPE_API_KEY"),
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1"
)

# Define available tools
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_current_weather",
            "description": "Get the current weather for a city",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "City name, e.g. Tokyo, New York"
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                        "description": "Temperature unit"
                    }
                },
                "required": ["city"]
            }
        }
    }
]

messages = [
    {"role": "user", "content": "What's the weather in Tokyo and should I bring an umbrella?"}
]

# First call: model decides which tool to use
response = client.chat.completions.create(
    model="qwen3.5-plus",
    messages=messages,
    tools=tools,
    tool_choice="auto"
)

# Check if model wants to call a tool
if response.choices[0].finish_reason == "tool_calls":
    tool_call = response.choices[0].message.tool_calls[0]
    function_args = json.loads(tool_call.function.arguments)
    
    # Execute the actual function
    weather_result = get_weather(function_args["city"])  # your actual function
    
    # Add tool result to conversation
    messages.append(response.choices[0].message)
    messages.append({
        "role": "tool",
        "tool_call_id": tool_call.id,
        "content": json.dumps(weather_result)
    })
    
    # Final response with tool results
    final_response = client.chat.completions.create(
        model="qwen3.5-plus",
        messages=messages
    )
    print(final_response.choices[0].message.content)

# Vision: analyze an image from URL

response = client.chat.completions.create(
    model="qwen3.5-plus",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image_url",
                    "image_url": {
                        "url": "https://example.com/chart.png"
                    }
                },
                {
                    "type": "text",
                    "text": "Analyze this chart and identify the key trends. What business insights can you extract?"
                }
            ]
        }
    ]
)
print(response.choices[0].message.content)

# Streaming response

stream = client.chat.completions.create(
    model="qwen3.5-plus",
    messages=[
        {"role": "user", "content": "Write a detailed analysis of MoE architecture in LLMs"}
    ],
    stream=True  # Enable streaming
)

for chunk in stream:
    if chunk.choices[0].delta.content is not None:
        print(chunk.choices[0].delta.content, end="", flush=True)

print()  # New line after completion

# Complete research agent with Qwen3.5-Plus

from openai import OpenAI
import json, os

client = OpenAI(
    api_key=os.environ["DASHSCOPE_API_KEY"],
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1"
)

# Define research tools
research_tools = [
    {
        "type": "function",
        "function": {
            "name": "web_search",
            "description": "Search the internet for recent information",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {"type": "string", "description": "Search query"},
                    "num_results": {"type": "integer", "default": 5}
                },
                "required": ["query"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "analyze_document",
            "description": "Extract key information from a document URL",
            "parameters": {
                "type": "object",
                "properties": {
                    "url": {"type": "string", "description": "Document or webpage URL"},
                    "focus": {"type": "string", "description": "What to focus on"}
                },
                "required": ["url"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "write_report",
            "description": "Write and save a final research report",
            "parameters": {
                "type": "object",
                "properties": {
                    "title": {"type": "string"},
                    "content": {"type": "string"},
                    "filename": {"type": "string"}
                },
                "required": ["title", "content"]
            }
        }
    }
]

def run_agent(task: str) -> str:
    """Run the research agent with a given task."""
    messages = [
        {
            "role": "system",
            "content": """You are an autonomous research agent. Use the available tools 
            to thoroughly research topics and write comprehensive reports.
            Always search multiple sources before drawing conclusions."""
        },
        {"role": "user", "content": task}
    ]
    
    # Agent loop: continue until task is complete
    max_iterations = 10
    for iteration in range(max_iterations):
        response = client.chat.completions.create(
            model="qwen3.5-plus",
            messages=messages,
            tools=research_tools,
            tool_choice="auto"
        )
        
        message = response.choices[0].message
        
        # Task complete — no more tool calls needed
        if response.choices[0].finish_reason == "stop":
            return message.content
        
        # Process tool calls
        if message.tool_calls:
            messages.append(message)
            
            for tool_call in message.tool_calls:
                func_name = tool_call.function.name
                func_args = json.loads(tool_call.function.arguments)
                
                # Execute appropriate tool
                if func_name == "web_search":
                    result = perform_web_search(func_args["query"])
                elif func_name == "analyze_document":
                    result = analyze_document_url(func_args["url"])
                elif func_name == "write_report":
                    result = save_report(func_args)
                
                messages.append({
                    "role": "tool",
                    "tool_call_id": tool_call.id,
                    "content": json.dumps(result)
                })
    
    return "Agent reached maximum iterations"

# Run the agent
result = run_agent(
    "Research the current state of open-source AI models in 2026, "
    "focusing on Qwen3.5's position in the market, and write a 500-word report."
)
print(result)