Genkit | Blog

Dotprompt comes to Genkit Dart: Richer prompt templating and management

Fri, 19 Jun 2026 12:00:00 GMT

Prompt engineering is an iterative process. The model, its parameters, and the prompt text all shape the output together, and getting them right takes many rounds of tuning. As a prompt grows in complexity, it helps to treat that whole bundle as an artifact you can edit, version, and test on its own. That is where Dotrpompt can help!

Genkit Dart 0.14.0 brings Dotprompt to Dart and Flutter developers. Simple prompts are often fine inline, and Genkit still supports that. When a prompt does more work, Dotprompt lets you move it into a .prompt file that lives alongside your app. You define the prompt there, iterate on it in the Developer UI, and run it from Dart by name.

A prompt in a file

A .prompt file is YAML front matter, holding the model and its config, followed by a Handlebars template. Drop this into your prompts/ directory as greeting.prompt:

---
model: googleai/gemini-flash-latest
config:
  temperature: 0.7
input:
  schema:
    name: string, the person to greet
    style: string, the greeting style (e.g. cheerful, casual, pirate)
---
{{role "system"}}
You are a friendly greeter. Greet the user warmly.
{{role "user"}}
Say hello to {{name}} in a {{style}} way.

Then load and run it from your app. By default Genkit looks for prompts in ./prompts:

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

void main() async {
  final ai = Genkit(plugins: [googleAI()]);

  final greeting = await ai.prompt('greeting');
  final response = await greeting({'name': 'Ada', 'style': 'cheerful'});
  print(response.text);
}

For a prompt like this, none of the prose lives in your code. The model and temperature sit right next to the text they shape, and your application asks for the prompt by name and stays out of the tuning loop.

When to give a prompt its own file

Not every prompt needs one. A single-line system prompt can stay in your Dart. Reach for a .prompt file once a prompt does enough work to earn the benefits below, which usually means complex or highly dynamic templating, or text that a separate subject-matter expert needs to review and edit.

Independent versioning: Prompt changes land as prompt diffs you can review and revert on their own, without untangling them from application logic. The history shows exactly how the wording, model, and config evolved.
Real templating: Handlebars helpers, partials, and conditionals express complex, dynamic prompts cleanly, so you can drop the brittle string concatenation in Dart.
Accessible for non-developers: A subject-matter expert who doesn’t work on the code can read the plain YAML and template and adjust the prompt with more confidence.
An executable, testable unit: The model, config, input and output schemas, and template all travel together as one runnable artifact. You render it, run it, and assert on its output directly, rather than reassembling the pieces at every call site.
Fast iteration: Load prompts in the Developer UI, where you run it against custom input, compare against variants, and view detailed execution traces for rapid iteration.

What shipped

This release brings the full Dotprompt feature set to Dart:

.prompt files with YAML front matter, Handlebars templates, and the {{role}} and {{media}} helpers for multi-message and multimodal prompts.
Structured I/O via input and output schemas, including Picoschema and schemas defined in code with schemantic.
Streaming with prompt.stream(), plus render() to inspect the final messages without calling the model.
Variants for side-by-side experimentation. Add a greeting.formal.prompt file and load it with await ai.prompt('greeting', variant: 'formal').
Partials for reusable snippets. A file like _signature.prompt can be included in any prompt with {{> signature}}.

Prompt templates in code

Prefer to keep prompts in code but still want the templating benefits? Define a strongly-typed input schema with schemantic:

@Schema()
abstract class $JokeInput {
  @Field(description: 'The joke topic (e.g. programming, cats, cooking)')
  String get topic;

  @Field(description: 'The joke style (e.g. punny, dry, dad)')
  String get style;
}

Then definePrompt() takes the same metadata as a .prompt file with a Handlebars template and the generated schema:

final jokePrompt = ai.definePrompt(
  name: 'joke',
  model: modelRef('googleai/gemini-flash-latest'),
  config: {'temperature': 0.9},
  inputSchema: JokeInput.$schema,
  system: 'You are a witty comedian. Keep jokes family-friendly.',
  prompt: 'Tell me a {{style}} joke about {{topic}}.',
);

final response = await jokePrompt(JokeInput(topic: 'cats', style: 'punny'));
print(response.text);

And when you need to build messages programmatically, defineCustomPrompt() lets you return a GenerateActionOptions describing the request yourself.

Iterate in the Developer UI

Every .prompt file loads straight into the Genkit Developer UI. There you can edit parameters, run them against live input, and compare variants side by side in traces.

Start the UI alongside your app:

genkit start -- dart run

Get started

Update to Genkit Dart 0.14.0 and start moving your prompts into .prompt files today.

Read the docs: Dive into the Dotprompt documentation to see everything you can do.
New to Genkit Dart? Start with the quickstart guide.
Join the community: Ask questions and chat with the team on our Discord server.
Stay updated: Follow us on X and LinkedIn.
Give feedback: Open an issue on the GitHub repository to report bugs or request features.

