Genkit | Blog

Announcing Genkit Middleware: Intercept, extend, and harden your agentic apps

Thu, 14 May 2026 00:00:00 GMT

Genkit is an open-source framework for building full-stack, AI-powered and agentic applications for any platform with support for TypeScript, Go, Dart, and Python. Building a production-ready agentic applications and AI features requires more than powerful models and careful prompting. You might need retries and fallbacks for maximum reliability, human approval before destructive tool calls, and observability across every layer.

Genkit solves this with middleware: composable hooks that intercept generation calls, including the tool execution loop, and inject custom behaviors. The middleware system is available today in TypeScript, Go, and Dart, with Python support coming soon.

How Genkit middleware works

Every generate() call in Genkit runs a tool loop: the model produces output, any requested tools execute, the results feed back into a new model call, and the cycle repeats until the model is done. Middleware hooks attach at three layers of this loop:

Hook	When it runs	Typical use
Generate	Once per tool-loop iteration	Context injection, message rewriting, conversation-level logic
Model	Once per model API call	Retry, fallback, caching, latency logging
Tool	Once per tool execution	Human-in-the-loop, sandboxing, per-tool logging

Pre-built middleware

Genkit offers several pre-built middleware solutions for common use-cases. Here’s what’s available today:

1. Retry

Automatically retries failed model API calls on transient errors (RESOURCE_EXHAUSTED, UNAVAILABLE, etc.) using exponential backoff with jitter. Only the model call is retried; the surrounding tool loop is not replayed.

const response = await ai.generate({
  model: googleAI.model('gemini-flash-latest'),
  prompt: 'Summarize the quarterly earnings report.',
  use: [
    retry({ maxRetries: 3, initialDelayMs: 1000, backoffFactor: 2 }),
  ],
});

resp, err := genkit.Generate(ctx, g,
    ai.WithModelName("googleai/gemini-flash-latest"),
    ai.WithPrompt("Summarize the quarterly earnings report."),
    ai.WithUse(&middleware.Retry{
        MaxRetries:     3,
        InitialDelayMs: 1000,
        BackoffFactor:  2,
    }),
)

final response = await ai.generate(
  model: googleAI.gemini('gemini-flash-latest'),
  prompt: 'Summarize the quarterly earnings report.',
  use: [
    retry(maxRetries: 3, initialDelayMs: 1000, backoffFactor: 2),
  ],
);

2. Fallback

Switches to an alternative model when the primary model fails on a specified set of error codes. Useful for falling back to a smaller, faster model, or a different provider entirely, when your primary model exceeds its quota.

TypeScript
Go

const response = await ai.generate({
  model: googleAI.model('gemini-pro-latest'),
  prompt: 'Analyze this complex document...',
  use: [
    fallback({
      models: [googleAI.model('gemini-flash-latest')],
      statuses: ['RESOURCE_EXHAUSTED'],
    }),
  ],
});

resp, err := genkit.Generate(ctx, g,
    ai.WithModelName("googleai/gemini-pro-latest"),
    ai.WithPrompt("Analyze this complex document..."),
    ai.WithUse(&middleware.Fallback{
        Models: []ai.ModelRef{
            googlegenai.ModelRef("googleai/gemini-flash-latest", nil),
        },
        Statuses: []core.StatusName{core.RESOURCE_EXHAUSTED},
    }),
)

Fallback isn’t available in the Dart SDK yet.

3. Tool approval

Restricts tool execution to an allow-list. Any tool not on the list triggers an interrupt, enabling human-in-the-loop confirmation before the action proceeds.

// 1. Initial attempt — an empty allow-list interrupts every tool call.
const response = await ai.generate({
  prompt: 'Delete the temp files',
  tools: [deleteFilesTool],
  use: [toolApproval({ approved: [] })],
});

if (response.finishReason === 'interrupted') {
  const interrupt = response.interrupts[0];

  // 2. Prompt the user for approval, then recreate the tool request.
  const approvedPart = restartTool(interrupt, { toolApproved: true });

  // 3. Resume execution with the approval.
  const resumed = await ai.generate({
    messages: response.messages,
    resume: { restart: [approvedPart] },
    use: [toolApproval({ approved: [] })],
  });
}

