Achievement: Qwen2.5-Coder-32B beats GPT-4o on all coding benchmarks with only 32B parameters — the first open-source model to reach this level.

Supported Programming Languages

• Tier 1 (92%+ pass rate): Python, JavaScript, TypeScript, Java, C++, Go
• Tier 2 (80–92%): Rust, Swift, Kotlin, C#, PHP, SQL
• Tier 3 (65–80%): Shell, Lua, R, Julia

3. Multilingual Capabilities: Vietnamese and Chinese

Multilingual Benchmark

Why Qwen Leads for Vietnamese

1. 151K token vocabulary: Tokenizes Vietnamese efficiently with fewer splits → fewer tokens → cheaper and faster
2. Diverse training data: High-quality Vietnamese text from Wikipedia, news, forums
3. Multilingual instruction tuning: Fine-tuned with Vietnamese prompts and responses
4. Natural language switching: Automatically responds in the user's language without special system prompts

Demo: Vietnamese with Qwen

from openai import OpenAI

client = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")

# Qwen automatically responds in Vietnamese when prompted in Vietnamese
response = client.chat.completions.create(
    model="qwen2.5:72b",
    messages=[{
        "role": "user",
        "content": "Explain the Dijkstra algorithm in Vietnamese and write a Python illustration."
    }],
    temperature=0.3
)
print(response.choices[0].message.content)

4. Ollama Deployment

# Common models
ollama pull qwen2.5:7b      # ~5GB — RTX 3060 12GB
ollama pull qwen2.5:14b     # ~9GB — RTX 4080/3090
ollama pull qwen2.5:32b     # ~20GB — 2× RTX 3090 or A100 40GB
ollama pull qwen2.5:72b     # ~45GB — 2× A100 40GB

# Code specialist
ollama pull qwen2.5-coder:32b

# Increase context (Ollama defaults to 2K)
cat > Qwen-Modelfile << 'EOF'
FROM qwen2.5:72b
PARAMETER num_ctx 32768
PARAMETER temperature 0.7
PARAMETER top_p 0.9
SYSTEM "You are a helpful AI assistant. Respond in the same language as the user."
EOF
ollama create qwen25-72b-32k -f Qwen-Modelfile

5. vLLM Production Deployment

# Single H100 80GB — run 72B FP16
python -m vllm.entrypoints.openai.api_server \
  --model Qwen/Qwen2.5-72B-Instruct \
  --tensor-parallel-size 1 \
  --gpu-memory-utilization 0.92 \
  --max-model-len 32768 \
  --dtype bfloat16 \
  --port 8000

# 2× A100 40GB — Tensor Parallel
python -m vllm.entrypoints.openai.api_server \
  --model Qwen/Qwen2.5-72B-Instruct \
  --tensor-parallel-size 2 \
  --max-model-len 65536 \
  --port 8000

# Coder model for code assistant
python -m vllm.entrypoints.openai.api_server \
  --model Qwen/Qwen2.5-Coder-32B-Instruct \
  --tensor-parallel-size 1 \
  --max-model-len 32768 \
  --port 8001

6. Building AI Agent Workflows: ReAct Pattern

Qwen 2.5 excels at agentic tasks — following complex instructions, calling tools, and maintaining context across many steps.

ReAct Agent

import json
from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="qwen")

