首页 > 科技周边 > 人工智能

Golang调用ChatGPTAPI教程详解

时间：2025-06-30 10:15:18 288浏览收藏

IT行业相对于一般传统行业，发展更新速度更快，一旦停止了学习，很快就会被行业所淘汰。所以我们需要踏踏实实的不断学习，精进自己的技术，尤其是初学者。今天golang学习网给大家整理了《Golang调用ChatGPT API完整教程》，聊聊，我们一起来看看吧！

要使用Golang调用ChatGPT API，首先需获取OpenAI API密钥并掌握基本HTTP请求知识。1. 准备API密钥：注册OpenAI账号并从环境变量中获取密钥；2. 编写Go代码：构建包含模型、消息和token限制的请求体，并通过net/http发送POST请求；3. 处理响应：解析JSON返回结果并提取内容；4. 错误处理：检查HTTP状态码、解析错误结构体并实现重试机制；5. 性能优化：使用连接池、并发控制、流式响应、压缩传输及缓存策略；6. Token限制管理：截断输入、设置输出长度上限、分割文本或使用摘要算法；7. 密钥安全：避免硬编码，采用环境变量或密钥管理系统存储；8. 常见问题应对：调整超时设置、限流控制、验证密钥有效性及确保编码一致。

Golang如何调用ChatGPT API 完整代码示例与解析

Golang调用ChatGPT API，简单来说，就是用Go语言编写代码，向OpenAI提供的ChatGPT接口发送请求，然后接收并处理返回的文本。这需要你准备好OpenAI API密钥，以及一些基础的HTTP请求知识。

解决方案

首先，你需要一个OpenAI API密钥。注册OpenAI账号并获取密钥后，就可以开始编写Go代码了。下面是一个完整的示例，展示了如何使用Golang调用ChatGPT API：

package main

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

type ChatCompletionRequest struct {
    Model     string      `json:"model"`
    Messages  []ChatMessage `json:"messages"`
    MaxTokens int         `json:"max_tokens"`
}

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

type ChatCompletionResponse struct {
    Choices []struct {
        Message struct {
            Content string `json:"content"`
        } `json:"message"`
    } `json:"choices"`
}

func main() {
    apiKey := os.Getenv("OPENAI_API_KEY") // 从环境变量中获取API密钥
    if apiKey == "" {
        log.Fatal("OPENAI_API_KEY is not set")
        return
    }

    prompt := "请用三句话介绍一下Golang。"

    // 构建请求体
    messages := []ChatMessage{
        {
            Role:    "user",
            Content: prompt,
        },
    }

    requestBody := ChatCompletionRequest{
        Model:     "gpt-3.5-turbo",
        Messages:  messages,
        MaxTokens: 150, // 限制返回的token数量
    }

    requestJson, err := json.Marshal(requestBody)
    if err != nil {
        log.Fatalf("JSON marshal error: %v", err)
        return
    }

    // 发送HTTP请求
    url := "https://api.openai.com/v1/chat/completions"
    req, err := http.NewRequest("POST", url, bytes.NewBuffer(requestJson))
    if err != nil {
        log.Fatalf("HTTP request error: %v", err)
        return
    }

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

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        log.Fatalf("HTTP response error: %v", err)
        return
    }
    defer resp.Body.Close()

    // 解析响应
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        log.Fatalf("Read response body error: %v", err)
        return
    }

    var chatCompletionResponse ChatCompletionResponse
    err = json.Unmarshal(body, &chatCompletionResponse)
    if err != nil {
        log.Fatalf("JSON unmarshal error: %v", err)
        return
    }

    // 输出结果
    if len(chatCompletionResponse.Choices) > 0 {
        fmt.Println(chatCompletionResponse.Choices[0].Message.Content)
    } else {
        fmt.Println("No response from ChatGPT API.")
    }
}

这段代码的关键点在于：

构建请求体: 使用ChatCompletionRequest结构体，指定模型、消息和最大token数。
发送HTTP请求: 使用net/http包创建一个POST请求，设置Content-Type和Authorization头部。
解析响应: 使用encoding/json包解析返回的JSON数据，提取ChatGPT的回复。

