【Go】ChatGPTのAPIを動かしてアプリの名付けツールを作るまで

package chat

// チャットの送信データ
type Request struct {
	Model    string            `json:"model"`
	Messages []*RequestMessage `json:"messages"`

	// 最大トークン
	MaxTokens int `json:"max_tokens"`
}

func NewRequest(modelID string, messages []*RequestMessage, maxTokens int) *Request {
	return &Request{
		Model:     modelID,
		Messages:  messages,
		MaxTokens: maxTokens,
	}
}

// チャットの送信メッセージ
type RequestMessage struct {
	// メッセージの役割(assistant, user, systemのどれか)
	Role string `json:"role"`

	// メッセージの本文
	Content string `json:"content"`
}

func NewRequestMessage(role string, content string) *RequestMessage {
	return &RequestMessage{
		Role:    role,
		Content: content,
	}
}

package chat

// チャットの受信データ
type Response struct {
	ID      string    `json:"id"`
	Object  string    `json:"object"`
	Created int       `json:"created"`
	Model   string    `json:"model"`
	Usage   *Usage    `json:"usage"`
	Choices []*Choice `json:"choices"`
}

// APIの使用量
type Usage struct {
	// 入力データのトークン
	PromptTokens int `json:"prompt_tokens"`

	// 出力データのトークン
	CompletionTokens int `json:"completion_tokens"`

	// 合計トークン
	TotalTokens int `json:"total_tokens"`
}

type Choice struct {
	// 受信メッセージ
	Message *ResponseMessage `json:"message"`

	// リクエストが異常終了した場合の理由(正常終了の場合は空文字)
	FinishReason string `json:"finish_reason"`

	// トークン化されたインデックス
	Index int `json:"index"`
}

// チャットの受信メッセージ
type ResponseMessage struct {
	// メッセージの役割(assistant, user, systemのどれか)
	Role string `json:"role"`

	// メッセージの本文
	Content string `json:"content"`
}

package chat

import (
	"bytes"
	"encoding/json"
	"errors"
	"time"

	"io"
	"net/http"
)

type ChatCompletions struct {
	// HTTPリクエストのタイムアウト
	timeout time.Duration

	// 応答の最大トークン
	maxTokens int

	// チャットに使用するモデルのID
	model string

	// APIキー
	secret string
}

func NewChatCompletions(model string, secret string, maxTokens int, timeout time.Duration) *ChatCompletions {
	return &ChatCompletions{
		maxTokens: maxTokens,
		model:     model,
		secret:    secret,
		timeout:   timeout,
	}
}

// APIにメッセージを送信する
func (c ChatCompletions) SendMessage(messages []*RequestMessage) (*Response, error) {
	data, err := json.Marshal(NewRequest(c.model, messages, c.maxTokens))
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest(http.MethodPost, "https://api.openai.com/v1/chat/completions", bytes.NewReader(data))
	if err != nil {
		return nil, err
	}
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Authorization", "Bearer "+c.secret)

	client := &http.Client{
		// リソース節約のためにタイムアウトを設定する
		Timeout: 20 * time.Second,
	}
	resp, err := client.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	if resp.StatusCode != 200 {
		return nil, errors.New("bad status: " + resp.Status)
	}

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return nil, err
	}

	var res Response
	if err := json.Unmarshal(body, &res); err != nil {
		return nil, err
	}
	return &res, nil
}

// 一回きりの質問をする
func (c ChatCompletions) AskOneQuestion(content string) (*Response, error) {
	messages := []*RequestMessage{
		NewRequestMessage("user", content),
	}
	return c.SendMessage(messages)
}

package main

import (
	"fmt"
	"gptapi-example/src/chat"
	"os"
	"time"
)

func main() {
	// コマンドライン引数から質問テキストを取得する
	if len(os.Args) < 2 {
		panic("too few arguments")
	}
	content := os.Args[1]

	// 環境変数からAPIキーを取得する
	secret, ok := os.LookupEnv("OPEN_AI_SECRET")
	if !ok {
		panic("open-api-secret is empty")
	}

	// リソース節約のためにタイムアウトを設定する
	timeout := 15 * time.Second

	// トークン節約のために応答の最大トークンを設定する
	maxTokens := 500

	// チャットに使用するモデルのID
	modelID := "gpt-3.5-turbo"

	c := chat.NewChatCompletions(modelID, secret, maxTokens, timeout)
	res, err := c.AskOneQuestion(content)
	if err != nil {
		fmt.Println(err.Error())
		return
	}

	fmt.Printf("In %d / Out %d / Total %d tokens\n", res.Usage.PromptTokens, res.Usage.CompletionTokens, res.Usage.TotalTokens)
	for _, v := range res.Choices {
		fmt.Printf("[%s]: %s\n", v.Message.Role, v.Message.Content)
	}

}

