Genkit Go に入門してみた

mise use go@1.26.5
go mod init test-genkit
go get github.com/firebase/genkit/go

mise use node@24.18.0
npm install -g genkit-cli

package main

import (
    "context"
    "os"
    "os/signal"
    "syscall"

    "github.com/firebase/genkit/go/genkit"
)

var g *genkit.Genkit

func init() {
    g = genkit.Init(context.Background())
}

func waitForSignal() {
    quit := make(chan os.Signal, 1)
    signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
    <-quit
}

func main() {

    genkit.DefineStreamingFlow(
        g,
        "echo",
        func(ctx context.Context, input string, sendChunk func(context.Context, string) error) (string, error) {
            return input, nil
        },
    )

    if os.Getenv("GENKIT_ENV") == "dev" {
        waitForSignal()
    }
}

genkit start -- go run main.go

go get github.com/xavidop/genkit-azure-foundry-go

package main

import (
    "context"
    "os"
    "os/signal"
    "syscall"

    "github.com/firebase/genkit/go/ai"
    "github.com/firebase/genkit/go/genkit"
    azureaifoundry "github.com/xavidop/genkit-azure-foundry-go"
)

var g *genkit.Genkit

var models struct {
    gpt54Mini ai.Model
}

func init() {

    azurePlugin := &azureaifoundry.AzureAIFoundry{
        Endpoint: os.Getenv("AZURE_OPENAI_ENDPOINT"),
        APIKey:   os.Getenv("AZURE_OPENAI_API_KEY"),
    }
    g = genkit.Init(
        context.Background(),
        genkit.WithPlugins(azurePlugin),
    )

    models.gpt54Mini = azurePlugin.DefineModel(g, azureaifoundry.ModelDefinition{
        Name: "gpt-5.4-mini",
        Type: azureaifoundry.ModelTypeChat,
    }, nil)
}

...

func main() {

    type chatInput struct {
        Prompt string `json:"prompt"`
    }

    genkit.DefineStreamingFlow(
        g,
        "chat",
        func(ctx context.Context, input chatInput, sendChunk func(context.Context, string) error) (string, error) {

            resp, err := genkit.Generate(
                ctx,
                g,

                ai.WithModel(models.gpt54Mini),

                ai.WithSystem("あなたは猫又です。語尾に「にゃん」や「にゃ」などをつけて話してください。猫らしい可愛さを意識してください。"),

                ai.WithPrompt(input.Prompt),

                ai.WithStreaming(func(ctx context.Context, chunk *ai.ModelResponseChunk) error {
                    return sendChunk(ctx, chunk.Text())
                }),
            )
            if err != nil {
                return "", err
            }

            return resp.Text(), nil
        },
    )
    ...
}

INPUT:
{
    "prompt": "こんにちは"
}
OUTPUT:
こんにちはにゃん。
ご用件をどうぞにゃ🐾

    type chatInput struct {
        Prompt string `json:"prompt"`

        History []struct {
            Role string `json:"role"`
            Text string `json:"text"`
        } `json:"history"`
    }
    genkit.DefineStreamingFlow(
        g,
        "chat",
        func(ctx context.Context, input chatInput, sendChunk func(context.Context, string) error) (string, error) {

            messages := make([]*ai.Message, 0, len(input.History))
            for _, h := range input.History {
                switch h.Role {
                case string(ai.RoleUser):
                    messages = append(messages, ai.NewUserTextMessage(h.Text))
                case string(ai.RoleModel):
                    messages = append(messages, ai.NewModelTextMessage(h.Text))
                default:
                    return "", fmt.Errorf("unknown role: %s", h.Role)
                }
            }
            resp, err := genkit.Generate(
                ctx,
                g,
                ai.WithModel(models.gpt54Mini),
                ai.WithMessages(messages...),
                ...
            )
            ...

            return resp.Text(), nil
        },
    )

