GLM 5.2 Embeddings：用 Zhipu API 生成文本向量

如果你正在用 GLM 5.2 构建检索增强生成（RAG）系统或语义搜索功能，几乎立刻会冒出一个问题：GLM 5.2 本身能生成文本嵌入（embedding）吗，还是需要单独的模型？

简短的回答是：GLM 5.2（模型名：glm-4-plus）是文本生成模型，不是嵌入模型。不过，GLM 5.2 背后的公司 Zhipu AI 在同一 API 平台上还提供了两款专用嵌入模型：embedding-2 和 embedding-3。它们共用同一个 API key 和 base URL，所以你只需要一个账号、一份客户端配置，就能搭建一条完整集成的流水线。

本教程带你走完全部流程：两款嵌入模型的区别、各自的使用时机，以及如何用 OpenAI Python SDK 把它们与 GLM 5.2 组装成一条可运行的 RAG 流水线。

痛点：GLM 5.2 不生成嵌入

许多开发者看到 GLM 5.2 亮眼的基准成绩——GPQA Diamond 89%、SWE-bench Pro 62.1%、1M token 上下文窗口——就想当然地以为它能端到端处理整个 RAG 技术栈。它不能，而且这是有意为之。为生成而优化的 LLM，其训练方式与为生成文本稠密向量表示而优化的模型完全不同。

如果你向 glm-4-plus 端点发送标准的嵌入请求，API 会返回错误。大多数前沿生成模型都是如此：OpenAI 的 GPT-4o 不生成嵌入，你需要 text-embedding-3-small 或 text-embedding-3-large。Zhipu 遵循同样的模式。

好消息是，Zhipu 的嵌入模型就在同一个平台上。不需要再注册一个账号，不需要安装单独的 SDK，也不需要不同的鉴权流程。一旦你有了 GLM 5.2 的 Zhipu API key，就自动获得了 embedding-2 和 embedding-3 的访问权。

Zhipu 嵌入模型一览

Zhipu 目前在生成模型之外提供两款嵌入模型：

模型	维度	最大输入 token	价格（约）
`embedding-2`	1,024	512	~$0.0005 / 1K tokens
`embedding-3`	2,048	8,192	~$0.0007 / 1K tokens

embedding-2 是更轻量的选项。每篇文档 512 token 的上限意味着它很适合短文本——产品描述、FAQ 条目、用户评论或代码注释。1,024 维的输出向量紧凑，存储与查询都很高效。

embedding-3 是严肃 RAG 工作负载的更好选择。8,192 token 的输入上限意味着大多数文档、长文或代码文件都能在单次调用中完成嵌入，无需激进切分。2,048 维输出能捕捉更多语义细节，通常在稠密语料上带来更好的检索精度。

对大多数生产流水线而言，embedding-3 搭配 GLM 5.2 是 Zhipu 平台上的推荐组合。

为什么这种集成效果很好

统一平台的做法是真正的差异化优势。如果你从 Hugging Face 使用 GLM 5.2——那里以 MIT 协议提供——就需要自托管或另找嵌入服务商。那意味着第二个 API key、第二个计费账号，以及每次查询在嵌入环节上的额外网络延迟。

使用 Zhipu 的托管 API，嵌入调用和生成调用共用同一个 base URL（https://open.bigmodel.cn/api/paas/v4/）和同一个 API key。你的基础设施更简单，调试面更小，账单也更集中。

想深入了解 GLM 5.2 的生成能力——包括函数调用、JSON 模式和视觉输入——可以看 glm5.app 上的 GLM 5.2 API 指南。本教程专注嵌入一侧。

如果你想在写任何代码之前先交互式地体验完整流水线，glm5.app 提供了 GLM 5.2 的浏览器界面，无需任何配置。

环境准备

安装 OpenAI Python SDK（1.x 或更高版本）。Zhipu 的 API 兼容 OpenAI，所以不需要 Zhipu 专用包：

pip install openai

把你的 Zhipu API key 导出为环境变量：

export ZHIPU_API_KEY="your_zhipu_api_key_here"

用 embedding-3 生成嵌入

