Anunciando o Genkit Dart 1.0: crie apps agênticos prontos para produção com Dart e Flutter

Anunciando o lançamento estável 1.0 do Genkit Dart, um framework de código aberto para criar funcionalidades com IA e fluxos de trabalho agênticos com Dart e Flutter.

A Dash está ao lado de uma pilha de blocos com os logos do Dart e do Genkit e o número da versão 1.0.

Dart e Flutter permitem criar apps de alta qualidade para mobile, web e desktop a partir de uma única base de código. Com o Genkit Dart, você pode levar essa mesma produtividade para apps full-stack e agênticos.

Hoje anunciamos o Genkit Dart 1.0, a primeira versão estável, pronta para produção, do framework open source do Google para criar recursos e agentes com IA em Dart. Desde o nosso lançamento de prévia no início deste ano, o feedback da comunidade Dart e Flutter ajudou a refinar as APIs e a expandir o kit de ferramentas para cargas de trabalho de produção.

Para começar, adicione genkit ao seu projeto:

shell
dart pub add genkit

Você também pode instalar a skill de agente para dar aos assistentes de programação com IA, como o Antigravity, o Claude Code e o Codex, conhecimento atualizado sobre as APIs e as melhores práticas do Genkit Dart:

shell
npx skills add genkit-ai/skills

Por que Genkit Dart

O Genkit oferece uma API unificada entre provedores de modelos, segurança de tipos de ponta a ponta entre seu servidor e seu cliente, e ferramentas locais para testar e depurar seus fluxos de trabalho de IA.

Use qualquer modelo com uma única API

O Genkit oferece suporte ao Google Gemini, ao Anthropic Claude, à OpenAI e a modelos compatíveis com a OpenAI por meio de uma única interface. Você registra provedores de modelos como plugins e pode trocar de modelo sem reescrever a lógica da sua aplicação:

dart
final ai = Genkit(plugins: [googleAI(), anthropic()]);
final prompt = 'Suggest a weekend getaway from San Francisco.';
​
final fromGemini = await ai.generate(
  model: googleAI.gemini('gemini-flash-latest'),
  prompt: prompt,
);
​
final fromClaude = await ai.generate(
  model: anthropic.model('claude-sonnet-5-5'),
  prompt: prompt,
);

Segurança de tipos de ponta a ponta com flows

O Genkit permite encapsular sua lógica de IA em flows: funções fortemente tipadas e observáveis, fáceis de testar e de implantar como endpoints HTTP. Usando o pacote schemantic, você pode definir seus esquemas de dados uma única vez em Dart, gerar saída estruturada a partir do modelo e compartilhar esses tipos exatos entre seu backend e seu app Flutter:

dart
// shared/lib/models.dart (used by both server and app)
@Schema()
abstract class $TripRequest {
  String get destination;
  int get days;
}
// ...plus an Itinerary schema for the result.
​
// server/bin/server.dart
final planTrip = ai.defineFlow(
  name: 'planTrip',
  inputSchema: TripRequest.$schema,
  outputSchema: Itinerary.$schema,
  fn: (request, _) async {
    final response = await ai.generate(
      model: googleAI.gemini('gemini-flash-latest'),
      prompt: 'Plan a ${request.days}-day trip to ${request.destination}.',
      outputSchema: Itinerary.$schema,
    );
    return response.output!;
  },
);
await (GenkitRouter()..addAction(planTrip)).serve(port: 8080); // POST /planTrip
​
// app/lib/main.dart
final planTrip = defineRemoteAction(
  url: 'https://api.example.com/planTrip', // Your Genkit endpoint
  inputSchema: TripRequest.$schema,
  outputSchema: Itinerary.$schema,
);
final itinerary = await planTrip(
  input: TripRequest(destination: 'Kyoto', days: 5),
);

Execute em qualquer lugar onde o Dart roda

Como sua lógica de IA é escrita em Dart padrão, você tem iterações rápidas com hot reload e a flexibilidade de executar seu código onde ele se encaixar melhor na sua arquitetura:

  • Diretamente no Flutter: chame modelos direto do seu app para prototipagem rápida ou experiências com chave própria do usuário (nunca embuta chaves de API privadas em um app cliente publicado).
  • Em um servidor Dart: execute flows complexos e mantenha prompts sensíveis no backend, e então chame-os a partir do Flutter usando defineRemoteAction, como mostrado acima.
  • No Flutter com modelos remotos: mantenha sua lógica de IA no app Flutter enquanto roteia as requisições aos modelos por um backend leve do Genkit que protege suas chaves de API e aplica autorização:
dart
// server/bin/server.dart
final genkit = GenkitRouter()
  ..addAction(
    googleAI().model('gemini-flash-latest'),
    path: '/gemini',
    // Runs before the model; throw a GenkitException to reject the request.
    contextProvider: (request) async =>
        {'user': await verifyUser(request.headers['authorization'])},
  );
await genkit.serve(port: 8080);
​
// app/lib/main.dart
final ai = Genkit();
final gemini = ai.defineRemoteModel(
  name: 'gemini',
  url: 'https://api.example.com/gemini',
  headers: (context) async => {'Authorization': 'Bearer ${await getIdToken()}'},
);
final response = await ai.generate(
  model: gemini,
  prompt: 'Suggest a packing list for Kyoto in April.',
);

Teste e depure com a Developer UI

O Genkit inclui uma Developer UI local para testar flows, experimentar prompts e inspecionar traces de execução passo a passo. Inicie-a junto com seu processo Dart usando a CLI do Genkit:

