curl http://localhost:8000/v1/chat/completions \
    -H "Content-Type: application/json" \
    -d '{
        "model": "qwen-7b",
        "messages": [
            {"role": "system", "content": "你是一个有用的助手。"},
            {"role": "user", "content": "什么是深度学习？"}
        ],
        "max_tokens": 300,
        "temperature": 0.7
    }'

{
    "id": "chatcmpl-abc123",
    "object": "chat.completion",
    "created": 1700000000,
    "model": "qwen-7b",
    "choices": [
        {
            "index": 0,
            "message": {
                "role": "assistant",
                "content": "深度学习是机器学习的一个子领域..."
            },
            "logprobs": null,
            "finish_reason": "stop"
        }
    ],
    "usage": {
        "prompt_tokens": 25,
        "completion_tokens": 156,
        "total_tokens": 181
    }
}

# multi_turn.py
"""多轮对话示例"""

from openai import OpenAI

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

# 维护对话历史
conversation = [
    {"role": "system", "content": "你是一个 Python 编程专家。"}
]

def chat(user_input: str) -> str:
    conversation.append({"role": "user", "content": user_input})
    
    response = client.chat.completions.create(
        model="qwen-7b",
        messages=conversation,
        max_tokens=500,
        temperature=0.7,
    )
    
    assistant_msg = response.choices[0].message.content
    conversation.append({"role": "assistant", "content": assistant_msg})
    
    return assistant_msg

# 多轮对话
print(chat("如何在 Python 中读取 CSV 文件？"))
print(chat("如果文件很大，有什么优化方法？"))
print(chat("能给出一个完整的代码示例吗？"))

# function_calling.py
"""Function Calling 示例"""

from openai import OpenAI

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

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "获取指定城市的天气信息",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "城市名称，如 '北京'",
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                        "description": "温度单位",
                    },
                },
                "required": ["city"],
            },
        },
    }
]

response = client.chat.completions.create(
    model="qwen-7b",
    messages=[
        {"role": "user", "content": "北京今天天气怎么样？"}
    ],
    tools=tools,
    tool_choice="auto",
)

print(response.choices[0].message)

# json_mode.py
"""结构化 JSON 输出"""

from openai import OpenAI

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

response = client.chat.completions.create(
    model="qwen-7b",
    messages=[
        {"role": "system", "content": "你是一个 JSON 输出助手。请始终以 JSON 格式回复。"},
        {"role": "user", "content": "列出3种常见的排序算法及其时间复杂度"},
    ],
    response_format={"type": "json_object"},
    max_tokens=500,
    temperature=0.3,
)

print(response.choices[0].message.content)
# 输出合法的 JSON 字符串

curl http://localhost:8000/v1/completions \
    -H "Content-Type: application/json" \
    -d '{
        "model": "qwen-7b",
        "prompt": "The meaning of life is",
        "max_tokens": 100,
        "temperature": 0.7
    }'

# completions_example.py
from openai import OpenAI

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

# 单条请求
response = client.completions.create(
    model="qwen-7b",
    prompt="def quicksort(arr):\n",
    max_tokens=200,
    temperature=0.2,
    stop=["\n\ndef"],  # 遇到下一个函数定义时停止
)
print(response.choices[0].text)

# 批量请求
response = client.completions.create(
    model="qwen-7b",
    prompt=["How to learn Python?", "How to learn Rust?"],
    max_tokens=100,
    temperature=0.5,
)
for choice in response.choices:
    print(f"[{choice.index}]: {choice.text[:100]}")

# cURL 流式请求
curl http://localhost:8000/v1/chat/completions \
    -H "Content-Type: application/json" \
    -d '{
        "model": "qwen-7b",
        "messages": [{"role": "user", "content": "写一首诗"}],
        "max_tokens": 200,
        "stream": true
    }'

# stream_example.py
"""流式输出完整示例"""

from openai import OpenAI

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

