推理模式

DeepSeek

DeepSeek 系列模型均为推理模型，且默认开启：

curl https://geekai.co/api/v1/chat/completions \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $GEEKAI_API_KEY" \
-d '{
    "model": "deepseek-flash",
    "messages": [
        {"role": "user", "content": "你好"}
    ],
    "stream": false
}'

# 先安装 OpenAI SDK: `pip3 install openai`

from openai import OpenAI

client = OpenAI(api_key="$GEEKAI_API_KEY", base_url="https://geekai.co/api/v1")

response = client.chat.completions.create(
    model="deepseek-flash",
    messages=[
        {"role": "user", "content": "你好"},
    ],
    stream=False
)

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

// 先安装 OpenAI SDK: `npm install openai`

import OpenAI from "openai";

const openai = new OpenAI({
    baseURL: 'https://geekai.co/api/v1',
    apiKey: '$GEEKAI_API_KEY'
});

async function main() {
    const completion = await openai.chat.completions.create({
        messages: [{role: "user", content: "你好"}],
        model: "deepseek-flash",
    });

    console.log(completion.choices[0].message.content);
    console.log(completion.choices[0].message.reasoning_content);
}

main();

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
)

func main() {
	requestBody := map[string]interface{}{
		"model": "deepseek-flash",
		"messages": []interface{}{
            map[string]interface{}{
                "role": "user", 
                "content": "你好",
            },
        }
	}
	
	jsonData, err := json.Marshal(requestBody)
	if err != nil {
		panic(err)
	}

	client := &http.Client{}
	req, err := http.NewRequest("POST", "https://geekai.co/api/v1/chat/completions", bytes.NewBuffer(jsonData))
	if err != nil {
		panic(err)
	}

	req.Header.Set("Authorization", "Bearer $GEEKAI_API_KEY")
	req.Header.Set("Content-Type", "application/json")

	resp, err := client.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		panic(err)
	}

	fmt.Println(string(body))
}

对于推理模型，可以从 AI 响应内容中通过 reasoning_content 字段读取推理的思考链内容并显示：

{
    "id": "02174473184980118a5d045ccc6bc157c3dd771c8dafe42a7c3c9",
    "created": 1744731857,
    "choices": [
        {
            "index": 0,
            "message": {
                "role": "assistant",
                "content": "\n\n你好！很高兴见到你，有什么我可以帮忙的吗？无论是问题、建议还是闲聊，我都在这里为你服务。😊",
                "reasoning_content": "好，用户发来了“你好”，这是常见的中文问候。我需要用中文回应，保持友好和自然。首先应该回复问候，比如“你好！有什么我可以帮助你的吗？”然后可以加上一句开放式的提问，鼓励用户进一步说明需求。注意不要用太正式的语气，保持亲切。同时检查有没有拼写错误，确保回答正确无误。另外，可能需要考虑用户接下来可能的问题，提前准备好相关的信息。比如，用户可能会问天气、新闻或者需要建议等。但在这个阶段，保持简洁和友好最重要。不需要太长的回复，避免让用户感到信息过载。确认回复符合公司的指导方针，没有涉及敏感内容。然后发送回复即可。\n"
            },
            "finish_reason": "stop"
        }
    ],
    "model": "deepseek-flash",
    "object": "chat.completion",
    "usage": {
        "prompt_tokens": 6,
        "completion_tokens": 169,
        "total_tokens": 175,
        "completion_tokens_details": {
            "reasoning_tokens": 142
        }
    }
}

推理模型通常不支持系统提示以及温度参数，因此在进行 API 调用的时候不要设置这两个参数。对于 DeepSeek 推理模型，还不支持函数调用及JSON输出功能，以及不支持 temperature、top_p、presence_penalty、frequency_penalty、logprobs、top_logprobs 参数。

OpenAI

OpenAI 旗下最新 5 系和 6 系均为推理模型，默认开启，且支持通过 thinking.reasoning_effort 设置推理的努力程度，可选值有：

