Com o avanço das tecnologias de inteligência artificial, cada vez mais desenvolvedores buscam integrar suas aplicações com APIs de IA para oferecer funcionalidades avançadas e personalizadas.

Uma dessas APIs é a do ChatGPT, desenvolvida pela OpenAI, que permite gerar texto de forma natural e coerente. Neste post, vou mostrar como você pode integrar uma aplicação Go com a API do ChatGPT para criar uma funcionalidade onde o usuário insere um valor monetário e a aplicação retorna esse valor por extenso.

Pré-requisitos para a Integração

Antes de iniciar a integração, é necessário cumprir alguns pré-requisitos:

1. Conta na OpenAI: Você precisará de uma conta na OpenAI para acessar a API do ChatGPT.
2. API Key: Após criar sua conta, você deve gerar uma chave de API (API Key) no painel de controle da OpenAI.

Gerar o Token

Para gerar o token (API Key), siga os passos abaixo:

1. Acesse o site da OpenAI.
2. Crie uma conta ou faça login se já tiver uma.
3. No painel de controle, navegue até a seção de API keys.
4. Gere uma nova chave e copie-a para um local seguro, pois ela será usada em sua aplicação Go.

Exemplo de integração com ChatGPT

Como dito no início, vamos criar um simples projeto onde o usuário irá inserir um valor monetário e, utilizando a API do ChatGPT, receberemos o valor escrito por extenso.

Primeiro, crie um novo diretório para o seu projeto e inicie um módulo Go:

mkdir chatgpt
cd chatgpt
go mod init github.com/aprendagolang/chatgpt

Agora, vamos criar um arquivo main.go e inicia-lo inserindo a url e structs necessárias para essa integração.

const apiURL = "https://api.openai.com/v1/chat/completions"

type GPTRequest struct {
	Messages []GPTMessage `json:"messages"`
	Model    string       `json:"model"`
}

type GPTMessage struct {
	Role    string `json:"role"`
	Content string `json:"content"`
}

type GPTResponse struct {
	Choices []struct {
		Message GPTMessage `json:"message"`
	} `json:"choices"`
}

Na sequência, iniciemos nossa função main obtendo a API KEY gerada anteriormente.

apiKey := os.Getenv("OPENAI_API_KEY")
if apiKey == "" {
	fmt.Println("Por favor, defina a variável de ambiente OPENAI_API_KEY com sua chave da API OpenAI.")
	return
}

Agora, vamos solicitar o input do usuário para receber o valor monetário.

var valor string
fmt.Print("Insira um valor monetário: ")
fmt.Scanln(&valor)

Com o valor do input guardado na variável valor, precisamos criar o payload e executar a request para a API do ChatGPT.

// Cria o payload
requestBody, err := json.Marshal(GPTRequest{
	Messages: []GPTMessage{
		{Role: "user", Content: fmt.Sprintf("Escreva o valor %s por extenso.", valor)},
	},
	Model: "gpt-3.5-turbo",
})
if err != nil {
	fmt.Printf("Erro ao criar a requisição: %v\n", err)
	return
}

// Inicia uma nova request
req, err := http.NewRequest("POST", apiURL, bytes.NewBuffer(requestBody))
if err != nil {
	fmt.Printf("Erro ao criar a requisição HTTP: %v\n", err)
	return
}

// Adiciona os Headers necessários
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", apiKey)) // API KEY do ChatGPT

client := &http.Client{}
resp, err := client.Do(req) // Executa a request
if err != nil {
	fmt.Printf("Erro ao enviar a requisição: %v\n", err)
	return
}
defer resp.Body.Close()

Por fim, lemos a respose da request e imprimimos no terminal o valor monetário escrito por extenso.

body, err := io.ReadAll(resp.Body)
if err != nil {
	fmt.Printf("Erro ao ler a resposta: %v\n", err)
	return
}

var gptResponse GPTResponse
err = json.Unmarshal(body, &gptResponse)
if err != nil {
	fmt.Printf("Erro ao desserializar a resposta: %v\n", err)
	return
}

if len(gptResponse.Choices) > 0 {
	fmt.Printf("Valor por extenso: %s\n", gptResponse.Choices[0].Message.Content)
} else {
	fmt.Println("Nenhuma resposta encontrada.")
}

O código completo ficará assim:

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"os"
)

const apiURL = "https://api.openai.com/v1/chat/completions"

type GPTRequest struct {
	Messages []GPTMessage `json:"messages"`
	Model    string       `json:"model"`
}

type GPTMessage struct {
	Role    string `json:"role"`
	Content string `json:"content"`
}

type GPTResponse struct {
	Choices []struct {
		Message GPTMessage `json:"message"`
	} `json:"choices"`
}

func main() {
	apiKey := os.Getenv("OPENAI_API_KEY")
	if apiKey == "" {
		fmt.Println("Por favor, defina a variável de ambiente OPENAI_API_KEY com sua chave da API OpenAI.")
		return
	}

	var valor string
	fmt.Print("Insira um valor monetário: ")
	fmt.Scanln(&valor)

	requestBody, err := json.Marshal(GPTRequest{
		Messages: []GPTMessage{
			{Role: "user", Content: fmt.Sprintf("Escreva o valor %s por extenso.", valor)},
		},
		Model: "gpt-3.5-turbo",
	})
	if err != nil {
		fmt.Printf("Erro ao criar a requisição: %v\n", err)
		return
	}

	req, err := http.NewRequest("POST", apiURL, bytes.NewBuffer(requestBody))
	if err != nil {
		fmt.Printf("Erro ao criar a requisição HTTP: %v\n", err)
		return
	}

	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", apiKey))

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		fmt.Printf("Erro ao enviar a requisição: %v\n", err)
		return
	}
	defer resp.Body.Close()

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		fmt.Printf("Erro ao ler a resposta: %v\n", err)
		return
	}

	var gptResponse GPTResponse
	err = json.Unmarshal(body, &gptResponse)
	if err != nil {
		fmt.Printf("Erro ao desserializar a resposta: %v\n", err)
		return
	}

	if len(gptResponse.Choices) > 0 {
		fmt.Printf("Valor por extenso: %s\n", gptResponse.Choices[0].Message.Content)
	} else {
		fmt.Println("Nenhuma resposta encontrada.")
	}
}

Por ser uma integração simples, note que não precisamos utilizar nenhuma SDK.

Antes de executar a aplicação, defina a variável de ambiente OPENAI_API_KEY com a sua chave de API gerada lá no inicio do post:

export OPENAI_API_KEY="sua-chave-de-api"

Agora, execute a aplicação:

$ go run main.go
$ Insira um valor monetário: 1543,20
$ Valor por extenso: Mil quinhentos e quarenta e três reais e vinte centavos.

Conclusão

Integrar a API do ChatGPT em uma aplicação Go é uma tarefa relativamente simples e pode adicionar funcionalidades poderosas e interativas ao seu software.

Neste exemplo, mostramos como transformar um valor monetário em texto por extenso, mas as possibilidades são vastas e limitadas apenas pela sua imaginação. Experimente outras integrações e veja como a inteligência artificial pode melhorar a experiência dos seus usuários.

Até a próxima!

Faça parte da comunidade!

Receba os melhores conteúdos sobre Go, Kubernetes, arquitetura de software, Cloud e esteja sempre atualizado com as tendências e práticas do mercado.