Första intrycket av Genkit Go

module genkit-with-ollama

go 1.25.1

require github.com/firebase/genkit/go v1.0.2

package main

import (
	"context"
	"fmt"
	"log"
	"net/http"

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

func main() {
	log.Fatal(run(context.Background(), "127.0.0.1:3400"))
}

func run(ctx context.Context, addr string) error {
	g := genkit.Init(ctx)

	genkit.DefineFlow(g, "greetingFlow",
		func(ctx context.Context, name string) (string, error) {
			return fmt.Sprintf("Hello, %s!", name), nil
		},
	)

	mux := http.NewServeMux()

	for _, a := range genkit.ListFlows(g) {
		mux.HandleFunc("POST /"+a.Name(), genkit.Handler(a))
	}

	return server.Start(ctx, addr, mux)
}

package main

import (
	"cmp"
	"context"
	"fmt"
	"log"
	"math/rand"
	"net/http"
	"os"
	"strings"

	"github.com/firebase/genkit/go/ai"
	"github.com/firebase/genkit/go/genkit"
	"github.com/firebase/genkit/go/plugins/ollama"
	"github.com/firebase/genkit/go/plugins/server"
)

const modelName = "llama3-groq-tool-use:8b"

func main() {
	addr := "127.0.0.1:3400"

	log.Fatal(run(context.Background(), addr))
}

func run(ctx context.Context, addr string) error {
	o := newOllamaPlugin()

	g := genkit.Init(ctx,
		genkit.WithPlugins(o),
		genkit.WithDefaultModel("ollama/"+modelName),
	)

	o.DefineModel(g, ollama.ModelDefinition{
		Name: modelName,
		Type: "llm",
	}, nil)

	genkit.DefineFlow(g, "rpgCharacterGeneratorFlow",
		func(ctx context.Context, input *RPGCharacterInput) (*RPGCharacter, error) {
			c := &RPGCharacter{
				Race:  randomRace(input.Race),
				Class: randomClass(input.Class),
			}

			{ // Generate the attributes of the character
				out, _, err := genkit.GenerateData[RPGCharacterAttributes](ctx, g,
					ai.WithPrompt(fmt.Sprintf(
						`Create attribute scores in the inclusive range 1-20 
						for a Role Playing Game character, for inspiration: 
						Class: %s Race: %s`,
						c.Class, c.Race,
					)),
				)
				if err != nil {
					return nil, fmt.Errorf("failed to generate attributes: %w", err)
				}

				c.RPGCharacterAttributes = *out
			}

			{ // Generate the name of the character
				out, _, err := genkit.GenerateData[RPGCharacterDetails](ctx, g,
					ai.WithPrompt(fmt.Sprintf(
						`The name and age of a Role Playing Game character with:
							Race:  %q 
							Class: %q
							Attributes: %+v
						`,
						c.Race, c.Class, c.RPGCharacterAttributes,
					)),
				)

				if err != nil {
					return nil, fmt.Errorf("failed to generate details: %w", err)
				}

				c.RPGCharacterDetails = *out
			}

			{ // Generate some extra information about the character
				out, _, err := genkit.GenerateData[RPGCharacterExtra](ctx, g,
					ai.WithPrompt(fmt.Sprintf(
						`Extra information about a Role Playing Game character, 
							for inspiration: %s %s named %s and its age is %d 
							with the attributes %+v
						`,
						c.Class, c.Race, c.Name, c.Age, c.RPGCharacterAttributes,
					)),
				)
				if err != nil {
					return nil, fmt.Errorf("failed to generate extra: %w", err)
				}

				c.RPGCharacterExtra = *out
			}

			return c, nil
		},
	)

	mux := setupMux(g)

	log.Println("Starting server on http://" + addr)
	log.Println("Available workflows:")

	for _, a := range genkit.ListFlows(g) {
		log.Println(" POST http://" + addr + "/" + a.Name())
	}

	return server.Start(ctx, addr, mux)
}

func setupMux(g *genkit.Genkit) *http.ServeMux {
	mux := http.NewServeMux()

	for _, a := range genkit.ListFlows(g) {
		mux.HandleFunc("POST /"+a.Name(), genkit.Handler(a))
	}

	return mux
}

func newOllamaPlugin() *ollama.Ollama {
	return &ollama.Ollama{ServerAddress: ollamaServerAddress()}
}

func ollamaServerAddress() string {
	ollamaAddr := cmp.Or(os.Getenv("OLLAMA_HOST"), "127.0.0.1:11434")

	if !strings.Contains(ollamaAddr, ":") {
		ollamaAddr += ":11434"
	}

	return fmt.Sprintf("http://%s", ollamaAddr)
}

func randomRace(races ...string) string {
	if len(races) == 0 ||
		len(races) == 1 && races[0] == "" {
		races = []string{
			"Human",
			"Elf",
			"Dwarf",
			"Halfling",
			"Gnome",
			"Half-Elf",
			"Half-Orc",
			"Tiefling",
		}
	}

	return races[rand.Intn(len(races))]
}

func randomClass(classes ...string) string {
	if len(classes) == 0 ||
		len(classes) == 1 && classes[0] == "" {
		classes = []string{
			"Fighter",
			"Rogue",
			"Wizard",
			"Cleric",
			"Ranger",
			"Bard",
			"Paladin",
			"Sorcerer",
		}
	}

	return classes[rand.Intn(len(classes))]
}

type RPGCharacterInput struct {
	Race  string `json:"race,omitempty" jsonschema:"description=Race of the RPG character"`
	Class string `json:"class,omitempty" jsonschema:"description=Class of the RPG character"`
}

type RPGCharacter struct {
	Race                   string `json:"race"`
	Class                  string `json:"class"`
	RPGCharacterAttributes `json:"attributes"`
	RPGCharacterDetails    `json:"details"`
	RPGCharacterExtra      `json:"extra"`
}

type RPGCharacterAttributes struct {
	STR int `json:"STR" jsonschema:"description=Physical power; affects melee attack rolls, carrying capacity, and physical feats."`
	DEX int `json:"DEX" jsonschema:"description=Agility, reflexes, and balance; affects ranged attacks, Armor Class (AC), and skills like Stealth."`
	CON int `json:"CON" jsonschema:"description=Endurance and health; affects hit points (HP) and resistance to fatigue or poison."`
	INT int `json:"INT" jsonschema:"description=Reasoning, memory, and knowledge; affects spellcasting for Wizards and skills like Arcana or Investigation."`
	WIS int `json:"WIS" jsonschema:"description=Perception, insight, and willpower; affects spellcasting for Clerics and Druids, and skills like Perception or Survival."`
	CHA int `json:"CHA" jsonschema:"description=Force of personality; affects social interactions and spellcasting for Bards, Sorcerers, and Warlocks."`
}

type RPGCharacterDetails struct {
	Name string `json:"name" jsonschema:"description=Name of the RPG character"`
	Age  int    `json:"age" jsonschema:"description=Age of the RPG character (max age per race: Human=90 Elf=750 Dwarf=350 Halfling=250 Gnome=400 Half-Elf=180 Half-Orc=75 Tiefling=100)"`
}

type RPGCharacterExtra struct {
	Background  string `json:"background" jsonschema:"description=Background of the character"`
	Personality string `json:"personality" jsonschema:"description=Personality of the character"`
	Appearance  string `json:"appearance" jsonschema:"description=Appearance of the character"`
}