# Go OpenAI
[](https://godoc.org/github.com/sashabaranov/go-gogpt)
[](https://goreportcard.com/report/github.com/sashabaranov/go-gogpt)
[](https://codecov.io/gh/sashabaranov/go-gogpt)
> **Note**: the repository was recently renamed from `go-gpt3` to `go-gogpt`
This library provides Go clients for [OpenAI API](https://platform.gogpt.com/). We support:
* ChatGPT
* GPT-3, GPT-4
* DALL·E 2
* Whisper
Installation:
```
go get github.com/sashabaranov/go-gogpt
```
ChatGPT example usage:
```go
package main
import (
"context"
"fmt"
gogpt "github.com/sashabaranov/go-gogpt"
)
func main() {
client := gogpt.NewClient("your token")
resp, err := client.CreateChatCompletion(
context.Background(),
gogpt.ChatCompletionRequest{
Model: gogpt.GPT3Dot5Turbo,
Messages: []gogpt.ChatCompletionMessage{
{
Role: gogpt.ChatMessageRoleUser,
Content: "Hello!",
},
},
},
)
if err != nil {
fmt.Printf("ChatCompletion error: %v\n", err)
return
}
fmt.Println(resp.Choices[0].Message.Content)
}
```
Other examples:
GPT-3 completion
```go
package main
import (
"context"
"fmt"
gogpt "github.com/sashabaranov/go-gogpt"
)
func main() {
c := gogpt.NewClient("your token")
ctx := context.Background()
req := gogpt.CompletionRequest{
Model: gogpt.GPT3Ada,
MaxTokens: 5,
Prompt: "Lorem ipsum",
}
resp, err := c.CreateCompletion(ctx, req)
if err != nil {
fmt.Printf("Completion error: %v\n", err)
return
}
fmt.Println(resp.Choices[0].Text)
}
```
GPT-3 streaming completion
```go
package main
import (
"errors"
"context"
"fmt"
"io"
gogpt "github.com/sashabaranov/go-gogpt"
)
func main() {
c := gogpt.NewClient("your token")
ctx := context.Background()
req := gogpt.CompletionRequest{
Model: gogpt.GPT3Ada,
MaxTokens: 5,
Prompt: "Lorem ipsum",
Stream: true,
}
stream, err := c.CreateCompletionStream(ctx, req)
if err != nil {
fmt.Printf("CompletionStream error: %v\n", err)
return
}
defer stream.Close()
for {
response, err := stream.Recv()
if errors.Is(err, io.EOF) {
fmt.Println("Stream finished")
return
}
if err != nil {
fmt.Printf("Stream error: %v\n", err)
return
}
fmt.Printf("Stream response: %v\n", response)
}
}
```
Audio Speech-To-Text
```go
package main
import (
"context"
"fmt"
gogpt "github.com/sashabaranov/go-gogpt"
)
func main() {
c := gogpt.NewClient("your token")
ctx := context.Background()
req := gogpt.AudioRequest{
Model: gogpt.Whisper1,
FilePath: "recording.mp3",
}
resp, err := c.CreateTranscription(ctx, req)
if err != nil {
fmt.Printf("Transcription error: %v\n", err)
return
}
fmt.Println(resp.Text)
}
```
DALL-E 2 image generation
```go
package main
import (
"bytes"
"context"
"encoding/base64"
"fmt"
gogpt "github.com/sashabaranov/go-gogpt"
"image/png"
"os"
)
func main() {
c := gogpt.NewClient("your token")
ctx := context.Background()
// Sample image by link
reqUrl := gogpt.ImageRequest{
Prompt: "Parrot on a skateboard performs a trick, cartoon style, natural light, high detail",
Size: gogpt.CreateImageSize256x256,
ResponseFormat: gogpt.CreateImageResponseFormatURL,
N: 1,
}
respUrl, err := c.CreateImage(ctx, reqUrl)
if err != nil {
fmt.Printf("Image creation error: %v\n", err)
return
}
fmt.Println(respUrl.Data[0].URL)
// Example image as base64
reqBase64 := gogpt.ImageRequest{
Prompt: "Portrait of a humanoid parrot in a classic costume, high detail, realistic light, unreal engine",
Size: gogpt.CreateImageSize256x256,
ResponseFormat: gogpt.CreateImageResponseFormatB64JSON,
N: 1,
}
respBase64, err := c.CreateImage(ctx, reqBase64)
if err != nil {
fmt.Printf("Image creation error: %v\n", err)
return
}
imgBytes, err := base64.StdEncoding.DecodeString(respBase64.Data[0].B64JSON)
if err != nil {
fmt.Printf("Base64 decode error: %v\n", err)
return
}
r := bytes.NewReader(imgBytes)
imgData, err := png.Decode(r)
if err != nil {
fmt.Printf("PNG decode error: %v\n", err)
return
}
file, err := os.Create("image.png")
if err != nil {
fmt.Printf("File creation error: %v\n", err)
return
}
defer file.Close()
if err := png.Encode(file, imgData); err != nil {
fmt.Printf("PNG encode error: %v\n", err)
return
}
fmt.Println("The image was saved as example.png")
}
```
Configuring proxy
```go
config := gogpt.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 := gogpt.NewClientWithConfig(config)
```
See also: https://pkg.go.dev/github.com/sashabaranov/go-gogpt#ClientConfig
ChatGPT support context
```go
package main
import (
"bufio"
"context"
"fmt"
"os"
"strings"
"github.com/sashabaranov/go-gogpt"
)
func main() {
client := gogpt.NewClient("your token")
messages := make([]gogpt.ChatCompletionMessage, 0)
reader := bufio.NewReader(os.Stdin)
fmt.Println("Conversation")
fmt.Println("---------------------")
for {
fmt.Print("-> ")
text, _ := reader.ReadString('\n')
// convert CRLF to LF
text = strings.Replace(text, "\n", "", -1)
messages = append(messages, gogpt.ChatCompletionMessage{
Role: gogpt.ChatMessageRoleUser,
Content: text,
})
resp, err := client.CreateChatCompletion(
context.Background(),
gogpt.ChatCompletionRequest{
Model: gogpt.GPT3Dot5Turbo,
Messages: messages,
},
)
if err != nil {
fmt.Printf("ChatCompletion error: %v\n", err)
continue
}
content := resp.Choices[0].Message.Content
messages = append(messages, gogpt.ChatCompletionMessage{
Role: gogpt.ChatMessageRoleAssistant,
Content: content,
})
fmt.Println(content)
}
}
```