Go (Golang) is a fast and efficient programming language, perfect for building reliable applications. It can also be used to interact with AI services like OpenAI.
In this blog post, I'll show you how to use Go to call OpenAI's Chat Completions API. We'll create a simple application that generates a social media posts for a real estate agent, demonstrating how easy it is to integrate Go with OpenAI's powerful AI models.
Create Chat completion API
This is the API contract provided by OpenAI which we will use. You can check out the detailed reference in their documentation.
https://platform.openai.com/docs/api-reference/chat/create
curl https://api.openai.com/v1/chat/completions \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-d '{
"model": "gpt-3.5-turbo",
"messages": [
{
"role": "system",
"content": "You are a helpful assistant."
},
{
"role": "user",
"content": "Hello!"
}
]
}'
Let's break down the code and explain each part.
1. Package Import
import (
"bytes"
"encoding/json"
"fmt"
"io"
"net/http"
"os"
)
We import necessary packages for handling HTTP requests, JSON encoding, reading environment variables, and I/O operations.
2. Defining the Payload and Message Structs
type Payload struct {
Model string `json:"model"`
Messages []Message `json:"messages"`
}
type Message struct {
Role string `json:"role"`
Content string `json:"content"`
}
These structs define the structure of our payload and individual messages. The Payload struct includes the model name and a slice of Message structs. Each Message struct includes a role (e.g., system, user) and content.
3. Main Function
The main function contains the core logic for sending a request to OpenAI's API and handling the response.
a. Setting Up the API URL and Key
url := "https://api.openai.com/v1/chat/completions"
apiKey := os.Getenv("OPENAI_API_KEY")
We define the API endpoint and retrieve the API key from environment variables.
b. Creating the Payload
messages := []Message{
{
Role: "system",
Content: "you are a real estate assistant and you will always answer in tagalog",
},
{
Role: "user",
Content: "give me a social media post about investing in real estate",
},
}
data := Payload{
Model: "gpt-3.5-turbo",
Messages: messages,
}
We create a slice of messages defining the system's behavior and the user's request. These are packed into the Payload struct.
c. Marshaling the Payload to JSON
jsonData, err := json.Marshal(data)
if err != nil {
panic(err)
}
We convert the Payload struct into JSON format using json.Marshal.
d. Creating the HTTP Request
req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
if err != nil {
panic(err)
}
req.Header.Set("Authorization", "Bearer "+apiKey)
req.Header.Set("Content-Type", "application/json")
We create a new POST request, set the authorization header with the API key, and specify the content type as JSON.
e. Sending the Request and Handling the Response
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer func(Body io.ReadCloser) {
err := Body.Close()
if err != nil {
}
}(resp.Body)
body, err := io.ReadAll(resp.Body)
if err != nil {
panic(err)
}
fmt.Println("Response:", string(body))
We send the request using an HTTP client and read the response. The response body is then printed to the console.
Here's the complete code for our project:
package main
import (
"bytes"
"encoding/json"
"fmt"
"io"
"net/http"
"os"
)
type Payload struct {
Model string `json:"model"`
Messages []Message `json:"messages"`
}
type Message struct {
Role string `json:"role"`
Content string `json:"content"`
}
func main() {
url := "https://api.openai.com/v1/chat/completions"
apiKey := os.Getenv("OPENAI_API_KEY")
messages := []Message{
{
Role: "system",
Content: "you are a real estate assistant and you will always answer in tagalog",
},
{
Role: "user",
Content: "give me a social media post about investing in real estate",
},
}
data := Payload{
Model: "gpt-3.5-turbo",
Messages: messages,
}
jsonData, err := json.Marshal(data)
if err != nil {
panic(err)
}
req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
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 func(Body io.ReadCloser) {
err := Body.Close()
if err != nil {
}
}(resp.Body)
body, err := io.ReadAll(resp.Body)
if err != nil {
panic(err)
}
fmt.Println("Response:", string(body))
}
Running the Code
To run this code, ensure you have set the OPENAI_API_KEY environment variable with your actual OpenAI API key. This can be done in your terminal:
export OPENAI_API_KEY="your-api-key-here"
Then, execute your Go program:
go run main.go
Here is a sample response you will receive when you run this Go program
{
"id": "chatcmpl-9c6K8Ic00b3k9dycy4BuIZ5T5z7Z8",
"object": "chat.completion",
"created": 1718867800,
"model": "gpt-3.5-turbo-0125",
"choices": [
{
"index": 0,
"message": {
"role": "assistant",
"content": "Naghahanap ka ba ng magandang investment? I-invest mo na sa real estate! Siguradong tataas ang value nito habang tumatagal. Mag-invest na sa real estate ngayon! 🏡💰 #RealEstateInvesting #MagandangInvestment #EdukasyonTungoSaTagumpay"
},
"logprobs": null,
"finish_reason": "stop"
}
],
"usage": {
"prompt_tokens": 36,
"completion_tokens": 78,
"total_tokens": 114
},
"system_fingerprint": null
}
In this blog post, we have walked through the process of creating a simple application using Go. This application interacts with OpenAI's Chat API, providing responses in Tagalog. This example can be a starting point for more complex integrations and customizations, enabling you to build powerful AI-driven applications.
If you're interested in learning more about integrating Go with Generative AI, follow this blog for more tutorials and insights. This is just the start!
I do live coding in Twitch and Youtube. You can follow me if you'd like to ask me questions when I go live. I also post in LinkedIn, you can connect with me there as well.
