Go 调用 LLM API：从零实现最小可用客户端

最近在做一个 AI 工作流项目，第一步是实现 LLM 客户端。这篇文章记录从零开始调用 DeepSeek API 的过程。

请求格式

1
POST /v1/chat/completions
2
Authorization: Bearer sk-xxx
3
Content-Type: application/json
4

5
{
6
    "model": "deepseek-chat",
7
    "messages": [
8
        {"role": "system", "content": "你是一个助手"},
9
        {"role": "user", "content": "用一句话介绍 Go 语言"}
10
    ],
11
    "max_tokens": 1024,
12
    "temperature": 0.7,
13
    "stream": false
14
}

关键字段：

字段	说明
`model`	模型名，不同平台不同
`messages`	对话历史，包含 role 和 content
`max_tokens`	最大输出 token 数
`temperature`	随机性，0-2，越高越随机
`stream`	是否流式输出

role 类型：

Role	说明
`system`	系统提示词，设定 AI 人设
`user`	用户输入
`assistant`	AI 的回复

响应格式

1
{
2
    "id": "chatcmpl-xxx",
3
    "object": "chat.completion",
4
    "created": 1234567890,
5
    "model": "deepseek-chat",
6
    "choices": [
7
        {
8
            "index": 0,
9
            "message": {
10
                "role": "assistant",
11
                "content": "Go 是一门由 Google 开发的静态强类型、编译型语言..."
12
            },
13
            "finish_reason": "stop"
14
        }
15
    ],
16
    "usage": {
17
        "prompt_tokens": 20,
18
        "completion_tokens": 50,
19
        "total_tokens": 70
20
    }
21
}

关键字段：

字段	说明
`choices[0].message.content`	AI 的回复内容
`finish_reason`	结束原因：stop（正常）、length（超长度）
`usage`	token 消耗，用于计费

Go 实现

定义数据结构

1
// 请求结构
2
type ChatRequest struct {
3
    Model       string    `json:"model"`
4
    Messages    []Message `json:"messages"`
5
    MaxTokens   int       `json:"max_tokens,omitempty"`
6
    Temperature float64   `json:"temperature,omitempty"`
7
    Stream      bool      `json:"stream"`
8
}
9

10
type Message struct {
11
    Role    string `json:"role"`
12
    Content string `json:"content"`
13
}
14

15
// 响应结构
16
type ChatResponse struct {
17
    ID      string   `json:"id"`
18
    Choices []Choice `json:"choices"`
19
    Usage   Usage    `json:"usage"`
20
}
21

22
type Choice struct {
23
    Index        int     `json:"index"`
24
    Message      Message `json:"message"`
25
    FinishReason string  `json:"finish_reason"`
26
}
27

28
type Usage struct {
29
    PromptTokens     int `json:"prompt_tokens"`
30
    CompletionTokens int `json:"completion_tokens"`
31
    TotalTokens      int `json:"total_tokens"`
32
}

客户端结构

1
type DeepSeekClient struct {
2
    apiKey  string
3
    baseURL string
4
    model   string
5
}
6

7
func NewDeepSeekClient(apiKey, baseURL, model string) *DeepSeekClient {
8
    return &DeepSeekClient{
9
        apiKey:  apiKey,
10
        baseURL: baseURL,
11
        model:   model,
12
    }
13
}

支持配置不同的 baseURL 和 model，方便切换不同的服务商：

服务商	baseURL	模型名示例
DeepSeek 官方	`https://api.deepseek.com/v1`	`deepseek-chat`
硅基流动	`https://api.siliconflow.cn/v1`	`deepseek-ai/DeepSeek-V3`
OpenAI	`https://api.openai.com/v1`	`gpt-4o-mini`

Chat 方法实现

