1. परिचय
इस कोडलैब में, Flutter, Firebase AI Logic, और नए genui पैकेज का इस्तेमाल करके, टास्क की सूची वाला ऐप्लिकेशन बनाने का तरीका बताया गया है. सबसे पहले, टेक्स्ट पर आधारित चैट ऐप्लिकेशन बनाएं. इसके बाद, GenUI की मदद से इसे अपग्रेड करें, ताकि एजेंट अपना यूज़र इंटरफ़ेस (यूआई) बना सके. आखिर में, अपना कस्टम और इंटरैक्टिव यूआई कॉम्पोनेंट बनाएं, जिसे आप और एजेंट सीधे तौर पर कंट्रोल कर सकें.

आपको क्या करना होगा
- Flutter और Firebase AI Logic का इस्तेमाल करके, बेसिक चैट इंटरफ़ेस बनाना
- जनरेटिव एआई की मदद से जनरेट होने वाले सरफ़ेस बनाने के लिए,
genuiपैकेज को इंटिग्रेट करें - एक प्रोग्रेस बार जोड़ें, ताकि यह पता चल सके कि ऐप्लिकेशन, एजेंट से जवाब मिलने का इंतज़ार कर रहा है
- नाम वाला कोई सर्फ़ेस बनाएं और उसे यूज़र इंटरफ़ेस में किसी खास जगह पर दिखाएं.
- कस्टम GenUI कैटलॉग कॉम्पोनेंट बनाएं. इससे आपको यह कंट्रोल मिलता है कि टास्क कैसे दिखाए जाएं
आपको किन चीज़ों की ज़रूरत होगी
- Chrome जैसा कोई वेब ब्राउज़र
- डिवाइस पर इंस्टॉल किया गया Flutter SDK
- Firebase CLI इंस्टॉल और कॉन्फ़िगर किया गया हो
यह कोडलैब, इंटरमीडिएट लेवल के Flutter डेवलपर के लिए है.
2. शुरू करने से पहले
Flutter प्रोजेक्ट सेट अप करना
- अगर आपने पहले से Flutter SDK इंस्टॉल नहीं किया है, तो इसे स्थानीय तौर पर इंस्टॉल करें.
- नया प्रोजेक्ट बनाने के लिए, अपना टर्मिनल खोलें और
flutter createचलाएं:flutter create intro_to_genui cd intro_to_genui - अपने Flutter प्रोजेक्ट में ज़रूरी डिपेंडेंसी जोड़ें:
आपका फ़ाइनलflutter pub add firebase_core firebase_ai genui json_schema_builderdependenciesसेक्शन कुछ ऐसा दिखना चाहिए (वर्शन नंबर थोड़े अलग हो सकते हैं):dependencies: flutter: sdk: flutter cupertino_icons: ^1.0.9 firebase_core: ^4.15.0 firebase_ai: ^4.0.0 genui: ^0.10.3 json_schema_builder: ^0.1.7 - सभी पैकेज डाउनलोड करने के लिए,
flutter pub getचलाएं.अगर आपको यह सूचना मिलती है कि पैकेज के नए वर्शन उपलब्ध हैं, तो वर्शन देखने के लिएflutter pub outdatedऔर अपनी डिपेंडेंसी अपडेट करने के लिएflutter pub upgradeचलाएं.
Firebase प्रोजेक्ट सेट अप करना
- अगर आपने पहले से ही ऐसा नहीं किया है, तो Firebase CLI इंस्टॉल करें.
- अपने Google खाते का इस्तेमाल करके, Firebase में लॉग इन करें:
firebase login - FlutterFire CLI इंस्टॉल करें:
dart pub global activate flutterfire_cli - Firebase का इस्तेमाल करने के लिए, अपने Flutter प्रोजेक्ट को कॉन्फ़िगर करने के लिए, अपनी Flutter प्रोजेक्ट डायरेक्ट्री से यह कमांड चलाएं:
इस निर्देश से ये काम किए जा सकेंगे:flutterfire configure- आपसे पूछा जाएगा कि आपको किसी मौजूदा Firebase प्रोजेक्ट का इस्तेमाल करना है या नया Firebase प्रोजेक्ट बनाना है. नया Firebase प्रोजेक्ट बनाएं को चुनें.
- आपसे पूछा जाएगा कि आपको अपने Flutter ऐप्लिकेशन के लिए किस प्लैटफ़ॉर्म (iOS, Android, वेब) को टारगेट करना है. फ़िलहाल, वेब को चुनें.
flutterfire configure कमांड, Firebase प्रोजेक्ट और उस Firebase प्रोजेक्ट में एक नया Firebase वेब ऐप्लिकेशन अपने-आप बना देता है. इसके बाद, यह कमांड एक Firebase कॉन्फ़िगरेशन फ़ाइल (firebase_options.dart) बनाता है और उसे आपके Flutter प्रोजेक्ट की lib/ डायरेक्ट्री में अपने-आप जोड़ देता है.
ध्यान दें कि इस कोडलैब के लिए ऐप्लिकेशन, आपकी मशीन पर इंस्टॉल किए गए Flutter SDK और Chrome के साथ ही काम करता है. इसका मतलब है कि यह एक वेब ऐप्लिकेशन के तौर पर काम करता है. हालांकि, इस ऐप्लिकेशन को Flutter की मदद से बनाया गया है. इसलिए, यह दूसरे प्लैटफ़ॉर्म पर भी काम करेगा! इसलिए, कोडलैब के आखिर में, iOS, Android या किसी अन्य प्लैटफ़ॉर्म के लिए सहायता जोड़ने के लिए, flutterfire configure को फिर से चलाएं. इसके बाद, उस प्लैटफ़ॉर्म पर ऐप्लिकेशन को फिर से बनाएं.
ज़्यादा जानकारी के लिए, Flutter ऐप्लिकेशन में Firebase जोड़ने के निर्देश देखें.
Firebase AI Logic सेट अप करना
- Firebase कंसोल में साइन इन करें. उसी Google खाते का इस्तेमाल करें जिससे आपने Firebase CLI में लॉग इन किया था.
- FlutterFire CLI का इस्तेमाल करके, अभी-अभी बनाया गया Firebase प्रोजेक्ट चुनें.
- बाईं ओर मौजूद नेविगेशन मेन्यू में जाकर, एआई सेवाएं > एआई लॉजिक चुनें.
- निर्देशों के साथ वर्कफ़्लो लॉन्च करने के लिए, शुरू करें पर क्लिक करें.
- Gemini Developer API से शुरू करने का विकल्प चुनें. इसके बाद, Firebase AI Logic को सेट अप करने के लिए, स्क्रीन पर मौजूद निर्देशों का पालन करें.
"Flutter प्रोजेक्ट सेट अप करें" सेक्शन में, Firebase AI Logic का इस्तेमाल करने के लिए ज़रूरी FlutterFire प्लग इन पहले से मौजूद हैं. अब अगले चरण में, अपने ऐप्लिकेशन को कोड करने के लिए तैयार हो जाएं!
3. बुनियादी चैट इंटरफ़ेस बनाना
जनरेटिव यूआई को लागू करने से पहले, आपके ऐप्लिकेशन में बुनियादी सुविधाएं होनी चाहिए. जैसे, Firebase AI Logic की मदद से काम करने वाला टेक्स्ट आधारित चैट ऐप्लिकेशन. तेज़ी से शुरुआत करने के लिए, चैट इंटरफ़ेस के पूरे सेटअप को कॉपी करके चिपकाएं.

