// 用 Gemini 3.8 Flash
g := genkit.Init(ctx,
    genkit.WithPlugins(&googlegenai.GoogleAI{}),
    genkit.WithDefaultModel("googleai/gemini-3.8-flash"),
)

// 换成本地 DeepSeek，其余代码一字不改
g := genkit.Init(ctx,
    genkit.WithPlugins(&ollama.Plugin{ServerAddress: "http://localhost:11434"}),
    genkit.WithDefaultModel("ollama/deepseek-r1:latest"),
)

// 换成 OpenAI
g := genkit.Init(ctx,
    genkit.WithPlugins(&compat_oai.Plugin{
        APIKey:  os.Getenv("OPENAI_API_KEY"),
        BaseURL: "https://api.openai.com/v1",
    }),
    genkit.WithDefaultModel("openai/gpt-4o"),
)

g := genkit.Init(ctx,
    genkit.WithPlugins(&googlegenai.GoogleAI{}),
)

// 定义一个 Tool：查询数据库里的订单状态
orderTool := genkit.DefineTool(
    g,
    "getOrderStatus",              // 工具名，模型用这个识别它
    "查询指定订单号的当前状态",      // 工具描述，模型用这个判断何时调用它
    func(ctx *ai.ToolContext, input struct {
        OrderID string `json:"order_id"`
    }) (string, error) {
        // 这里写真实的数据库查询逻辑
        status := db.QueryOrderStatus(input.OrderID)
        return status, nil
    },
)

chatFlow := genkit.DefineFlow(
    g,
    "chatFlow",
    func(ctx context.Context, userMessage string) (string, error) {
        return genkit.GenerateText(ctx, g,
            ai.WithPrompt(userMessage),
            ai.WithTools(orderTool),
        )
    },
)

// 调用
result, err := chatFlow.Run(ctx, "帮我查一下订单 ORD-12345 的状态")

// 生成纯文本
text, err := genkit.GenerateText(ctx, g,
    ai.WithPrompt("用一句话介绍 Go 语言"),
)

// 生成结构化数据（模型输出会被严格校验并反序列化）
type ProductInfo struct {
    Name  string  `json:"name"`
    Price float64 `json:"price"`
}
resp, err := genkit.GenerateData[ProductInfo](ctx, g,
    ai.WithPrompt("描述一款笔记本电脑，返回名称和价格"),
)
fmt.Println(resp.Output.Name, resp.Output.Price)

mkdir my-genkit-app && cd my-genkit-app
go mod init my-genkit-app
go get github.com/firebase/genkit/go@latest
go get github.com/firebase/genkit/go/plugins/googlegenai@latest

export GEMINI_API_KEY="你申请到的 Key"

package main

import (
	"context"
	"fmt"
	"log"
	"strings"
	"time"

	"github.com/firebase/genkit/go/ai"
	"github.com/firebase/genkit/go/genkit"
	"github.com/firebase/genkit/go/plugins/googlegenai"
)

// 工具的输入类型，Genkit 会自动将 struct 转为 JSON Schema 传给模型
type WeatherInput struct {
	City string `json:"city" description:"要查询的城市名，比如北京、深圳"`
}

type WeatherResult struct {
	City        string `json:"city"`
	Temperature string `json:"temperature"`
	Description string `json:"description"`
}