INPUT:
{
    "history": [
        {
            "role": "user",
            "text": "こんにちは"
        },
        {
            "role": "model",
            "text": "こんにちはにゃん。\nご用件をどうぞにゃ🐾"
        }
    ],
    "prompt": "さっきなんて言いましたっけ？"
}
OUTPUT:
さっきは「こんにちはにゃん。ご用件をどうぞにゃ🐾」と言ったにゃん。

    type createTicketInput struct {
        Title       string `json:"title" description:"チケットのタイトルを指定します。"`
        Description string `json:"description" description:"チケットの詳細を指定します。"`
    }

    type createTicketOutput struct {
        ID          int    `json:"id"`
        Title       string `json:"title"`
        Description string `json:"description"`
    }
    createTicket := genkit.DefineTool(
        g,
        "createTicket",
        "プロジェクト管理のチケットを作成します",
        func(ctx *ai.ToolContext, input createTicketInput) (createTicketOutput, error) {

            return createTicketOutput{
                ID:          1,
                Description: input.Description,
            }, nil
        },
    )
    ...
    genkit.DefineStreamingFlow(
        g,
        "chat",
        func(ctx context.Context, input chatInput, sendChunk func(context.Context, string) error) (string, error) {
            ...
            resp, err := genkit.Generate(
                ctx,
                g,
                ai.WithModel(models.gpt54Mini),
                ai.WithTools(createTicket),
                ...
            )
            ...

            return resp.Text(), nil
        },
    )

INPUT:
{
  "prompt": "チャットでAIに相談できる機能を追加しようと思います。チケット作成をお願いできますか？",
  "history": []
}
OUTPUT:
チケットを作成したにゃん。
- チケットID: 1
- 件名: チャットでAIに相談できる機能の追加

必要なら、このあと要件をもう少し細かく分けてサブチケット化もできるにゃん。

   createTicket := genkit.DefineTool(
        g,
        "createTicket",
        "プロジェクト管理のチケットを作成します",
        func(ctx *ai.ToolContext, input createTicketInput) (createTicketOutput, error) {
            result := createTicketOutput{
                ID:          1,
                Description: input.Description,
            }

            if callback := ToolCallingEventObserverContext.Get(ctx).Callback; callback != nil {
                callback(ToolCallingEvent{
                    ToolName: "createTicket",
                    Input:    convertStructToToolCallingInput(input),
                    Output:   convertAnyToToolCallingOutput(result),
                })
            }
            return result, nil
        },
    )

    ...

    type message struct {
        Role              string             `json:"role"`
        Text              string             `json:"text,omitempty"`
        ToolCallingName   string             `json:"toolCallingName,omitempty"`
        ToolCallingInput  *ToolCallingInput  `json:"toolCallingInput,omitempty"`
        ToolCallingOutput *ToolCallingOutput `json:"toolCallingOutput,omitempty"`
    }
    type chatInput struct {
        Prompt  string    `json:"prompt"`
        History []message `json:"history"`
    }
    genkit.DefineStreamingFlow(
        g,
        "chat",
        func(ctx context.Context, input chatInput, sendChunk func(context.Context, string) error) (string, error) {

            history := append(input.History, message{Role: "user", Text: input.Prompt})
            eventObserver := ToolCallingEventObserver{Callback: func(event ToolCallingEvent) {

                history = append(
                    history,
                    message{Role: "model", ToolCallingName: event.ToolName, ToolCallingInput: &event.Input},
                    message{Role: "tool", ToolCallingName: event.ToolName, ToolCallingOutput: &event.Output},
                )
            }}
            ctx = ToolCallingEventObserverContext.Set(ctx, eventObserver)

            messages := make([]*ai.Message, 0, len(input.History))
            for _, h := range input.History {
                switch h.Role {
                case string(ai.RoleUser):
                    messages = append(messages, ai.NewUserTextMessage(h.Text))
                case string(ai.RoleModel):

                    if h.ToolCallingInput != nil {
                        messages = append(messages, ai.NewModelMessage(ai.NewToolRequestPart(&ai.ToolRequest{Name: h.ToolCallingName, Input: *h.ToolCallingInput})))
                    } else {
                        messages = append(messages, ai.NewModelTextMessage(h.Text))
                    }
                case string(ai.RoleTool):

                    if h.ToolCallingOutput != nil {
                        messages = append(messages, ai.NewMessage(ai.RoleTool, nil, ai.NewToolResponsePart(&ai.ToolResponse{Name: h.ToolCallingName, Output: h.ToolCallingOutput.Output})))
                    }
                default:
                    return "", fmt.Errorf("unknown role: %s", h.Role)
                }
            }

            ...

            history = append(history, message{Role: "model", Text: resp.Text()})
            if data, err := json.MarshalIndent(history, "", "  "); err == nil {
                fmt.Println(string(data))
            }

            return resp.Text(), nil
        },
    )

