फ़ंक्शन कॉलिंग का ट्यूटोरियल

फ़ंक्शन कॉलिंग की मदद से, स्ट्रक्चर्ड डेटा के आउटपुट आसानी से हासिल किए जा सकते हैं जनरेटिव मॉडल. इसके बाद, इन आउटपुट का इस्तेमाल करके अन्य एपीआई को कॉल किया जा सकता है और इन आउटपुट का इस्तेमाल किया जा सकता है मॉडल के लिए काम के रिस्पॉन्स डेटा का इस्तेमाल करती है. दूसरे शब्दों में, फ़ंक्शन कॉलिंग मदद करता है आप जनरेटिव मॉडल को बाहरी सिस्टम से जोड़ते हैं. इससे, जनरेट किया गया कॉन्टेंट में अप-टू-डेट और सटीक जानकारी होती है.

Gemini के मॉडल के हिसाब से, उनके काम करने के तरीक़े की जानकारी दी जा सकती है. ये हैं आपके ऐप्लिकेशन की भाषा में लिखते हैं (यानी कि वे Google Cloud Functions). मॉडल आपसे फ़ंक्शन को कॉल करने और वापस भेजने के लिए कह सकता है इस नतीजे की मदद से, मॉडल आपकी क्वेरी को मैनेज करता है.

अगर आपने अब तक ऐसा नहीं किया है, तो इसे देखें सीखने के लिए, फ़ंक्शन कॉलिंग के बारे में जानकारी ज़्यादा.

लाइटिंग कंट्रोल के लिए एपीआई का उदाहरण

मान लें कि आपके पास एक बेसिक लाइटिंग सिस्टम है, जो किसी ऐप्लिकेशन प्रोग्रामिंग के साथ काम करता है का इंटरफ़ेस (API) है और आप उपयोगकर्ताओं को आसान तरीके से लाइटों को नियंत्रित करने की अनुमति देना चाहते हैं टेक्स्ट अनुरोध. फ़ंक्शन कॉलिंग की सुविधा का इस्तेमाल करके, लाइटिंग को समझा जा सकता है लाइटिंग सेट करने के लिए, उपयोगकर्ताओं के अनुरोधों को बदलें और उन्हें एपीआई कॉल में अनुवाद करें वैल्यू. इस काल्पनिक लाइटिंग सिस्टम की मदद से, आपको लाइट की चमक और उसका कलर टेंपरेचर, जिन्हें दो अलग-अलग तरीकों से दिखाया गया है पैरामीटर:

पैरामीटर टाइप ज़रूरी है ब्यौरा
brightness संख्या हां रोशनी का स्तर 0 से 100 तक. 'शून्य' सेटिंग बंद है और '100' मोड में पूरी स्क्रीन की रोशनी है.
colorTemperature स्ट्रिंग हां लाइट फ़िक्स्चर का कलर टेंपरेचर, जो daylight, cool या warm हो सकता है.

सरलता के लिए, इस काल्पनिक लाइटिंग सिस्टम में सिर्फ़ एक लाइट होती है, इसलिए उपयोगकर्ता कमरे या जगह की जानकारी देना ज़रूरी नहीं है. यहां JSON अनुरोध का एक उदाहरण दिया गया है लाइट लेवल को 50% पर सेट करने के लिए, लाइटिंग कंट्रोल एपीआई को भेजा जा सकता है डेलाइट कलर टेंपरेचर का इस्तेमाल करके:

{
  "brightness": "50",
  "colorTemperature": "daylight"
}

इस ट्यूटोरियल में, Gemini API के लिए फ़ंक्शन कॉल सेट अप करने का तरीका बताया गया है लाइटिंग के अनुरोधों को समझें और एपीआई सेटिंग पर मैप करें, ताकि रोशनी की चमक और कलर टेंपरेचर के मान.

शुरू करने से पहले: अपना प्रोजेक्ट और एपीआई पासकोड सेट अप करें

Gemini API को कॉल करने से पहले, आपको अपना प्रोजेक्ट सेट अप करना होगा और उसे कॉन्फ़िगर करना होगा आपकी एपीआई कुंजी.

एपीआई फ़ंक्शन तय करना

