Google आपकी पसंदीदा भाषा में कॉन्टेंट का अनुवाद करने के लिए, एआई टेक्नोलॉजी का इस्तेमाल करता है. एआई से मिले अनुवादों में गलतियां हो सकती हैं.

फ़ंक्शन कॉलिंग का इस्तेमाल करना

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

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

मुख्य सुविधाएं

फ़ंक्शन कॉलिंग की सुविधा से ये मुख्य काम किए जा सकते हैं:

सिंगल-टर्न फ़ंक्शन कॉलिंग: Gemini Nano, एक या उससे ज़्यादा टूल कॉल (FunctionCall) का अनुमान लगाता है. आपका ऐप्लिकेशन, फ़ंक्शन को डिवाइस पर ही एक्ज़ीक्यूट करता है. साथ ही, मॉडल से फ़ॉलो-अप रिस्पॉन्स की ज़रूरत के बिना ही फ़्लो पूरा हो जाता है.
मल्टी-टर्न फ़ंक्शन कॉलिंग: Gemini Nano, एक या उससे ज़्यादा टूल कॉल (FunctionCall) का अनुमान लगाता है. आपका ऐप्लिकेशन, फ़ंक्शन को स्थानीय तौर पर एक्ज़ीक्यूट करता है और नतीजों को वापस भेजता है (FunctionResponsePart), ताकि ज़्यादा टूल कॉल या सिंथेसाइज़ किया गया टेक्स्ट रिस्पॉन्स मिल सके.

फ़ंक्शन कॉलिंग की सुविधा लागू करते समय, आपको ये फ़ायदे मिल सकते हैं:

प्रोग्राम के हिसाब से टूल की परिभाषाएं: ML Kit GenAI स्कीमा एपीआई (com.google.mlkit:genai-schema) का इस्तेमाल करके, रनटाइम के दौरान डाइनैमिक FunctionDeclaration और FunctionSchema टूल की परिभाषाएं बनाएं.
स्ट्रक्चर्ड आर्ग्युमेंट पार्सिंग: अपने लोकल ऐप्लिकेशन लॉजिक को लागू करने के लिए, मॉडल के रिस्पॉन्स कैंडिडेट से सीधे तौर पर स्ट्रॉन्गली टाइप्ड आर्ग्युमेंट वैल्यू पाएं.

ध्यान दें: डायरेक्ट मॉडल ऐक्सेस (genai-prompt) टूल को प्रोग्राम के हिसाब से तय करता है. इसके लिए, वह FunctionDeclaration का इस्तेमाल करता है. साथ ही, फ़ंक्शन को अपने-आप डिस्पैच या एक्ज़ीक्यूट नहीं करता. मॉडल, अपने जवाब में अनुमानित फ़ंक्शन के नाम और आर्ग्युमेंट दिखाता है. साथ ही, आपका ऐप्लिकेशन फ़ंक्शन के लिए लोकल लॉजिक को लागू करने और लागू करने के नतीजों को वापस भेजने को कंट्रोल करता है. Android के @AppFunction एनोटेशन का इस्तेमाल करके, डिक्लेरेटिव तरीके से टूल तय करने और ML Kit को एजेंटिक लूप में कई बार टूल चलाने की सुविधा अपने-आप देने के लिए, एजेंटिक वर्कफ़्लो देखें.

परिणामों के उदाहरण

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

एक्ज़ीक्यूशन फ़्लो	उपयोगकर्ता का प्रॉम्प्ट	मॉडल आउटपुट
सिंगल-टर्न	"लिविंग रूम की लाइटों की रोशनी 80% तक बढ़ाओ."	टूल कॉल: `turn_on_light(room="living room", brightness=80)`
सिंगल-टर्न	"कैमरा ऐप्लिकेशन खोलो."	टूल कॉल: `open_app(appName="Camera")`
Multi-turn	"सैन फ़्रांसिस्को में सेल्सियस में मौसम कैसा है?"	इंटरमीडिएट टूल कॉल: `get_current_weather(location="San Francisco, CA", unit="celsius")` उपयोगकर्ता को दिखाया गया फ़ाइनल मॉडल आउटपुट: `In SF it's currently 25 degrees Celsius.`

ज़रूरी शर्तें

फ़ंक्शन कॉलिंग की सुविधा का इस्तेमाल करने के लिए, आपके डिवाइस और खाते को ये ज़रूरी शर्तें पूरी करनी होंगी:

आपके डिवाइस पर Prompt API काम करता हो.
आपके डिवाइस पर मौजूद Google खाता, AICore Developer Preview program का हिस्सा है.

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

