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.
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:
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:
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:
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:
// 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:
// 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:
genkit start -- dart run bin/server.dart
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(...):
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:
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:
---
model: googleai/gemini-flash-latest
input:
schema:
destination: string
---
Write a friendly, two-sentence introduction to {{destination}} for a first-time visitor.
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:
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:
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.
- Comece por aqui: siga o guia de início rápido.
- Explore os exemplos: navegue pelos apps de exemplo no GitHub.
- Participe da comunidade: converse com a equipe no Discord.
- Fique por dentro: siga o Genkit no X e no LinkedIn.
- Dê seu feedback: abra uma issue no repositório do GitHub.
Mal podemos esperar para ver o que você vai criar com o Genkit Dart 1.0!