none（GPT-5.1 开始支持）：关闭思考模式，GPT-6 Astra 不支持该配置值，适用于那些对延迟要求极高的任务，不适合使用任何推理机制或多链调用工具，如语音识别、快速检索和分类任务场景。
low：适用于需要工具使用、计划制定、搜索或多步决策的场景，同时还能优化速度和成本效益的场景，如数据分析、文档编写、面向执行的编码工作，以及客户支持/聊天助手相关的工作流程。
medium：当质量和可靠性变得重要时，任务就涉及到规划、复杂的推理以及判断。适用于代理式编码、研究工作、处理电子表格和幻灯片，以及分配长期性的工作任务。
high：适用于需要严谨的推理、复杂的调试工作、深入的计划制定，以及那些对质量和智能有高要求的任务，如代理式编码、长期规划的研究以及知识型工作。根据任务的复杂程度，需要同时考虑 medium 和 high 这两个方面。
xhigh：适用于需要深入的研究、异步工作流程以及需要长时间运行的任务，如安全检查和代码审查、企业生产力提升、更深入的研究任务，以及复杂的编码工作流程处理。
max：对于最复杂的任务，请使用最合理的推理方法。如果您目前正在使用 xhigh ，那么请评估 max 是否能够实现更出色的性能提升。

默认为 medium（GPT 5.1 默认 none，即不开启推理）。

curl --location --request POST 'https://geekai.co/api/v1/chat/completions' \
--header 'Authorization: Bearer $GEEKAI_API_KEY' \
--header 'Content-Type: application/json' \
--data-raw '{
    "model": "gpt-6-astra",
    "messages": [
        {
            "role": "user",
            "content": "你好"
        }
    ],
    "thinking": {
        "reasoning_effort": "high"
    },
    "stream": true
}'

# 先安装 OpenAI SDK: `pip3 install openai`

from openai import OpenAI

client = OpenAI(api_key="$GEEKAI_API_KEY", base_url="https://geekai.co/api/v1")

response = client.chat.completions.create(
    model="gpt-6-astra",
    messages=[
        {"role": "user", "content": "你好"},
    ],
    stream=False
)

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

// 先安装 OpenAI SDK: `npm install openai`

import OpenAI from "openai";

const openai = new OpenAI({
    baseURL: 'https://geekai.co/api/v1',
    apiKey: '$GEEKAI_API_KEY'
});

async function main() {
    const completion = await openai.chat.completions.create({
        messages: [{role: "user", content: "你好"}],
        model: "gpt-6-astra",
    });

    console.log(completion.choices[0].message.content);
    console.log(completion.choices[0].message.reasoning_content);
}

main();

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
)

func main() {
	requestBody := map[string]interface{}{
		"model": "gpt-6-astra",
		"messages": []interface{}{
            map[string]interface{}{
                "role": "user", 
                "content": "你好",
            },
        }
	}
	
	jsonData, err := json.Marshal(requestBody)
	if err != nil {
		panic(err)
	}

	client := &http.Client{}
	req, err := http.NewRequest("POST", "https://geekai.co/api/v1/chat/completions", bytes.NewBuffer(jsonData))
	if err != nil {
		panic(err)
	}

	req.Header.Set("Authorization", "Bearer $GEEKAI_API_KEY")
	req.Header.Set("Content-Type", "application/json")

	resp, err := client.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		panic(err)
	}

	fmt.Println(string(body))
}

OpenAI 推理的思考链内容默认通过 <think> 和 </think> 标签包裹，并且和 AI 响应内容混在一起，这在流式响应中很难提取，为了降低开发者兼容成本，极客智坊所有推理模型思考链内容均兼容 DeepSeek 推理模型，都是从 AI 响应内容的 reasoning_content 字段获取（如果没有思考链，则对应字段值为空）。

关于 thinking 配置的更多细节，请参考 API 手册说明。

Claude

目前最新的 Claude 4 系和 5 系模型均支持推理模式，支持推理模式的 Cluade 模型都是混合推理模型，需要通过设置 thinking.type 配置项开启/关闭：

enabled：开启推理模式（仅 Claude 4.5 系列及以下模型支持，Claude 4.6 及以上版本不再支持，传递该值会返回 400 错误）
disabled：关闭推理模式（Claude Fable 系列模型不支持该配置值）
adaptive：根据请求自行决定何时思考以及思考的深度，Claude 4.6 及以上版本模型支持该配置值，并且是默认值。

当 thinking.type 设置为 enabled 时，可以通过 thinking.budget_tokens 配置用于思考的 tokens 预算：

