इस ट्यूटोरियल में बताया गया है कि Gemini API को सीधे Android ऐप्लिकेशन में, Android के लिए Google के एआई क्लाइंट SDK टूल का इस्तेमाल किया जा रहा है. आप इसका इस्तेमाल कर सकते हैं अगर आपको सीधे REST API या सर्वर-साइड कोड के साथ काम नहीं करना है, तो क्लाइंट SDK टूल का इस्तेमाल किया जा सकता है (जैसे Python).
इस ट्यूटोरियल में आप इन कामों को करने का तरीका जानेंगे:
- एपीआई पासकोड के साथ अपना प्रोजेक्ट सेट अप करना
- सिर्फ़ टेक्स्ट वाले इनपुट से टेक्स्ट जनरेट करना
- टेक्स्ट और इमेज इनपुट से टेक्स्ट जनरेट करना (मल्टीमॉडल)
- बातचीत करना (चैट)
- ज़्यादा तेज़ इंटरैक्शन के लिए स्ट्रीमिंग का इस्तेमाल करना
इसके अलावा, इस ट्यूटोरियल में बेहतर इस्तेमाल के उदाहरणों (जैसे टोकन गिनना) और साथ ही, कॉन्टेंट जनरेट करने के कंट्रोल को कंट्रोल करना.
डिवाइस पर Gemini को ऐक्सेस करें
इस ट्यूटोरियल में बताए गए Android के क्लाइंट SDK टूल की मदद से, Gemini Pro के मॉडल जो Google के सर्वर पर चलते हैं. इस्तेमाल के ऐसे मामलों के लिए जिनमें संवेदनशील डेटा को प्रोसेस करने, ऑफ़लाइन उपलब्धता या पैसे की बचत के लिए बार-बार इस्तेमाल होने वाले यूज़र फ़्लो के लिए, Gemini Nano को ऐक्सेस करने की ज़रूरत है जो डिवाइस पर काम करती है. ज़्यादा जानकारी के लिए, इसे देखें Android (डिवाइस पर) ट्यूटोरियल.
ज़रूरी शर्तें
इस ट्यूटोरियल में यह माना गया है कि आपने इन कामों के लिए Android Studio का इस्तेमाल किया है Android ऐप्लिकेशन डेवलप करने के लिए.
इस ट्यूटोरियल को पूरा करने के लिए, पक्का करें कि आपका डेवलपमेंट एनवायरमेंट और Android ऐप्लिकेशन इन ज़रूरी शर्तों को पूरा करता है:
- Android Studio (नया वर्शन)
- आपके Android ऐप्लिकेशन को, एपीआई लेवल 21 या उसके बाद के लेवल को टारगेट करना होगा.
अपना प्रोजेक्ट सेट अप करना
Gemini API का इस्तेमाल करने से पहले, आपको अपना Android प्रोजेक्ट सेट अप करना होगा. इसमें एपीआई पासकोड सेट अप करना और Android में SDK टूल डिपेंडेंसी जोड़ना शामिल है प्रोजेक्ट बनाना शुरू किया जाता है और मॉडल को शुरू किया जाता है.
एपीआई पासकोड सेट अप करना
Gemini API का इस्तेमाल करने के लिए, आपको एपीआई पासकोड की ज़रूरत होगी. अगर आपके पास पहले से कोई AdSense खाता नहीं है, तो Google AI Studio में कोई पासकोड बनाएं.
एपीआई पासकोड को सुरक्षित रखना
हमारा सुझाव है कि आप अपने वर्शन में एपीआई पासकोड की जांच न करें
कंट्रोल सिस्टम पर काम करते हैं. इसके बजाय, आपको इसे किसी local.properties
फ़ाइल में सेव करना चाहिए
(जो आपके प्रोजेक्ट की रूट डायरेक्ट्री में मौजूद है, लेकिन
कंट्रोल) से जोड़ा जा सकता है और फिर
Android के लिए सीक्रेट Gradle प्लग इन
ताकि एपीआई पासकोड को बिल्ड कॉन्फ़िगरेशन वैरिएबल के तौर पर पढ़ा जा सके.
Kotlin
// Access your API key as a Build Configuration variable
val apiKey = BuildConfig.apiKey
Java
// Access your API key as a Build Configuration variable
String apiKey = BuildConfig.apiKey;
इस ट्यूटोरियल में दिए गए सभी स्निपेट, इस सबसे सही तरीके का इस्तेमाल करते हैं. साथ ही, अगर आपको
Secrets Gradle प्लग इन को लागू करने का तरीका देखना है, तो
ऐप्लिकेशन का नमूना
या Android Studio Iguana की नई झलक का इस्तेमाल करें. इसमें
Gemini API Starter टेंप्लेट
(जिसमें शुरुआत करने के लिए local.properties
फ़ाइल शामिल है).
अपने प्रोजेक्ट में SDK टूल डिपेंडेंसी जोड़ना
आपके मॉड्यूल (ऐप्लिकेशन-लेवल) में Gradle कॉन्फ़िगरेशन फ़ाइल (जैसे
<project>/<app-module>/build.gradle.kts
), तो Android के लिए Google का एआई SDK टूल:Kotlin
dependencies { // ... other androidx dependencies // add the dependency for the Google AI client SDK for Android implementation("com.google.ai.client.generativeai:generativeai:0.9.0") }
Java
Java के लिए, आपको दो अतिरिक्त लाइब्रेरी जोड़नी होंगी.
dependencies { // ... other androidx dependencies // add the dependency for the Google AI client SDK for Android implementation("com.google.ai.client.generativeai:generativeai:0.9.0") // Required for one-shot operations (to use `ListenableFuture` from Guava Android) implementation("com.google.guava:guava:31.0.1-android") // Required for streaming operations (to use `Publisher` from Reactive Streams) implementation("org.reactivestreams:reactive-streams:1.0.4") }
अपने Android प्रोजेक्ट को Gradle फ़ाइलों के साथ सिंक करें.
जनरेटिव मॉडल शुरू करें
एपीआई कॉल करने से पहले, आपको जनरेटिव मॉडल शुरू करना होगा:
Kotlin
val generativeModel = GenerativeModel(
// The Gemini 1.5 models are versatile and work with most use cases
modelName = "gemini-1.5-flash",
// Access your API key as a Build Configuration variable (see "Set up your API key" above)
apiKey = BuildConfig.apiKey
)
Java
Java के लिए, आपको GenerativeModelFutures
ऑब्जेक्ट भी शुरू करना होगा.
// Use a model that's applicable for your use case
// The Gemini 1.5 models are versatile and work with most use cases
GenerativeModel gm = new GenerativeModel(/* modelName */ "gemini-1.5-flash",
// Access your API key as a Build Configuration variable (see "Set up your API key" above)
/* apiKey */ BuildConfig.apiKey);
// Use the GenerativeModelFutures Java compatibility layer which offers
// support for ListenableFuture and Publisher APIs
GenerativeModelFutures model = GenerativeModelFutures.from(gm);
मॉडल तय करते समय, इन बातों का ध्यान रखें:
उस मॉडल का इस्तेमाल करें जो आपके इस्तेमाल के उदाहरण के हिसाब से हो. उदाहरण के लिए,
gemini-1.5-flash
मल्टीमोडल इनपुट के लिए है). इस गाइड में, हर विज्ञापन के लिए निर्देश लागू करने के लिए, इस्तेमाल के हर उदाहरण के लिए सुझाए गए मॉडल की सूची दी जानी चाहिए.
इस्तेमाल के सामान्य उदाहरण लागू करना
आपका प्रोजेक्ट सेट अप हो गया है. अब Gemini API का इस्तेमाल करके, इस्तेमाल के अलग-अलग उदाहरण लागू करें:
- सिर्फ़ टेक्स्ट वाले इनपुट से टेक्स्ट जनरेट करना
- टेक्स्ट और इमेज इनपुट से टेक्स्ट जनरेट करना (मल्टीमॉडल)
- बातचीत करना (चैट)
- ज़्यादा तेज़ इंटरैक्शन के लिए स्ट्रीमिंग का इस्तेमाल करना
सिर्फ़ टेक्स्ट इनपुट से टेक्स्ट जनरेट करें
अगर प्रॉम्प्ट इनपुट में सिर्फ़ टेक्स्ट शामिल है, तो Gemini के 1.5 मॉडल या
टेक्स्ट आउटपुट जनरेट करने के लिए, generateContent
के साथ Gemini 1.0 Pro मॉडल:
Kotlin
ध्यान दें कि generateContent()
एक निलंबित फ़ंक्शन है और इसे
कोरूटीन स्कोप से कॉल किया गया है. अगर आपको कोरूटीन के बारे में नहीं पता है, तो ज़्यादा जानकारी के लिए पढ़ें
Android पर Kotlin कोरूटीन.
val generativeModel = GenerativeModel(
// The Gemini 1.5 models are versatile and work with both text-only and multimodal prompts
modelName = "gemini-1.5-flash",
// Access your API key as a Build Configuration variable (see "Set up your API key" above)
apiKey = BuildConfig.apiKey
)
val prompt = "Write a story about a magic backpack."
val response = generativeModel.generateContent(prompt)
print(response.text)
Java
ध्यान दें कि generateContent()
, ListenableFuture
दिखाता है. अगर आपने
आप इस एपीआई के बारे में नहीं जानते, तो इसके बारे में Android दस्तावेज़ देखें
ListenableFuture
का इस्तेमाल करना.
// The Gemini 1.5 models are versatile and work with both text-only and multimodal prompts
GenerativeModel gm = new GenerativeModel(/* modelName */ "gemini-1.5-flash",
// Access your API key as a Build Configuration variable (see "Set up your API key" above)
/* apiKey */ BuildConfig.apiKey);
GenerativeModelFutures model = GenerativeModelFutures.from(gm);
Content content = new Content.Builder()
.addText("Write a story about a magic backpack.")
.build();
Executor executor = // ...
ListenableFuture<GenerateContentResponse> response = model.generateContent(content);
Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
@Override
public void onSuccess(GenerateContentResponse result) {
String resultText = result.getText();
System.out.println(resultText);
}
@Override
public void onFailure(Throwable t) {
t.printStackTrace();
}
}, executor);
टेक्स्ट और इमेज इनपुट से टेक्स्ट जनरेट करें (मल्टीमॉडल)
Gemini कई तरह के मॉडल उपलब्ध कराता है, जो मल्टीमोडल इनपुट को हैंडल कर सकते हैं (Gemini 1.5 मॉडल) की जानकारी, ताकि टेक्स्ट और इमेज, दोनों इनपुट किए जा सकें. पक्का करें कि प्रॉम्प्ट के लिए इमेज से जुड़ी ज़रूरी शर्तें पढ़ें.
अगर प्रॉम्प्ट इनपुट में टेक्स्ट और इमेज, दोनों शामिल हैं, तो Gemini के 1.5 मॉडल का इस्तेमाल
टेक्स्ट आउटपुट जनरेट करने के लिए generateContent
:
Kotlin
ध्यान दें कि generateContent()
एक निलंबित फ़ंक्शन है और इसे
कोरूटीन स्कोप से कॉल किया गया है. अगर आपको कोरूटीन के बारे में नहीं पता है, तो ज़्यादा जानकारी के लिए पढ़ें
Android पर Kotlin कोरूटीन.
val generativeModel = GenerativeModel(
// The Gemini 1.5 models are versatile and work with both text-only and multimodal prompts
modelName = "gemini-1.5-flash",
// Access your API key as a Build Configuration variable (see "Set up your API key" above)
apiKey = BuildConfig.apiKey
)
val image1: Bitmap = // ...
val image2: Bitmap = // ...
val inputContent = content {
image(image1)
image(image2)
text("What's different between these pictures?")
}
val response = generativeModel.generateContent(inputContent)
print(response.text)
Java
ध्यान दें कि generateContent()
, ListenableFuture
दिखाता है. अगर आपने
आप इस एपीआई के बारे में नहीं जानते, तो इसके बारे में Android दस्तावेज़ देखें
ListenableFuture
का इस्तेमाल करना.
// The Gemini 1.5 models are versatile and work with both text-only and multimodal prompts
GenerativeModel gm = new GenerativeModel(/* modelName */ "gemini-1.5-flash",
// Access your API key as a Build Configuration variable (see "Set up your API key" above)
/* apiKey */ BuildConfig.apiKey);
GenerativeModelFutures model = GenerativeModelFutures.from(gm);
Bitmap image1 = // ...
Bitmap image2 = // ...
Content content = new Content.Builder()
.addText("What's different between these pictures?")
.addImage(image1)
.addImage(image2)
.build();
Executor executor = // ...
ListenableFuture<GenerateContentResponse> response = model.generateContent(content);
Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
@Override
public void onSuccess(GenerateContentResponse result) {
String resultText = result.getText();
System.out.println(resultText);
}
@Override
public void onFailure(Throwable t) {
t.printStackTrace();
}
}, executor);
बार-बार होने वाली बातचीत (चैट) की सुविधा तैयार करें
Gemini की मदद से, अलग-अलग मौकों पर फ़्रीफ़ॉर्म तरीके से बातचीत की जा सकती है. कॉन्टेंट बनाने
SDK टूल, बातचीत की प्रोसेस को मैनेज करके इस प्रक्रिया को आसान बनाता है. यह प्रोसेस को आसान बनाता है
generateContent
के साथ, आपको बातचीत के इतिहास को सेव करने की ज़रूरत नहीं होती है
खुद को बेहतर बनाएं.
कई चरणों में होने वाली बातचीत (जैसे, चैट) शुरू करने के लिए, Gemini के 1.5 मॉडल या
Gemini 1.0 Pro मॉडल का इस्तेमाल करें और startChat()
को कॉल करके चैट शुरू करें.
इसके बाद, उपयोगकर्ता को नया मैसेज भेजने के लिए sendMessage()
का इस्तेमाल करें. इससे, यह भी जुड़ जाएगा
मैसेज और चैट के इतिहास पर दिया गया जवाब.
इसमें मौजूद कॉन्टेंट से जुड़े role
के लिए दो विकल्प हो सकते हैं:
बातचीत:
user
: वह भूमिका जो प्रॉम्प्ट देती है. यह मान इसके लिए डिफ़ॉल्ट है:sendMessage
कॉल.model
: वह भूमिका जो जवाब देती है. इस भूमिका का इस्तेमाल तब किया जा सकता है, जब मौजूदाhistory
सेstartChat()
को कॉल किया जा रहा है.
Kotlin
ध्यान दें कि generateContent()
एक निलंबित फ़ंक्शन है और इसे
कोरूटीन स्कोप से कॉल किया गया है. अगर आपको कोरूटीन के बारे में नहीं पता है, तो ज़्यादा जानकारी के लिए पढ़ें
Android पर Kotlin कोरूटीन.
val generativeModel = GenerativeModel(
// The Gemini 1.5 models are versatile and work with multi-turn conversations (like chat)
modelName = "gemini-1.5-flash",
// Access your API key as a Build Configuration variable (see "Set up your API key" above)
apiKey = BuildConfig.apiKey
)
val chat = generativeModel.startChat(
history = listOf(
content(role = "user") { text("Hello, I have 2 dogs in my house.") },
content(role = "model") { text("Great to meet you. What would you like to know?") }
)
)
chat.sendMessage("How many paws are in my house?")
Java
ध्यान दें कि generateContent()
, ListenableFuture
दिखाता है. अगर आपने
आप इस एपीआई के बारे में नहीं जानते, तो इसके बारे में Android दस्तावेज़ देखें
ListenableFuture
का इस्तेमाल करना.
// The Gemini 1.5 models are versatile and work with multi-turn conversations (like chat)
GenerativeModel gm = new GenerativeModel(/* modelName */ "gemini-1.5-flash",
// Access your API key as a Build Configuration variable (see "Set up your API key" above)
/* apiKey */ BuildConfig.apiKey);
GenerativeModelFutures model = GenerativeModelFutures.from(gm);
// (optional) Create previous chat history for context
Content.Builder userContentBuilder = new Content.Builder();
userContentBuilder.setRole("user");
userContentBuilder.addText("Hello, I have 2 dogs in my house.");
Content userContent = userContentBuilder.build();
Content.Builder modelContentBuilder = new Content.Builder();
modelContentBuilder.setRole("model");
modelContentBuilder.addText("Great to meet you. What would you like to know?");
Content modelContent = userContentBuilder.build();
List<Content> history = Arrays.asList(userContent, modelContent);
// Initialize the chat
ChatFutures chat = model.startChat(history);
// Create a new user message
Content.Builder userMessageBuilder = new Content.Builder();
userMessageBuilder.setRole("user");
userMessageBuilder.addText("How many paws are in my house?");
Content userMessage = userMessageBuilder.build();
Executor executor = // ...
// Send the message
ListenableFuture<GenerateContentResponse> response = chat.sendMessage(userMessage);
Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
@Override
public void onSuccess(GenerateContentResponse result) {
String resultText = result.getText();
System.out.println(resultText);
}
@Override
public void onFailure(Throwable t) {
t.printStackTrace();
}
}, executor);
तेज़ी से इंटरैक्शन करने के लिए स्ट्रीमिंग का इस्तेमाल करें
डिफ़ॉल्ट रूप से, मॉडल पूरी जनरेशन पूरी होने के बाद रिस्पॉन्स दिखाता है प्रोसेस. पूरी प्रोसेस के दौरान इंतज़ार किए बिना, तेज़ी से इंटरैक्शन किए जा सकते हैं का इस्तेमाल किया जा सकता है और आंशिक नतीजों को मैनेज करने के लिए स्ट्रीमिंग का इस्तेमाल किया जा सकता है.
नीचे दिए गए उदाहरण में,
टेक्स्ट और इमेज इनपुट प्रॉम्प्ट से टेक्स्ट जनरेट करने के लिए generateContentStream
.
Kotlin
ध्यान दें कि generateContentStream()
एक निलंबित फ़ंक्शन है और इसे
कोरूटीन स्कोप से कॉल किया गया है. अगर आपको कोरूटीन के बारे में नहीं पता है, तो ज़्यादा जानकारी के लिए पढ़ें
Android पर Kotlin कोरूटीन.
val generativeModel = GenerativeModel(
// The Gemini 1.5 models are versatile and work with both text-only and multimodal prompts
modelName = "gemini-1.5-flash",
// Access your API key as a Build Configuration variable (see "Set up your API key" above)
apiKey = BuildConfig.apiKey
)
val image1: Bitmap = // ...
val image2: Bitmap = // ...
val inputContent = content {
image(image1)
image(image2)
text("What's the difference between these pictures?")
}
var fullResponse = ""
generativeModel.generateContentStream(inputContent).collect { chunk ->
print(chunk.text)
fullResponse += chunk.text
}
Java
इस SDK टूल में मौजूद Java की स्ट्रीमिंग के तरीकों से, Publisher
टाइप मिलता है
प्रतिक्रिया वाली स्ट्रीम से
लाइब्रेरी.
// The Gemini 1.5 models are versatile and work with both text-only and multimodal prompts
GenerativeModel gm = new GenerativeModel(/* modelName */ "gemini-1.5-flash",
// Access your API key as a Build Configuration variable (see "Set up your API key" above)
/* apiKey */ BuildConfig.apiKey);
GenerativeModelFutures model = GenerativeModelFutures.from(gm);
Bitmap image1 = // ...
Bitmap image2 = // ...
Content content = new Content.Builder()
.addText("What's different between these pictures?")
.addImage(image1)
.addImage(image2)
.build();
Publisher<GenerateContentResponse> streamingResponse =
model.generateContentStream(content);
StringBuilder outputContent = new StringBuilder();
streamingResponse.subscribe(new Subscriber<GenerateContentResponse>() {
@Override
public void onNext(GenerateContentResponse generateContentResponse) {
String chunk = generateContentResponse.getText();
outputContent.append(chunk);
}
@Override
public void onComplete() {
System.out.println(outputContent);
}
@Override
public void onError(Throwable t) {
t.printStackTrace();
}
@Override
public void onSubscribe(Subscription s) {
s.request(Long.MAX_VALUE);
}
});
सिर्फ़ टेक्स्ट इनपुट और चैट के इस्तेमाल के लिए, इसी तरीके का इस्तेमाल किया जा सकता है:
Kotlin
ध्यान दें कि generateContentStream()
एक निलंबित फ़ंक्शन है और इसे
कोरूटीन स्कोप से कॉल किया गया है. अगर आपको कोरूटीन के बारे में नहीं पता है, तो ज़्यादा जानकारी के लिए पढ़ें
Android पर Kotlin कोरूटीन.
// Use streaming with text-only input
generativeModel.generateContentStream(inputContent).collect { chunk ->
print(chunk.text)
}
// Use streaming with multi-turn conversations (like chat)
val chat = generativeModel.startChat()
chat.sendMessageStream(inputContent).collect { chunk ->
print(chunk.text)
}
Java
इस SDK टूल में मौजूद Java की स्ट्रीमिंग के तरीकों से, Publisher
टाइप मिलता है
प्रतिक्रिया वाली स्ट्रीम से
लाइब्रेरी.
// Use streaming with text-only input
Publisher<GenerateContentResponse> streamingResponse =
model.generateContentStream(inputContent);
StringBuilder outputContent = new StringBuilder();
streamingResponse.subscribe(new Subscriber<GenerateContentResponse>() {
@Override
public void onNext(GenerateContentResponse generateContentResponse) {
String chunk = generateContentResponse.getText();
outputContent.append(chunk);
}
@Override
public void onComplete() {
System.out.println(outputContent);
}
@Override
public void onSubscribe(Subscription s) {
s.request(Long.MAX_VALUE);
}
// ... other methods omitted for brevity
});
// Use streaming with multi-turn conversations (like chat)
ChatFutures chat = model.startChat(history);
Publisher<GenerateContentResponse> streamingResponse =
chat.sendMessageStream(inputContent);
StringBuilder outputContent = new StringBuilder();
streamingResponse.subscribe(new Subscriber<GenerateContentResponse>() {
@Override
public void onNext(GenerateContentResponse generateContentResponse) {
String chunk = generateContentResponse.getText();
outputContent.append(chunk);
}
@Override
public void onComplete() {
System.out.println(outputContent);
}
@Override
public void onSubscribe(Subscription s) {
s.request(Long.MAX_VALUE);
}
// ... other methods omitted for brevity
});
इस्तेमाल के बेहतर उदाहरण लागू करना
इस ट्यूटोरियल सहायता के पिछले सेक्शन में, इस्तेमाल के जिन सामान्य उदाहरणों के बारे में बताया गया है तो आपको Gemini API का इस्तेमाल करने में कोई दिक्कत नहीं है. इस सेक्शन में, कुछ ऐसी जिन्हें ज़्यादा बेहतर माना जा सकता है.
फ़ंक्शन कॉलिंग
फ़ंक्शन कॉलिंग की मदद से, स्ट्रक्चर्ड डेटा के आउटपुट आसानी से हासिल किए जा सकते हैं जनरेटिव मॉडल. इसके बाद, इन आउटपुट का इस्तेमाल करके अन्य एपीआई को कॉल किया जा सकता है और इन आउटपुट का इस्तेमाल किया जा सकता है मॉडल के लिए काम के रिस्पॉन्स डेटा का इस्तेमाल करती है. दूसरे शब्दों में, फ़ंक्शन कॉलिंग मदद करता है आप जनरेटिव मॉडल को बाहरी सिस्टम से जोड़ते हैं. इससे, जनरेट किया गया कॉन्टेंट में अप-टू-डेट और सटीक जानकारी होती है. ज़्यादा जानकारी के लिए इस लिंक पर जाएं फ़ंक्शन कॉलिंग का ट्यूटोरियल.
टोकन गिनें
लंबे प्रॉम्प्ट का इस्तेमाल करते समय, किसी भी मैसेज को भेजने से पहले टोकन की गिनती करना मददगार हो सकता है
मॉडल के लिए कॉन्टेंट उपलब्ध कराता है. नीचे दिए गए उदाहरणों में, countTokens()
को इस्तेमाल करने का तरीका बताया गया है
इस तरह की जानकारी:
Kotlin
ध्यान दें कि countTokens()
एक निलंबित फ़ंक्शन है और इसे
कोरूटीन स्कोप से कॉल किया गया है. अगर आपको कोरूटीन के बारे में नहीं पता है, तो ज़्यादा जानकारी के लिए पढ़ें
Android पर Kotlin कोरूटीन.
// For text-only input
val (totalTokens) = generativeModel.countTokens("Write a story about a magic backpack.")
// For text-and-image input (multi-modal)
val multiModalContent = content {
image(image1)
image(image2)
text("What's the difference between these pictures?")
}
val (totalTokens) = generativeModel.countTokens(multiModalContent)
// For multi-turn conversations (like chat)
val history = chat.history
val messageContent = content { text("This is the message I intend to send")}
val (totalTokens) = generativeModel.countTokens(*history.toTypedArray(), messageContent)
Java
ध्यान दें कि countTokens()
, ListenableFuture
दिखाता है. अगर आपने
आप इस एपीआई के बारे में नहीं जानते, तो इसके बारे में Android दस्तावेज़ देखें
ListenableFuture
का इस्तेमाल करना.
Content text = new Content.Builder()
.addText("Write a story about a magic backpack.")
.build();
Executor executor = // ...
// For text-only input
ListenableFuture<CountTokensResponse> countTokensResponse = model.countTokens(text);
Futures.addCallback(countTokensResponse, new FutureCallback<CountTokensResponse>() {
@Override
public void onSuccess(CountTokensResponse result) {
int totalTokens = result.getTotalTokens();
System.out.println("TotalTokens = " + totalTokens);
}
@Override
public void onFailure(Throwable t) {
t.printStackTrace();
}
}, executor);
// For text-and-image input
Bitmap image1 = // ...
Bitmap image2 = // ...
Content multiModalContent = new Content.Builder()
.addImage(image1)
.addImage(image2)
.addText("What's different between these pictures?")
.build();
ListenableFuture<CountTokensResponse> countTokensResponse = model.countTokens(multiModalContent);
// For multi-turn conversations (like chat)
List<Content> history = chat.getChat().getHistory();
Content messageContent = new Content.Builder()
.addText("This is the message I intend to send")
.build();
Collections.addAll(history, messageContent);
ListenableFuture<CountTokensResponse> countTokensResponse = model.countTokens(history.toArray(new Content[0]));
कॉन्टेंट जनरेट करने की प्रोसेस को कंट्रोल करने के विकल्प
मॉडल पैरामीटर कॉन्फ़िगर करके और इनका इस्तेमाल करके, कॉन्टेंट जनरेट होने की प्रोसेस को कंट्रोल किया जा सकता है सुरक्षा सेटिंग.
मॉडल पैरामीटर कॉन्फ़िगर करें
मॉडल को भेजे जाने वाले हर प्रॉम्प्ट में पैरामीटर की वैल्यू शामिल होती हैं. इनकी मदद से, यह तय किया जाता है कि तो मॉडल जवाब जनरेट करता है. मॉडल, GA4 प्रॉपर्टी के लिए अलग-अलग नतीजे जनरेट कर सकता है पैरामीटर वैल्यू अलग-अलग हैं. इसके बारे में ज़्यादा जानें मॉडल पैरामीटर.
Kotlin
val config = generationConfig {
temperature = 0.9f
topK = 16
topP = 0.1f
maxOutputTokens = 200
stopSequences = listOf("red")
}
val generativeModel = GenerativeModel(
// The Gemini 1.5 models are versatile and work with most use cases
modelName = "gemini-1.5-flash",
apiKey = BuildConfig.apiKey,
generationConfig = config
)
Java
GenerationConfig.Builder configBuilder = new GenerationConfig.Builder();
configBuilder.temperature = 0.9f;
configBuilder.topK = 16;
configBuilder.topP = 0.1f;
configBuilder.maxOutputTokens = 200;
configBuilder.stopSequences = Arrays.asList("red");
GenerationConfig generationConfig = configBuilder.build();
// The Gemini 1.5 models are versatile and work with most use cases
GenerativeModel gm = new GenerativeModel(
"gemini-1.5-flash",
BuildConfig.apiKey,
generationConfig
);
GenerativeModelFutures model = GenerativeModelFutures.from(gm);
सुरक्षा सेटिंग का इस्तेमाल करना
सुरक्षा सेटिंग का इस्तेमाल करके, यह तय किया जा सकता है कि लोगों को किस तरह के जवाब मिलने चाहिए नुकसान पहुंचाने वाला कॉन्टेंट माना जा सकता है. सुरक्षा सेटिंग, डिफ़ॉल्ट रूप से मीडियम साइज़ वाले कॉन्टेंट को ब्लॉक करती हैं और/या सभी डाइमेंशन में असुरक्षित कॉन्टेंट होने की संभावना ज़्यादा हो. ज़्यादा जानें सुरक्षा की सेटिंग के बारे में ज़्यादा जानकारी.
यहां एक सुरक्षा सेटिंग सेट करने का तरीका बताया गया है:
Kotlin
val generativeModel = GenerativeModel(
// The Gemini 1.5 models are versatile and work with most use cases
modelName = "gemini-1.5-flash",
apiKey = BuildConfig.apiKey,
safetySettings = listOf(
SafetySetting(HarmCategory.HARASSMENT, BlockThreshold.ONLY_HIGH)
)
)
Java
SafetySetting harassmentSafety = new SafetySetting(HarmCategory.HARASSMENT,
BlockThreshold.ONLY_HIGH);
// The Gemini 1.5 models are versatile and work with most use cases
GenerativeModel gm = new GenerativeModel(
"gemini-1.5-flash",
BuildConfig.apiKey,
null, // generation config is optional
Collections.singletonList(harassmentSafety)
);
GenerativeModelFutures model = GenerativeModelFutures.from(gm);
आप एक से ज़्यादा सुरक्षा सेटिंग भी सेट कर सकते हैं:
Kotlin
val harassmentSafety = SafetySetting(HarmCategory.HARASSMENT, BlockThreshold.ONLY_HIGH)
val hateSpeechSafety = SafetySetting(HarmCategory.HATE_SPEECH, BlockThreshold.MEDIUM_AND_ABOVE)
val generativeModel = GenerativeModel(
// The Gemini 1.5 models are versatile and work with most use cases
modelName = "gemini-1.5-flash",
apiKey = BuildConfig.apiKey,
safetySettings = listOf(harassmentSafety, hateSpeechSafety)
)
Java
SafetySetting harassmentSafety = new SafetySetting(HarmCategory.HARASSMENT,
BlockThreshold.ONLY_HIGH);
SafetySetting hateSpeechSafety = new SafetySetting(HarmCategory.HATE_SPEECH,
BlockThreshold.MEDIUM_AND_ABOVE);
// The Gemini 1.5 models are versatile and work with most use cases
GenerativeModel gm = new GenerativeModel(
"gemini-1.5-flash",
BuildConfig.apiKey,
null, // generation config is optional
Arrays.asList(harassmentSafety, hateSpeechSafety)
);
GenerativeModelFutures model = GenerativeModelFutures.from(gm);
आगे क्या करना है
प्रॉम्प्ट डिज़ाइन ऐसे प्रॉम्प्ट बनाने की प्रोसेस है जो आपके काम के लैंग्वेज मॉडल से मिले रिस्पॉन्स. अच्छी तरह से स्ट्रक्चर किए गए प्रॉम्प्ट लिखना बहुत ज़रूरी है यह पक्का किया जा सकता है कि किसी भाषा के मॉडल से सही और अच्छी क्वालिटी के जवाब मिले हैं. प्रॉम्प्ट लिखने के सबसे सही तरीके जानें.
अलग-अलग कामों की ज़रूरतों को पूरा करने के लिए, Gemini कई तरह के मॉडल उपलब्ध कराता है मामलों, जैसे इनपुट प्रकार और जटिलता, चैट या अन्य डायलॉग लैंग्वेज टास्क, और साइज़ कंस्ट्रेंट. Gemini के उपलब्ध मॉडल के बारे में जानें.
इस ट्यूटोरियल में बताए गए Android के क्लाइंट SDK टूल की मदद से, Gemini Pro के मॉडल जो Google के सर्वर पर चलते हैं. इस्तेमाल के ऐसे मामलों के लिए जिनमें संवेदनशील डेटा को प्रोसेस करने, ऑफ़लाइन उपलब्धता या पैसे की बचत के लिए बार-बार इस्तेमाल होने वाले यूज़र फ़्लो के लिए, Gemini Nano को ऐक्सेस करने की ज़रूरत है जो डिवाइस पर काम करती है. ज़्यादा जानकारी के लिए, इसे देखें Android (डिवाइस पर) ट्यूटोरियल.