def stream_chat(prompt: str):
    """流式 Chat 输出"""
    stream = client.chat.completions.create(
        model="qwen-7b",
        messages=[{"role": "user", "content": prompt}],
        max_tokens=500,
        temperature=0.7,
        stream=True,
        stream_options={"include_usage": True},  # 包含用量统计
    )
    
    for chunk in stream:
        if chunk.choices and len(chunk.choices) > 0:
            delta = chunk.choices[0].delta
            if delta.content:
                print(delta.content, end="", flush=True)
            
            # 检查完成原因
            if chunk.choices[0].finish_reason:
                print(f"\n[完成原因: {chunk.choices[0].finish_reason}]")
        
        # 最后一个 chunk 包含 usage 信息
        if chunk.usage:
            print(f"[用量: prompt={chunk.usage.prompt_tokens}, "
                  f"completion={chunk.usage.completion_tokens}]")

stream_chat("解释量子纠缠的概念")

# async_stream.py
"""异步流式输出"""

import asyncio
from openai import AsyncOpenAI

async def stream_chat_async(prompt: str):
    client = AsyncOpenAI(
        base_url="http://localhost:8000/v1",
        api_key="none",
    )
    
    stream = await client.chat.completions.create(
        model="qwen-7b",
        messages=[{"role": "user", "content": prompt}],
        max_tokens=300,
        stream=True,
    )
    
    async for chunk in stream:
        if chunk.choices and chunk.choices[0].delta.content:
            print(chunk.choices[0].delta.content, end="", flush=True)
    print()

# 并发多个流式请求
async def main():
    tasks = [
        stream_chat_async("什么是机器学习？"),
        stream_chat_async("什么是深度学习？"),
        stream_chat_async("什么是强化学习？"),
    ]
    await asyncio.gather(*tasks)

asyncio.run(main())

# embeddings.py
"""文本向量化示例"""

from openai import OpenAI

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

# 启动服务时加载 embedding 模型
# vllm serve BAAI/bge-base-zh-v1.5 --task embedding

response = client.embeddings.create(
    model="bge-base-zh",
    input=["什么是人工智能？", "机器学习的基本概念"],
)

for i, embedding in enumerate(response.data):
    print(f"文本 {i}: 维度={len(embedding.embedding)}, "
          f"前5个值={embedding.embedding[:5]}")

# concurrent_requests.py
"""并发请求示例"""

import time
import concurrent.futures
from openai import OpenAI

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

def send_request(prompt: str) -> dict:
    """发送单个请求"""
    start = time.time()
    response = client.chat.completions.create(
        model="qwen-7b",
        messages=[{"role": "user", "content": prompt}],
        max_tokens=100,
        temperature=0.7,
    )
    elapsed = time.time() - start
    return {
        "prompt": prompt[:30],
        "response": response.choices[0].message.content[:50],
        "tokens": response.usage.completion_tokens,
        "time": elapsed,
    }

# 并发 20 个请求
prompts = [f"用一句话解释概念 {i}" for i in range(20)]

start = time.time()
with concurrent.futures.ThreadPoolExecutor(max_workers=10) as executor:
    results = list(executor.map(send_request, prompts))
total_time = time.time() - start

# 统计
total_tokens = sum(r["tokens"] for r in results)
print(f"总耗时: {total_time:.2f}s")
print(f"总 tokens: {total_tokens}")
print(f"吞吐量: {total_tokens / total_time:.1f} tokens/s")

# async_concurrent.py
"""异步并发请求"""

import asyncio
import time
from openai import AsyncOpenAI

