Introduzione: cos’è Genkit Dart e perché dovresti conoscerlo
Se sviluppi app con Flutter, probabilmente hai già iniziato a chiederti come integrare l’AI nei tuoi progetti. La risposta di Google si chiama Genkit Dart — e cambia le regole del gioco.
Annunciato a inizio 2026, Genkit Dart è il porting in Dart del framework AI open-source di Google. La promessa è semplice ma potente: costruire app AI complete — frontend Flutter e backend Dart — nello stesso linguaggio, con gli stessi strumenti, senza cambiare contesto.
Il punto di forza principale? È model-agnostic. Puoi usare Google Gemini, Anthropic Claude o OpenAI GPT e passare da uno all’altro con una sola riga di codice. Noi di SpaghettiCoders lo stiamo già sperimentando su progetti reali, e in questa guida ti mostriamo tutto quello che hai bisogno per iniziare.
Setup: installazione e primo progetto in 5 minuti
Per iniziare, aggiunge le dipendenze nel tuo pubspec.yaml:
yaml
dependencies:
genkit: ^0.1.0
genkit_google_ai: ^0.1.0 # oppure genkit_anthropic, genkit_openai
dev_dependencies:
genkit_cli: ^0.1.0Poi inizializza Genkit nel tuo backend Dart:
dart
import 'package:genkit/genkit.dart';
import 'package:genkit_google_ai/genkit_google_ai.dart';
void main() async {
final ai = Genkit(
plugins: [googleAI()],
);
// Il tuo server è pronto
await ai.startFlowServer();
}Installa la CLI globalmente con dart pub global activate genkit_cli e lancia il progetto con genkit start. In pochi secondi hai la Developer UI accessibile su localhost:4000 — un pannello interattivo per testare i tuoi flow AI senza scrivere un singolo test.
Primo flow AI: generatore di ricette tipizzato
Un “flow” in Genkit è una funzione AI definita con schema di input e output. Ecco un esempio concreto — un generatore di ricette che restituisce dati strutturati:
dart
import 'package:genkit/genkit.dart';
// Schema tipizzato per l'output
class Recipe {
final String name;
final List<String> ingredients;
final String instructions;
final int prepTimeMinutes;
Recipe({
required this.name,
required this.ingredients,
required this.instructions,
required this.prepTimeMinutes,
});
}
// Definizione del flow
final recipeFlow = defineFlow(
name: 'generateRecipe',
inputSchema: Schema.string(),
outputSchema: Schema.object<Recipe>(),
fn: (ingredient) async {
final response = await generate(
model: gemini15Flash,
prompt: 'Crea una ricetta italiana usando: $ingredient. '
'Rispondi in formato JSON con name, ingredients, instructions e prepTimeMinutes.',
output: OutputConfig(schema: Schema.object<Recipe>()),
);
return response.output!;
},
);Il risultato è un oggetto Recipe completamente tipizzato — niente Map<String, dynamic>, niente parsing manuale. Genkit gestisce la traduzione da testo AI a oggetti Dart per te.
Type Safety con Schemantic: output strutturato end-to-end
Uno dei problemi classici quando si integra un LLM in un’app è la fragilità dell’output: il modello restituisce JSON “quasi corretto” e il tuo parser va in crash. Genkit risolve questo con Schemantic, il suo sistema di schema tipizzato.
Definisci lo schema una volta e Genkit:
- istruisce il modello a rispettare la struttura
- valida l’output ricevuto
- rilancia la generazione se la validazione fallisce
dart
final schema = Schema.object({
'titolo': Schema.string(description: 'Titolo della ricetta'),
'ingredienti': Schema.array(Schema.string()),
'difficolta': Schema.enumValue(['facile', 'media', 'difficile']),
});Questo si traduce in type safety end-to-end: da Flutter fino al modello AI e di ritorno, senza eccezioni runtime sorprendenti.
Multi-model: switcha tra Gemini, Claude e GPT in una riga
Uno dei vantaggi più pratici di Genkit è la portabilità tra modelli. Bastano due cambiamenti:
dart
// Con Google Gemini
import 'package:genkit_google_ai/genkit_google_ai.dart';
final ai = Genkit(plugins: [googleAI()]);
// model: gemini15Flash
// Con Anthropic Claude
import 'package:genkit_anthropic/genkit_anthropic.dart';
final ai = Genkit(plugins: [anthropic()]);
// model: claude35Sonnet
// Con OpenAI
import 'package:genkit_openai/genkit_openai.dart';
final ai = Genkit(plugins: [openAI()]);
// model: gpt4oIl resto del codice — i flow, gli schema, la logica — rimane identico. Perfetto per confrontare modelli, abbattere i costi o usare modelli diversi per task diversi nella stessa app.
Tool Calling: agenti AI con strumenti tipizzati
Il tool calling è la funzionalità che trasforma un LLM da “generatore di testo” a “agente capace di agire”. Con Genkit definisci strumenti tipizzati che il modello può invocare autonomamente:
dart
final weatherTool = defineTool(
name: 'getWeather',
description: 'Ottieni le condizioni meteo per una città',
inputSchema: Schema.object({
'city': Schema.string(),
'country': Schema.string(),
}),
outputSchema: Schema.object({
'temperature': Schema.number(),
'condition': Schema.string(),
}),
fn: (input) async {
// Chiama la tua API meteo reale
return await weatherApi.fetch(input['city'], input['country']);
},
);
// Il modello decide autonomamente quando e come usare il tool
final response = await generate(
model: gemini15Flash,
prompt: 'Che tempo fa a Napoli oggi? Suggerisci un outfit.',
tools: [weatherTool],
);Il modello capisce quando invocare lo strumento, passa i parametri corretti, riceve il risultato e lo integra nella risposta finale — tutto in automatico.
Architettura Flutter: 3 pattern per integrare Genkit
Esistono tre approcci principali per connettere Flutter a Genkit, ognuno con pro e contro:
1. Client-side (solo per prototipi) Il flow gira direttamente sul device. Semplice da implementare, ma espone le API key e non scala.
2. Server-side (produzione) Flutter chiama un server Dart che espone i flow via HTTP. Il pattern consigliato per app reali.
dart
// Nel tuo provider Riverpod (come vediamo nel nostro corso Flutter - Lezione 7)
final recipeProvider = FutureProvider.family<Recipe, String>((ref, ingredient) async {
final response = await http.post(
Uri.parse('https://api.tuaapp.com/generateRecipe'),
body: json.encode({'ingredient': ingredient}),
);
return Recipe.fromJson(json.decode(response.body));
});3. Ibrido Flow leggeri on-device, flow pesanti o con dati sensibili sul server. Utile per app con funzionalità offline parziali.
Deploy: Shelf server, Docker e Firebase Functions
Genkit Dart supporta più strategie di deploy. La più interessante per il mondo Flutter è Firebase Cloud Functions con Dart:
dockerfile
# Dockerfile per il tuo server Genkit
FROM dart:stable AS build
WORKDIR /app
COPY pubspec.* ./
RUN dart pub get
COPY . .
RUN dart compile exe bin/server.dart -o bin/server
FROM debian:bullseye-slim
COPY --from=build /app/bin/server /app/bin/server
EXPOSE 8080
CMD ["/app/bin/server"]Con Shelf come HTTP server e Firebase come infrastruttura, si ottengono cold start nell’ordine dei 10ms — performance difficili da raggiungere con Node.js o Python nelle stesse condizioni.
Per un server Shelf minimale:
dart
import 'package:shelf/shelf.dart';
import 'package:shelf/shelf_io.dart';
import 'package:genkit/genkit.dart';
void main() async {
final ai = Genkit(plugins: [googleAI()]);
final handler = const Pipeline()
.addMiddleware(logRequests())
.addHandler(ai.httpHandler());
await serve(handler, '0.0.0.0', 8080);
print('Server in ascolto su porta 8080');
}Developer UI: testa i flow senza scrivere test
Una delle killer feature di Genkit è la Developer UI integrata. Lanciando genkit start, ottieni un pannello web su localhost:4000 dove puoi:
- eseguire qualsiasi flow con input personalizzati
- vedere input, output e trace completo di ogni run
- ispezionare le chiamate al modello e i tool invocati
- confrontare output di run diverse
È il modo più rapido per iterare sul comportamento dei tuoi flow AI durante lo sviluppo — senza bisogno di costruire un’interfaccia di test separata.
Quando usare Genkit Dart vs alternative
Genkit Dart è la scelta giusta quando:
✅ Il tuo team conosce già Dart/Flutter e vuole evitare di imparare Node.js o Python per il backend AI ✅ Hai bisogno di type safety end-to-end tra frontend e backend ✅ Vuoi la flessibilità di cambiare modello AI senza riscrivere la logica ✅ Stai costruendo su Firebase e vuoi deploy rapidi con cold start bassi
Considera le alternative se:
- Il tuo backend è già in Python (LangChain, LlamaIndex sono più maturi per quell’ecosistema)
- Hai bisogno di feature avanzate di RAG o vector store (l’ecosistema Genkit Dart è ancora giovane)
- Il tuo team ha più esperienza con l’ecosistema JavaScript (Genkit JS è più avanzato)
Conclusioni e prossimi passi
Genkit Dart è ancora giovane — la versione 0.1.x porta con sé alcune limitazioni rispetto al porting JavaScript — ma la direzione è chiara e promettente. Per i team Flutter che vogliono abbracciare l’AI senza abbandonare l’ecosistema Dart, è già oggi lo strumento più coerente disponibile.
Noi di SpaghettiCoders lo stiamo usando su progetti reali e continueremo a documentare l’esperienza in questa serie. Nel prossimo articolo esploreremo come costruire un RAG (Retrieval-Augmented Generation) completo con Genkit Dart e un vector store — stay tuned.
Risorse utili:
- Documentazione ufficiale Genkit
- Repository GitHub
- Pacchetto su pub.dev
- Google AI Studio — per ottenere la tua API key Gemini
🎓 Vuoi imparare Flutter da zero? Nel nostro Corso Flutter trovi tutto quello che ti serve per diventare uno sviluppatore Flutter completo — dalla Lezione 1 sulle basi fino alla Lezione 7 su Riverpod e MVVM, lo stesso stack che usiamo in questa guida.
Preferisci iniziare gratis? Dai un’occhiata al nostro corso YouTube gratuito oppure aspetta il prossimo corso live in partenza.