如何处理ChatGPT API的错误和异常？

调用外部API，错误处理至关重要。首先，检查HTTP响应状态码。如果状态码不是200，说明请求可能失败了。例如，401表示未授权，429表示请求过多被限流。

if resp.StatusCode != http.StatusOK {
    body, _ := ioutil.ReadAll(resp.Body)
    log.Fatalf("API request failed with status code: %d, response: %s", resp.StatusCode, string(body))
    return
}

其次，OpenAI API会返回详细的错误信息，可以解析响应体来获取这些信息。例如，可以定义一个错误响应结构体：

type ErrorResponse struct {
    Error struct {
        Message string `json:"message"`
        Type    string `json:"type"`
        Code    string `json:"code"`
    } `json:"error"`
}

然后在解析响应体时，先尝试解析为ErrorResponse，如果解析成功，说明发生了错误。

var chatCompletionResponse ChatCompletionResponse
err = json.Unmarshal(body, &chatCompletionResponse)
if err != nil {
    var errorResponse ErrorResponse
    err2 := json.Unmarshal(body, &errorResponse)
    if err2 == nil && errorResponse.Error.Message != "" {
        log.Fatalf("API error: %s", errorResponse.Error.Message)
        return
    }
    log.Fatalf("JSON unmarshal error: %v", err)
    return
}

最后，考虑重试机制。对于一些临时性的错误，例如网络问题或服务器过载，可以尝试重试请求。可以使用指数退避算法来控制重试的频率，避免对服务器造成过大的压力。

如何优化Golang调用ChatGPT API的性能？

性能优化是一个持续的过程，以下是一些建议：

连接池复用: net/http包默认使用连接池，但确保你没有禁用它。复用连接可以减少TCP连接建立和关闭的开销。

并发处理: 如果你需要同时处理多个请求，可以使用goroutine和channel来实现并发。但是，要注意控制并发的数量，避免超过OpenAI API的限流。

func processRequest(prompt string, resultChan chan string) {
    // 调用ChatGPT API的代码
    response := callChatGPT(prompt)
    resultChan <- response
}

func main() {
    prompts := []string{"prompt1", "prompt2", "prompt3"}
    resultChan := make(chan string, len(prompts))

    for _, prompt := range prompts {
        go processRequest(prompt, resultChan)
    }

    for i := 0; i < len(prompts); i++ {
        result := <-resultChan
        fmt.Println(result)
    }
}

流式响应: ChatGPT API支持流式响应，可以逐步返回结果，而不是等待所有结果都生成完毕。这可以提高响应速度，并减少内存占用。需要在请求中设置stream: true，并使用bufio.Scanner来逐行读取响应。
压缩: 可以启用HTTP压缩来减少传输的数据量。需要在请求头中设置Accept-Encoding: gzip，并使用gzip包来解压缩响应。
缓存: 对于一些静态的或不经常变化的prompt，可以将结果缓存起来，避免重复调用API。可以使用内存缓存或外部缓存系统，例如Redis。
选择合适的模型: 不同的ChatGPT模型具有不同的性能和价格。选择最适合你的需求的模型，可以降低成本并提高性能。

如何处理Golang调用ChatGPT API时的Token限制？

OpenAI API对每个请求的token数量有限制。超过限制会导致API返回错误。处理token限制的方法包括：

限制输入长度: 在调用API之前，对输入文本进行截断，确保token数量不超过限制。可以使用tiktoken库来计算文本的token数量。

import (
    "fmt"
    "github.com/pkoukkou/tiktoken-go"
)

func main() {
    enc, err := tiktoken.GetEncoding("cl100k_base")
    if err != nil {
        panic(err)
    }

    text := "This is a long text that needs to be truncated."
    tokens := enc.Encode(text, nil, nil)
    maxTokens := 10

    if len(tokens) > maxTokens {
        truncatedTokens := tokens[:maxTokens]
        truncatedText := enc.Decode(truncatedTokens)
        fmt.Println("Truncated text:", truncatedText)
    } else {
        fmt.Println("Text:", text)
    }
}