इसके अलावा, आपके प्रोजेक्ट को ये ज़रूरी शर्तें पूरी करनी होंगी:

Kotlin का 2.3.0 या इसके बाद का वर्शन
SDK टूल (minSdk) का वर्शन 26 या इसके बाद का होना चाहिए

अपनी प्रोफ़ाइल बनाना शुरू करें

फ़ंक्शन कॉलिंग का इस्तेमाल शुरू करने के लिए, यह तरीका अपनाएं.

अपने प्रोजेक्ट-लेवल की settings.gradle.kts (या settings.gradle) फ़ाइल में, repositories {} ब्लॉक में mavenCentral() जोड़ें.

dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        google()
        mavenCentral()
    }
}

अपने मॉड्यूल-लेवल की build.gradle.kts (या build.gradle फ़ाइल) में, ML Kit Prompt API और स्कीमा डिपेंडेंसी जोड़ें:

Kotlin

plugins {
    id("com.android.application")
    id("org.jetbrains.kotlin.android")
}

dependencies {
    // ML Kit GenAI Prompt and Schema SDKs
    implementation("com.google.mlkit:genai-prompt:1.0.0-beta5")
    implementation("com.google.mlkit:genai-schema:1.0.0-alpha2")
}

ग्रूवी

plugins {
    id 'com.android.application'
    id 'org.jetbrains.kotlin.android'
}

dependencies {
    // ML Kit GenAI Prompt and Schema SDKs
    implementation 'com.google.mlkit:genai-prompt:1.0.0-beta5'
    implementation 'com.google.mlkit:genai-schema:1.0.0-alpha2'
}

अपने मॉड्यूल-लेवल की build.gradle (या build.gradle.kts फ़ाइल) में, minSdk वर्शन को 26 या इसके बाद के वर्शन पर सेट करें.

Kotlin

android {
    defaultConfig {
        // ...
        minSdk = 26
        // ...
    }
}

ग्रूवी

android {
    defaultConfig {
        // ...
        minSdk 26
        // ...
    }
}

फ़ंक्शन कॉलिंग एपीआई इस्तेमाल करने का तरीका

फ़ंक्शन कॉलिंग की सुविधा लागू करने के लिए, यह तरीका अपनाएं:

अपने टूल तय करें.
मॉडल चुनें.
अपने अनुरोध में टूल अटैच करें.
टूल कॉल (सिंगल-टर्न या मल्टी-टर्न) को हैंडल करना.

अगले सेक्शन में, इन चरणों को समझाने के लिए एक उदाहरण दिया गया है.

अपने टूल तय करना

com.google.mlkit.genai.schema.tools पैकेज से FunctionDeclaration, FunctionSchema, और FunctionType का इस्तेमाल करके, प्रोग्राम के हिसाब से टूल स्कीमा बनाएं. (Android के @AppFunction एनोटेशन का इस्तेमाल करके, कंपाइल के समय टूल को डिक्लेयर करने के लिए, टूल तय करें लेख पढ़ें. इससे टूल अपने-आप काम करने लगते हैं.)

उदाहरण के लिए, कार्रवाई पर आधारित टूल को तय किया जा सकता है. जैसे, एक बार में कार्रवाई करने के लिए स्मार्ट लाइट चालू करना:

import com.google.mlkit.genai.schema.tools.FunctionDeclaration
import com.google.mlkit.genai.schema.tools.FunctionSchema
import com.google.mlkit.genai.schema.tools.FunctionType

val turnOnLightTool = FunctionDeclaration(
    name = "turn_on_light",
    description = "Turn on the lights in a room and set the brightness",
    parameters = FunctionSchema(
        type = FunctionType.OBJECT,
        properties = mapOf(
            "room" to FunctionSchema(
                type = FunctionType.STRING,
                description = "The room name"
            ),
            "brightness" to FunctionSchema(
                type = FunctionType.INTEGER,
                description = "Brightness level from 0 to 100"
            )
        ),
        required = listOf("room")
    )
)

इसके अलावा, डेटा वापस पाने वाला कोई टूल तय करें. जैसे, कई बार बातचीत करने के लिए, मौजूदा मौसम की जानकारी फ़ेच करना:

import com.google.mlkit.genai.schema.tools.FunctionDeclaration
import com.google.mlkit.genai.schema.tools.FunctionSchema
import com.google.mlkit.genai.schema.tools.FunctionType

