如何用 Python 调用 GLM 5.2 API：完整集成指南

pip install openai

python -m venv glm-env
source glm-env/bin/activate   # Windows: glm-env\Scripts\activate
pip install openai

python -c "import openai; print(openai.__version__)"

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_ZAI_KEY",          # replace with your Z.ai API key
    base_url="https://api.z.ai/v1",  # GLM 5.2 endpoint
)

response = client.chat.completions.create(
    model="glm-5.2",
    messages=[
        {"role": "user", "content": "Explain the Mixture of Experts architecture in two sentences."}
    ],
)

print(response.choices[0].message.content)

python glm_hello.py

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_ZAI_KEY",
    base_url="https://api.z.ai/v1",
)

response = client.chat.completions.create(
    model="glm-5.2",
    messages=[
        {
            "role": "system",
            "content": (
                "You are a senior Python engineer. "
                "Always respond with production-quality code and include error handling. "
                "Add type hints and docstrings to every function."
            ),
        },
        {
            "role": "user",
            "content": "Write a function that retries an HTTP request up to 3 times with exponential backoff.",
        },
    ],
)

print(response.choices[0].message.content)

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_ZAI_KEY",
    base_url="https://api.z.ai/v1",
)

stream = client.chat.completions.create(
    model="glm-5.2",
    messages=[
        {"role": "user", "content": "Write a 500-word essay on the history of transformer models."}
    ],
    stream=True,
)

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

print()  # newline after streaming finishes

full_response = ""
for chunk in stream:
    delta = chunk.choices[0].delta
    if delta.content:
        full_response += delta.content
        print(delta.content, end="", flush=True)
print()
print(f"\nTotal characters: {len(full_response)}")

import json
from openai import OpenAI

client = OpenAI(
    api_key="YOUR_ZAI_KEY",
    base_url="https://api.z.ai/v1",
)

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get the current weather for a given city.",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "The city name, e.g. Tokyo",
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                        "description": "Temperature unit",
                    },
                },
                "required": ["city"],
            },
        },
    }
]

messages = [
    {"role": "user", "content": "What is the weather like in Tokyo right now?"}
]

response = client.chat.completions.create(
    model="glm-5.2",
    messages=messages,
    tools=tools,
    tool_choice="auto",
)

choice = response.choices[0]
if choice.finish_reason == "tool_calls":
    tool_call = choice.message.tool_calls[0]
    function_name = tool_call.function.name
    arguments = json.loads(tool_call.function.arguments)
    print(f"Model wants to call: {function_name}")
    print(f"Arguments: {arguments}")

    # In production, call your actual function here:
    # result = get_weather(**arguments)
    # Then add the result back to messages and call the API again.

from openai import OpenAI
import json

client = OpenAI(
    api_key="YOUR_ZAI_KEY",
    base_url="https://api.z.ai/v1",
)

response = client.chat.completions.create(
    model="glm-5.2",
    messages=[
        {
            "role": "system",
            "content": "You always respond with valid JSON.",
        },
        {
            "role": "user",
            "content": (
                "Return a JSON object with fields: "
                "model_name (string), parameter_count (string), "
                "speed_tps (number), context_tokens (number)."
            ),
        },
    ],
    response_format={"type": "json_object"},
)

data = json.loads(response.choices[0].message.content)
print(json.dumps(data, indent=2))

import asyncio
from openai import AsyncOpenAI

client = AsyncOpenAI(
    api_key="YOUR_ZAI_KEY",
    base_url="https://api.z.ai/v1",
)

async def summarize(text: str) -> str:
    response = await client.chat.completions.create(
        model="glm-5.2",
        messages=[
            {"role": "system", "content": "Summarize the following text in one paragraph."},
            {"role": "user", "content": text},
        ],
    )
    return response.choices[0].message.content

async def main():
    texts = [
        "Mixture of Experts (MoE) is an architecture where only a subset of parameters...",
        "The attention mechanism in transformers computes queries, keys, and values...",
        "Reinforcement learning from human feedback (RLHF) fine-tunes language models...",
    ]
    # Run all three requests concurrently
    results = await asyncio.gather(*[summarize(t) for t in texts])
    for i, result in enumerate(results):
        print(f"Summary {i + 1}: {result}\n")

asyncio.run(main())

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_OPENROUTER_KEY",
    base_url="https://openrouter.ai/api/v1",
)

response = client.chat.completions.create(
    model="z-ai/glm-5.2",   # note the OpenRouter model identifier
    messages=[
        {"role": "user", "content": "What is 158 tokens per second in practical terms?"}
    ],
)

print(response.choices[0].message.content)