shell
genkit start -- dart run bin/server.dart
Inspecionando as chamadas de modelo e de ferramentas de um agente na Developer UI do Genkit
Inspecionando as chamadas de modelo e de ferramentas de um agente na Developer UI do Genkit

Feito para fluxos de trabalho agênticos

Desde o lançamento da prévia, expandimos o Genkit Dart com recursos pensados para fluxos de trabalho agênticos de várias etapas, incluindo interrupções human-in-the-loop, middleware de geração, gerenciamento de prompts e telemetria de produção.

Dê ferramentas aos modelos com interrupções human-in-the-loop

As ferramentas permitem que os modelos chamem suas funções Dart para buscar dados ou disparar ações, como pesquisar voos ou reservar um hotel. Quando uma ação exige confirmação do usuário, uma ferramenta pode pausar o loop de geração retornando .interrupt(...) em vez de .response(...):

dart
final bookHotel = ai.defineTool(
  name: 'bookHotel',
  description: 'Books a hotel room for the user.',
  inputSchema: HotelBooking.$schema,
  fn: (input, ctx) async {
    // Ask the user to confirm before charging their card.
    if (ctx.resumed == null) {
      return .interrupt({'hotel': input.hotelName, 'total': input.totalPrice});
    }
    final confirmation = await hotels.book(input);
    return .response(confirmation.id);
  },
);

Colocar a verificação de aprovação dentro da ferramenta garante que o modelo não consiga contorná-la. Quando generate retorna com FinishReason.interrupted, seu app Flutter pode pedir a confirmação do usuário e retomar a execução a partir de onde parou.

Estenda a geração com middleware

O middleware se conecta diretamente ao loop generate para interceptar chamadas de modelo, injetar ferramentas ou modificar requisições e respostas. Usando genkit e genkit_middleware, você pode acoplar recursos pré-empacotados, como novas tentativas automáticas, carregamento dinâmico de SKILL.md e regras de aprovação de ferramentas, a qualquer chamada de generate:

dart
final ai = Genkit(plugins: [googleAI(), SkillsPlugin(), ToolApprovalPlugin()]);
​
final response = await ai.generate(
  model: googleAI.gemini('gemini-flash-latest'),
  prompt: 'Move my Kyoto hotel check-in to Friday.',
  tools: [findBookings, updateBooking],
  use: [
    retry(maxRetries: 3),
    skills(skillPaths: ['./skills']),
    toolApproval(approved: ['findBookings', 'use_skill']),
  ],
);

Você também pode criar middleware personalizado com defineGenerateMiddleware para lógica transversal, como log, cache ou fallbacks de modelo.

Gerencie prompts com o Dotprompt

Dotprompt permite gerenciar templates de prompt, configuração de modelo e esquemas de entrada e saída juntos em arquivos .prompt . O Genkit carrega automaticamente os prompts do seu diretório prompts/, para que você possa invocá-los como funções chamáveis em Dart:

dotprompt
---
model: googleai/gemini-flash-latest
input:
  schema:
    destination: string
---
Write a friendly, two-sentence introduction to {{destination}} for a first-time visitor.
dart
final introPrompt = await ai.prompt('destinationIntro');
final response = await introPrompt({'destination': 'Kyoto'});

Monitore seu app em produção

Quando estiver pronto para implantar, o pacote genkit_otel exporta traces, métricas de uso de tokens e de latência usando as convenções semânticas do OpenTelemetry GenAI, integrando-se diretamente ao seu backend de observabilidade existente:

dart
import 'package:dartastic_opentelemetry/dartastic_opentelemetry.dart';
import 'package:genkit/telemetry.dart';
import 'package:genkit_otel/genkit_otel.dart';
​
await OTel.initialize();
configureInstrumentation(GenAiInstrumentation());

O que vem por aí: agentes com estado e UI generativa

Junto com o núcleo estável 1.0, estamos desenvolvendo APIs de agentes de nível mais alto sob o import package:genkit/experimental.dart, para que você possa testá-las cedo e ajudar a moldar o design delas.

Agentes com estado combinam um modelo, ferramentas, instruções de sistema e estado em uma única chamada defineAgent. As conversas persistem entre turnos e reinicializações do app usando armazenamentos de sessão, e você pode usar remoteAgent para delegar tarefas a subagentes ou expor agentes via HTTP para se conectar ao seu app Flutter:

dart
import 'package:genkit/experimental.dart';
​
final travelAgent = ai.defineAgent(
  name: 'travelAgent',
  model: googleAI.gemini('gemini-flash-latest'),
  system: 'You help users plan and book trips.',
  tools: [searchFlights, bookHotel],
  store: FirestoreSessionStore(collection: 'sessions'),
);
​
final chat = travelAgent.chat(sessionId: 'user-123');
final response = await chat.send(text: 'Find me a weekend in Lisbon.');

UI generativa com A2UI permite que agentes transmitam superfícies de UI interativas em vez de texto simples. Com genkit_a2ui, um agente pode emitir componentes como seletores de data, formulários e cartões de confirmação que seu app Flutter renderiza incrementalmente como widgets nativos. Confira o guia do A2UI para saber mais.

Começar

O Genkit Dart 1.0 já está disponível no pub.dev hoje. Obrigado a todos da comunidade Dart e Flutter que criaram com a prévia, reportaram problemas e contribuíram com pull requests para levar o Genkit Dart até a versão 1.0.

Mal podemos esperar para ver o que você vai criar com o Genkit Dart 1.0!

Mais do Flutter