val getWeatherTool = FunctionDeclaration(
    name = "get_current_weather",
    description = "Get the current weather for a location",
    parameters = FunctionSchema(
        type = FunctionType.OBJECT,
        properties = mapOf(
            "location" to FunctionSchema(
                type = FunctionType.STRING,
                description = "The city and state, e.g. San Francisco, CA"
            ),
            "unit" to FunctionSchema(
                type = FunctionType.STRING,
                description = "The temperature unit, either 'celsius' or 'fahrenheit'"
            )
        ),
        required = listOf("location")
    )
)

मॉडल चुनें

फ़ंक्शन कॉलिंग के लिए, Gemini Nano 4 ज़रूरी है. Gemini Nano 4 को ऐक्सेस करने के लिए, मॉडल चुनने वाले एपीआई का इस्तेमाल करें. इससे, GenerativeModel इंस्टेंस को ModelReleaseStage.PREVIEW और ModelPreference.FAST को टारगेट करने के लिए कॉन्फ़िगर किया जा सकेगा.

import com.google.mlkit.genai.prompt.Generation
import com.google.mlkit.genai.prompt.ModelPreference
import com.google.mlkit.genai.prompt.ModelReleaseStage
import com.google.mlkit.genai.prompt.generationConfig
import com.google.mlkit.genai.prompt.modelConfig

// Target the preview fast model (Gemini Nano 4)
val config = generationConfig {
    modelConfig = modelConfig {
        releaseStage = ModelReleaseStage.PREVIEW
        preference = ModelPreference.FAST
    }
}
val generativeModel = Generation.getClient(config)

अपने अनुरोध में टूल अटैच करना

GenerateContentRequest ऑब्जेक्ट बनाते समय, अपनी FunctionDeclaration सूची को रिक्वेस्ट बिल्डर में setTools() को पास करें.

उदाहरण के लिए, सिस्टम से जुड़े निर्देश के साथ, सिंगल-टर्न ऐक्शन के अनुरोध के लिए कोई टूल अटैच करना:

import com.google.mlkit.genai.prompt.SystemInstruction
import com.google.mlkit.genai.prompt.TextPart
import com.google.mlkit.genai.prompt.generateContentRequest

val requestText = "Turn on the living room lights and set brightness to 50"

val request = generateContentRequest(
    SystemInstruction("You are a helpful home automation assistant."),
    TextPart(requestText)
) {
    // Attach the FunctionDeclaration tool schemas
    setTools(listOf(turnOnLightTool))
    temperature = 0.2f
}

// Run non-streaming inference
val response = generativeModel.generateContent(request)

या फिर, एक से ज़्यादा बार पूछे जाने वाले सवाल के लिए, अपनी FunctionDeclaration सूची अटैच करने के लिए:

import com.google.mlkit.genai.prompt.SystemInstruction
import com.google.mlkit.genai.prompt.TextPart
import com.google.mlkit.genai.prompt.generateContentRequest

val availableTools = listOf(getWeatherTool)

// Use the generateContentRequest DSL
val request = generateContentRequest(
    TextPart("What is the weather in San Francisco, CA in celsius?")
) {
    setTools(availableTools)
}
val response = generativeModel.generateContent(request)

टूल कॉल मैनेज करना

जब Gemini Nano किसी टूल को इस्तेमाल करने का फ़ैसला लेता है, तो मॉडल के जवाब में candidate.functionCalls में एक या उससे ज़्यादा FunctionCall ऑब्जेक्ट शामिल होते हैं. टूल कॉल को मैनेज करने के लिए, आपके ऐप्लिकेशन को सबसे पहले रिस्पॉन्स कैंडिडेट की जांच करनी होगी. इससे यह पुष्टि की जा सकेगी कि किसी टूल कॉल का अनुमान लगाया गया था या नहीं:

import com.google.mlkit.genai.common.FunctionArgValue
import com.google.mlkit.genai.prompt.Content
import com.google.mlkit.genai.prompt.FunctionCallPart
import com.google.mlkit.genai.prompt.FunctionResponsePart
import com.google.mlkit.genai.prompt.GenerateContentRequest
import com.google.mlkit.genai.prompt.TextPart
import com.google.mlkit.genai.prompt.content

val candidate = response.candidates.firstOrNull()
val functionCalls = candidate?.functionCalls ?: emptyList()

if (functionCalls.isNotEmpty()) {
    // Process tool calls using either the single-turn or multi-turn flow
    // described in the following sections
}

सिंगल-टर्न फ़ंक्शन कॉलिंग

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

