[Part 1] Genkit Go Quickstart: Setup, Flows, and Debugging

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"os"
	"path/filepath"
	"strings"

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

// RecipeInput Define input schema
type RecipeInput struct {
	Ingredient          string `json:"ingredient" jsonschema:"description=Main ingredient or cuisine type"`
	DietaryRestrictions string `json:"dietaryRestrictions,omitempty" jsonschema:"description=Any dietary restrictions"`
}

// Recipe Define output schema
type Recipe struct {
	Title        string   `json:"title"`
	Description  string   `json:"description"`
	PrepTime     string   `json:"prepTime"`
	CookTime     string   `json:"cookTime"`
	Servings     int      `json:"servings"`
	Ingredients  []string `json:"ingredients"`
	Instructions []string `json:"instructions"`
	Tips         []string `json:"tips,omitempty"`
}

func main() {
	// Load .env first, otherwise the config below and HTTPS_PROXY won't be picked up
	loadDotEnv()

	ctx := context.Background()

	// Custom model: any OpenAI-compatible endpoint works; see .env in the project root
	provider := envOr("CUSTOM_MODEL_PROVIDER", "custom")
	modelID := envOr("CUSTOM_MODEL_ID", "gpt-4o-mini")
	baseURL := os.Getenv("CUSTOM_API_BASE_URL")
	apiKey := os.Getenv("CUSTOM_API_KEY")

	switch {
	case baseURL == "":
		log.Fatal("Missing CUSTOM_API_BASE_URL: set the proxy endpoint in the project's .env")
	case apiKey == "":
		log.Fatal("Missing CUSTOM_API_KEY: set the API key in the project's .env")
	}
	log.Printf("Model %s/%s @ %s", provider, modelID, baseURL)

	// Initialize Genkit with the OpenAI-compatible plugin
	g := genkit.Init(ctx,
		genkit.WithPlugins(&compat_oai.OpenAICompatible{
			Provider: provider,
			APIKey:   apiKey,
			BaseURL:  baseURL,
		}),
		genkit.WithDefaultModel(provider+"/"+modelID))

	// Define a recipe generator flow
	recipeFlow := genkit.DefineFlow(g, "recipeGeneratorFlow", func(ctx context.Context, input *RecipeInput) (*Recipe, error) {
		// Create a prompt based on the input
		dietaryRestrictions := input.DietaryRestrictions
		if dietaryRestrictions == "" {
			dietaryRestrictions = "none"
		}

		prompt := fmt.Sprintf(`Create a recipe with the following requirements:
            Main ingredient: %s
            Dietary restrictions: %s`, input.Ingredient, dietaryRestrictions)

		// Generate structured recipe data using the same schema
		recipe, _, err := genkit.GenerateData[Recipe](ctx, g,
			ai.WithPrompt(prompt),
		)
		if err != nil {
			return nil, fmt.Errorf("failed to generate recipe: %w", err)
		}

		return recipe, nil
	})
	// Run the flow once to test it.
	// Don't kill the process on failure: upstream 5xx errors happen intermittently,
	// and the server should still start when the API is unreachable.
	recipe, err := recipeFlow.Run(ctx, &RecipeInput{
		Ingredient:          "avocado",
		DietaryRestrictions: "vegetarian",
	})
	if err != nil {
		log.Printf("warn: startup self-check failed, server will still start: %v", err)
	} else {
		// Print the structured recipe
		recipeJSON, _ := json.MarshalIndent(recipe, "", "  ")
		fmt.Println("Sample recipe generated:")
		fmt.Println(string(recipeJSON))
	}

	// Start a server to serve the flow and keep the app running for the Developer UI
	mux := http.NewServeMux()
	mux.HandleFunc("POST /recipeGeneratorFlow", genkit.Handler(recipeFlow))

	log.Println("Starting server on http://localhost:3400")
	log.Println("Flow available at: POST http://localhost:3400/recipeGeneratorFlow")
	log.Fatal(server.Start(ctx, "127.0.0.1:3400", mux))
}

// envOr returns the environment variable or fallback when it is empty.
func envOr(key, fallback string) string {
	if v := os.Getenv(key); v != "" {
		return v
	}
	return fallback
}

// loadDotEnv reads the nearest .env, walking up from the working directory, and
// sets each key in the process environment. Variables already present in the
// real environment always win, so `FOO=bar go run .` overrides the file.
func loadDotEnv() {
	dir, err := os.Getwd()
	if err != nil {
		return
	}
	for range 4 {
		path := filepath.Join(dir, ".env")
		if data, err := os.ReadFile(path); err == nil {
			applyDotEnv(string(data))
			log.Printf("Loaded %s", path)
			return
		}
		parent := filepath.Dir(dir)
		if parent == dir {
			return
		}
		dir = parent
	}
}

// applyDotEnv parses the subset of dotenv syntax the project uses: blank lines,
// `#` comments, an optional `export ` prefix, and optionally quoted values.
func applyDotEnv(content string) {
	for _, line := range strings.Split(content, "\n") {
		line = strings.TrimSpace(line)
		if line == "" || strings.HasPrefix(line, "#") {
			continue
		}
		key, value, ok := strings.Cut(strings.TrimPrefix(line, "export "), "=")
		if !ok {
			continue
		}
		key = strings.TrimSpace(key)
		value = strings.TrimSpace(value)
		if len(value) >= 2 && (value[0] == '"' || value[0] == '\'') && value[len(value)-1] == value[0] {
			value = value[1 : len(value)-1]
		}
		if key == "" || os.Getenv(key) != "" {
			continue
		}
		os.Setenv(key, value)
	}
}