resp, _ := genkit.Generate(ctx, g,
    ai.WithPrompt("Delete the temp files"),
    ai.WithTools(deleteFilesTool),
    ai.WithUse(&middleware.ToolApproval{
        AllowedTools: []string{}, // empty = every tool call interrupts
    }),
)

if len(resp.Interrupts()) > 0 {
    interrupt := resp.Interrupts()[0]

    // Prompt the user for approval, then resume with the approval flag.
    approved, _ := deleteFilesTool.RestartWith(interrupt,
        ai.WithResumedMetadata[DeleteInput](map[string]any{"toolApproved": true}),
    )

    resp, err := genkit.Generate(ctx, g,
        ai.WithMessages(resp.History()...),
        ai.WithTools(deleteFilesTool),
        ai.WithToolRestarts(approved),
        ai.WithUse(&middleware.ToolApproval{}),
    )
    fmt.Println(resp.Text())
}

// 1. Initial attempt — an empty allow-list interrupts every tool call.
final response = await ai.generate(
  prompt: 'Delete the temp files',
  tools: [deleteFilesTool],
  use: [toolApproval(approved: [])],
);

if (response.finishReason == FinishReason.interrupted) {
  final part = response.interrupts.first;

  // 2. Ask the user for approval, then resume execution.
  final resumed = await ai.generate(
    messages: response.messages,
    resume: [InterruptResponse(part, true)],
    use: [toolApproval(approved: [])],
  );
}

4. Skills

Scans a directory for SKILL.md files and injects their content into the system prompt. Also exposes a use_skill tool so the model can load specific skills on demand.

const response = await ai.generate({
  prompt: 'How do I deploy this service?',
  use: [skills({ skillPaths: ['./skills'] })],
});

resp, err := genkit.Generate(ctx, g,
    ai.WithPrompt("How do I deploy this service?"),
    ai.WithUse(&middleware.Skills{SkillPaths: []string{"./skills"}}),
)

final response = await ai.generate(
  prompt: 'How do I deploy this service?',
  use: [skills(skillPaths: ['./skills'])],
);

5. Filesystem

Gives the model scoped access to the local filesystem through injected tools (list_files, read_file, plus write_file and edit_file when writes are enabled). Path safety is enforced so the model can never escape the root directory.

const response = await ai.generate({
  prompt: 'Create a hello world program in the workspace',
  use: [filesystem({ rootDirectory: './workspace', allowWriteAccess: true })],
});

resp, err := genkit.Generate(ctx, g,
    ai.WithPrompt("Create a hello world program in the workspace"),
    ai.WithUse(&middleware.Filesystem{
        RootDir:          "./workspace",
        AllowWriteAccess: true,
    }),
)

final response = await ai.generate(
  prompt: 'Create a hello world program in the workspace',
  use: [filesystem(rootDirectory: './workspace')],
);

Building custom middleware

The pre-built middleware covers common scenarios, but the real power of the system is in writing your own. Imagine you’re building an agentic customer-support app and need to ensure the model never mentions competitor products or internal pricing data. Rather than encoding these rules in every prompt, you can enforce them deterministically with middleware.

Custom middleware follows a simple contract across all languages: provide a name and a factory that returns the hooks you want. The factory runs once per generate() invocation, and you implement only the hooks you need.

Here’s a complete, custom content filter that rejects any response containing a forbidden term:

import { generateMiddleware, z } from 'genkit';

export const contentFilter = generateMiddleware(
  {
    name: 'contentFilter',
    description: 'Rejects model responses containing forbidden terms',
    configSchema: z.object({ forbiddenTerms: z.array(z.string()) }),
  },
  ({ config }) => ({
    model: async (req, ctx, next) => {
      const resp = await next(req, ctx);
      const text = resp.text.toLowerCase();
      for (const term of config?.forbiddenTerms ?? []) {
        if (text.includes(term.toLowerCase())) {
          throw new Error(`content filter: response contains "${term}"`);
        }
      }
      return resp;
    },
  }),
);

// ContentFilter rejects model responses containing any forbidden term.
type ContentFilter struct {
    ForbiddenTerms []string `json:"forbiddenTerms"`
}

func (ContentFilter) Name() string { return "app/contentFilter" }

