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

// Payload struct defines the structure of the payload to send to OpenAI
type Payload struct {
    Model    string    `json:"model"`
    Messages []Message `json:"messages"`
}

// Message struct defines the structure of individual 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") // Replace this with your actual 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 panic for now, you can handle this properly later on
}

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) // we panic for now, you can handle this properly later on
}

// Set headers
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)

// Read response
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"
)

// Payload struct defines the structure of the payload to send to OpenAI
type Payload struct {
    Model    string    `json:"model"`
    Messages []Message `json:"messages"`
}

// Message struct defines the structure of individual 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") // Replace this with your actual API key

    // Setup 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,
    }

    // Marshal data into JSON
    jsonData, err := json.Marshal(data)
    if err != nil {
        panic(err)
    }

    // Create a new request using http
    req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
    if err != nil {
        panic(err)
    }

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

    // Send req using http Client
    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)

    // Read response
    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.