> 原始 Markdown 孪生体（构建期从源 Markdown 生成）。渲染页：https://docs.gatellm.io/zh-CN/sdk/vendor-sdks · 文档索引：https://docs.gatellm.io/zh-CN/llms.txt


# 官方厂商 SDK

官方 SDK 是各厂商的「母语」入口。经网关用它们，与直连厂商唯一的区别就是 [通用三步](/zh-CN/sdk/index.md#three-steps)：改 base_url、换访问密钥、填网关模型名。本节按厂商给 Python 与 Node 双语示例，覆盖语言、图像、向量、语音等能力（实时在 [实时会话与语音](/zh-CN/sdk/realtime-and-audio.md) 单列）。

> 示例里的模型名是某套网关配置下的真实名字，实际以你的控制台为准。密钥统一用占位符 `<你的访问密钥>`。

## OpenAI SDK {#openai}

```bash
pip install openai            # Python
npm i openai                  # Node
```

base_url 指到 `/v1`。Python 与 Node 都能调语言、图像、向量、语音；rerank 端点（`/v1/rerank`）官方 SDK 暂无对应方法，用 HTTP 直调。

**语言（Chat Completions）**：

::: code-group

```python [Python]
from openai import OpenAI

client = OpenAI(base_url="http://localhost:7890/v1", api_key="<你的访问密钥>")

resp = client.chat.completions.create(
    model="gpt-5.4-mini",
    messages=[{"role": "user", "content": "用一句话介绍你自己"}],
)
print(resp.choices[0].message.content)
```

```ts [TypeScript]
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "http://localhost:7890/v1",
  apiKey: "<你的访问密钥>",
});

const resp = await client.chat.completions.create({
  model: "gpt-5.4-mini",
  messages: [{ role: "user", content: "用一句话介绍你自己" }],
});
console.log(resp.choices[0].message.content);
```

:::

**Responses API**（上游模型为 `openai_response` 协议时也可用）：

::: code-group

```python [Python]
resp = client.responses.create(
    model="gpt-5.6-sol",
    input="用一句话介绍你自己",
    max_output_tokens=64,
)
print(resp.output_text)
```

```ts [TypeScript]
const resp = await client.responses.create({
  model: "gpt-5.6-sol",
  input: "用一句话介绍你自己",
  max_output_tokens: 64,
});
console.log(resp.output_text);
```

:::

> **跨协议字段会被翻译、并受目标协议约束**：若你网关里 `gpt-5.6-sol` 的上游是 Responses 协议，用 Chat Completions 客户端传 `max_tokens` 时，网关会把它译成 `max_output_tokens`，而上游可能要求该值不低于某个下限（例如 ≥16），传太小会 400。直接用 Responses 客户端（上例）则字段原样对齐。

**流式**（Chat Completions）：

```python
stream = client.chat.completions.create(
    model="gpt-5.4-mini",
    messages=[{"role": "user", "content": "数到 5"}],
    stream=True,
)
for chunk in stream:
    delta = chunk.choices[0].delta.content
    if delta:
        print(delta, end="")
```

**工具调用**：

```python
tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "查询城市天气",
        "parameters": {
            "type": "object",
            "properties": {"city": {"type": "string"}},
            "required": ["city"],
        },
    },
}]
resp = client.chat.completions.create(
    model="gpt-5.4-mini",
    messages=[{"role": "user", "content": "北京天气怎么样？"}],
    tools=tools,
)
print(resp.choices[0].message.tool_calls)
```

**向量**：

```python
r = client.embeddings.create(
    model="text-embedding-3-small",
    input=["你好", "世界"],
)
print(len(r.data[0].embedding))  # 向量维度
```

**图像生成**：

```python
img = client.images.generate(
    model="gpt-image-2",
    prompt="一只在代码海洋里游泳的猫，赛博朋克风",
    size="1024x1024",
)
print(img.data[0].url)
```

**语音转写（ASR）**：

```python
audio = open("speech.mp3", "rb")
t = client.audio.transcriptions.create(model="whisper-1", file=audio)
print(t.text)
```

**文本转语音（TTS）**：

```python
speech = client.audio.speech.create(model="tts-1", voice="alloy", input="你好，世界")
speech.write_to_file("out.mp3")
```

**重排（rerank，HTTP 直调）**：

```python
import requests

r = requests.post(
    "http://localhost:7890/v1/rerank",
    headers={"Authorization": "Bearer <你的访问密钥>"},
    json={"model": "bge-m3-reranker", "query": "猫", "documents": ["一只猫", "一辆车"]},
)
print([res["relevance_score"] for res in r.json()["results"]])
```

## Anthropic SDK {#anthropic}

```bash
pip install anthropic          # Python
npm i @anthropic-ai/sdk        # Node
```

base_url 指到**根**（SDK 自动拼 `/v1/messages`）。Anthropic 是语言类协议，支持图像**输入理解**，无图像/视频生成与实时会话端点。

::: code-group

```python [Python]
import anthropic

client = anthropic.Anthropic(base_url="http://localhost:7890", api_key="<你的访问密钥>")

msg = client.messages.create(
    model="claude-haiku-4-5",
    max_tokens=256,
    messages=[{"role": "user", "content": "用一句话介绍你自己"}],
)
# content 是数组；Claude 思考模型可能先返回 type=="thinking" 再返回 type=="text"
text = "".join(b.text for b in msg.content if b.type == "text")
print(text)
```

```ts [TypeScript]
import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic({
  baseURL: "http://localhost:7890",
  apiKey: "<你的访问密钥>",
});

const msg = await client.messages.create({
  model: "claude-haiku-4-5",
  max_tokens: 256,
  messages: [{ role: "user", content: "用一句话介绍你自己" }],
});
const text = msg.content.filter((b) => b.type === "text").map((b) => b.text).join("");
console.log(text);
```

:::

> **思考块**：Claude 的思考模型（如 `claude-opus-5`、`claude-sonnet-5`）可能先返回一个 `type == "thinking"` 的内容块，再返回 `type == "text"`。取正文时按 `type` 过滤，别假设 `content[0]` 一定是文本。

> 经协议互译，这个 SDK 也能调非 Claude 模型——`model` 填网关里配的任意模型名即可，见 [协议互通矩阵](/zh-CN/reference/protocol-matrix.md)。

## Google GenAI SDK {#google}

```bash
pip install google-genai        # Python
npm i @google/genai             # Node
```

base_url 指到**根**，经 `http_options.base_url`（不是参数里的 `base_url`）。

::: code-group

```python [Python]
from google import genai

client = genai.Client(
    api_key="<你的访问密钥>",
    http_options={"base_url": "http://localhost:7890"},
)

resp = client.models.generate_content(
    model="gemini-3.5-flash",
    contents="用一句话介绍你自己",
)
print(resp.text)
```

```ts [TypeScript]
import { GoogleGenAI } from "@google/genai";

const client = new GoogleGenAI({
  apiKey: "<你的访问密钥>",
  httpOptions: { baseUrl: "http://localhost:7890" },
});

const resp = await client.models.generateContent({
  model: "gemini-3.5-flash",
  contents: "用一句话介绍你自己",
});
console.log(resp.text);
```

:::

**图像生成**（`generateContent` 内联图像输出，与 `openai_images` 互译）：

```python
from google.genai import types

resp = client.models.generate_content(
    model="gemini-3.1-flash-image",
    contents="画一只在代码海洋里游泳的猫，赛博朋克风",
    config=types.GenerateContentConfig(response_modalities=["IMAGE", "TEXT"]),
)
for part in resp.candidates[0].content.parts:
    if part.inline_data:
        with open("cat.png", "wb") as f:
            f.write(part.inline_data.data)
```

## OpenAI 兼容第三方 {#openai-compatible}

DeepSeek、Moonshot Kimi、智谱 GLM、xAI Grok、MiniMax、字节豆包、Groq、Together、Mistral、Cohere、OpenRouter、Azure OpenAI、Cerebras，以及 vLLM / Ollama 等自托管服务，都提供 **OpenAI 兼容端点**——客户端侧**原样用 OpenAI SDK**，只改 base_url 与 `model`。

```python
from openai import OpenAI

client = OpenAI(base_url="http://localhost:7890/v1", api_key="<你的访问密钥>")

# model 填网关里配的第三方模型名
resp = client.chat.completions.create(
    model="deepseek-v4-pro",   # 换成 glm-5.2 / kimi-k3 / grok-4.5 等
    messages=[{"role": "user", "content": "用一句话介绍你自己"}],
)
print(resp.choices[0].message.content)
```

差异只在「上游真实端点」：这些供应商的上游仍是它们自己的 OpenAI 兼容地址，网关在中间做翻译或透传。对你（客户端）来说，代码与调 OpenAI 完全一致。各供应商能开的能力（图像/向量/重排等）取决于上游自身，见 [支持的供应商与模型](/zh-CN/reference/supported-models-and-sdks.md)。

| 供应商 | 示例模型名（网关配置） | 说明 |
|--------|----------------------|------|
| DeepSeek | `deepseek-v4-pro` / `deepseek-v4-flash` | 纯文本/代码 |
| 智谱 GLM | `glm-5.2` / `glm-5.1` | 纯文本 |
| Moonshot Kimi | `kimi-k3` / `kimi-k2.7-code` | 文本/代码 |
| xAI Grok | `grok-4.5` | 纯文本 |
| Azure OpenAI | 你的部署名 | base_url 换成 `https://<resource>.openai.azure.com`，网关侧走 `openai` 兼容 |

## AWS Bedrock（上游侧协议） {#bedrock}

Bedrock **不是客户端协议**——网关不暴露 Bedrock 形态的客户端端点。想调 Bedrock 托管的模型，客户端用 OpenAI / Anthropic / Gemini 等 SDK，经协议互译访问；或经 `/v3/{model}/{*rest}` 透传。详见 [端点 · 关于 AWS Bedrock 与透传](/zh-CN/reference/endpoints.md#aws-bedrock-passthrough) 与 [接入 AWS Bedrock 上游](/zh-CN/quickstart/aws-bedrock.md)。

## 下一步 {#next}

- 前端 / Next.js 统一 SDK：看 [统一 SDK 与网关层](/zh-CN/sdk/unified-sdks.md)。
- 实时语音会话：看 [实时会话与语音](/zh-CN/sdk/realtime-and-audio.md)。
- DashScope 原生 SDK 与异步视频：看 [DashScope 原生与异步任务](/zh-CN/sdk/dashscope-native.md)。