tools = [
    {
        "type": "function",
        "function": {
            "name": "search_web",
            "description": "Search for information on the web",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {"type": "string"}
                },
                "required": ["query"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "execute_python",
            "description": "Execute Python code and return the result",
            "parameters": {
                "type": "object",
                "properties": {
                    "code": {"type": "string"}
                },
                "required": ["code"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "read_file",
            "description": "Read file contents",
            "parameters": {
                "type": "object",
                "properties": {
                    "path": {"type": "string"}
                },
                "required": ["path"]
            }
        }
    }
]

def run_agent(user_task: str, max_steps: int = 10) -> str:
    messages = [
        {
            "role": "system",
            "content": "You are an AI agent with tool access. Complete tasks by calling appropriate tools step by step."
        },
        {"role": "user", "content": user_task}
    ]

    for step in range(max_steps):
        response = client.chat.completions.create(
            model="qwen2.5-72b-instruct",
            messages=messages,
            tools=tools,
            tool_choice="auto",
            temperature=0.1  # Low temperature for stable agent behavior
        )

        msg = response.choices[0].message
        messages.append(msg)

        # Agent finishes when it stops calling tools
        if not msg.tool_calls:
            return msg.content

        # Execute tool calls
        for tool_call in msg.tool_calls:
            result = execute_tool(
                tool_call.function.name,
                json.loads(tool_call.function.arguments)
            )
            messages.append({
                "role": "tool",
                "tool_call_id": tool_call.id,
                "content": str(result)
            })

    return "Max steps reached"

def execute_tool(name: str, args: dict) -> str:
    if name == "search_web":
        # Integrate with Tavily, SerpAPI, etc.
        return f"[Search results for: {args['query']}]"
    elif name == "execute_python":
        import subprocess
        result = subprocess.run(
            ["python3", "-c", args["code"]],
            capture_output=True, text=True, timeout=30
        )
        return result.stdout or result.stderr
    elif name == "read_file":
        with open(args["path"]) as f:
            return f.read()
    return "Tool not found"

# Example usage
result = run_agent(
    "Analyze the sales_data.csv file and create a report with monthly revenue metrics."
)
print(result)

7. Multi-Agent Pipeline

from openai import OpenAI

class QwenAgent:
    def __init__(self, name: str, system_prompt: str, model: str = "qwen2.5:72b"):
        self.name = name
        self.system_prompt = system_prompt
        self.client = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")
        self.model = model

    def run(self, task: str, context: str = "") -> str:
        messages = [
            {"role": "system", "content": self.system_prompt},
            {"role": "user", "content": f"Context:\n{context}\n\nTask: {task}"}
        ]
        response = self.client.chat.completions.create(
            model=self.model,
            messages=messages,
            temperature=0.3
        )
        return response.choices[0].message.content

# Define specialized agents
researcher = QwenAgent(
    "Researcher",
    "You are a research specialist. Collect and summarize information about the requested topic."
)
coder = QwenAgent(
    "Coder",
    "You are a senior software engineer. Write clean Python code with tests and documentation.",
    model="qwen2.5-coder:32b"
)
reviewer = QwenAgent(
    "Reviewer",
    "You are a technical reviewer. Evaluate code for performance, security, and best practices."
)

def run_pipeline(task: str) -> dict:
    # Step 1: Research
    research = researcher.run(f"Research and summarize: {task}")

    # Step 2: Code generation
    code = coder.run(
        f"Implement solution for: {task}",
        context=research
    )

    # Step 3: Code review
    review = reviewer.run(
        "Review this code and suggest improvements",
        context=code
    )

    return {"research": research, "code": code, "review": review}

result = run_pipeline("Build a REST API endpoint for Vietnamese sentiment analysis")

8. Structured Output with Pydantic

from pydantic import BaseModel
from typing import List
import json

class TaskBreakdown(BaseModel):
    objective: str
    subtasks: List[str]
    estimated_complexity: str  # "low", "medium", "high"
    dependencies: List[str]
    suggested_tech_stack: List[str]

def analyze_task(description: str) -> TaskBreakdown:
    response = client.chat.completions.create(
        model="qwen2.5:72b",
        messages=[
            {
                "role": "system",
                "content": "You are a technical architect. Analyze tasks and return JSON."
            },
            {
                "role": "user",
                "content": f"""Analyze this task following the TaskBreakdown schema:
Task: {description}

Schema:
{{
  "objective": "string",
  "subtasks": ["string"],
  "estimated_complexity": "low|medium|high",
  "dependencies": ["string"],
  "suggested_tech_stack": ["string"]
}}

Return only pure JSON, no other text."""
            }
        ],
        temperature=0.1,
        response_format={"type": "json_object"}
    )

    data = json.loads(response.choices[0].message.content)
    return TaskBreakdown(**data)

result = analyze_task("Build a RAG-powered customer service chatbot system")
print(f"Complexity: {result.estimated_complexity}")
print(f"Subtasks: {', '.join(result.subtasks)}")

9. Production Code Assistant

class QwenCodeAssistant:
    def __init__(self):
        self.client = OpenAI(
            base_url="http://localhost:8001/v1",  # Coder model port
            api_key="qwen"
        )

    def generate_code(self, spec: str, language: str = "python") -> str:
        response = self.client.chat.completions.create(
            model="qwen2.5-coder-32b-instruct",
            messages=[
                {
                    "role": "system",
                    "content": f"You are an expert {language} developer. Write clean code with docstrings and unit tests."
                },
                {"role": "user", "content": spec}
            ],
            temperature=0.1,
            max_tokens=4096
        )
        return response.choices[0].message.content

    def review_code(self, code: str) -> str:
        response = self.client.chat.completions.create(
            model="qwen2.5-coder-32b-instruct",
            messages=[
                {
                    "role": "system",
                    "content": "Review code and identify: bugs, security issues, performance bottlenecks, style problems."
                },
                {"role": "user", "content": f"```\n{code}\n```"}
            ],
            temperature=0.2
        )
        return response.choices[0].message.content

    def explain_code(self, code: str, audience: str = "junior developer") -> str:
        response = self.client.chat.completions.create(
            model="qwen2.5-coder-32b-instruct",
            messages=[{
                "role": "user",
                "content": f"Explain this code for a {audience}:\n```\n{code}\n```"
            }],
            temperature=0.5
        )
        return response.choices[0].message.content

assistant = QwenCodeAssistant()
code = assistant.generate_code(
    "Write a FastAPI endpoint to upload and analyze CSV files, returning basic statistics"
)
print(code)

10. Qwen 2.5 vs Other Models

11. Model Selection by Use Case

Conclusion

Qwen 2.5 stands out through three core strengths:

1. Coding SOTA: Qwen2.5-Coder-32B is the best open-source model for coding, surpassing GPT-4o on HumanEval (92.7%) and LiveCodeBench
2. Multilingual leader: 151K token vocabulary and diverse training data make Qwen the top choice for Vietnamese and Chinese among self-hosted models
3. Powerful AI agents: Accurate tool calling, stable instruction following, and structured JSON output support — all essential for production agent workflows

For enterprises wanting to self-host the best multilingual model or build production-grade code assistants and AI agents, Qwen 2.5 is the unrivaled choice in the open-source world.