for (functionCall in functionCalls) {
    val name = functionCall.name
    val args = functionCall.arguments // Map<String, FunctionArgValue>

    when (name) {
        "open_app" -> {
            val appName = (args["appName"] as? FunctionArgValue.StringValue)?.value
            launchApp(appName)
        }
        "turn_on_light" -> {
            val room = (args["room"] as? FunctionArgValue.StringValue)?.value
            val brightness = (args["brightness"] as? FunctionArgValue.IntValue)?.value ?: 100
            setLightState(room, brightness)
        }
        else -> Log.w(TAG, "Unhandled tool call: $name")
    }
}

मल्टी-टर्न फ़ंक्शन कॉलिंग

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

मल्टी-टर्न फ़्लो में, आपका ऐप्लिकेशन ये काम करता है:

अनुरोध किए गए फ़ंक्शन को स्थानीय तौर पर लागू करता है.
नतीजे को FunctionResponsePart ऑब्जेक्ट में पैकेज करता है.
यह बातचीत के इतिहास में, मॉडल के कॉल (MODEL रोल) और आपके एक्ज़ीक्यूशन के नतीजे (USER रोल), दोनों को जोड़ता है.
यह Gemini Nano को फ़ॉलो-अप अनुरोध भेजता है, ताकि वह नैचुरल लैंग्वेज में जवाब तैयार कर सके.

// 1. Execute each predicted tool call and collect results
val responseParts = mutableListOf<FunctionResponsePart>()

for (functionCall in functionCalls) {
    val responsePart: FunctionResponsePart = when {
        functionCall.name == "get_current_weather" -> {
            val location = (functionCall.arguments["location"] as? FunctionArgValue.StringValue)?.value ?: ""
            val unit = (functionCall.arguments["unit"] as? FunctionArgValue.StringValue)?.value ?: "celsius"

            val weatherData = fetchWeather(location, unit) // Local network/API call

            // Package the tool execution result as a key-value map
            FunctionResponsePart(
                id = functionCall.id,
                name = functionCall.name,
                response = mapOf("result" to weatherData)
            )
        }

        else -> throw IllegalArgumentException("Unknown tool: ${functionCall.name}")
    }
    responseParts.add(responsePart)
}

// 2. Append turns to conversation history to construct the multi-turn context
val history = request.contents.toMutableList().apply {
    // Turn 1: Model's request containing the predicted FunctionCallPart object
    add(
        content(Content.Role.MODEL) {
            for (call in functionCalls) {
                addPart(FunctionCallPart(call))
            }
        }
    )
    // Turn 2: User's response containing the executed FunctionResponsePart object
    add(
        content(Content.Role.USER) {
            for (responsePart in responseParts) {
                addPart(responsePart)
            }
        }
    )
}

// 3. Send the updated history back to Gemini Nano for final text synthesis
val followUpRequest = GenerateContentRequest.Builder(history)
    .setTools(availableTools) // Include tools in case the model requires subsequent tool calls
    .build()

val finalResponse = generativeModel.generateContent(followUpRequest)
val answer = finalResponse.candidates.firstOrNull()?.text

Log.d(TAG, "Final Model Response: $answer")

सैंपल कोड

Android ऐप्लिकेशन में फ़ंक्शन कॉलिंग का पूरा उदाहरण देखने के लिए, यह ML Kit सैंपल ऐप्लिकेशन देखें.

ज्ञात समस्याएं

डायरेक्ट मॉडल ऐक्सेस (genai-prompt) में AndroidX AppFunctions (@AppFunction): Prompt API (com.google.mlkit:genai-prompt:1.0.0-beta5) के ज़रिए, कंपाइल के समय @AppFunction टूल को सीधे तौर पर खोजने और इस्तेमाल करने की सुविधा अब तक उपलब्ध नहीं है. genai-prompt लाइब्रेरी में मौजूद टूल को FunctionDeclaration क्लास का इस्तेमाल करके, प्रोग्राम के हिसाब से तय किया जाना चाहिए. @AppFunction टूल का इस्तेमाल करने के लिए, एजेंटिक वर्कफ़्लो (com.google.mlkit:genai-agent) का इस्तेमाल करें.
स्ट्रीमिंग अनुरोधों (generateContentStream) का इस्तेमाल करते समय, टूल कॉल को टोकन-दर-टोकन स्ट्रीम नहीं किया जाता. इसके बजाय, मॉडल के टूल कॉल जनरेट करने के बाद, FunctionCall ऑब्जेक्ट उत्सर्जित किए जाते हैं. ये ऑब्जेक्ट, StreamingCallback.onNewFunctionCall के ज़रिए या स्ट्रीम किए गए फ़ाइनल GenerateContentResponse.candidates[0].functionCalls में उत्सर्जित किए जाते हैं.