curl --location --request POST 'https://geekai.co/api/v1/messages' \
--header 'Authorization: Bearer $GEEKAI_API_KEY"' \
--header 'Content-Type: application/json' \
--data-raw '{
    "model": "claude-sonnet-5",
    "messages": [
        {
            "role": "user",
            "content": "你好"
        }
    ],
    "thinking": {
		"type":"enabled",
        "budget_tokens": 10000
    },
	"max_tokens": 16000,
    "stream": true
}'

# 先安装 OpenAI SDK: `pip3 install openai`

from openai import OpenAI

client = OpenAI(api_key="$GEEKAI_API_KEY", base_url="https://geekai.co/api/v1")

response = client.chat.completions.create(
    model="claude-sonnet-5",
    messages=[
        {"role": "user", "content": "你好"},
    ],
    stream=False
)

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

// 先安装 OpenAI SDK: `npm install openai`

import OpenAI from "openai";

const openai = new OpenAI({
    baseURL: 'https://geekai.co/api/v1',
    apiKey: '$GEEKAI_API_KEY'
});

async function main() {
    const completion = await openai.chat.completions.create({
        messages: [{role: "user", content: "你好"}],
        model: "claude-sonnet-5",
    });

    console.log(completion.choices[0].message.content);
    console.log(completion.choices[0].message.reasoning_content);
}

main();

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
)

func main() {
	requestBody := map[string]interface{}{
		"model": "claude-sonnet-5",
		"messages": []interface{}{
            map[string]interface{}{
                "role": "user", 
                "content": "你好",
            },
        }
	}
	
	jsonData, err := json.Marshal(requestBody)
	if err != nil {
		panic(err)
	}

	client := &http.Client{}
	req, err := http.NewRequest("POST", "https://geekai.co/api/v1/chat/completions", bytes.NewBuffer(jsonData))
	if err != nil {
		panic(err)
	}

	req.Header.Set("Authorization", "Bearer $GEEKAI_API_KEY")
	req.Header.Set("Content-Type", "application/json")

	resp, err := client.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		panic(err)
	}

	fmt.Println(string(body))
}

如果请求设置了 max_tokens，则 budget_tokens 的值不能超过 max_tokens 的值。Claude 开启推理模式后不支持 temperature、top_p、top_k 参数设置。对于 Claude 4.6 以上版本，可以通过 output_config.effort 参数控制 Claude 在整个响应中投入多少工作量，在自适应思考模式下，这包括它思考的频率和深度：

curl --location --request POST 'https://geekai.co/api/v1/messages' \
--header 'Authorization: Bearer $GEEKAI_API_KEY"' \
--header 'Content-Type: application/json' \
--data-raw '{
    "model": "claude-opus-5",
    "max_tokens": 4096,
    "messages": [{
      "role": "user",
      "content": "分析微服务架构与单体架构之间的取舍（利弊权衡）"
    }],
	"thinking": {
		"type": "adaptive"
	},
    "output_config": {
      "effort": "medium"
    }
}'

# 先安装 Anthropic SDK: `pip3 install anthropic`

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-opus-5",
    max_tokens=4096,
    messages=[
        {
            "role": "user",
            "content": "分析微服务架构与单体架构之间的取舍（利弊权衡）",
        }
    ],
    thinking={"type": "adaptive"},
    output_config={"effort": "medium"},
)

// 先安装 Anthropic SDK: `npm install anthropic`

const client = new Anthropic();

const response = await client.messages.create({
  model: "claude-opus-5",
  max_tokens: 4096,
  messages: [
    {
      role: "user",
      content: "分析微服务架构与单体架构之间的取舍（利弊权衡）"
    }
  ],
  thinking: {
    type: "adaptive"
  },
  output_config: {
    effort: "medium"
  }
});

const textBlock = response.content.find(
  (block): block is Anthropic.TextBlock => block.type === "text"
);
console.log(textBlock?.text);

client := anthropic.NewClient()

response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
	Model:     anthropic.ModelClaudeOpus5,
	MaxTokens: 4096,
	Messages: []anthropic.MessageParam{
		anthropic.NewUserMessage(anthropic.NewTextBlock("分析微服务架构与单体架构之间的取舍（利弊权衡）")),
	},
	Thinking: anthropic.ThinkingConfigParamUnion{
		OfAdaptive: &anthropic.ThinkingConfigAdaptiveParam{
			Type: "adaptive",
		},
	},
	OutputConfig: anthropic.OutputConfigParam{
		Effort: anthropic.OutputConfigEffortMedium,
	},
})
if err != nil {
	log.Fatal(err)
}
for _, block := range response.Content {
	if textBlock, ok := block.AsAny().(anthropic.TextBlock); ok {
		fmt.Println(textBlock.Text)
	}
}