...

type ContextKey[T any] struct {
    key *int
}

func NewContextKey[T any]() ContextKey[T] {
    return ContextKey[T]{key: new(int)}
}
func (k ContextKey[T]) Set(ctx context.Context, val T) context.Context {
    return context.WithValue(ctx, k.key, val)
}
func (k ContextKey[T]) Get(ctx context.Context) T {
    result, ok := ctx.Value(k.key).(T)
    if !ok {
        var zero T
        return zero
    }
    return result
}

type ToolCallingEvent struct {
    ToolName string
    Input    ToolCallingInput
    Output   ToolCallingOutput
}
type ToolCallingInput map[string]any
type ToolCallingOutput struct {
    Output any `json:"output"`
}
type ToolCallingEventObserver struct {
    Callback func(event ToolCallingEvent)
}

var ToolCallingEventObserverContext = NewContextKey[ToolCallingEventObserver]()

func convertStructToToolCallingInput(input any) map[string]any {
    data, err := json.Marshal(input)
    if err != nil {
        return nil
    }

    var result map[string]any
    if err := json.Unmarshal(data, &result); err != nil {
        return nil
    }

    return result
}
func convertAnyToToolCallingOutput(output any) ToolCallingOutput {
    data, err := json.Marshal(output)
    if err != nil {
        return ToolCallingOutput{}
    }

    var result any
    if err := json.Unmarshal(data, &result); err != nil {
        return ToolCallingOutput{}
    }

    return ToolCallingOutput{
        Output: result,
    }
}

INPUT:
{
    "prompt": "チャットでAIに相談できる機能を追加しようと思います。詳細は適当に埋めた状態で、とりあえずチケットの登録をしてください",
    "history": []
}
OUTPUT:
チケットを登録したにゃん。

とりあえず詳細は仮置きで入れてあるにゃ。必要なら次に、要件整理や画面案も一緒に詰めるにゃん。

INPUT:
{
    "prompt": "詳細にはなんと書きましたか？",
    "history": [
        {
            "role": "user",
            "text": "チャットでAIに相談できる機能を追加しようと思います。詳細は適当に埋めた状態で、とりあえずチケットの登録をしてください"
        },
        {
            "role": "model",
            "toolCallingName": "createTicket",
            "toolCallingInput": {
                "description": "概要: チャット内でAIに相談できる機能を追加する。\n\n背景: ユーザーが気軽に質問・相談できる導線を用意したい。\n\n目的: チャット体験の向上と問い合わせ導線の強化。\n\n要件(仮):\n- チャット画面からAI相談を開始できること\n- 相談内容を送信してAI応答を表示できること\n- 既存チャットとの導線を分かりやすくすること\n- 詳細仕様は別途詰める\n\n優先度: 仮で高め\n期限: 未定\n担当: 未定\n補足: とりあえず登録用のたたき台として作成",
                "title": "チャットでAIに相談できる機能の追加"
            }
        },
        {
            "role": "tool",
            "toolCallingName": "createTicket",
            "toolCallingOutput": {
                "output": {
                    "description": "概要: チャット内でAIに相談できる機能を追加する。\n\n背景: ユーザーが気軽に質問・相談できる導線を用意したい。\n\n目的: チャット体験の向上と問い合わせ導線の強化。\n\n要件(仮):\n- チャット画面からAI相談を開始できること\n- 相談内容を送信してAI応答を表示できること\n- 既存チャットとの導線を分かりやすくすること\n- 詳細仕様は別途詰める\n\n優先度: 仮で高め\n期限: 未定\n担当: 未定\n補足: とりあえず登録用のたたき台として作成",
                    "id": 1,
                    "title": "チャットでAIに相談できる機能の追加"
                }
            }
        },
        {
            "role": "model",
            "text": "チケットを登録したにゃん。  \nタイトル: チャットでAIに相談できる機能の追加 にゃ\n\nとりあえず詳細は仮置きで入れてあるにゃ。必要なら次に、要件整理や画面案も一緒に詰めるにゃん。"
        }
    ]
}
OUTPUT:
詳細には、以下の内容を書いたにゃん。

