Anunciando Genkit Dart: Construye aplicaciones AI full-stack con Dart y Flutter

Las comunidades de Dart y Flutter siempre han expandido los límites de lo que es posible en las pantallas. Han demostrado que construir aplicaciones de alta calidad y multiplataforma no requiere comprometer la experiencia del desarrollador. Ahora estamos trayendo la misma filosofía de "escribe una vez, ejecuta en cualquier lugar" a las funciones y aplicaciones potenciadas con IA.

Estamos emocionados de anunciar el lanzamiento en preview de Genkit Dart, un framework de IA de código abierto para desarrolladores de Dart y Flutter. Ya disponible para TypeScript, Go y Python, Genkit ahora te empodera para construir aplicaciones de alta calidad, full-stack y potenciadas con IA para cualquier plataforma.

Genkit Dart te proporciona las siguientes capacidades:

• API agnóstica al modelo: Soporta modelos de Google, Anthropic, OpenAI y compatibles con la API de OpenAI listos para usar. Nunca estás bloqueado en un único proveedor.

• Seguridad de tipos: Usa el sistema de tipos fuerte de Dart con el paquete schemantic para generar datos fuertemente tipados y crear flujos de IA con seguridad de tipos.

• Ejecuta código en cualquier lugar: Escribe tu lógica de IA una vez y ejecútala como un servicio backend o directamente dentro de tu app de Flutter.

• UI para desarrolladores: Incluye una interfaz web local donde puedes probar prompts, ver trazas y depurar tus flujos.

• Toolkit completo de IA: Proporciona todo lo que necesitas para construir funciones de IA de alta calidad, incluyendo salida estructurada, herramientas, flujos multi-paso, observabilidad y más.

Genkit está diseñado para soportar cualquier proveedor de LLM, con soporte listo para usar para modelos de Google, Anthropic, OpenAI y compatibles con la API de OpenAI en este lanzamiento. Esto te permite cambiar entre proveedores con cambios mínimos en el código.

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',
  );
}

Genkit te permite envolver tu lógica de IA en funciones testeables, observables y desplegables llamadas flows.

Aquí hay un ejemplo de un flow de Travel Planner usando esquemas de entrada y salida fuertemente tipados, con 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);
}

Cuando estés listo, puedes exponer fácilmente tu flow como una API usando el paquete genkit_shelf y desplegarlo en cualquier plataforma que soporte 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);
}

La mayoría de la lógica de IA compleja se ejecuta en un servidor. Sin embargo, como Dart funciona tanto en el frontend como en el backend, Genkit te permite mover fácilmente tu código de IA entre tu servidor y tu app de Flutter.

Aquí hay algunas formas en las que puedes construir con Genkit Dart:

Puedes escribir toda tu lógica de Genkit, incluyendo llamadas al modelo, directamente en tu app de Flutter. Esto es genial para prototipos o apps donde los usuarios proporcionan sus propias API keys y los prompts no son privados.

Advertencia: Nunca debes publicar una app con tu API key incrustada en el código fuente, ya que puede ser extraída y usada por otros.

Cuando tus prompts son sensibles o tu lógica de IA es compleja, puedes mover todo el flow a tu backend. Tu app de Flutter puede entonces llamar a este flow definiéndolo como una "acción remota". Dado que el backend y el frontend están ambos en Dart, pueden compartir los mismos esquemas para seguridad de tipos de extremo a extremo.

Aquí hay un ejemplo que muestra cómo llamar al flow del backend de Trip Planner que definimos antes desde tu app de Flutter:

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),
);

Para asegurar tus API keys mientras mantienes la lógica central de IA en tu app de Flutter, puedes crear un pequeño backend de Genkit que haga proxy de las peticiones al proveedor del modelo con lógica de autorización personalizada. Los modelos expuestos a través de este backend son modelos remotos.

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);
}

En tu app de Flutter, usa el modelo remoto en lugar de un plugin de modelo directo, pasando cualquier header que tu servidor necesite. Esto te evita exponer tus API keys y te da más control sobre la autorización de peticiones.

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.');

Construir aplicaciones de IA de alta calidad requiere pruebas exhaustivas e iteración continua para lograr resultados confiables. Para ayudar con esto, Genkit proporciona una potente UI de desarrollador local.

Puedes iniciar la UI de desarrollador junto con tu código ejecutando tu app con el CLI de Genkit:

genkit start -- dart run bin/server.dart

Aquí hay un vistazo a la prueba de una versión más avanzada de nuestro flow de Trip Planner en la UI de desarrollador:

Para la mejor experiencia usando Genkit Dart con herramientas de IA para programar como Antigravity, Gemini CLI, o Claude Code, instala el agent skill de Genkit Dart. Esto le da a tu asistente de IA el conocimiento para escribir y depurar tus funciones de IA con precisión.

Añade el skill a tu proyecto:

npx skills add genkit-ai/skills

Este lanzamiento es una preview temprana. Queremos trabajar con desarrolladores de Dart y Flutter para mejorar el framework. Puedes encontrar los paquetes centrales y los plugins de proveedores en pub.dev hoy.

• Comienza: Lee nuestra guía de inicio rápido.

• Únete a la comunidad: Únete a nuestro servidor de Discord para hacer preguntas y chatear con el equipo.

• Mantente actualizado: Síguenos en X y LinkedIn.

• Da feedback: Abre un issue en nuestro repositorio de GitHub para reportar bugs o solicitar funciones.

¡Estamos ansiosos por ver qué construyes con Genkit Dart!