मैसेज बबल विजेट बनाना
उपयोगकर्ता और एजेंट के टेक्स्ट मैसेज दिखाने के लिए, आपके ऐप्लिकेशन को विजेट की ज़रूरत होती है. lib/message_bubble.dart नाम की एक नई फ़ाइल बनाएं और उसमें यह क्लास जोड़ें:
import 'package:flutter/material.dart';
class MessageBubble extends StatelessWidget {
final String text;
final bool isUser;
const MessageBubble({super.key, required this.text, required this.isUser});
@override
Widget build(BuildContext context) {
final theme = Theme.of(context);
final colorScheme = theme.colorScheme;
final bubbleColor = isUser
? colorScheme.primary
: colorScheme.surfaceContainerHighest;
final textColor = isUser
? colorScheme.onPrimary
: colorScheme.onSurfaceVariant;
return Padding(
padding: const EdgeInsets.symmetric(vertical: 6.0, horizontal: 8.0),
child: Column(
crossAxisAlignment: isUser
? CrossAxisAlignment.end
: CrossAxisAlignment.start,
children: [
Row(
mainAxisAlignment: isUser
? MainAxisAlignment.end
: MainAxisAlignment.start,
children: [
Flexible(
child: Container(
padding: const EdgeInsets.symmetric(
horizontal: 16.0,
vertical: 12.0,
),
decoration: BoxDecoration(
color: bubbleColor,
borderRadius: BorderRadius.only(
topLeft: const Radius.circular(20),
topRight: const Radius.circular(20),
bottomLeft: Radius.circular(isUser ? 20 : 0),
bottomRight: Radius.circular(isUser ? 0 : 20),
),
boxShadow: [
BoxShadow(
color: Colors.black.withAlpha(20),
blurRadius: 4,
offset: const Offset(0, 2),
),
],
gradient: isUser
? LinearGradient(
colors: [
colorScheme.primary,
colorScheme.primary.withAlpha(200),
],
begin: Alignment.topLeft,
end: Alignment.bottomRight,
)
: null,
),
child: Text(
text,
style: theme.textTheme.bodyLarge?.copyWith(
color: textColor,
height: 1.3,
),
),
),
),
],
),
const SizedBox(height: 2),
],
),
);
}
}
MessageBubble एक StatelessWidget है, जो एक चैट मैसेज दिखाता है. इस कोडलैब में, इसका इस्तेमाल बाद में आपके और एजेंट, दोनों के मैसेज दिखाने के लिए किया जाएगा. हालांकि, यह ज़्यादातर मामलों में सिर्फ़ एक शानदार Text विजेट होता है.
main.dart में चैट यूज़र इंटरफ़ेस (यूआई) लागू करना
lib/main.dart के पूरे कॉन्टेंट को, टेक्स्ट चैटबॉट के इस पूरे कोड से बदलें:
import 'package:flutter/material.dart';
import 'package:firebase_core/firebase_core.dart';
import 'package:firebase_ai/firebase_ai.dart';
import 'package:intro_to_genui/message_bubble.dart';
import 'firebase_options.dart';
Future<void> main() async {
WidgetsFlutterBinding.ensureInitialized();
await Firebase.initializeApp(options: DefaultFirebaseOptions.currentPlatform);
runApp(const MyApp());
}
class MyApp extends StatelessWidget {
const MyApp({super.key});
@override
Widget build(BuildContext context) {
return MaterialApp(
title: 'Just Today',
theme: ThemeData(
colorScheme: ColorScheme.fromSeed(seedColor: Colors.blue),
),
home: const MyHomePage(),
);
}
}
class MyHomePage extends StatefulWidget {
const MyHomePage({super.key});
@override
State<MyHomePage> createState() => _MyHomePageState();
}
sealed class ConversationItem {}
class TextItem extends ConversationItem {
final String text;
final bool isUser;
TextItem({required this.text, this.isUser = false});
}
class _MyHomePageState extends State<MyHomePage> {
final List<ConversationItem> _items = [];
final _textController = TextEditingController();
final _scrollController = ScrollController();
late final ChatSession _chatSession;
@override
void initState() {
super.initState();
final model = FirebaseAI.googleAI().generativeModel(
model: 'gemini-3.5-flash',
);
_chatSession = model.startChat();
_chatSession.sendMessage(Content.text(systemInstruction));
}
void _scrollToBottom() {
WidgetsBinding.instance.addPostFrameCallback((_) {
if (_scrollController.hasClients) {
_scrollController.animateTo(
_scrollController.position.maxScrollExtent,
duration: const Duration(milliseconds: 300),
curve: Curves.easeOut,
);
}
});
}
@override
void dispose() {
_textController.dispose();
_scrollController.dispose();
super.dispose();
}
Future<void> _addMessage() async {
final text = _textController.text;
if (text.trim().isEmpty) {
return;
}
_textController.clear();
setState(() {
_items.add(TextItem(text: text, isUser: true));
});
_scrollToBottom();
final response = await _chatSession.sendMessage(Content.text(text));
if (response.text?.isNotEmpty ?? false) {
setState(() {
_items.add(TextItem(text: response.text!, isUser: false));
});
_scrollToBottom();
}
}
@override
Widget build(BuildContext context) {
return Scaffold(
appBar: AppBar(
backgroundColor: Theme.of(context).colorScheme.inversePrimary,
title: const Text('Just Today'),
),
body: Column(
children: [
Expanded(
child: ListView(
controller: _scrollController,
padding: const EdgeInsets.all(16),
children: [
for (final item in _items)
switch (item) {
TextItem() => MessageBubble(
text: item.text,
isUser: item.isUser,
),
},
],
),
),
SafeArea(
child: Padding(
padding: const EdgeInsets.symmetric(horizontal: 16.0),
child: Row(
children: [
Expanded(
child: TextField(
controller: _textController,
onSubmitted: (_) => _addMessage(),
decoration: const InputDecoration(
hintText: 'Enter a message',
),
),
),
const SizedBox(width: 8),
ElevatedButton(
onPressed: _addMessage,
child: const Text('Send'),
),
],
),
),
),
],
),
);
}
}
const systemInstruction = '''
## PERSONA
You are an expert task planner.
## GOAL
Work with me to produce a list of tasks that I should do today, and then track
the completion status of each one.
## RULES
Talk with me only about tasks that I should do today.
Do not engage in conversation about any other topic.
Do not offer suggestions unless I ask for them.
Do not offer encouragement unless I ask for it.
Do not offer advice unless I ask for it.
Do not offer opinions unless I ask for them.
## PROCESS
### Planning
* Ask me for information about tasks that I should do today.
* Synthesize a list of tasks from that information.
* Ask clarifying questions if you need to.
* When you have a list of tasks that you think I should do today, present it
to me for review.
* Respond to my suggestions for changes, if I have any, until I accept the
list.
### Tracking
* Once the list is accepted, ask me to let you know when individual tasks are
complete.
* If I tell you a task is complete, mark it as complete.
* Once all tasks are complete, send a message acknowledging that, and then
end the conversation.
''';
आपने जो main.dart फ़ाइल कॉपी-पेस्ट की है वह Firebase AI Logic और systemInstruction में मौजूद प्रॉम्प्ट का इस्तेमाल करके, एक बुनियादी ChatSession सेट अप करती है. यह TextItem एलिमेंट की सूची को बनाए रखता है और उपयोगकर्ता के सवालों के साथ उन्हें दिखाता है. इसके लिए, यह उस MessageBubble विजेट का इस्तेमाल करता है जिसे आपने पहले बनाया था.
आगे बढ़ने से पहले, इन बातों का ध्यान रखें:
initStateमेथड में, Firebase AI Logic से कनेक्शन सेट अप किया जाता है.- ऐप्लिकेशन में
TextFieldऔर एजेंट को मैसेज भेजने के लिए एक बटन मौजूद होता है. _addMessageतरीके का इस्तेमाल करके, उपयोगकर्ता का मैसेज एजेंट को भेजा जाता है._itemsसूची में, बातचीत का इतिहास सेव किया जाता है.- मैसेज,
ListViewमेंMessageBubbleविजेट का इस्तेमाल करके दिखाए जाते हैं.
ऐप्लिकेशन को टेस्ट करना
ऐसा करने के बाद, अब ऐप्लिकेशन को चलाया जा सकता है और उसकी जांच की जा सकती है.
flutter run -d chrome
एजेंट से उन कामों के बारे में चैट करें जो आपको आज पूरे करने हैं. सिर्फ़ टेक्स्ट पर आधारित यूआई से भी काम हो सकता है, लेकिन GenUI से अनुभव को आसान और तेज़ बनाया जा सकता है.
टेस्टिंग पूरी करने के बाद, अगले चरण पर जाने से पहले, टर्मिनल में q (या Ctrl+C) दबाकर, चल रहे ऐप्लिकेशन को बंद करें.
4. GenUI पैकेज को इंटिग्रेट करना
अब समय आ गया है कि सामान्य टेक्स्ट से जनरेटिव यूज़र इंटरफ़ेस पर अपग्रेड किया जाए. आपको Firebase के बेसिक मैसेजिंग लूप को GenUI Conversation, Catalog, और SurfaceController ऑब्जेक्ट से बदलना होगा. इससे एआई मॉडल को चैट स्ट्रीम में, असली Flutter विजेट को इंस्टैंशिएट करने की अनुमति मिलती है.

