go-openai

The go-openai library provides unofficial Go clients for various OpenAI API features, including:

• ChatGPT (4o, o1)
• GPT-3 and GPT-4
• DALL·E 2, DALL·E 3, and GPT Image 1
• Whisper

To use Azure OpenAI, use openai.DefaultAzureConfig(apiKey, endpoint). You can also customize config.AzureModelMapperFunc if your deployment names differ from the standard model names.

config := openai.DefaultAzureConfig("your Azure OpenAI Key", "https://your Azure OpenAI Endpoint")
// If you use a deployment name different from the model name, you can customize the AzureModelMapperFunc function
// config.AzureModelMapperFunc = func(model string) string {
// 	azureModelMapping := map[string]string{
// 		"gpt-3.5-turbo": "your gpt-3.5-turbo deployment name",
// 	}
// 	return azureModelMapping[model]
// }

client := openai.NewClientWithConfig(config)

To use a proxy, use openai.DefaultConfig to create a configuration, then set the HTTPClient field with a custom http.Client containing a configured http.Transport with your Proxy URL. Finally, initialize the client using openai.NewClientWithConfig(config).

config := openai.DefaultConfig("token")
proxyUrl, err := url.Parse("http://localhost:{port}")
if err != nil {
	panic(err)
}
transport := &http.Transport{
	Proxy: http.ProxyURL(proxyUrl),
}
config.HTTPClient = &http.Client{
	Transport: transport,
}

c := openai.NewClientWithConfig(config)

Install the unofficial Go client for the OpenAI API using go get. This library requires Go version 1.18 or greater.

go get github.com/sashabaranov/go-openai

Use CreateBatchWithUploadFile to perform a two-step process: upload a .jsonl file containing multiple requests and immediately start a batch job using that file. This is the most convenient way to handle batch processing.

To prepare the file, use UploadBatchFileRequest and its helper methods like AddChatCompletion to populate the lines. Supported endpoints include:

• BatchEndpointChatCompletions (/v1/chat/completions)
• BatchEndpointCompletions (/v1/completions)
• BatchEndpointEmbeddings (/v1/embeddings)

Use errors.As to check if an error is an *openai.APIError. You can then switch on the HTTPStatusCode to handle specific cases like 401 (invalid auth), 429 (rate limiting), or 500 (server error).

e := &openai.APIError{}
if errors.As(err, &e) {
	switch e.HTTPStatusCode {
	case 401:
		// invalid auth or key (do not retry)
	case 429:
		// rate limiting or engine overload (wait and retry)
	case 500:
		// openai server error (retry)
	default:
		// unhandled
	}
}

In go-openai, setting the Temperature field to 0 may not work as expected because the omitempty JSON tag causes the field to be removed from the request, resulting in the OpenAI API applying its default value of 1.

To achieve behavior similar to a temperature of 0, use math.SmallestNonzeroFloat32 instead of 0 in the temperature field.

To interact with ChatGPT models, use the CreateChatCompletion method. You must provide a ChatCompletionRequest containing the model (e.g., openai.GPT3Dot5Turbo) and a slice of ChatCompletionMessage objects defining the conversation roles (e.g., openai.ChatMessageRoleUser).

package main

import (
	"context"
	"fmt"
	openai "github.com/sashabaranov/go-openai"
)

func main() {
	client := openai.NewClient("your token")
	resp, err := client.CreateChatCompletion(
		context.Background(),
		openai.ChatCompletionRequest{
			Model: openai.GPT3Dot5Turbo,
			Messages: []openai.ChatCompletionMessage{
				{
					Role:    openai.ChatMessageRoleUser,
					Content: "Hello!",
				},
			},
		},
	)

	if err != nil {
		fmt.Printf("ChatCompletion error: %v\n", err)
		return
	}

	fmt.Println(resp.Choices[0].Message.Content)
}