Gemini

Gemini 2.5 开始所有模型默认为推理模型，且默认开启，你可以通过将 thinking.budget_tokens 设置为 0 关闭推理模式（对 Gemini 2.5 Pro 无效，因为其不支持关闭推理模式），以加速 AI 回复速度，如果你想要显示思考链内容，可以将 thinking.include_thoughts 设置为 true（默认 false 不显示思考链），还可以通过修改 thinking.budget_tokens 调节用于推理的最大 tokens 数，该数值越大，思考深度越深：

curl https://geekai.co/api/v1/chat/completions \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $GEEKAI_API_KEY" \
-d '{
    "model": "gemini-2.5-flash",
    "messages": [
        {"role": "user", "content": "1+1为什么等于2？"}
    ],
	"thinking": {
		"include_thoughts": true,
		"budget_tokens": 30000
	},
	"stream": false
}'

# 先安装 OpenAI SDK: `pip3 install openai`

from openai import OpenAI

client = OpenAI(api_key="$GEEKAI_API_KEY", base_url="https://geekai.co/api/v1")

response = client.chat.completions.create(
    model="gemini-2.5-flash",
    messages=[
        {"role": "user", "content": "1+1为什么等于2？"},
    ],
	thinking={"include_thoughts": True, "budget_tokens": 30000},
    stream=False
)

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

// 先安装 OpenAI SDK: `npm install openai`

import OpenAI from "openai";

const openai = new OpenAI({
    baseURL: 'https://geekai.co/api/v1',
    apiKey: '$GEEKAI_API_KEY'
});

async function main() {
    const completion = await openai.chat.completions.create({
        messages: [{role: "user", content: "1+1为什么等于2？"}],
		thinking: { include_thoughts:true, budget_tokens: 30000 },
        model: "gemini-2.5-flash",
    });

    console.log(completion.choices[0].message.content);
}

main();

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
)

func main() {
	requestBody := map[string]interface{}{
		"model": "gemini-2.5-flash",
		"messages": []interface{}{
            map[string]interface{}{
                "role": "user", 
                "content": "1+1为什么等于2？",
            },
        },
		"thinking": map[string]interface{}{
			"include_thoughts": true,
			"budget_tokens": 30000,
		},
		"stream": false,
	}
	
	jsonData, err := json.Marshal(requestBody)
	if err != nil {
		panic(err)
	}

	client := &http.Client{}
	req, err := http.NewRequest("POST", "https://geekai.co/api/v1/chat/completions", bytes.NewBuffer(jsonData))
	if err != nil {
		panic(err)
	}

	req.Header.Set("Authorization", "Bearer $GEEKAI_API_KEY")
	req.Header.Set("Content-Type", "application/json")

	resp, err := client.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		panic(err)
	}

	fmt.Println(string(body))
}

Gemini 推理模式思考链内容也兼容 DeepSeek 推理模型，通过 reasoning_content 字段获取。

如果使用的是名称带 :no-thinking 后缀的模型，则默认已关闭推理模式，且 budget_tokens 值为 0，可以不传递 thinking 参数。

Grok 4

Grok 4 是 xAI 最新发布的、支持图片输入的视觉推理模型，默认开启推理模式，且目前不支持关闭，调用方式和 Grok 3 一致：

curl https://geekai.co/api/v1/chat/completions \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $GEEKAI_API_KEY" \
-d '{
    "model": "grok-4",
    "messages": [
        {
			"role": "user",
			"content": [
				{
					"type": "text",
					"text": "请帮我解答这个数学题，并给出详细过程和答案"
				},
				{
					"type": "image_url",
					"image_url": {
						"url" : "https://static.geekai.co/storage/2025/07/11/math-question.jpeg"
					}
				}
			]
      }
    ]
}'

# 先安装 OpenAI SDK: `pip3 install openai`
from openai import OpenAI
client = OpenAI(api_key="$GEEKAI_API_KEY", base_url="https://geekai.co/api/v1")
response = client.chat.completions.create(
	model="grok-4",
	messages=[
		{
			"role": "user",
			"content": [
				{
					"type": "text",
					"text": "请帮我解答这个数学题，并给出详细过程和答案"
				},
				{
					"type": "image_url",
					"image_url": {
						"url" : "https://static.geekai.co/storage/2025/07/11/math-question.jpeg"
					}
				}
			]
		}
	],
	stream=False
)

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