func main() {
	ctx := context.Background()

	// 初始化 Genkit，插件负责对接 Google Gemini
	// GEMINI_API_KEY 环境变量会被自动读取
	g := genkit.Init(ctx,
		genkit.WithPlugins(&googlegenai.GoogleAI{}),
		genkit.WithDefaultModel("googleai/gemini-3.8-flash"),
	)

	// Tool 1：获取系统当前时间
	// 大模型没有实时时钟，这个 Tool 让它能回答"现在几点"这类问题
	timeTool := genkit.DefineTool(g,
		"getCurrentTime",
		"获取服务器当前的精确时间",
		func(ctx *ai.ToolContext, _ struct{}) (string, error) {
			return time.Now().Format("2006年01月02日 15:04:05 MST"), nil
		},
	)

	// Tool 2：查询城市天气（这里用模拟数据，实际项目里接真实 API 或数据库）
	weatherTool := genkit.DefineTool(g,
		"getCityWeather",
		"查询指定城市的实时天气情况",
		func(ctx *ai.ToolContext, input WeatherInput) (*WeatherResult, error) {
			// 模拟天气数据，实际替换成真实 API 调用
			data := map[string]WeatherResult{
				"北京": {City: "北京", Temperature: "28°C", Description: "晴，微风"},
				"上海": {City: "上海", Temperature: "23°C", Description: "多云转阵雨"},
				"深圳": {City: "深圳", Temperature: "32°C", Description: "高温，有雷阵雨"},
			}
			for key, result := range data {
				if strings.Contains(input.City, key) {
					r := result
					return &r, nil
				}
			}
			return &WeatherResult{
				City:        input.City,
				Temperature: "未知",
				Description: "暂无该城市数据",
			}, nil
		},
	)

	// 定义一个 Flow，把工具挂上去
	// Flow 会出现在 Dev UI 里，可以直接在浏览器里测试
	assistantFlow := genkit.DefineFlow(g,
		"assistantFlow",
		func(ctx context.Context, question string) (string, error) {
			return genkit.GenerateText(ctx, g,
				ai.WithPrompt(question),
				ai.WithTools(timeTool, weatherTool),
			)
		},
	)

	// 测试几个问题，观察模型如何自主决定调用哪个工具
	questions := []string{
		"现在是几点？",
		"北京今天天气怎么样，出门需要带伞吗？",
		"上海和深圳今天哪个城市更热？",
	}

	for _, q := range questions {
		fmt.Printf("\n🙋 问：%s\n", q)
		answer, err := assistantFlow.Run(ctx, q)
		if err != nil {
			log.Printf("出错了: %v", err)
			continue
		}
		fmt.Printf("🤖 答：%s\n", answer)
		fmt.Println("────────────────────────────────────────")
	}
}

go run main.go

npm install -g genkit-cli

genkit start -- go run main.go

---
model: googleai/gemini-3.8-flash
config:
  temperature: 0.5
  maxOutputTokens: 1024
input:
  schema:
    userName: string
    issue: string
---
你是一名专业的客服助手，态度耐心、回答简洁。

用户名：{{userName}}
用户反馈的问题：{{issue}}

请分析问题的可能原因，并提供 2-3 个解决方案，每个方案用一句话说明步骤。

// 在初始化 Genkit 时指定 prompt 文件目录
g := genkit.Init(ctx,
    genkit.WithPlugins(&googlegenai.GoogleAI{}),
    genkit.WithPromptDir("./prompts"),
)

// 加载并执行，不需要重新编译 Go 代码
prompt := genkit.LookupPrompt(g, "support")
resp, err := prompt.Execute(ctx, map[string]any{
    "userName": "张三",
    "issue":    "App 登录时提示网络错误，但我的网络是正常的",
})
fmt.Println(resp.Text())

// 示例：在独立的 ai 包里初始化
package genai

import (
    "context"
    "github.com/firebase/genkit/go/genkit"
    "github.com/firebase/genkit/go/plugins/googlegenai"
)

var G *genkit.Genkit

func Init(ctx context.Context, apiKey, model string) {
    G = genkit.Init(ctx,
        genkit.WithPlugins(&googlegenai.GoogleAI{APIKey: apiKey}),
        genkit.WithDefaultModel("googleai/" + model),
    )
    registerTools() // 在这里统一注册所有 Tool
}

err = genkit.Generate(ctx, g,
    ai.WithPrompt(userMessage),
    ai.WithStreaming(func(ctx context.Context, chunk *ai.ModelResponseChunk) error {
        // 每生成一个 chunk 就推给前端（通过 SSE 或 WebSocket）
        fmt.Print(chunk.Text())
        return nil
    }),
)

history := sessionStore.Get(sessionID) // 从 Redis 取历史消息

resp, err := genkit.GenerateText(ctx, g,
    ai.WithMessages(history...),       // 注入历史上下文
    ai.WithPrompt(newUserMessage),
)

sessionStore.Append(sessionID, newUserMessage, resp) // 存回去