We can’t wait to see what you build. Happy prompting! 🚀

Is it thinking or is it broken? Building transparent AI chat UIs with Genkit

Wed, 17 Jun 2026 12:00:00 GMT

One of the worst user experiences imaginable is that your users are convinced your app is broken while your app is working correctly. This is even more apparent with AI powered apps since processing takes some time to occur with AI models. Your user sends a chat message and then they are stuck waiting on a response with no insight into whether or not the app is doing anything. In this post, we are going to break down how to give your users insights into your agents’ thought process to make sure your users aren’t left hanging.

Streaming thoughts

Genkit has the capability through server sent events to emit a stream of data to clients connecting to your agent. Some of the things that can be streamed include the regular text responses but most models now include things like thinking to improve their reasoning and responses to users. The following is an example of the experience you can create with Genkit that visualizes your thinking process for your model.

Agent Streaming Session Demo

Hello! I am your simulated Genkit AI instance powered by Gemini 3.5 Flash. Ask me a question or try a suggestion below, and I'll stream my step-by-step thinking process alongside my final response!

Suggestions:

This not only gives you insight into what the agent is doing but also improves the output of the response. By using thinking, we can improve our agents’ responses and also provide a better user experience. Below is a Genkit code snippet on how to extract a thought from an agent and then by using a server sent events stream that thought process down to the user.

// 1. Generate a stream with thinking config enabled
const { stream, response } = await ai.generateStream({
  model: googleAI.model('gemini-flash-latest'),
  prompt: 'Why is Genkit so cool?',
  config: {
    thinkingConfig: {
      includeThoughts: true,
      thinkingLevel: 'MEDIUM',
    },
  },
});

// 2. Consume the stream and separate reasoning from the final response
for await (const chunk of stream) {
  // Extract reasoning (thinking process)
  const thoughtText = chunk.reasoning || '';
  if (thoughtText) {
    sendChunk({ type: 'thought', content: thoughtText });
  }

  // Extract standard text response
  const text = chunk.text;
  if (text) {
    sendChunk({ type: 'text', content: text });
  }
}

After looking at this sample, you may be wondering what sendChunk is returning. This is the Output Schema that we defined for our Genkit flow. In this example, it looks something like this:

const StreamChunkSchema = z.object({
  messageId: z.string(),
  type: z.enum(['thought', 'text']),
  content: z.string(),
  currentStep: z.string().optional(),
});

Rendering the thoughts in the chat window

By having the thoughts being streamed from the server, we can now put together responses that our client would receive to give some clarity to our users. We designed a React component that is a thought box that uses CSS to show an animation as new thoughts are streamed down. We also provided an option to then receive those thoughts and store all of them in a smaller text box that is collapsible so users can inspect the full thought contents as they are received giving the user a choice to see what exactly the model is doing or to continue to recieve high level updates.

import React, { useState } from 'react';

interface ThoughtBoxProps {
  content: string;    // The full accumulated thought content
  stepName?: string;  // The current step description (e.g. "Analyzing input")
}

export const ThoughtBox: React.FC<ThoughtBoxProps> = ({ content, stepName }) => {
  const [isOpen, setIsOpen] = useState(false);
  const activeStep = stepName || 'Thinking';

  return (
    <div className="message thought-message">
      <div className="thought-box">
        {/* Animated header showing the current step */}
        <div className="thought-header">
          <div key={`indicator-${activeStep}`} className="thought-indicator indicator-animate" />
          <div key={`label-${activeStep}`} className="thought-step-label step-animate">
            Thinking: {activeStep}
          </div>
        </div>

        {/* Collapsible details wrapper for the full thought content */}
        <details
          className="thought-details"
          onToggle={(e) => setIsOpen(e.currentTarget.open)}
        >
          <summary className="thought-summary">
            <span className="summary-text">
              {isOpen ? 'Hide Full Reasoning' : 'Show Full Reasoning'}
            </span>
          </summary>
          <div className="thought-body">{content}</div>
        </details>
      </div>
    </div>
  );
};

With this component, we can easily add it to other apps that are not strictly chat based apps but other apps that might want to have a thought component rendered while the models are thinking.

Putting it all together

Using a small React component with our Genkit flow allows us to keep the user informed of what is going on while our models are thinking. This makes it appear that the model is working and processing information keeping the user informed and limiting their impression that the app has stalled or is broken.

If you want to try out the React component and Genkit streaming server-sent events yourself, you can check out the streaming thoughts sample in our samples repository.

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

Thu, 14 May 2026 12: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 12: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 12: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-flash-latest"),
    )

    // 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-flash-latest"),
    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

Dotprompt comes to Genkit Dart: Richer prompt templating and management

A prompt in a file

When to give a prompt its own file

What shipped

Prompt templates in code

Iterate in the Developer UI

Get started

Is it thinking or is it broken? Building transparent AI chat UIs with Genkit

Streaming thoughts

Rendering the thoughts in the chat window

Putting it all together

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`