// 先安装 OpenAI SDK: `npm install openai`
import OpenAI from "openai";
const openai = new OpenAI({
	baseURL: 'https://geekai.co/api/v1',
	apiKey: '$GEEKAI_API_KEY'
});
async function main() {
	const completion = await openai.chat.completions.create({
		messages: [
			{
				"role": "user",
				"content": [
					{
						"type": "text",
						"text": "请帮我解答这个数学题，并给出详细过程和答案"
					},
					{
						"type": "image_url",
						"image_url": {
							"url" : "https://static.geekai.co/storage/2025/07/11/math-question.jpeg"
						}
					}
				]
			}
		],
		model: "grok-4",
	});

	console.log(completion.choices[0].message.content);
}
main();

package main
import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
)
func main() {
	requestBody := map[string]interface{}{
		"model": "grok-4",
		"messages": []interface{}{
			map[string]interface{}{
				"role": "user",
				"content": []interface{}{
					map[string]interface{}{
						"type": "text",
						"text": "请帮我解答这个数学题，并给出详细过程和答案",
					},
					map[string]interface{}{
						"type": "image_url",
						"image_url": map[string]interface{}{
							"url": "https://static.geekai.co/storage/2025/07/11/math-question.jpeg",
						},
					},
				},
			},
		},
	}
	
	jsonData, err := json.Marshal(requestBody)
	if err != nil {
		panic(err)
	}

	client := &http.Client{}
	req, err := http.NewRequest("POST", "https://geekai.co/api/v1/chat/completions", bytes.NewBuffer(jsonData))
	if err != nil {
		panic(err)
	}

	req.Header.Set("Authorization", "Bearer $GEEKAI_API_KEY")
	req.Header.Set("Content-Type", "application/json")

	resp, err := client.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		panic(err)
	}

	fmt.Println(string(body))
}

Grok 4 推理模式思考链内容也兼容 DeepSeek 推理模型，通过 reasoning_content 字段获取。

Qwen3

Qwen3 系列所有模型均为推理模式和非推理模式融合模型，且支持通过 enable_thinking 参数切换（仅千问模型支持该参数）：

curl https://geekai.co/api/v1/chat/completions \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $GEEKAI_API_KEY" \
-d '{
    "model": "qwen3.8-max",
    "messages": [
        {"role": "user", "content": "1+1为什么等于2？"}
    ],
    "stream": true,
    "enable_thinking": true
}'

# 先安装网络库 `pip3 install aiohttp asyncio`

import aiohttp
import asyncio
import json

async def invoke_geekai():
	headers = {
		"Authorization": "Bearer $GEEKAI_API_KEY",
		"Content-Type": "application/json"
	}
	
	body =     {
      "model": "qwen3.8-max",
      "messages": [
        {
          "role": "user",
          "content": "1+1为什么等于2？"
        }
      ],
      "enable_thinking": True,
      "stream": True
    }

	async with aiohttp.ClientSession() as session:
		async with session.post(
			"https://geekai.co/v1/chat/completions", 
			headers=headers,
			json=body
		) as response:
			async for line in response.content:
				line = line.decode("utf-8").strip()
				if line.startswith("data: "):
					data = line[6:]
					if data == "[DONE]":
						break
					try:
						chunk = data.strip()
						if chunk:
							print(chunk)
					except Exception as e:
						print(f"Error parsing chunk: {e}")

asyncio.run(invoke_geekai())

const response = await fetch("https://geekai.co/v1/chat/completions", {
    method: "POST",
    headers: {
        "Authorization": "Bearer $GEEKAI_API_KEY",
        "Content-Type": "application/json"
    },
    body: JSON.stringify({
        "model": "qwen3.8-max",
        "messages": [
            {
                "role": "user",
                "content": "1+1为什么等于2？"
            }
        ],
        "stream": true,
        "enable_thinking": true
    })
});

const data = await response.json();
console.log(data);

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
)