func (f ContentFilter) New(ctx context.Context) (*ai.Hooks, error) {
    return &ai.Hooks{
        WrapModel: func(ctx context.Context, p *ai.ModelParams, next ai.ModelNext) (*ai.ModelResponse, error) {
            resp, err := next(ctx, p)
            if err != nil {
                return nil, err
            }
            text := strings.ToLower(resp.Text())
            for _, term := range f.ForbiddenTerms {
                if strings.Contains(text, strings.ToLower(term)) {
                    return nil, fmt.Errorf("content filter: response contains %q", term)
                }
            }
            return resp, nil
        },
    }, nil
}

// Reject model responses containing any forbidden term.
class ContentFilter extends GenerateMiddleware {
  final List<String> forbiddenTerms;

  ContentFilter({this.forbiddenTerms = const []});

  @override
  Future model(ModelRequest request, dynamic ctx, dynamic next) async {
    final response = await next(request, ctx);
    final text = response.text.toLowerCase();
    for (final term in forbiddenTerms) {
      if (text.contains(term.toLowerCase())) {
        throw Exception('content filter: response contains "$term"');
      }
    }
    return response;
  }
}

Register it with defineMiddleware to expose a contentFilter() helper you can drop into a use array. See the middleware docs for the full registered pattern.

You can even compose and stack different middleware solutions. Middleware stacks left-to-right, with the first listed being the outermost wrapper:

const response = await ai.generate({
  model: googleAI.model('gemini-flash-latest'),
  prompt: 'What CRM should our customer use?',
  use: [
    retry({ maxRetries: 3 }), // outer: retries the inner stack
    contentFilter({           // inner: validates model output
      forbiddenTerms: ['CompetitorCRM', 'RivalCo', 'internal price'],
    }),
  ],
});

resp, err := genkit.Generate(ctx, g,
    ai.WithModelName("googleai/gemini-flash-latest"),
    ai.WithPrompt("What CRM should our customer use?"),
    ai.WithUse(
        &middleware.Retry{MaxRetries: 3},           // outer: retries the inner stack
        &ContentFilter{                              // inner: validates model output
            ForbiddenTerms: []string{"CompetitorCRM", "RivalCo", "internal price"},
        },
    ),
)

final response = await ai.generate(
  model: googleAI.gemini('gemini-flash-latest'),
  prompt: 'What CRM should our customer use?',
  use: [
    retry(maxRetries: 3),                 // outer: retries the inner stack
    contentFilter(forbiddenTerms: const [ // inner: validates model output
      'CompetitorCRM', 'RivalCo', 'internal price',
    ]),
  ],
);

Here Retry wraps ContentFilter, which wraps the model call. Order matters, and Genkit makes it explicit.

If you think you’ve built a middleware that will be valuable to other developers, you can publish it as a package for others to benefit from!

The Developer UI experience

You can use the Genkit Developer UI to inspect, test, and debug your application, including middleware execution. When you register middleware, it becomes visible in the Dev UI: you can inspect its configuration, trace execution through each hook layer, and test different combinations.

Get started

We’re excited for the capabilities that Genkit middleware unlocks for your apps, and we’re looking forward to seeing what custom middleware you’ll build to solve for your use-cases. Check out the middleware documentation to dive deeper, or get started with Genkit if you’re new to the framework.

Have an idea for a new pre-built middleware? File an issue. We’d love to hear what would improve your development experience!

Happy coding! 🚀

Announcing Genkit Dart: Build full-stack AI apps with Dart and Flutter

Tue, 10 Mar 2026 00:00:00 GMT

The Dart and Flutter communities have always pushed the boundaries of what’s possible across screens. You’ve shown that building high-quality, multi-platform applications doesn’t require compromising on developer experience. Now we’re bringing the same “write once, run anywhere” philosophy to AI-powered features and applications.

We are thrilled to announce the preview launch of Genkit Dart, an open-source AI framework for Dart and Flutter developers. Already available for TypeScript, Go, and Python, Genkit now empowers you to build high-quality, full-stack, AI-powered applications for any platform.

Why choose Genkit Dart?

Genkit Dart provides you with the following capabilities:

Model-agnostic API: Supports Google, Anthropic, OpenAI, and OpenAI API-compatible models out-of-the-box. You’re never locked into a single provider.
Type safety: Uses Dart’s strong type system with the schemantic package to generate strongly typed data and create type-safe AI flows.
Run code anywhere: Write your AI logic once and run it as a backend service or directly inside your Flutter app.
Developer UI: Includes a localhost web UI where you can test prompts, view traces, and debug your flows.
Complete AI toolkit: Provides everything you need to build high-quality AI features, including structured output, tools, multi-step flows, observability, and more.

Model-agnostic API

Genkit is designed to support any LLM provider, with out-of-the-box support for Google, Anthropic, OpenAI, and OpenAI API-compatible models in this release. This lets you switch between providers with minimal code changes.

import 'package:genkit/genkit.dart';
import 'package:genkit_google_genai/genkit_google_genai.dart';
import 'package:genkit_anthropic/genkit_anthropic.dart';

void main() async {
  // Initialize Genkit with plugins
  final ai = Genkit(plugins: [
    googleAI(),
    anthropic(),
  ]);

  // Call Google Gemini
  final geminiResponse = await ai.generate(
    model: googleAI.gemini('gemini-3.1-pro-preview'),
    prompt: 'Hello from Gemini',
  );

  // Call Anthropic Claude
  final claudeResponse = await ai.generate(
    model: anthropic.model('claude-opus-4.6'),
    prompt: 'Hello from Claude',
  );
}

Type-safe AI flows

Genkit lets you wrap your AI logic into testable, observable, deployable functions called flows.

Here is an example of a Travel Planner flow using strongly-typed input and output schemas, with tool calling:

import 'package:genkit/genkit.dart';
import 'package:genkit_google_genai/genkit_google_genai.dart';
import 'package:schemantic/schemantic.dart';

part 'travel_flow.g.dart';

// Define flow input schema with schemantic
@Schema()
abstract class $TripRequest {
  String get destination;
  int get days;
}

// Define tool input schema
@Schema()
abstract class $WeatherRequest {
  @Field(description: 'The city name')
  String get city;
}

void main() async {
  // Initialize Genkit and register the Google AI plugin
  final ai = Genkit(plugins: [googleAI()]);

  // Define a tool the model can invoke to fetch live data
  ai.defineTool(
    name: 'fetchWeather',
    description: 'Retrieves the current weather forecast for a given city',
    inputSchema: WeatherRequest.$schema,
    fn: (request, _) async => request.city.toLowerCase() == 'seattle' ? 'Rainy' : 'Sunny',
  );

  // Construct a strongly-typed, observable flow
  final tripPlannerFlow = ai.defineFlow(
    name: 'planTrip',
    inputSchema: TripRequest.$schema,
    outputSchema: .string(),
    fn: (request, _) async {
      // Generate content using the model and tool
      final response = await ai.generate(
        model: googleAI.gemini('gemini-3.1-pro-preview'),
        prompt: 'Build a ${request.days}-day travel itinerary for ${request.destination}. '
                'Make sure to check the weather forecast first to suggest appropriate activities.',
        toolNames: ['fetchWeather'],
      );

      return response.text;
    },
  );

  // Run the flow
  final itinerary = await tripPlannerFlow(
    TripRequest(destination: 'Seattle', days: 3)
  );
  print(itinerary);
}

When you’re ready, you can easily expose your flow as an API using the genkit_shelf package and deploy it to any platform that supports Dart.

import 'package:genkit_shelf/genkit_shelf.dart';
import 'package:shelf_router/shelf_router.dart';
import 'package:shelf/shelf_io.dart' as io;

void main() async {
  // ... initialize Genkit and define tripPlannerFlow ...

  final router = Router()
    ..post(
      '/api/planTrip',
      shelfHandler(tripPlannerFlow),
    );

  await io.serve(router.call, 'localhost', 8080);
}

Run anywhere Dart runs

Most complex AI logic runs on a server. However, because Dart works on both the frontend and backend, Genkit lets you easily move your AI code between your server and your Flutter app.

Here are a few ways you can build with Genkit Dart:

1. Entirely in Flutter for prototyping

You can write all of your Genkit logic, including model calls, directly in your Flutter app. This is great for prototypes or apps where users provide their own API keys and prompts aren’t private.