एपीआई अनुरोध करने वाला फ़ंक्शन बनाएं. इस फ़ंक्शन को तय किया जाना चाहिए आपके ऐप्लिकेशन के कोड में हो, लेकिन उससे बाहर की सेवाओं या एपीआई को कॉल कर सके आपका ऐप्लिकेशन. Gemini API, इस फ़ंक्शन को सीधे तौर पर कॉल नहीं करता है, इसलिए आपको इस बात को कंट्रोल कर सकता है कि आपके ऐप्लिकेशन से इस फ़ंक्शन को कब और कैसे एक्ज़ीक्यूट किया जाए कोड. यह दिखाने के लिए, इस ट्यूटोरियल में एक मॉक एपीआई फ़ंक्शन के बारे में बताया गया है बस अनुरोध की गई लाइटिंग वैल्यू दिखाता है:

Future<Map<String, Object?>> setLightValues(
  Map<String, Object?> arguments,
) async =>
    // This mock API returns the requested lighting values
    {
      'brightness': arguments['brightness'],
      'colorTemperature': arguments['colorTemp'],
    };

फ़ंक्शन का एलान करें

जनरेटिव मॉडल को भेजने के लिए, फ़ंक्शन का एलान करें. टास्क कब शुरू होगा आप मॉडल के अनुसार उपयोग करने के लिए किसी फ़ंक्शन का एलान करते हैं, तो आपको अपनी कस्टम जानकारी में फ़ंक्शन और पैरामीटर की जानकारी में जितना संभव हो सके. जनरेटिव मॉडल इस जानकारी का इस्तेमाल यह तय करने के लिए करता है कि कौनसा फ़ंक्शन चुनना है और कैसे उपलब्ध कराना है फ़ंक्शन कॉल में पैरामीटर के लिए वैल्यू. नीचे दिया गया कोड, लाइटिंग कंट्रोल फ़ंक्शन के बारे में बताएं:

final lightControlTool = FunctionDeclaration(
    'setLightValues',
    'Set the brightness and color temperature of a room light.',
    Schema(SchemaType.object, properties: {
      'brightness': Schema(SchemaType.number,
          description: 'Light level from 0 to 100. '
              'Zero is off and 100 is full brightness.'),
      'colorTemperature': Schema(SchemaType.string,
          description: 'Color temperature of the light fixture, '
              'which can be `daylight`, `cool` or `warm`.'),
    }, requiredProperties: [
      'brightness',
      'colorTemperature'
    ]));

मॉडल शुरू करने के दौरान, फ़ंक्शन बताएं

जब आपको किसी मॉडल के साथ फ़ंक्शन कॉलिंग का इस्तेमाल करना हो, तो आपको फ़ंक्शन घोषणाएं होती हैं. आपने एलान किया फ़ंक्शन को मॉडल के tools पैरामीटर से सेट करके इस तरह से फ़ंक्शन को एक्ज़ीक्यूट किया जा सकता है. Dart SDK टूल की मदद से, generateContent या generateContentStream एपीआई.

final model = GenerativeModel(
  model: 'gemini-1.5-flash',
  apiKey: apiKey,

  // Specify the function declaration.
  tools: [
    Tool(functionDeclarations: [lightControlTool])
  ],
);

फ़ंक्शन कॉल जनरेट करें

अपने फ़ंक्शन की जानकारी के साथ मॉडल शुरू करने के बाद, तय फ़ंक्शन वाला मॉडल. आपको इसका उपयोग करके फ़ंक्शन कॉलिंग का उपयोग करना चाहिए चैट प्रॉम्प्ट (sendMessage()), क्योंकि फ़ंक्शन से कॉल करने के लिए, आम तौर पर पिछले प्रॉम्प्ट और रिस्पॉन्स के बारे में जानकारी मौजूद हो.

final chat = model.startChat(); final prompt =
  'Dim the lights so the room feels cozy and warm.';

// Send the message to the generative model.
var response = await chat.sendMessage(Content.text(prompt));

final functionCalls = response.functionCalls.toList();
// When the model response with a function call, invoke the function.
if (functionCalls.isNotEmpty) {
  final functionCall = functionCalls.first;
  final result = switch (functionCall.name) {
    // Forward arguments to the hypothetical API.
    'setLightValues' => await setLightValues(functionCall.args),
    // Throw an exception if the model attempted to call a function that was
    // not declared.
    _ => throw UnimplementedError(
        'Function not implemented: ${functionCall.name}')
  };
  // Send the response to the model so that it can use the result to generate
  // text for the user.
  response = await chat
      .sendMessage(Content.functionResponse(functionCall.name, result));
}
// When the model responds with non-null text content, print it.
if (response.text case final text?) {
  print(text);
}