1
func (c *DeepSeekClient) Chat(prompt string) (string, error) {
2
    // 1. 构造请求体
3
    chatReq := ChatRequest{
4
        Model: c.model,
5
        Messages: []Message{
6
            {Role: "user", Content: prompt},
7
        },
8
        MaxTokens:   1024,
9
        Temperature: 0.7,
10
        Stream:      false,
11
    }
12

13
    // 序列化为 JSON
14
    body, err := json.Marshal(chatReq)
15
    if err != nil {
16
        return "", fmt.Errorf("marshal request: %w", err)
17
    }
18

19
    // 2. 发送 HTTP 请求
20
    req, err := http.NewRequest("POST", c.baseURL+"/chat/completions", bytes.NewReader(body))
21
    if err != nil {
22
        return "", fmt.Errorf("create request: %w", err)
23
    }
24

25
    req.Header.Set("Content-Type", "application/json")
26
    req.Header.Set("Authorization", "Bearer "+c.apiKey)
27

28
    resp, err := http.DefaultClient.Do(req)
29
    if err != nil {
30
        return "", fmt.Errorf("do request: %w", err)
31
    }
32
    defer resp.Body.Close()
33

34
    // 读取响应
35
    respBody, err := io.ReadAll(resp.Body)
36
    if err != nil {
37
        return "", fmt.Errorf("read response: %w", err)
38
    }
39

40
    // 检查状态码
41
    if resp.StatusCode != http.StatusOK {
42
        return "", fmt.Errorf("API error (status %d): %s", resp.StatusCode, string(respBody))
43
    }
44

45
    // 3. 解析响应
46
    var chatResp ChatResponse
47
    if err := json.Unmarshal(respBody, &chatResp); err != nil {
48
        return "", fmt.Errorf("unmarshal response: %w", err)
49
    }
50

51
    if len(chatResp.Choices) == 0 {
52
        return "", fmt.Errorf("no choices in response")
53
    }
54

55
    return chatResp.Choices[0].Message.Content, nil
56
}

代码流程：

1
构造请求体 → JSON 序列化 → HTTP POST → 读取响应 → JSON 反序列化 → 提取内容

测试代码

1
func main() {
2
    godotenv.Load()
3

4
    apiKey := os.Getenv("DEEPSEEK_API_KEY")
5
    baseURL := os.Getenv("DEEPSEEK_BASEURL")
6
    model := os.Getenv("DEEPSEEK_MODEL")
7

8
    if baseURL == "" {
9
        baseURL = "https://api.siliconflow.cn/v1"
10
    }
11
    if model == "" {
12
        model = "deepseek-ai/DeepSeek-V3"
13
    }
14

15
    client := llm.NewDeepSeekClient(apiKey, baseURL, model)
16

17
    resp, err := client.Chat("用一句话介绍一下 Go 语言")
18
    if err != nil {
19
        log.Fatal(err)
20
    }
21

22
    fmt.Println("Response:", resp)
23
}

运行结果

1
$ go run ./cmd/llmtest
2

3
Using baseURL: https://api.siliconflow.cn/v1, model: deepseek-ai/DeepSeek-V3
4
Response: Go 语言是一种由 Google 开发的静态强类型、编译型、并发型且具有垃圾回收功能的编程语言，以其简洁高效和强大的并发编程能力著称。

1
## 下一步
2

3
这个最小实现还缺少一些功能：
4

5
| 功能 | 说明 |
6
|------|------|
7
| System Prompt | 设定 AI 人设 |
8
| 多轮对话 | 保持上下文 |
9
| 流式输出 | 实时显示生成过程 |
10
| 超时控制 | 避免请求卡住 |
11
| 重试机制 | 处理临时失败 |
12

13
这些会在后续的 AI 工作流项目中逐步完善。
14

15
## 总结
16

17
调用 LLM API 本质上就是：
18

19
1. **构造 JSON 请求** - messages 数组，包含对话历史
20
2. **发送 HTTP POST** - 带上 Authorization header
21
3. **解析 JSON 响应** - 提取 choices[0].message.content
22

23
理解了 OpenAI 兼容格式，就能对接市面上大多数 LLM API。
24

25
## 相关链接
26

27
- [DeepSeek API 文档](https://platform.deepseek.com/docs)
28
- [硅基流动](https://cloud.siliconflow.cn)
29
- [OpenAI API 文档](https://platform.openai.com/docs/api-reference/chat)