Warning: You should never publish an app with your API key embedded in the source code as it can be extracted and used by others.

2. Call backend flows from Flutter

When your prompts are sensitive or your AI logic is complex, you can move the entire flow to your backend. Your Flutter app can then call this flow by defining it as a “remote action”. Since the backend and frontend are both in Dart, they can share the same schemas for end-to-end type safety.

Here is an example showing how to call the Trip Planner backend flow we defined earlier from your Flutter app:

import 'package:genkit/client.dart';
import 'package:my_shared_models/models.dart'; // Shared schema

final tripPlannerFlow = defineRemoteAction(
  url: 'https://your-server.com/api/planTrip',
  inputSchema: TripRequest.$schema,
  outputSchema: .string(),
);

final itinerary = await tripPlannerFlow(
  input: TripRequest(destination: 'Tokyo', days: 5),
);

3. In Flutter with remote models

To secure your API keys while keeping the core AI logic in your Flutter app, you can create a small Genkit backend that proxies requests to the model provider with custom authorization logic. The models exposed through this backend are remote models.

import 'package:genkit_google_genai/genkit_google_genai.dart';
import 'package:genkit_shelf/genkit_shelf.dart';
import 'package:shelf_router/shelf_router.dart';
import 'package:shelf/shelf_io.dart' as io;

// Backend securely proxies requests to the model
void main() async {
  final geminiApi = googleAI();
  final targetModel = geminiApi.model('gemini-3.1-flash-lite-preview');
  final router = Router()
    ..post(
      '/api/gemini-model',
      shelfHandler(
        targetModel,
        // Insert custom authorization logic here
        contextProvider: (req) async => {'customAuth': true},
      ),
    );
  await io.serve(router.call, 'localhost', 8080);
}

In your Flutter app, use the remote model instead of a direct model plugin, passing any headers your server needs. This saves you from exposing your API keys and gives you more control over request authorization.

import 'package:genkit/genkit.dart';

// Flutter app communicates with the proxy server
final ai = Genkit();
final secureModel = ai.defineRemoteModel(
  name: 'secureModel',
  url: 'https://api.yourdomain.com/api/gemini-model',
  headers: (context) => {'Authorization': 'Bearer ${fetchSessionToken()}'},
);
final response = await ai.generate(model: secureModel, prompt: 'Write me a poem.');

Powerful tools for AI development

Building high-quality AI applications requires thorough testing and continuous iteration to achieve reliable results. To help with this, Genkit provides a powerful local Developer UI.

You can start the Developer UI alongside your code by running your app with the Genkit CLI:

genkit start -- dart run bin/server.dart

Here is a look at testing a more advanced version of our Trip Planner flow in the Developer UI:

AI coding assistance

For the best experience using Genkit Dart with AI coding tools like Antigravity, Gemini CLI, or Claude Code, install the Genkit Dart agent skill. This gives your AI assistant the knowledge to accurately write and debug your AI features.

Add the skill to your project:

npx skills add genkit-ai/skills

Learn more

This release is an early preview. We want to work with Dart and Flutter developers to improve the framework. You can find the core packages and provider plugins on pub.dev today.

Get started: Read our quickstart guide.
Join the community: Join our Discord server to ask questions and chat with the team.
Stay updated: Follow us on X and LinkedIn.
Give feedback: Open an issue on our GitHub repository to report bugs or request features.

We can’t wait to see what you build with Genkit Dart!

Announcing Genkit Go 1.0 and enhanced AI-assisted development

Wed, 10 Sep 2025 00:00:00 GMT

We’re excited to announce the release of Genkit Go 1.0, the first stable, production-ready release of Google’s open-source AI development framework for the Go ecosystem. Along with this release, we’re also introducing the genkit init:ai-tools command to supercharge your AI-assisted development workflow.

Genkit is an open-source framework for building full-stack AI-powered applications. It provides a unified interface for multiple model providers and streamlined APIs for multimodal content, structured outputs, tool calling, retrieval-augmented generation (RAG), and agentic workflows. With Genkit Go, you can now build and deploy production-ready AI applications with the speed, safety, and reliability of Go.

TL;DR

Genkit Go is now stable and ready for production use!

Key features:

