Genkit Dart: Construindo Backends de IA Full-Stack com Flutter

O que é o Genkit Dart?

O Genkit Dart é um framework de IA full-stack para Dart e Flutter, criado pelo Google. Diferente do Firebase AI Logic (que é client-side), o Genkit permite construir backends de IA completos em Dart, oferecendo controle total sobre fluxos, modelos e segurança.

Se o Firebase AI Logic é para prototipagem rápida, o Genkit Dart é para aplicações em produção que precisam de lógica complexa no servidor.

Firebase AI Logic vs Genkit Dart

Antes de mergulhar, entenda a diferença fundamental:

Firebase AI Logic — App → API Gemini (client-side). Simples, rápido, menos controle.
Genkit Dart — App → Seu servidor Dart → API Gemini (server-side). Mais controle, mais flexibilidade, mais segurança.

Na prática: use Firebase AI Logic para prototipagem e apps simples. Use Genkit quando precisar de lógica complexa, proteger chaves de API ou criar pipelines de IA sofisticados.

Arquitetura do Genkit

1. Flows (Fluxos)

Fluxos são o conceito central do Genkit. Cada flow é uma função Dart que:

Recebe uma entrada estruturada
Executa uma ou mais chamadas de IA
Retorna uma saída estruturada

2. Plugins

Plugins conectam o Genkit a provedores de IA (Google AI, OpenAI, etc.) e serviços externos.

3. Actions

Actions são funções que o modelo pode chamar durante a geração (tool calling).

Como Começar

1. Instalação do Servidor

# Criar projeto Dart
dart create my_ai_server
cd my_ai_server

# Adicionar Genkit ao pubspec.yaml
dependencies:
  genkit: ^latest
  genkit_google_ai: ^latest

2. Configurar o Flow

import 'package:genkit/genkit.dart';

final ai = Genkit(
  plugins: [
    GoogleAI(apiKey: Platform.environment['GOOGLE_AI_KEY']!),
  ],
);

// Definir um flow
final generateOutline = ai.defineFlow(
  name: 'generateOutline',
  inputType: Schema.string,
  outputType: Schema.string,
) async (topic) {
  final response = await ai.generate(
    model: 'googleai/gemini-2.0-flash',
    prompt: 'Gere um outline detalhado para um artigo sobre: $topic',
  );
  return response.text;
};

3. Expor como API

import 'package:shelf/shelf.dart';
import 'package:shelf_router/shelf_router.dart';

final router = Router();

router.post('/api/generate', (Request request) async {
  final body = await request.readAsString();
  final result = await generateOutline(body);
  return Response.ok(result, headers: {'content-type': 'application/json'});
});

4. Chamar do Flutter

// No app Flutter
final response = await http.post(
  Uri.parse('https://seu-servidor.com/api/generate'),
  body: 'Inteligência Artificial',
);
print(response.body);

Tool Calling: Ações para o Modelo

Uma das features mais poderosas do Genkit é o tool calling — permitir que o modelo chame funções Dart:

// Definir uma action
final searchProduct = ai.defineAction(
  name: 'searchProduct',
  description: 'Busca produto no banco de dados',
  inputType: Schema.object({
    'query': Schema.string(),
  }),
  outputType: Schema.object({
    'name': Schema.string(),
    'price': Schema.number(),
  }),
) async (input) {
  // Lógica de busca no banco
  return {'name': 'iPhone 16', 'price': 7999.99};
};

// Usar no flow
final chat = ai.defineFlow(
  name: 'productAssistant',
  inputType: Schema.string,
  outputType: Schema.string,
) async (question) {
  final response = await ai.generate(
    model: 'googleai/gemini-2.0-flash',
    tools: [searchProduct],
    prompt: question,
  );
  return response.text;
};

Pipelines de IA Complexos

Com Genkit, você pode criar pipelines com múltiplas etapas:

final processDocument = ai.defineFlow(
  name: 'processDocument',
  inputType: Schema.bytes,
  outputType: Schema.object({
    'resumo': Schema.string(),
    'categorias': Schema.list(Schema.string()),
    'sentimento': Schema.string(),
  }),
) async (documentBytes) {
  // Etapa 1: Extrair texto
  final texto = await extractText(documentBytes);
  
  // Etapa 2: Gerar resumo
  final resumo = await ai.generate(
    model: 'googleai/gemini-2.0-flash',
    prompt: 'Resuma este documento: $texto',
  );
  
  // Etapa 3: Classificar
  final classificacao = await ai.generate(
    model: 'googleai/gemini-2.0-flash',
    prompt: 'Classifique o documento em categorias e sentimento: $texto',
    outputType: Schema.object({
      'categorias': Schema.list(Schema.string()),
      'sentimento': Schema.string(),
    }),
  );
  
  return {
    'resumo': resumo.text,
    'categorias': classificacao.output['categorias'],
    'sentimento': classificacao.output['sentimento'],
  };
};

Deploy

O Genkit Dart pode ser implantado em vários ambientes:

Google Cloud Run — Recomendado para produção
Firebase Functions — Integração nativa com Firebase
Docker — Qualquer ambiente containerizado
Servidor próprio — Controle total da infraestrutura

Boas Práticas

Valide entradas e saídas — Use schemas para garantir tipos corretos
Trate erros — Sempre implemente fallbacks
Cacheie resultados — Para fluxos pesados, use Redis ou similar
Monitore custos — Cada chamada de IA tem custo, meça uso
Segure suas chaves — Nunca exponha API keys no cliente

Conclusão

O Genkit Dart é uma ferramenta poderosa para quem quer construir aplicações de IA full-stack em Dart. Com suporte a tool calling, pipelines complexos e deploy flexível, é ideal para projetos que precisam de controle total sobre a lógica de IA no servidor.

Tem dúvidas sobre Genkit Dart? Já construiu algo com ele? Compartilhe sua experiência!