用 Go 做一个命令行 AI 对话客户端

https://api.example.com/v1/chat/completions

API Key 记得保密。对这种客户端来说，它就是唯一的身份凭证，泄露了基本等于别人拿你的额度在跑。

项目结构与实现

先初始化模块：

go mod init go_line

go.mod 里会是：

module go_line
go 1.23.6

模块名就按项目名来写，Go 版本固定住，后面构建时少一点不确定性。

核心逻辑放在 main.go。这类程序没必要拆得太散，结构清楚比'看起来很工程化'更重要。

package main

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

const (
	apiURL = "https://api.example.com/v1/chat/completions"
	apiKey = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
	model  = "/maas/deepseek-ai/DeepSeek-V3.2"
)

type Message struct {
	Role    string `json:"role"`
	Content string `json:"content"`
}

type ChatRequest struct {
	Model    string    `json:"model"`
	Messages []Message `json:"messages"`
}

type ChatResponse struct {
	Choices []struct {
		Message Message `json:"message"`
	} `json:"choices"`
	Error *struct {
		Message string `json:"message"`
	} `json:"error,omitempty"`
}

func chat(history []Message) (string, error) {
	body, err := json.Marshal(ChatRequest{Model: model, Messages: history})
	if err != nil {
		return "", err
	}
	req, err := http.NewRequest("POST", apiURL, bytes.NewReader(body))
	if err != nil {
		return "", err
	}
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Authorization", "Bearer "+apiKey)
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		return "", err
	}
	defer resp.Body.Close()
	raw, err := io.ReadAll(resp.Body)
	if err != nil {
		return "", err
	}
	var cr ChatResponse
	if err := json.Unmarshal(raw, &cr); err != nil {
		return "", fmt.Errorf("parse error: %w\nraw: %s", err, raw)
	}
	if cr.Error != nil {
		return "", fmt.Errorf("API error: %s", cr.Error.Message)
	}
	if len(cr.Choices) == 0 {
		return "", fmt.Errorf("no choices returned")
	}
	return cr.Choices[0].Message.Content, nil
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	var history []Message
	fmt.Println("AI Chat - type 'exit' to quit, 'clear' to reset history")
	fmt.Println("---")
	for {
		fmt.Print("You: ")
		if !scanner.Scan() {
			break
		}
		input := strings.TrimSpace(scanner.Text())
		if input == "" {
			continue
		}
		if input == "exit" {
			fmt.Println("Bye!")
			break
		}
		if input == "clear" {
			history = nil
			fmt.Println("History cleared.")
			continue
		}
		history = append(history, Message{Role: "user", Content: input})
		reply, err := chat(history)
		if err != nil {
			fmt.Fprintf(os.Stderr, "Error: %v\n", err)
			history = history[:len(history)-1]
			continue
		}
		history = append(history, Message{Role: "assistant", Content: reply})
		fmt.Printf("AI: %s\n\n", reply)
	}
}

这里的关键不是'写了一个聊天程序'，而是把三件事串起来了：请求体序列化、HTTP 调用、上下文维护。

Message、ChatRequest、ChatResponse 这几个结构体，作用都很直接。前两个负责把历史消息按接口要求发出去，ChatResponse 负责把返回结果拆回来。API 如果报错，也留了 Error 字段接住，不至于一上来就崩掉。

chat 函数做的事情比较单纯：把历史消息打包成 JSON，发 POST 请求，读回响应，再从 choices[0].message.content 里取出回复。接口兼容 OpenAI 风格时，这种写法通常够用了。

main 函数的重点是 history。每次用户输入都会先追加到历史里，再把完整上下文发给模型。这样模型才能知道前面聊过什么，不会每轮都像第一次见面。

出错时会把最后一条用户消息回滚掉。这个处理不花哨，但很实用。否则一次网络失败，就会把一条无效输入留在上下文里，后面越聊越乱。

程序里还留了两个简单命令：exit 退出，clear 清空历史。CLI 工具就该这样，别把退出方式藏得太深。

编译和运行

编译很直接：

go build -o go_line .

Go 的静态编译在这种场景里很好用，产物单文件，拷到别的机器上也方便。

运行：

./go_line

启动后，程序会在终端里等待输入。你输入的问题会被追加到上下文，再发到云端模型，返回结果后直接打印出来。只要 API 地址、Key 和模型名没写错，这个流程就能跑通。

从实现上看，这个客户端没有什么复杂技巧，重点在于把几个基础环节接稳：环境、鉴权、上下文、错误回滚。做 CLI 很多时候就是这样，功能不大，但细节一松手，体验就立刻变差。