async def main():
    client = AsyncOpenAI(
        base_url="http://localhost:8000/v1",
        api_key="none",
    )
    
    async def send_request(prompt: str):
        response = await client.chat.completions.create(
            model="qwen-7b",
            messages=[{"role": "user", "content": prompt}],
            max_tokens=100,
        )
        return response.usage.completion_tokens
    
    prompts = [f"用一句话解释概念 {i}" for i in range(50)]
    
    start = time.time()
    tasks = [send_request(p) for p in prompts]
    results = await asyncio.gather(*tasks)
    total_time = time.time() - start
    
    print(f"50 个请求并发完成，总耗时: {total_time:.2f}s")
    print(f"总 tokens: {sum(results)}")
    print(f"吞吐量: {sum(results) / total_time:.1f} tokens/s")

asyncio.run(main())

vllm serve Qwen/Qwen2.5-7B-Instruct \
    --host 0.0.0.0 \
    --port 8000 \
    --served-model-name qwen-7b \
    --max-model-len 8192 \
    --gpu-memory-utilization 0.9 \
    --tensor-parallel-size 1 \
    --dtype auto \
    --seed 42 \
    --enable-prefix-caching \
    --disable-log-requests \
    --max-num-seqs 256 \
    --max-num-batched-tokens 8192

# 实例 1：通用模型
vllm serve Qwen/Qwen2.5-7B-Instruct \
    --port 8000 \
    --served-model-name qwen-7b

# 实例 2：代码模型
vllm serve Qwen/Qwen2.5-Coder-7B-Instruct \
    --port 8001 \
    --served-model-name qwen-coder

# 实例 3：数学模型
vllm serve Qwen/Qwen2.5-Math-7B-Instruct \
    --port 8002 \
    --served-model-name qwen-math

# /etc/nginx/conf.d/vllm.conf
upstream vllm_cluster {
    server 127.0.0.1:8000 weight=1;
    server 127.0.0.1:8001 weight=1;
    server 127.0.0.1:8002 weight=1;
}

server {
    listen 80;
    server_name llm.example.com;

    location /v1/ {
        proxy_pass http://vllm_cluster/v1/;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        
        # 流式输出必需
        proxy_buffering off;
        proxy_cache off;
        
        # 超时设置（LLM 生成可能较慢）
        proxy_read_timeout 300s;
        proxy_send_timeout 300s;
    }
}

# 启动时设置 API Key
# vllm serve model --api-key YOUR_SECRET_KEY

# 带 API Key 的请求
curl http://localhost:8000/v1/chat/completions \
    -H "Authorization: Bearer YOUR_SECRET_KEY" \
    -H "Content-Type: application/json" \
    -d '{"model": "qwen-7b", "messages": [{"role": "user", "content": "Hello"}]}'

# Python 客户端
client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="YOUR_SECRET_KEY",
)

# 允许跨域访问（开发环境）
vllm serve model --allowed-origins '["*"]'

# error_handling.py
"""API 错误处理示例"""

from openai import OpenAI, APIError, RateLimitError, APITimeoutError
import time

client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="none",
    timeout=60.0,
    max_retries=3,
)

def call_with_retry(prompt: str, max_attempts: int = 3) -> str:
    for attempt in range(max_attempts):
        try:
            response = client.chat.completions.create(
                model="qwen-7b",
                messages=[{"role": "user", "content": prompt}],
                max_tokens=200,
            )
            return response.choices[0].message.content
        
        except RateLimitError:
            wait = 2 ** attempt
            print(f"请求限流，等待 {wait}s 后重试...")
            time.sleep(wait)
        
        except APITimeoutError:
            print(f"请求超时，第 {attempt + 1} 次重试...")
        
        except APIError as e:
            print(f"API 错误: {e}")
            if attempt == max_attempts - 1:
                raise
    
    raise Exception("超过最大重试次数")

# 根据请求内容路由到不同模型
def route_request(prompt: str, model_type: str):
    if model_type == "code":
        return call_vllm("http://coder:8000/v1", prompt)
    elif model_type == "chat":
        return call_vllm("http://chat:8000/v1", prompt)
    else:
        return call_vllm("http://general:8000/v1", prompt)