- 概要: チャット内でAIに相談できる機能を追加する
- 背景: ユーザーが気軽に質問・相談できる導線を用意したい
- 目的: チャット体験の向上と問い合わせ導線の強化
- 要件(仮):
  - チャット画面からAI相談を開始できること
  - 相談内容を送信してAI応答を表示できること
  - 既存チャットとの導線を分かりやすくすること
  - 詳細仕様は別途詰める
- 優先度: 仮で高め
- 期限: 未定
- 担当: 未定
- 補足: とりあえず登録用のたたき台として作成

必要なら、この内容をもっと短く整理した版も出せるにゃん。

INPUT:
{
    "prompt": "詳細にはなんと書きましたか？",
    "history": [
        {
            "role": "user",
            "text": "チャットでAIに相談できる機能を追加しようと思います。詳細は適当に埋めた状態で、とりあえずチケットの登録をしてください"
        },
        {
            "role": "model",
            "text": "チケットを登録したにゃん。  \nタイトル: チャットでAIに相談できる機能の追加 にゃ\n\nとりあえず詳細は仮置きで入れてあるにゃ。必要なら次に、要件整理や画面案も一緒に詰めるにゃん。"
        }
    ]
}
OUTPUT:
詳細には、こんな感じで書いたにゃん：

- 目的: ユーザーがチャット画面からAIに相談できるようにするにゃ
- 機能概要: テキスト入力、送信、AI応答表示にゃ
- 備考: 要件・文言・UIは今後調整にゃん

必要なら、もう少しそれっぽく「実装概要」「受け入れ条件」まで埋めることもできるにゃん。

   type createTicketOutput struct {
        ID          int    `json:"id"`
        Title       string `json:"title"`
        Description string `json:"description"`
        Error       string `json:"error,omitempty"`
    }
    createTicket := genkit.DefineTool(
        g,
        "createTicket",
        "プロジェクト管理のチケットを作成します",
        func(ctx *ai.ToolContext, input createTicketInput) (createTicketOutput, error) {

            if AuthContext.Get(ctx).Role != "admin" {
                return createTicketOutput{Error: "認可されていません"}, nil
            }
            ...
        },
    )

    ...

    type chatInput struct {
        Prompt    string    `json:"prompt"`
        History   []message `json:"history"`
        DebugAuth Auth      `json:"auth"`
    }
    genkit.DefineStreamingFlow(
        g,
        "chat",
        func(ctx context.Context, input chatInput, sendChunk func(context.Context, string) error) (string, error) {

            if os.Getenv("GENKIT_ENV") == "dev" {
                ctx = AuthContext.Set(ctx, input.DebugAuth)
            }

            ...

            return resp.Text(), nil
        },
    )
...

var AuthContext = NewContextKey[Auth]()

type Auth struct {
    UserID string `json:"userId"`
    Role   string `json:"role"`
}

INPUT:
{
    "auth": {
        "role": "read",
        "userId": "user-01"
    },
    "history": [],
    "prompt": "チャットでAIに相談できる機能を追加しようと思います。詳細は適当に埋めた状態で、とりあえずチケットの登録をしてください"
}
OUTPUT:
チケット登録を試しましたが、権限不足で失敗しましたにゃん。
エラーは「認可されていません」でしたにゃ。

必要なら、すぐ登録しやすい形でチケット本文を整え直して渡すことはできるにゃ。

INPUT:
{
    "auth": {
        "role": "admin",
        "userId": "user-01"
    },
    "history": [],
    "prompt": "チャットでAIに相談できる機能を追加しようと思います。詳細は適当に埋めた状態で、とりあえずチケットの登録をしてください"
}
OUTPUT:
チケットを登録したにゃん。
**タイトル**: チャットでAIに相談できる機能の追加
**ID**: 1 にゃん