Type-safe AI flows with Go structs and JSON schema validation
Unified model interface supporting Google AI, Vertex AI, OpenAI, Ollama, and more
Tool calling, RAG, and multimodal support
Rich local development tools with a standalone CLI binary and Developer UI
AI coding assistant integration via the genkit init:ai-tools command for tools like the Gemini CLI

Ready to start coding? Check out our get started guide.

What’s new in Genkit Go 1.0

Production-ready

Genkit Go 1.0 represents our commitment to providing a stable, reliable foundation for building AI-powered applications in Go. With this release, you can deploy AI-powered applications to production with Genkit, knowing that the API is stable and well-tested.

Like Go itself, it is intended that programs written with Genkit 1.* will continue to compile and run correctly, unchanged, even as future “point” releases of Genkit arise (Genkit 1.1, Genkit 1.2, etc.).

Type-safe AI flows

One of Genkit’s most powerful features is flows: functions for AI use-cases that provide observability, easy testing, and simplified deployment. Here’s how you can define a flow in Go for generating structured recipes:

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "log"

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

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

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() {
    ctx := context.Background()

    // Initialize Genkit with plugins
    g := genkit.Init(ctx,
        genkit.WithPlugins(&googlegenai.GoogleAI{}),
        genkit.WithDefaultModel("googleai/gemini-2.5-flash"),
    )

    // Define a type-safe flow
    recipeFlow := genkit.DefineFlow(g, "recipeGeneratorFlow",
        func(ctx context.Context, input *RecipeInput) (*Recipe, error) {
            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 data with type safety
            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
    recipe, err := recipeFlow.Run(ctx, &RecipeInput{
        Ingredient:          "avocado",
        DietaryRestrictions: "vegetarian",
    })
    if err != nil {
        log.Fatalf("could not generate recipe: %v", err)
    }

    // Print the structured recipe
    recipeJSON, _ := json.MarshalIndent(recipe, "", "  ")
    fmt.Println("Sample recipe generated:")
    fmt.Println(string(recipeJSON))

    <-ctx.Done() // Used for local testing only
}

Unified model interface

Genkit Go provides a single, consistent interface for working with multiple AI model providers including Google AI, Vertex AI, OpenAI, Anthropic, and Ollama. Learn more about generating content with AI models:

// Use Google AI models
resp, err := genkit.Generate(ctx, g,
    ai.WithModelName("googleai/gemini-2.5-flash"),
    ai.WithPrompt("What is the weather like today?"),
)

// Use OpenAI models
resp, err := genkit.Generate(ctx, g,
    ai.WithModelName("openai/gpt-4o"),
    ai.WithPrompt("How are you today?"),
)

// Switch to Ollama for local models
resp, err := genkit.Generate(ctx, g,
    ai.WithModelName("ollama/llama3"),
    ai.WithPrompt("What is the meaning of life?"),
)

Tool calling

Genkit Go makes it easy to give your AI models access to external functions and APIs. See the complete tool calling guide:

// Define a tool
type WeatherInput struct {
    Location string `json:"location" jsonschema_description:"Location to get weather for"`
}

getWeatherTool := genkit.DefineTool(g, "getWeather",
    "Gets the current weather in a given location",
    func(ctx *ai.ToolContext, input WeatherInput) (string, error) {
        // Your weather API logic here
        return fmt.Sprintf("The current weather in %s is 72°F and sunny.", input.Location), nil
    })

// Use the tool in generation
resp, err := genkit.Generate(ctx, g,
    ai.WithPrompt("What's the weather in San Francisco?"),
    ai.WithTools(getWeatherTool),
)

Easy deployment

Deploy your flows as HTTP endpoints with minimal setup. See the deployment guides for more options:

// Create HTTP handlers for your flows
mux := http.NewServeMux()
mux.HandleFunc("POST /recipeGeneratorFlow", genkit.Handler(recipeFlow))

// Start the server
log.Fatal(server.Start(ctx, "127.0.0.1:3400", mux))

Rich developer tooling

Genkit Go comes with a comprehensive set of development tools designed to make building AI applications fast and intuitive. The entire local toolchain is available through a single CLI that works seamlessly with your Go development workflow.

Standalone CLI installation

Get started quickly with our standalone CLI binary, with no other runtime installations required:

For macOS and Linux:

curl -sL cli.genkit.dev | bash

For Windows: Download directly from cli.genkit.dev.

The CLI works with Genkit applications in any supported language (JavaScript, Go, Python) and provides you with several convenient commands to rapidly test and iterate such as running and evaluating your flows.

Interactive Developer UI

The Developer UI provides a visual interface for testing and debugging your AI applications:

Test flows interactively: Run flows with different inputs and see cleanly rendered results
Debug with detailed tracing: Visualize exactly what your AI flows are doing step-by-step
Monitor performance: Track latency, token usage, and costs
Experiment with prompts: Test different prompts and model configurations

Launch the Developer UI alongside your Go application through the CLI:

genkit start -- go run .

Here’s what the experience looks like when running and inspecting the recipeGenerator flow from earlier:

Introducing `genkit init:ai-tools`

We’re also excited to introduce the genkit init:ai-tools command that revolutionizes how you work with AI assistants during development. This feature, now available for both JavaScript and Go developers, automatically configures popular AI coding assistants to work seamlessly with the Genkit framework and tooling. Learn more about AI-assisted development in Genkit.

To use it, install the Genkit CLI and run:

genkit init:ai-tools

Running the command does the following:

Detects existing AI assistant configurations and preserves your current settings
Installs the Genkit MCP server with powerful development tools:
- lookup_genkit_docs: Search Genkit documentation from genkit.dev
- list_flows: List all flows in your current Genkit app
- run_flow: Execute flows with test inputs
- get_trace: Fetch execution traces for debugging and analysis
Creates a GENKIT.md file with comprehensive language-specific instructions for AI assistants

Supported AI tools

The command has built-in support for:

Gemini CLI - Google’s CLI-based AI coding assistant
Firebase Studio - Firebase’s agentic, cloud-based development environment
Claude Code - Anthropic’s coding assistant
Cursor - AI-powered code editor

For other tools, select the “generic” option to get a GENKIT.md file you can integrate manually.

Enhanced development experience

With AI assistant integration, you can:

Ask questions about Genkit Go APIs and get accurate, up-to-date answers
Generate Go-specific Genkit code that follows best practices
Debug flows by having your AI assistant analyze traces
Test your applications with AI-generated inputs
Get help with Go-specific patterns and idiomatic code

Quick start

1. Create a new project:

mkdir my-genkit-app && cd my-genkit-app
go mod init example/my-genkit-app

2. Install Genkit and CLI:

go get github.com/firebase/genkit/go
curl -sL cli.genkit.dev | bash

3. Set up AI assistant integration:

genkit init:ai-tools

4. Create your first flow using the examples above

5. Start the Developer UI:

genkit start -- go run .

For a more detailed walkthrough, see the get started guide.

Learn more

Documentation: genkit.dev
Get started guide: Go quickstart
Go API reference: pkg.go.dev
Examples: GitHub samples
Community: Genkit Discord

Genkit Go 1.0 combines Go’s performance and reliability with Genkit’s production-ready AI framework and tooling. We can’t wait to see what you build!

Happy coding! 🚀

Genkit | Blog

Announcing Genkit Middleware: Intercept, extend, and harden your agentic apps

How Genkit middleware works

Pre-built middleware

1. Retry

2. Fallback

3. Tool approval

4. Skills

5. Filesystem

Building custom middleware

The Developer UI experience

Get started

Announcing Genkit Dart: Build full-stack AI apps with Dart and Flutter

Why choose Genkit Dart?

Model-agnostic API

Type-safe AI flows

Run anywhere Dart runs

1. Entirely in Flutter for prototyping

2. Call backend flows from Flutter

3. In Flutter with remote models

Powerful tools for AI development

AI coding assistance

Learn more

Announcing Genkit Go 1.0 and enhanced AI-assisted development

TL;DR

What’s new in Genkit Go 1.0

Production-ready

Type-safe AI flows

Unified model interface

Tool calling

Easy deployment

Rich developer tooling

Standalone CLI installation

Interactive Developer UI

Introducing genkit init:ai-tools

Supported AI tools

Enhanced development experience

Quick start

Learn more

Introducing `genkit init:ai-tools`