genui पैकेज में पांच क्लास उपलब्ध हैं. इस कोडलैब में इनका इस्तेमाल किया जाएगा:
SurfaceController, मॉडल से जनरेट किए गए यूज़र इंटरफ़ेस (यूआई) को स्क्रीन पर मैप करता है.A2uiTransportAdapter, इंटरनल GenUI अनुरोधों को किसी बाहरी लैंग्वेज मॉडल से जोड़ता है.Conversationआपके Flutter ऐप्लिकेशन के लिए, कंट्रोलर और ट्रांसपोर्ट अडैप्टर को एक ही एपीआई में रैप करता है.Catalogमें, लैंग्वेज मॉडल के लिए उपलब्ध विजेट और प्रॉपर्टी के बारे में बताया गया है.Surfaceएक विजेट है, जो मॉडल से जनरेट किया गया यूज़र इंटरफ़ेस (यूआई) दिखाता है.
जनरेट किए गए Surface को दिखाने के लिए तैयार हो जाएं
lib/main.dart में, मौजूदा कोड में एक TextItem क्लास शामिल है. यह क्लास, बातचीत में मौजूद एक मैसेज को दिखाती है. TextItem क्लास के तुरंत बाद, एजेंट से बनाए गए Surface को दिखाने के लिए, SurfaceItem क्लास जोड़ें:
class TextItem extends ConversationItem {
// ... existing code ...
}
// New!
class SurfaceItem extends ConversationItem {
final String surfaceId;
SurfaceItem({required this.surfaceId});
}
GenUI के बिल्डिंग ब्लॉक शुरू करना
lib/main.dart में सबसे ऊपर, genui लाइब्रेरी इंपोर्ट करें:
import 'package:genui/genui.dart' hide TextPart;
import 'package:genui/genui.dart' as genui;
genui पैकेज और firebase_ai पैकेज, दोनों में TextPart क्लास शामिल है. genui को इस तरह इंपोर्ट करने से, TextPart के वर्शन को genui.TextPart के तौर पर नेमस्पेस किया जाता है. इससे नाम के टकराव से बचा जा सकता है.
_chatSession के बाद, _MyHomePageState में मुख्य फ़ंक्शनल कंट्रोलर का एलान करें:
class _MyHomePageState extends State<MyHomePage> {
// ... existing members
late final ChatSession _chatSession;
// Add GenUI controllers
late final SurfaceController _controller;
late final A2uiTransportAdapter _transport;
late final Conversation _conversation;
late final Catalog catalog;
इसके बाद, GenUI लाइब्रेरी के कंट्रोलर तैयार करने के लिए, initState को अपडेट करें.
initState से यह लाइन हटाएं:
_chatSession.sendMessage(Content.text(systemInstruction));
इसके बाद, यह कोड जोड़ें:
@override
void initState() {
// ... existing code ...
// Initialize the GenUI Catalog.
// The genui package provides a default set of primitive widgets (like text
// and basic buttons) out of the box using this class.
catalog = BasicCatalogItems.asCatalog();
// Create a SurfaceController to manage the state of generated surfaces.
_controller = SurfaceController(catalogs: [catalog]);
// Create a transport adapter that will process messages to and from the
// agent, looking for A2UI messages.
_transport = A2uiTransportAdapter(onSend: _sendAndReceive);
// Link the transport and SurfaceController together in a Conversation,
// which provides your app a unified API for interacting with the agent.
_conversation = Conversation(
controller: _controller,
transport: _transport,
);
}
यह कोड एक Conversation फ़साड बनाता है, जो कंट्रोलर और अडैप्टर को मैनेज करता है. इस बातचीत से आपके ऐप्लिकेशन को इवेंट की एक स्ट्रीम मिलती है. इसका इस्तेमाल करके, यह पता लगाया जा सकता है कि एजेंट क्या बना रहा है. साथ ही, इससे एजेंट को मैसेज भेजने का तरीका भी मिलता है.
इसके बाद, बातचीत वाले इवेंट के लिए एक लिसनर बनाएं. इनमें, टेक्स्ट मैसेज और गड़बड़ियों के साथ-साथ, प्लैटफ़ॉर्म से जुड़े इवेंट भी शामिल हैं:
@override
void initState() {
// ... existing code ...
// Listen to GenUI stream events to update the UI
_conversation.events.listen((event) {
setState(() {
switch (event) {
case ConversationSurfaceAdded added:
_items.add(SurfaceItem(surfaceId: added.surfaceId));
_scrollToBottom();
case ConversationSurfaceRemoved removed:
_items.removeWhere(
(item) =>
item is SurfaceItem && item.surfaceId == removed.surfaceId,
);
case ConversationContentReceived content:
_items.add(TextItem(text: content.text, isUser: false));
_scrollToBottom();
case ConversationError error:
debugPrint('GenUI Error: ${error.error}');
default:
}
});
});
}
आखिर में, सिस्टम प्रॉम्प्ट बनाएं और उसे एजेंट को भेजें:
@override
void initState() {
// ... existing code ...
// Create the system prompt for the agent, which will include this app's
// system instruction as well as the schema for the catalog.
final promptBuilder = PromptBuilder.chat(
catalog: catalog,
systemPromptFragments: [systemInstruction],
);
// Send the prompt into the Conversation, which will subsequently route it
// to Firebase using the transport mechanism.
_conversation.sendRequest(
ChatMessage.system(promptBuilder.systemPromptJoined()),
);
}
_MyHomePageState में dispose() तरीके को भी अपडेट करें, ताकि विजेट को हटाए जाने पर, नए जोड़े गए GenUI कंट्रोलर ठीक से हटाए जा सकें:
@override
void dispose() {
_conversation.dispose();
_transport.dispose();
_controller.dispose();
_textController.dispose();
_scrollController.dispose();
super.dispose();
}
डिसप्ले प्लैटफ़ॉर्म
इसके बाद, _items सूची में SurfaceItem दिखाने के लिए, ListView के build तरीके को अपडेट करें:
Expanded(
child: ListView(
controller: _scrollController,
padding: const EdgeInsets.all(16),
children: [
for (final item in _items)
switch (item) {
TextItem() => MessageBubble(
text: item.text,
isUser: item.isUser,
),
// New!
SurfaceItem() => Surface(
surfaceContext: _controller.contextFor(
item.surfaceId,
),
),
},
],
),
),
Surface विजेट के लिए कंस्ट्रक्टर, surfaceContext लेता है. इससे उसे पता चलता है कि उसे कौनसा डिसप्ले दिखाना है. पहले बनाया गया SurfaceController, _controller, हर सरफेस के लिए परिभाषा और स्थिति देता है. साथ ही, यह पक्का करता है कि अपडेट होने पर यह फिर से बन जाए.
GenUI को Firebase AI Logic से कनेक्ट करना
genui पैकेज, "अपना मॉडल खुद लाएं" तरीके का इस्तेमाल करता है. इसका मतलब है कि आपके पास यह कंट्रोल होता है कि आपको किस एलएलएम का इस्तेमाल करना है. इस मामले में, Firebase AI Logic का इस्तेमाल किया जा रहा है. हालांकि, इस पैकेज को अलग-अलग एजेंट और सेवा देने वाली कंपनियों के साथ काम करने के लिए बनाया गया है.
इस सुविधा की वजह से, आपको कुछ अतिरिक्त ज़िम्मेदारियां भी मिलती हैं: आपको genui पैकेज से जनरेट हुए मैसेज को अपने चुने हुए एजेंट को भेजना होगा. साथ ही, एजेंट के जवाबों को वापस genui में भेजना होगा.
इसके लिए, आपको पिछले चरण के कोड में बताए गए _sendAndReceive तरीके को तय करना होगा. lib/main.dart में, _MyHomePageState क्लास के अंदर _sendAndReceive जोड़ें. उदाहरण के लिए, late final Catalog catalog; लाइन के ठीक बाद:
class _MyHomePageState extends State<MyHomePage> {
// ... existing code ...
late final Catalog catalog;
// New!
Future<void> _sendAndReceive(ChatMessage msg) async {
final buffer = StringBuffer();
// Reconstruct the message part fragments
for (final part in msg.parts) {
if (part.isUiInteractionPart) {
buffer.write(part.asUiInteractionPart!.interaction);
} else if (part is genui.TextPart) {
buffer.write(part.text);
}
}
if (buffer.isEmpty) {
return;
}
final text = buffer.toString();
// Send the string to Firebase AI Logic.
final response = await _chatSession.sendMessage(Content.text(text));
if (response.text?.isNotEmpty ?? false) {
// Feed the response back into GenUI's transportation layer
_transport.addChunk(response.text!);
}
}
जब भी genui पैकेज को एजेंट को कोई मैसेज भेजना होगा, तब इस तरीके को कॉल किया जाएगा. तरीके के आखिर में addChunk को कॉल करने से, एजेंट का जवाब वापस genui पैकेज में चला जाता है. इससे को जवाब को प्रोसेस करने और यूज़र इंटरफ़ेस (यूआई) जनरेट करने की अनुमति मिलती है.
आखिर में, अपनी मौजूदा _addMessage विधि को पूरी तरह से इस नए वर्शन से बदलें, ताकि यह सीधे Firebase के बजाय Conversation में मैसेज भेज सके:
Future<void> _addMessage() async {
final text = _textController.text;
if (text.trim().isEmpty) {
return;
}
_textController.clear();
setState(() {
_items.add(TextItem(text: text, isUser: true));
});
_scrollToBottom();
// Send the user's input through GenUI instead of directly to Firebase.
await _conversation.sendRequest(ChatMessage.user(text));
}
हो गया! ऐप्लिकेशन को फिर से चलाने की कोशिश करें. टेक्स्ट मैसेज के अलावा, आपको एजेंट के जनरेट किए गए यूज़र इंटरफ़ेस (यूआई) भी दिखेंगे. जैसे, बटन, टेक्स्ट विजेट वगैरह.
एजेंट से यूज़र इंटरफ़ेस (यूआई) को किसी खास तरीके से दिखाने के लिए भी कहा जा सकता है. उदाहरण के लिए, इस तरह का मैसेज आज़माएं, "मुझे मेरे टास्क एक कॉलम में दिखाओ. साथ ही, हर टास्क को पूरा हो गया के तौर पर मार्क करने के लिए एक बटन भी दिखाओ."
5. इंतज़ार की स्थिति जोड़ना
एलएलएम जनरेशन एसिंक्रोनस होता है. जवाब का इंतज़ार करते समय, चैट इंटरफ़ेस को इनपुट बटन बंद करने होंगे और प्रोग्रेस इंडिकेटर दिखाना होगा. इससे उपयोगकर्ता को पता चलेगा कि GenUI कॉन्टेंट बना रहा है. अच्छी बात यह है कि genui पैकेज में एक Listenable मौजूद होता है. इसका इस्तेमाल करके, बातचीत की स्थिति को ट्रैक किया जा सकता है. ConversationState वैल्यू में isWaiting प्रॉपर्टी शामिल होती है. इससे यह पता चलता है कि मॉडल कॉन्टेंट जनरेट कर रहा है या नहीं.
इनपुट कंट्रोल को ValueListenableBuilder के साथ रैप करें
lib/main.dart में _MyHomePageState के build तरीके में, Column के सबसे नीचे मौजूद SafeArea विजेट ढूंढें. इसके बाद, इसके चाइल्ड Row (जिसमें आपका TextField और ElevatedButton शामिल है) को ValueListenableBuilder में रैप करें. यह _conversation.state को सुनता है. state.isWaiting की जांच करके, मॉडल के कॉन्टेंट जनरेट करने के दौरान इनपुट देने की सुविधा बंद की जा सकती है:
SafeArea(
child: Padding(
padding: const EdgeInsets.symmetric(horizontal: 16.0),
// Wrap the Row in a ValueListenableBuilder:
child: ValueListenableBuilder<ConversationState>(
valueListenable: _conversation.state,
builder: (context, state, child) {
return Row(
children: [
Expanded(
child: TextField(
controller: _textController,
// Also disable the Enter key submission when waiting!
onSubmitted: state.isWaiting ? null : (_) => _addMessage(),
decoration: const InputDecoration(
hintText: 'Enter a message',
),
),
),
const SizedBox(width: 8),
ElevatedButton(
// Disable the send button when the model is generating
onPressed: state.isWaiting ? null : _addMessage,
child: const Text('Send'),
),
],
);
},
),
),
),
प्रोग्रेस बार जोड़ना
_MyHomePageState के build तरीके में, मुख्य Column विजेट को Stack के अंदर रैप करें. साथ ही, एक ValueListenableBuilder जोड़ें, जो उस Stack के दूसरे चाइल्ड के तौर पर LinearProgressIndicator को रेंडर करता है. सेट अप पूरा करने के बाद, आपके Scaffold का body कुछ ऐसा दिखेगा:
body: Stack( // New!
children: [
Column(
children: [
// ... existing Expanded and SafeArea widgets ...
],
),
// Listen to the state again, this time to render a progress indicator
ValueListenableBuilder<ConversationState>(
valueListenable: _conversation.state,
builder: (context, state, child) {
if (state.isWaiting) {
return const LinearProgressIndicator();
}
return const SizedBox.shrink();
},
),
],
),
6. GenUI Surface को बनाए रखना
अब तक, टास्क की सूची को स्क्रोल की जा सकने वाली चैट स्ट्रीम में रेंडर किया जाता था. इसमें हर नए मैसेज या प्लैटफ़ॉर्म को सूची में जोड़ा जाता था. अगले चरण में, आपको किसी प्लैटफ़ॉर्म को नाम देने और उसे यूज़र इंटरफ़ेस (यूआई) में किसी खास जगह पर दिखाने का तरीका पता चलेगा.
सबसे पहले, lib/main.dart के सबसे ऊपर, void main() से पहले, एक कॉन्स्टेंट का एलान करें, ताकि उसे सर्फ़ेस आईडी के तौर पर इस्तेमाल किया जा सके:
const taskDisplaySurfaceId = 'task_display';
दूसरा, initState() में, Conversation लिसनर में मौजूद switch स्टेटमेंट को अपडेट करें. इससे यह पक्का किया जा सकेगा कि उस आईडी वाला कोई भी सर्फ़ेस, _items में न जोड़ा जाए. इसके लिए, _conversation.events.listen में मौजूद case ConversationSurfaceAdded added: ब्रांच को अपडेट करें. इसके लिए, _items.add(...) और _scrollToBottom() लाइनों को if स्टेटमेंट में रैप करें:
_conversation.events.listen((event) {
setState(() {
switch (event) {
case ConversationSurfaceAdded added:
// Wrap these two lines in an if check:
if (added.surfaceId != taskDisplaySurfaceId) {
_items.add(SurfaceItem(surfaceId: added.surfaceId));
_scrollToBottom();
}
case ConversationSurfaceRemoved removed:
// ... existing code ...
इसके बाद, _MyHomePageState.build में अपने विजेट ट्री के लेआउट स्ट्रक्चर को खोलें, ताकि पिन किए गए सर्फ़ेस के लिए जगह बनाई जा सके. यह जगह, चैट लॉग से ठीक पहले होनी चाहिए. AnimatedSize और const Divider() को मुख्य Column के पहले दो चाइल्ड टैग के तौर पर डालें. इन्हें Expanded(child: ListView(...)) कोड से ठीक पहले डालें:
body: Stack(
children: [
Column(
children: [
// Insert these two new widgets at the top of the Column:
AnimatedSize(
duration: const Duration(milliseconds: 300),
child: Container(
padding: const EdgeInsets.all(16),
alignment: Alignment.topLeft,
child: Surface(
surfaceContext: _controller.contextFor(
taskDisplaySurfaceId,
),
),
),
),
const Divider(),
Expanded(
child: ListView(
// ... existing code ...
अब तक, आपके एजेंट के पास अपनी ज़रूरत के हिसाब से सरफ़ेस बनाने और उनका इस्तेमाल करने की पूरी छूट थी. इसे ज़्यादा सटीक निर्देश देने के लिए, आपको सिस्टम प्रॉम्प्ट पर फिर से जाना होगा. systemInstruction कॉन्सटैंट में सेव किए गए प्रॉम्प्ट के आखिर में, यह ## USER INTERFACE सेक्शन जोड़ें:
const systemInstruction = '''
// ... existing prompt content ...
## USER INTERFACE
* To display the list of tasks create one and only one instance of the
TaskDisplay catalog item. Use "$taskDisplaySurfaceId" as its surface ID.
* Update $taskDisplaySurfaceId as necessary when the list changes.
* $taskDisplaySurfaceId must include a button for each task that I can use
to mark it complete. When I use that button to mark a task complete, it
should send you a message indicating what I've done.
* Avoid repeating the same information in a single message.
* When responding with text, rather than A2UI messages, be brief.
''';
अपने एजेंट को साफ़ तौर पर निर्देश देना ज़रूरी है कि यूज़र इंटरफ़ेस (यूआई) की सरफ़ेस का इस्तेमाल कब और कैसे करना है. एजेंट को किसी खास कैटलॉग आइटम और सरफ़ेस आईडी का इस्तेमाल करने के लिए कहें. साथ ही, उसे एक ही इंस्टेंस का फिर से इस्तेमाल करने के लिए कहें. इससे आपको अपनी पसंद का इंटरफ़ेस बनाने में मदद मिल सकती है.
अभी और काम करना बाकी है. हालांकि, अपने ऐप्लिकेशन को फिर से चलाकर देखा जा सकता है कि एजेंट, यूज़र इंटरफ़ेस (यूआई) के सबसे ऊपर टास्क दिखाने वाला सरफ़ेस बनाता है या नहीं.
7. अपनी पसंद के मुताबिक कैटलॉग विजेट बनाना
फ़िलहाल, TaskDisplay कैटलॉग आइटम मौजूद नहीं है. अगले कुछ चरणों में, आपको इस समस्या को ठीक करने का तरीका बताया जाएगा. इसके लिए, आपको एक डेटा स्कीमा, उस स्कीमा को पार्स करने के लिए एक क्लास, एक विजेट, और कैटलॉग आइटम बनाना होगा. कैटलॉग आइटम, इन सभी चीज़ों को एक साथ जोड़ता है.
सबसे पहले, अपने प्रोजेक्ट की lib/ डायरेक्ट्री में task_display.dart नाम की एक नई फ़ाइल बनाएं और यहां दिए गए इंपोर्ट जोड़ें:
import 'package:flutter/material.dart';
import 'package:genui/genui.dart';
import 'package:json_schema_builder/json_schema_builder.dart';
डेटा स्कीमा बनाना
इसके बाद, वह डेटा स्कीमा तय करें जो एजेंट, टास्क डिसप्ले बनाने के लिए उपलब्ध कराएगा. इस प्रोसेस में, json_schema_builder पैकेज के कुछ खास कंस्ट्रक्टर का इस्तेमाल किया जाता है. हालांकि, असल में आपको सिर्फ़ एक JSON स्कीमा तय करना होता है. इसका इस्तेमाल एजेंट को भेजे जाने वाले और उससे मिलने वाले मैसेज में किया जाता है.
कॉम्पोनेंट के नाम का S.object इस्तेमाल करके, बुनियादी जानकारी से शुरुआत करें:
final taskDisplaySchema = S.object(
properties: {
'component': S.string(enumValues: ['TaskDisplay']),
},
);
इसके बाद, स्कीमा प्रॉपर्टी में title, tasks, name, isCompleted, और completeAction जोड़ें.
final taskDisplaySchema = S.object(
properties: {
'component': S.string(enumValues: ['TaskDisplay']),
'title': S.string(description: 'The title of the task list'),
'tasks': S.list(
description: 'A list of tasks to be completed today',
items: S.object(
properties: {
'name': S.string(description: 'The name of the task to be completed'),
'isCompleted': S.boolean(
description: 'Whether the task is completed',
),
'completeAction': A2uiSchemas.action(
description:
'The action performed when the user has completed the task.',
),
},
),
),
},
);
completeAction प्रॉपर्टी देखें. इसे A2uiSchemas.action की मदद से बनाया गया है. यह स्कीमा प्रॉपर्टी के लिए कंस्ट्रक्टर है, जो A2UI ऐक्शन को दिखाता है. स्कीमा में कोई कार्रवाई जोड़ने का मतलब है कि ऐप्लिकेशन, एजेंट को यह बता रहा है, "जब मुझे कोई टास्क दिया जाए, तो उस कार्रवाई का नाम और मेटाडेटा भी दें जिसका इस्तेमाल करके मैं आपको बता सकूँ कि टास्क पूरा हो गया है." बाद में, जब उपयोगकर्ता किसी चेकबॉक्स पर टैप करेगा, तो ऐप्लिकेशन उस कार्रवाई को ट्रिगर करेगा.
इसके बाद, स्कीमा में required फ़ील्ड जोड़ें. इनसे एजेंट को हर बार कुछ प्रॉपर्टी की जानकारी भरने का निर्देश मिलता है. इस मामले में, हर प्रॉपर्टी ज़रूरी है!
final taskDisplaySchema = S.object(
properties: {
'component': S.string(enumValues: ['TaskDisplay']),
'title': S.string(description: 'The title of the task list'),
'tasks': S.list(
description: 'A list of tasks to be completed today',
items: S.object(
properties: {
'name': S.string(description: 'The name of the task to be completed'),
'isCompleted': S.boolean(
description: 'Whether the task is completed',
),
'completeAction': A2uiSchemas.action(
description:
'The action performed when the user has completed the task.',
),
},
// New!
required: ['name', 'isCompleted', 'completeAction'],
),
),
},
// New!
required: ['title', 'tasks'],
);
डेटा पार्स करने वाली क्लास बनाना
इस कॉम्पोनेंट के इंस्टेंस बनाते समय, एजेंट स्कीमा से मैच होने वाला डेटा भेजेगा. आने वाले JSON को Dart ऑब्जेक्ट में पार्स करने के लिए, दो क्लास जोड़ें. ध्यान दें कि _TaskDisplayData, रूट स्ट्रक्चर को कैसे मैनेज करता है. साथ ही, इनर ऐरे पार्सिंग को _TaskData को कैसे डेलिगेट करता है.
class _TaskData {
final String name;
final bool isCompleted;
final String actionName;
final JsonMap? actionContext;
_TaskData({
required this.name,
required this.isCompleted,
required this.actionName,
this.actionContext,
});
factory _TaskData.fromJson(Map<String, Object?> json) {
try {
final action = json['completeAction']! as JsonMap;
final event = action['event']! as JsonMap;
return _TaskData(
name: json['name'] as String,
isCompleted: json['isCompleted'] as bool,
actionName: event['name'] as String,
actionContext: event['context'] as JsonMap?,
);
} catch (e) {
throw Exception('Invalid JSON for _TaskData: $e');
}
}
}
class _TaskDisplayData {
final String title;
final List<_TaskData> tasks;
_TaskDisplayData({required this.title, required this.tasks});
factory _TaskDisplayData.fromJson(Map<String, Object?> json) {
try {
return _TaskDisplayData(
title: (json['title'] as String?) ?? 'Tasks',
tasks: (json['tasks'] as List<Object?>)
.map((e) => _TaskData.fromJson(e as Map<String, Object?>))
.toList(),
);
} catch (e) {
throw Exception('Invalid JSON for _TaskDisplayData: $e');
}
}
}
अगर आपने पहले Flutter का इस्तेमाल किया है, तो ये क्लास शायद आपकी बनाई गई क्लास जैसी ही होंगी. ये JsonMap को स्वीकार करते हैं और JSON से पार्स किए गए डेटा वाला एक स्ट्रॉन्गली-टाइप्ड ऑब्जेक्ट दिखाते हैं.
_TaskData में actionName और actionContext फ़ील्ड देखें. इन्हें JSON की completeAction प्रॉपर्टी से निकाला जाता है. इनमें कार्रवाई का नाम और उसके डेटा का कॉन्टेक्स्ट शामिल होता है. कॉन्टेक्स्ट, GenUI के डेटा मॉडल में कार्रवाई की जगह का रेफ़रंस होता है. इनका इस्तेमाल बाद में UserActionEvent बनाने के लिए किया जाएगा.
डेटा मॉडल, सभी डाइनैमिक यूज़र इंटरफ़ेस (यूआई) स्टेट के लिए एक सेंट्रलाइज़्ड और ऑब्ज़र्वेबल स्टोर है. इसे genui लाइब्रेरी मैनेज करती है. जब एजेंट, कैटलॉग से कोई यूज़र इंटरफ़ेस (यूआई) कॉम्पोनेंट बनाता है, तो वह कॉम्पोनेंट के स्कीमा से मेल खाने वाला डेटा ऑब्जेक्ट भी बनाता है. यह डेटा ऑब्जेक्ट, क्लाइंट में डेटा मॉडल में सेव किया जाता है, ताकि इसका इस्तेमाल विजेट बनाने और एजेंट को बाद में भेजे जाने वाले मैसेज में रेफ़रंस के तौर पर किया जा सके. जैसे, completeAction, जिसे आपको विजेट से कनेक्ट करना है.
विजेट जोड़ें
अब सूची दिखाने के लिए, एक विजेट बनाएं. इसे _TaskDisplayData क्लास का इंस्टेंस और टास्क पूरा होने पर कॉल करने के लिए कॉलबैक स्वीकार करना चाहिए.
class _TaskDisplay extends StatelessWidget {
final _TaskDisplayData data;
final void Function(_TaskData) onCompleteTask;
const _TaskDisplay({required this.data, required this.onCompleteTask});
@override
Widget build(BuildContext context) {
return Column(
crossAxisAlignment: CrossAxisAlignment.start,
mainAxisSize: MainAxisSize.min,
children: [
Padding(
padding: const EdgeInsets.all(16.0),
child: Text(
data.title,
style: Theme.of(context).textTheme.titleLarge,
),
),
...data.tasks.map(
(task) => CheckboxListTile(
title: Text(
task.name,
style: TextStyle(
decoration: task.isCompleted
? TextDecoration.lineThrough
: TextDecoration.none,
),
),
value: task.isCompleted,
onChanged: task.isCompleted
? null
: (val) {
if (val == true) {
onCompleteTask(task);
}
},
),
),
],
);
}
}
CatalogItem बनाना
स्कीमा, पार्सर, और विजेट बना लेने के बाद, अब इन सभी को एक साथ जोड़ने के लिए CatalogItem बनाया जा सकता है.
task_display.dart के सबसे नीचे, taskDisplay को टॉप-लेवल वैरिएबल के तौर पर बनाएं. साथ ही, आने वाले JSON को पार्स करने के लिए _TaskDisplayData का इस्तेमाल करें और _TaskDisplay विजेट का इंस्टेंस बनाएं.
final taskDisplay = CatalogItem(
name: 'TaskDisplay',
dataSchema: taskDisplaySchema,
widgetBuilder: (itemContext) {
final json = itemContext.data as Map<String, Object?>;
final data = _TaskDisplayData.fromJson(json);
return _TaskDisplay(
data: data,
onCompleteTask: (task) async {
// We will implement this next!
},
);
},
);
onCompleteTask लागू करना
विजेट के काम करने के लिए, यह ज़रूरी है कि जब कोई टास्क पूरा हो जाए, तो वह एजेंट को इसकी सूचना दे. टास्क डेटा से completeAction का इस्तेमाल करके, इवेंट बनाने और उसे भेजने के लिए, खाली onCompleteTask प्लेसहोल्डर को इस कोड से बदलें.
onCompleteTask: (task) async {
// A data context is a reference to a location in the data model. This line
// turns that reference into a concrete data object that the agent can use.
// It's kind of like taking a pointer and replacing it with the value it
// points to.
final JsonMap resolvedContext = await resolveContext(
itemContext.dataContext,
task.actionContext,
);
// Dispatch an event back to the agent, letting it know a task was completed.
// This will be sent to the agent in an A2UI message that includes the name
// of the action, the surface ID, and the resolved data context.
itemContext.dispatchEvent(
UserActionEvent(
name: task.actionName,
sourceComponentId: itemContext.id,
context: resolvedContext,
),
);
}
कैटलॉग आइटम रजिस्टर करना
आखिर में, main.dart खोलें, नई फ़ाइल इंपोर्ट करें, और उसे कैटलॉग के अन्य आइटम के साथ रजिस्टर करें.
इस इंपोर्ट को lib/main.dart के सबसे ऊपर जोड़ें:
import 'task_display.dart';
अपने initState() फ़ंक्शन में catalog = BasicCatalogItems.asCatalog(); को इससे बदलें:
// The Catalog is immutable, so use copyWith to create a new version
// that includes our custom catalog item along with the basics.
catalog = BasicCatalogItems.asCatalog().copyWith(newItems: [taskDisplay]);
आपका काम पूरा हुआ! बदलाव देखने के लिए, ऐप्लिकेशन को हॉट रीस्टार्ट करें.
8. एजेंट के साथ इंटरैक्ट करने के अलग-अलग तरीके आज़माना

आपने Catalog में नया विजेट जोड़ दिया है और ऐप्लिकेशन के यूज़र इंटरफ़ेस (यूआई) में इसके लिए जगह बना ली है. अब एजेंट के साथ काम करने का समय आ गया है. GenUI का एक मुख्य फ़ायदा यह है कि इससे आपको अपने डेटा के साथ इंटरैक्ट करने के दो तरीके मिलते हैं: बटन और चेकबॉक्स जैसे ऐप्लिकेशन यूआई के ज़रिए और नैचुरल लैंग्वेज को समझने वाले और डेटा के बारे में तर्क करने वाले एजेंट के ज़रिए. दोनों को आज़माकर देखें!
- टेक्स्ट फ़ील्ड का इस्तेमाल करके, तीन या चार टास्क के बारे में जानकारी दें. इसके बाद, उन्हें सूची में देखें.
- किसी टास्क को पूरा या अधूरा के तौर पर टॉगल करने के लिए, चेकबॉक्स का इस्तेमाल करें.
- पांच से छह टास्क की सूची बनाएं. इसके बाद, एजेंट को वे टास्क हटाने के लिए कहें जिनके लिए आपको कहीं जाना पड़े.
- एजेंट को बार-बार किए जाने वाले टास्क की सूची को अलग-अलग आइटम के तौर पर बनाने के लिए कहें. जैसे, "मुझे माँ, पिताजी, और दादी के लिए छुट्टियों का कार्ड खरीदना है. इनके लिए अलग-अलग टास्क बनाओ.").
- एजेंट को सभी टास्क को 'पूरा हुआ' या 'पूरा नहीं हुआ' के तौर पर मार्क करने के लिए कहें. इसके अलावा, पहले दो या तीन टास्क पर सही का निशान लगाने के लिए कहें.
9. बधाई हो
बधाई हो! आपने जनरेटिव यूआई और Flutter का इस्तेमाल करके, एआई की मदद से काम करने वाला टास्क ट्रैकिंग ऐप्लिकेशन बनाया है.
आपने क्या सीखा
- Flutter Firebase SDK का इस्तेमाल करके, Google के फ़ाउंडेशन मॉडल से इंटरैक्ट करना
- इस कुकी का इस्तेमाल, GenUI का इस्तेमाल करके Gemini से जनरेट किए गए इंटरैक्टिव सर्फ़ेस को रेंडर करने के लिए किया जाता है
- पहले से तय किए गए स्टैटिक रेंडरिंग आईडी का इस्तेमाल करके, लेआउट में सरफ़ेस पिन करना
- बेहतर इंटरैक्शन लूप के लिए, कस्टम स्कीमा और विजेट कैटलॉग डिज़ाइन करना