下面的示例用 embedding-3 对一组文档块做嵌入：

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["ZHIPU_API_KEY"],
    base_url="https://open.bigmodel.cn/api/paas/v4/",
)

documents = [
    "GLM 5.2 is a 753-billion-parameter mixture-of-experts model from Zhipu AI.",
    "The model supports a context window of up to one million tokens.",
    "Zhipu's embedding-3 model produces 2048-dimensional vectors.",
    "RAG pipelines combine a retriever with a generative language model.",
]

response = client.embeddings.create(
    model="embedding-3",
    input=documents,
)

# Each embedding is a list of 2048 floats
for i, item in enumerate(response.data):
    print(f"Document {i}: {len(item.embedding)} dimensions")

response.data 列表与 input 的顺序一一对应，所以 response.data[0].embedding 就是 documents[0] 的向量。每个向量都是普通的 Python 浮点数列表——可以直接插入任何向量数据库。

构建最小 RAG 流水线

完整的 RAG 系统分两个阶段：索引（为文档生成嵌入并存储向量）和查询（为用户问题生成嵌入、检索最相近的文档，再用 GLM 5.2 生成答案）。

下面的示例使用内存存储加余弦相似度做演示。生产环境中，你应该用 Pinecone、Qdrant、Weaviate 或 pgvector 等向量数据库替换内存索引。

import os
import math
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["ZHIPU_API_KEY"],
    base_url="https://open.bigmodel.cn/api/paas/v4/",
)

# ── INDEXING PHASE ─────────────────────────────────────────────────────────────

corpus = [
    "GLM 5.2 uses a mixture-of-experts architecture with 753B total parameters "
    "and 40B active parameters per forward pass.",
    "The Zhipu API is OpenAI-compatible. You can use the openai Python SDK by "
    "setting base_url to https://open.bigmodel.cn/api/paas/v4/.",
    "GLM 5.2 achieved 89% on the GPQA Diamond benchmark and 62.1% on SWE-bench Pro.",
    "Zhipu's embedding-3 model supports up to 8192 tokens per document and "
    "produces 2048-dimensional vectors.",
    "GLM-4-Air is a lightweight Zhipu model priced at approximately $0.0001 per "
    "1000 tokens, suitable for high-volume low-complexity tasks.",
]

def embed(texts: list[str]) -> list[list[float]]:
    resp = client.embeddings.create(model="embedding-3", input=texts)
    return [item.embedding for item in resp.data]

def cosine_similarity(a: list[float], b: list[float]) -> float:
    dot = sum(x * y for x, y in zip(a, b))
    norm_a = math.sqrt(sum(x ** 2 for x in a))
    norm_b = math.sqrt(sum(y ** 2 for y in b))
    return dot / (norm_a * norm_b) if norm_a and norm_b else 0.0

# Build the index
corpus_embeddings = embed(corpus)

# ── QUERYING PHASE ─────────────────────────────────────────────────────────────

def retrieve(query: str, top_k: int = 2) -> list[str]:
    """Return the top-k most relevant corpus chunks for a query."""
    query_embedding = embed([query])[0]
    scores = [
        (cosine_similarity(query_embedding, doc_emb), doc)
        for doc_emb, doc in zip(corpus_embeddings, corpus)
    ]
    scores.sort(key=lambda x: x[0], reverse=True)
    return [doc for _, doc in scores[:top_k]]

def rag_answer(question: str) -> str:
    """Retrieve context, then generate an answer with GLM 5.2."""
    context_chunks = retrieve(question)
    context = "\n\n".join(context_chunks)

    messages = [
        {
            "role": "system",
            "content": (
                "You are a helpful assistant. Answer the user's question using "
                "only the provided context. If the context does not contain "
                "enough information, say so."
            ),
        },
        {
            "role": "user",
            "content": f"Context:\n{context}\n\nQuestion: {question}",
        },
    ]

    completion = client.chat.completions.create(
        model="glm-4-plus",
        messages=messages,
        temperature=0.2,
    )
    return completion.choices[0].message.content

# Try it
question = "What benchmark scores did GLM 5.2 achieve?"
print(rag_answer(question))

这个示例清晰地展示了核心模式：