控制输出长度: 在请求中设置max_tokens参数，限制ChatGPT生成的文本的token数量。
使用更长的上下文窗口模型: 一些ChatGPT模型支持更长的上下文窗口，可以处理更多的token。但是，这些模型通常价格更高。
分割长文本: 将长文本分割成多个较小的片段，分别调用API处理，然后将结果拼接起来。这需要仔细设计分割策略，确保片段之间的语义连贯。
摘要: 使用摘要算法对长文本进行摘要，减少token数量。可以使用现成的摘要库，例如go-summarize。
迭代式对话: 如果需要处理非常长的对话，可以使用迭代式对话的方式。每次只传递最新的几轮对话，而不是整个对话历史。
监控Token使用情况: OpenAI提供了API来监控token的使用情况。可以定期查询API，了解token的使用情况，并及时调整策略。

如何保护OpenAI API密钥的安全？

API密钥是访问OpenAI API的凭证，泄露会导致安全风险。保护API密钥的方法包括：

不要硬编码密钥: 不要将API密钥硬编码到代码中。应该从环境变量、配置文件或密钥管理系统中读取密钥。
使用环境变量: 将API密钥存储在环境变量中，并在运行时读取。这可以避免将密钥提交到代码仓库。
```
apiKey := os.Getenv("OPENAI_API_KEY")
if apiKey == "" {
    log.Fatal("OPENAI_API_KEY is not set")
    return
}
```
使用密钥管理系统: 使用专业的密钥管理系统，例如HashiCorp Vault或AWS Secrets Manager，来存储和管理API密钥。这些系统提供了更高级的安全功能，例如访问控制、审计和密钥轮换。
限制API密钥的权限: OpenAI允许你限制API密钥的权限，例如限制可以访问的模型、IP地址和请求频率。
定期轮换API密钥: 定期更换API密钥，即使密钥泄露了，也可以减少损失。
监控API密钥的使用情况: 监控API密钥的使用情况，及时发现异常行为。
不要在公共场所展示密钥: 避免在公共场所（例如论坛、博客、社交媒体）展示API密钥。
使用.gitignore文件: 确保你的代码仓库中包含.gitignore文件，并排除包含API密钥的文件。
加密存储: 如果必须将API密钥存储在本地，应该使用加密算法进行加密。

Golang调用ChatGPT API的常见问题与解决方案

context deadline exceeded: 这个问题通常是由于网络连接超时导致的。可以尝试增加HTTP客户端的超时时间。
```
client := &http.Client{
    Timeout: time.Minute * 5, // 设置超时时间为5分钟
}
```
429 Too Many Requests: 这个问题是由于请求频率超过了OpenAI API的限制导致的。可以尝试降低请求频率，或使用指数退避算法进行重试。
401 Unauthorized: 这个问题是由于API密钥无效或过期导致的。请检查API密钥是否正确，并确保密钥没有过期。
500 Internal Server Error: 这个问题是由于OpenAI服务器内部错误导致的。可以尝试稍后重试。
JSON解析错误: 这个问题是由于响应体不是有效的JSON格式导致的。请检查请求参数是否正确，并确保OpenAI API返回的是有效的JSON数据。
Token限制错误: 这个问题是由于请求的token数量超过了OpenAI API的限制导致的。请参考前面关于token限制的处理方法。
乱码问题: 这个问题是由于字符编码不一致导致的。请确保请求和响应都使用UTF-8编码。
模型不存在错误: 这个问题是由于请求的模型名称不存在导致的。请检查模型名称是否正确。
API密钥泄露: 如果怀疑API密钥泄露，请立即更换API密钥。
版本兼容性问题: 确保使用的tiktoken-go版本与你的代码兼容。升级或降级库版本可能解决一些意外问题。

总而言之，调用ChatGPT API需要细致的错误处理和性能优化。希望以上信息能帮助你更好地使用Golang调用ChatGPT API。

文中关于golang的知识介绍，希望对你的学习有所帮助！若是受益匪浅，那就动动鼠标收藏这篇《Golang调用ChatGPTAPI教程详解》文章吧，也可关注golang学习网公众号了解相关技术文章。

golang