func main() {
	requestBody := map[string]interface{}{
		"model": "qwen3.8-max",
		"messages": []interface{}{
            map[string]interface{}{
                "role": "user", 
                "content": "1+1为什么等于2？",
            },
        },
        "enable_thinking": true,
        "stream": true,
	}
	
	jsonData, err := json.Marshal(requestBody)
	if err != nil {
		panic(err)
	}

	client := &http.Client{}
	req, err := http.NewRequest("POST", "https://geekai.co/api/v1/chat/completions", bytes.NewBuffer(jsonData))
	if err != nil {
		panic(err)
	}

	req.Header.Set("Authorization", "Bearer $GEEKAI_API_KEY")
	req.Header.Set("Content-Type", "application/json")

	resp, err := client.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		panic(err)
	}

	fmt.Println(string(body))
}

GLM 推理模型

最新的 GLM 5 系模型均为推理模型，且默认开启，如果想要控制思考模式开启关闭，可以通过设置 thinking.type 参数来实现：

enabled：开启推理模式
disabled：关闭推理模式

要设置思考推理的努力程度，通过 thinking.reasoning_effort 参数来实现，该参数仅 GLM 5.2 以上版本且推理模式开启时才生效，支持的配置值和 OpenAI 完全一致。

curl https://geekai.co/api/v1/chat/completions \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $GEEKAI_API_KEY" \
-d '{
    "model": "glm-5.3-flash",
    "messages": [
        {"role": "user", "content": "你好"}
    ],
    "stream": false
}'

# 先安装 OpenAI SDK: `pip3 install openai`

from openai import OpenAI

client = OpenAI(api_key="$GEEKAI_API_KEY", base_url="https://geekai.co/api/v1")

response = client.chat.completions.create(
    model="glm-5.3-flash",
    messages=[
        {"role": "user", "content": "你好"},
    ],
    stream=False
)

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

// 先安装 OpenAI SDK: `npm install openai`

import OpenAI from "openai";

const openai = new OpenAI({
    baseURL: 'https://geekai.co/api/v1',
    apiKey: '$GEEKAI_API_KEY'
});

async function main() {
    const completion = await openai.chat.completions.create({
        messages: [{role: "user", content: "你好"}],
        model: "glm-5.3-flash",
    });

    console.log(completion.choices[0].message.content);
    console.log(completion.choices[0].message.reasoning_content);
}

main();

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
)

func main() {
	requestBody := map[string]interface{}{
		"model": "glm-5.3-flash",
		"messages": []interface{}{
            map[string]interface{}{
                "role": "user", 
                "content": "你好",
            },
        }
	}
	
	jsonData, err := json.Marshal(requestBody)
	if err != nil {
		panic(err)
	}

	client := &http.Client{}
	req, err := http.NewRequest("POST", "https://geekai.co/api/v1/chat/completions", bytes.NewBuffer(jsonData))
	if err != nil {
		panic(err)
	}

	req.Header.Set("Authorization", "Bearer $GEEKAI_API_KEY")
	req.Header.Set("Content-Type", "application/json")

	resp, err := client.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		panic(err)
	}

	fmt.Println(string(body))
}

兼容 Anthropic SDK 的 GLM 模型调用 message 接口思考模式传参和 Claude 系列模型一致，不再单独列举。

其他推理模型

除了上面列举的之外，还有很多其他支持推理模式的 AI 模型，如 Grok 3、Grok 4、通义 QwQ/QvQ、ERNIE X1、混元 T1 等，所有推理模型请求/响应参数兼容 DeepSeek，对于不兼容的推理模型，极客智坊底层会自动对齐。需要注意的是，只有推理模型支持推理模式，你可以在模型广场查看极客智坊支持的所有推理模型，目前极客智坊已支持40多个推理模型，特定模型还支持联网推理以及深度推理，如 DeepSeek 联网推理版、DeepSeek 深度推理版、Grok 深度推理版等：

另外，推理模型通常不支持系统提示以及温度参数，因此在进行 API 调用的时候不要设置这两个参数。

Chat API

Response API

Message API

文本向量化

DeepSeek

OpenAI

Claude

Gemini

Grok 4

Qwen3

GLM 推理模型

其他推理模型

​DeepSeek

​OpenAI

​Claude

​Gemini

​Grok 4

​Qwen3

​GLM 推理模型

​其他推理模型

DeepSeek

OpenAI

Claude

Gemini

Grok 4

Qwen3

GLM 推理模型

其他推理模型