go run ./src/cmd/test/main.go "ディーゼルエンジンの仕組みを教えてください"

In 28 / Out 309 / Total 337 tokens
[assistant]: 

ディーゼルエンジンの仕組みは以下の通りです。

1. 空気の吸入：エンジンに空気を送り込みます。

2. 圧縮：ピストンが上がり、空気が高い圧力で縮まります。このとき、気温が非常に高くなります。

3. 燃料噴射：燃料が高圧で噴射されます。ディーゼルエンジンでは、燃料が空気に混ざって自己着火することで爆発的な燃焼が起こります。

4. 燃焼：燃焼することで、ピストンが下がります。

5. 排気：燃焼で発生したガスは排気バルブから外に放出されます。

このサイクルが繰り返されることで、ディーゼルエンジンは動きます。ディーゼルエンジンは大型車や船舶、発電機などに広く使用されています。

In 28 / Out 50 / Total 78 tokens
[assistant]: 

ディーゼルエンジンは、内燃機関の一種で、燃料と空気を混合させ、圧縮して爆発

あなたは優秀なソフトウェアエンジニアです。
以下のWho,What,Howからなるアプリに最適なネーミングを数字つきリストで10個考えてください。
それぞれ理由も明記してください。
既存のアプリ名ではなく今までにないアプリ名を考えてください。

# Who

ソフトウェア開発者

# What

アプリの命名ツール

# How

3つの質問で簡単にアプリ名を生成できる

package naming

// 質問文のテンプレート。[ID]は解答データと置き換えられる
const template = `
あなたは優秀なソフトウェアエンジニアです。
以下のWho,What,Howからなるアプリに最適なネーミングを数字つきリストで10個考えてください。
それぞれ理由も明記してください。
既存のアプリ名ではなく今までにないアプリ名を考えてください。

# Who
[who]

# What
[what]

# How
[how]
`

package naming

import (
	"fmt"
	"strings"
)

// ユーザーへの質問の管理
type QuestionCollection struct {
	items []*Question
}

func NewQuestionCollection(items []*Question) *QuestionCollection {
	return &QuestionCollection{items}
}

// 質問を対話式に表示してユーザーから解答を入力してもらう
func (c *QuestionCollection) InputAnswers() error {
	for i := 0; i < len(c.items); i++ {
		var answer string
		fmt.Println(c.items[i].Value)
		if _, err := fmt.Scan(&answer); err != nil {
			return err
		}
		c.items[i].Answer = answer
	}
	return nil
}

// APIに渡すプロンプトを作成する
func (c QuestionCollection) CreateContent() string {
	// テンプレート内のIDを解答データで置き換える
	content := template
	for _, v := range c.items {
		content = strings.Replace(content, v.ID, v.Answer, 1)
	}
	return content
}

package naming

// 質問データ
type Question struct {
	// 質問の種別(Who, What, Howのどれか)
	ID string

	// 質問
	Value string

	// 解答
	Answer string
}

func NewQuestion(id string, value string) *Question {
	return &Question{
		ID:    id,
		Value: value,
	}
}

package main

import (
	"fmt"
	"gptapi-example/src/chat"
	"gptapi-example/src/naming"
	"os"
	"time"
)

func main() {
	// 環境変数からAPIキーを取得する
	secret, ok := os.LookupEnv("OPEN_AI_SECRET")
	if !ok {
		panic("open-api-secret is empty")
	}

	// リソース節約のためにタイムアウトを設定する
	timeout := 60 * time.Second

	// トークン節約のために応答の最大トークンを設定する
	maxTokens := 1500

	// チャットに使用するモデルのID
	modelID := "gpt-3.5-turbo"

	// ユーザーへの3つの質問を作成する
	items := []*naming.Question{
		naming.NewQuestion("[who]", "そのアプリは誰のためのアプリですか？"),
		naming.NewQuestion("[what]", "そのアプリは人々に何を与えますか？"),
		naming.NewQuestion("[how]", "それはどんな方法で与えられますか？"),
	}
	qc := naming.NewQuestionCollection(items)

	// 対話式にユーザーの解答を取得する
	if err := qc.InputAnswers(); err != nil {
		panic(err)
	}

	// テンプレートと解答データを組み合わせてプロンプトを作成する
	content := qc.CreateContent()
	fmt.Println("...")

	// APIにメッセージを送信する
	c := chat.NewChatCompletions(modelID, secret, maxTokens, timeout)
	res, err := c.AskOneQuestion(content)
	if err != nil {
		panic(err)
	}

	fmt.Printf("In %d / Out %d / Total %d tokens\n", res.Usage.PromptTokens, res.Usage.CompletionTokens, res.Usage.TotalTokens)
	for _, v := range res.Choices {
		fmt.Println(v.Message.Content)
	}
}

go run ./src/cmd/main/main.go