- 获取 OpenAI API Key：你可以通过 OpenAI 官方网站申请一个 API 密钥。
- 安装必要的 Go 包：你可以使用 Go 的内置 net/http 库来发送 HTTP 请求，也可以选择使用第三方的库来简化开发。
- 构建 API 请求：根据 API 文档构建请求并解析响应。
1. 获取 OpenAI API Key
你需要一个 OpenAI API 密钥来访问 API。你可以在 OpenAI 官网注册账号并生成你的 API Key。
2. 安装必要的 Go 包
可以使用 net/http 库，也可以选择安装像 resty 这样的第三方 HTTP 客户端库。
使用标准库 net/http：
go get net/http如果想使用 resty，可以安装它：
go get github.com/go-resty/resty/v23. 调用 API 的示例代码
调用 ChatGPT、GPT-3、GPT-4 的示例
以调用 gpt-3.5-turbo 为例，使用 net/http 发送请求：
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
"os"
)
const OPENAI_API_URL = "https://api.openai.com/v1/chat/completions"
func main() {
// OpenAI API Key
apiKey := os.Getenv("OPENAI_API_KEY")
// 请求的载荷
requestBody, err := json.Marshal(map[string]interface{}{
"model": "gpt-3.5-turbo", // 或者 "gpt-4"
"messages": []map[string]string{
{
"role": "system",
"content": "You are a helpful assistant.",
},
{
"role": "user",
"content": "Tell me a joke.",
},
},
})
if err != nil {
panic(err)
}
// 创建 HTTP 请求
req, err := http.NewRequest("POST", OPENAI_API_URL, bytes.NewBuffer(requestBody))
if err != nil {
panic(err)
}
// 设置请求头
req.Header.Set("Authorization", "Bearer "+apiKey)
req.Header.Set("Content-Type", "application/json")
// 发送请求
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
// 读取响应
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
panic(err)
}
fmt.Println("Response from OpenAI:")
fmt.Println(string(body))
}调用 DALL·E 3 的示例
DALL·E 3 的 API 也是通过 POST 请求生成图像的。基本上请求结构和 GPT 的很类似，只是请求体的参数不同。
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
"os"
)
const DALL_E_API_URL = "https://api.openai.com/v1/images/generations"
func main() {
apiKey := os.Getenv("OPENAI_API_KEY")
// 构建 DALL·E 的请求体
requestBody, err := json.Marshal(map[string]interface{}{
"prompt": "A futuristic city with flying cars",
"n": 1,
"size": "1024x1024",
})
if err != nil {
panic(err)
}
req, err := http.NewRequest("POST", DALL_E_API_URL, bytes.NewBuffer(requestBody))
if err != nil {
panic(err)
}
req.Header.Set("Authorization", "Bearer "+apiKey)
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
panic(err)
}
fmt.Println("DALL·E response:")
fmt.Println(string(body))
}调用 Whisper API 的示例
Whisper 是 OpenAI 的语音转文字 API，调用时需要上传音频文件。
package main
import (
"bytes"
"fmt"
"io"
"mime/multipart"
"net/http"
"os"
"path/filepath"
)
const WHISPER_API_URL = "https://api.openai.com/v1/audio/transcriptions"
func main() {
apiKey := os.Getenv("OPENAI_API_KEY")
// 打开音频文件
audioFilePath := "audio_sample.mp3"
file, err := os.Open(audioFilePath)
if err != nil {
panic(err)
}
defer file.Close()
// 创建 multipart form 文件上传
body := &bytes.Buffer{}
writer := multipart.NewWriter(body)
part, err := writer.CreateFormFile("file", filepath.Base(audioFilePath))
if err != nil {
panic(err)
}
_, err = io.Copy(part, file)
if err != nil {
panic(err)
}
writer.WriteField("model", "whisper-1") // Whisper 模型
err = writer.Close()
if err != nil {
panic(err)
}
// 构建 HTTP 请求
req, err := http.NewRequest("POST", WHISPER_API_URL, body)
if err != nil {
panic(err)
}
req.Header.Set("Authorization", "Bearer "+apiKey)
req.Header.Set("Content-Type", writer.FormDataContentType())
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
respBody, err := io.ReadAll(resp.Body)
if err != nil {
panic(err)
}
fmt.Println("Whisper response:")
fmt.Println(string(respBody))
}通过使用 Go 语言调用 OpenAI API，可以轻松地与 GPT 系列、DALL·E 和 Whisper 进行交互。基本的步骤包括：
- 获取 API Key。
- 构建 HTTP 请求。
- 处理 API 的响应。
你可以根据需求在请求中调整不同的参数，例如 model、prompt、n、size 等等，来实现不同的功能。
常见的问题
Go OpenAI 是否提供一个方法来计算令牌？
是的，OpenAI 并没有直接为 Go 提供计算令牌的官方方法，但你可以使用以下几种方式来计算令牌：
- 使用第三方库
- 通过 API 响应的 usage 字段来获取已用令牌数量
- 自己实现简单的令牌计数算法
1. 使用第三方库
虽然 OpenAI 官方没有为 Go 提供现成的令牌计算方法，但是社区有一些非官方的库，可以帮助你计算令牌数量。例如，可以使用 Go 语言的 tiktoken 库。tiktoken 是 OpenAI 官方的 Python 库，它用于处理 OpenAI 模型的令牌化。虽然目前 OpenAI 没有为 Go 提供直接的库，你可以参考类似的实现逻辑。
目前 Go 社区有非官方的 tiktoken 实现，例如：
- go-tiktoken：Go 的非官方实现。
使用 go-tiktoken 示例：
package main
import (
"fmt"
tiktoken_go "github.com/pkoukk/tiktoken-go"
)
func main() {
// 创建编码器，基于模型
enc, err := tiktoken_go.EncodingForModel("gpt-3.5-turbo")
if err != nil {
panic(err)
}
// 需要计算令牌的文本
text := "OpenAI provides cutting-edge AI technologies."
// 使用编码器对文本进行编码，得到令牌数组
tokens := enc.Encode(text, nil, nil)
fmt.Printf("Token count: %d\n", len(tokens)) // 输出令牌数量
fmt.Println("Tokens:", tokens) // 输出令牌数组
}2. 通过 API 响应的 usage 字段
如果你只是想在调用 OpenAI API 时查看消耗了多少令牌，可以通过 API 响应中的 usage 字段来获取。例如，在调用 ChatGPT 时，响应中包含令牌的使用信息：
{
"id": "chatcmpl-abc123",
"object": "chat.completion",
"usage": {
"prompt_tokens": 20,
"completion_tokens": 30,
"total_tokens": 50
}
}这意味着，提示（prompt）使用了 20 个令牌，回复（completion）使用了 30 个令牌，总共 50 个令牌。
在 Go 中，你可以通过解析这个响应来获取 prompt_tokens 和 total_tokens：
package main
import (
"encoding/json"
"fmt"
)
type APIResponse struct {
Usage struct {
PromptTokens int `json:"prompt_tokens"`
CompletionTokens int `json:"completion_tokens"`
TotalTokens int `json:"total_tokens"`
} `json:"usage"`
}
func main() {
response := `{
"usage": {
"prompt_tokens": 20,
"completion_tokens": 30,
"total_tokens": 50
}
}`
var apiResponse APIResponse
err := json.Unmarshal([]byte(response), &apiResponse)
if err != nil {
panic(err)
}
fmt.Printf("Prompt Tokens: %d\n", apiResponse.Usage.PromptTokens)
fmt.Printf("Completion Tokens: %d\n", apiResponse.Usage.CompletionTokens)
fmt.Printf("Total Tokens: %d\n", apiResponse.Usage.TotalTokens)
}3. 自己实现令牌计数算法
如果你不想依赖第三方库，或不关心高精度的令牌计数，可以手动基于字符或单词数量进行简单的估算。OpenAI 的令牌化方式大致上是按照单词、标点符号、空格等计算的。
但是准确的令牌计数方式依赖于模型的编码方式。对于精确的令牌计算，建议使用类似 tiktoken 的实现。
