ट्यूटोरियल: Gemini API का इस्तेमाल शुरू करना

Python Node.js वेब आराम शुरू करें डार्ट (फ़्लटर) Android Swift

इस ट्यूटोरियल में बताया गया है कि Gemini API को सीधे Google के AI Swift SDK टूल का इस्तेमाल करने वाला Swift ऐप्लिकेशन. अगर आपको किसी SDK टूल की ज़रूरत नहीं है, तो उसका इस्तेमाल किया जा सकता है REST API या सर्वर-साइड कोड (जैसे Python) के साथ सीधे काम करने के लिए आपके Swift ऐप्लिकेशन में Gemini के मॉडल.

इस ट्यूटोरियल में आप इन कामों को करने का तरीका जानेंगे:

• एपीआई पासकोड के साथ अपना प्रोजेक्ट सेट अप करना
• सिर्फ़ टेक्स्ट वाले इनपुट से टेक्स्ट जनरेट करना
• टेक्स्ट और इमेज इनपुट से टेक्स्ट जनरेट करना (मल्टीमॉडल)
• बातचीत करना (चैट)
• ज़्यादा तेज़ इंटरैक्शन के लिए स्ट्रीमिंग का इस्तेमाल करना

इसके अलावा, इस ट्यूटोरियल में बेहतर इस्तेमाल के उदाहरणों (जैसे टोकन गिनना) और साथ ही, कॉन्टेंट जनरेट करने के कंट्रोल को कंट्रोल करना.

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

इस ट्यूटोरियल में यह माना गया है कि आपको स्विफ़्ट को डेवलप करने के लिए Xcode का इस्तेमाल करने के बारे में जानकारी है दिखाई देता है.

इस ट्यूटोरियल को पूरा करने के लिए, पक्का करें कि आपका डेवलपमेंट एनवायरमेंट और Swift ऐप्लिकेशन इन ज़रूरी शर्तों को पूरा करता है:

• Xcode 15.0 या इसके बाद का वर्शन
• यह ज़रूरी है कि Swift ऐप्लिकेशन, iOS 15 या उसके बाद के वर्शन या macOS 12 या उसके बाद के वर्शन को टारगेट करे.

अपना प्रोजेक्ट सेट अप करना

Gemini API को कॉल करने से पहले, आपको अपना Xcode प्रोजेक्ट सेट अप करना होगा. इसमें एपीआई पासकोड सेट अप करना, Xcode प्रोजेक्ट में SDK टूल का पैकेज जोड़ना, और इसकी मदद से मॉडल बनाया जा सकता है.

एपीआई पासकोड सेट अप करना

Gemini API का इस्तेमाल करने के लिए, आपको एपीआई पासकोड की ज़रूरत होगी. अगर आपके पास पहले से कोई AdSense खाता नहीं है, तो Google AI Studio में कोई पासकोड बनाएं.

एपीआई पासकोड पाएं

एपीआई पासकोड को सुरक्षित रखना

हमारा सुझाव है कि आप अपने वर्शन में एपीआई पासकोड की जांच न करें कंट्रोल सिस्टम पर काम करते हैं. एक विकल्प यह है कि इसे GenerativeAI-Info.plist फ़ाइल डाउनलोड करें और फिर .plist से एपीआई पासकोड पढ़ें फ़ाइल से लिए जाते हैं. इस .plist फ़ाइल को अपने ऐप्लिकेशन के रूट फ़ोल्डर में रखना न भूलें और इसे वर्शन कंट्रोल से बाहर रखें.

enum APIKey {
  // Fetch the API key from `GenerativeAI-Info.plist`
  static var `default`: String {
    guard let filePath = Bundle.main.path(forResource: "GenerativeAI-Info", ofType: "plist")
    else {
      fatalError("Couldn't find file 'GenerativeAI-Info.plist'.")
    }
    let plist = NSDictionary(contentsOfFile: filePath)
    guard let value = plist?.object(forKey: "API_KEY") as? String else {
      fatalError("Couldn't find key 'API_KEY' in 'GenerativeAI-Info.plist'.")
    }
    if value.starts(with: "_") {
      fatalError(
        "Follow the instructions at https://ai.google.dev/tutorials/setup to get an API key."
      )
    }
    return value
  }
}

आपको यह जानकारी भी मिलेगी: ऐप्लिकेशन का नमूना .plist फ़ाइल में एपीआई पासकोड सेव करने का तरीका जानें.

इस ट्यूटोरियल में मौजूद सभी स्निपेट को लगता है कि एपीआई पासकोड ऐक्सेस किया जा रहा है इस मांग पर उपलब्ध संसाधन .plist फ़ाइल से.

अपने प्रोजेक्ट में SDK टूल का पैकेज जोड़ें

अपने Swift ऐप्लिकेशन में Gemini API का इस्तेमाल करने के लिए, GoogleGenerativeAI जोड़ें पैकेज जोड़ें:

1. Xcode में, प्रोजेक्ट नेविगेटर में अपने प्रोजेक्ट पर राइट क्लिक करें.

2. संदर्भ मेन्यू से, पैकेज जोड़ें चुनें.

3. पैकेज जोड़ें डायलॉग में, खोज बार में पैकेज यूआरएल चिपकाएं:

   https://github.com/google/generative-ai-swift
   

4. पैकेज जोड़ें पर क्लिक करें. Xcode अब GoogleGenerativeAI पैकेज जोड़ देगा को भी शामिल किया जा सकता है.

जनरेटिव मॉडल शुरू करें

एपीआई कॉल करने से पहले, आपको जनरेटिव मॉडल शुरू करना होगा.

1. GoogleGenerativeAI मॉड्यूल इंपोर्ट करें:

   import GoogleGenerativeAI
   

2. जनरेटिव मॉडल शुरू करें:

   // Access your API key from your on-demand resource .plist file
   // (see "Set up your API key" above)
   // The Gemini 1.5 models are versatile and work with most use cases
   let model = GenerativeModel(name: "gemini-1.5-flash", apiKey: APIKey.default)
   

मॉडल तय करते समय, इन बातों का ध्यान रखें:

• उस मॉडल का इस्तेमाल करें जो आपके इस्तेमाल के उदाहरण के हिसाब से हो. उदाहरण के लिए, gemini-1.5-flash मल्टीमोडल इनपुट के लिए है). इस गाइड में, हर विज्ञापन के लिए निर्देश लागू करने के लिए, इस्तेमाल के हर उदाहरण के लिए सुझाए गए मॉडल की सूची दी जानी चाहिए.

इस्तेमाल के सामान्य उदाहरण लागू करना

आपका प्रोजेक्ट सेट अप हो गया है. अब Gemini API का इस्तेमाल करके, इस्तेमाल के अलग-अलग उदाहरण लागू करें:

• सिर्फ़ टेक्स्ट वाले इनपुट से टेक्स्ट जनरेट करना
• टेक्स्ट और इमेज इनपुट से टेक्स्ट जनरेट करना (मल्टीमॉडल)
• बातचीत करना (चैट)
• ज़्यादा तेज़ इंटरैक्शन के लिए स्ट्रीमिंग का इस्तेमाल करना

सिर्फ़ टेक्स्ट इनपुट से टेक्स्ट जनरेट करें

अगर प्रॉम्प्ट इनपुट में सिर्फ़ टेक्स्ट शामिल है, तो Gemini के 1.5 मॉडल या टेक्स्ट आउटपुट जनरेट करने के लिए, generateContent के साथ Gemini 1.0 Pro मॉडल:

import GoogleGenerativeAI

// The Gemini 1.5 models are versatile and work with both text-only and multimodal prompts
// Access your API key from your on-demand resource .plist file (see "Set up your API key" above)
let model = GenerativeModel(name: "gemini-1.5-flash", apiKey: APIKey.default)

let prompt = "Write a story about a magic backpack."
let response = try await model.generateContent(prompt)
if let text = response.text {
  print(text)
}

टेक्स्ट और इमेज इनपुट से टेक्स्ट जनरेट करें (मल्टीमॉडल)

Gemini कई तरह के मॉडल उपलब्ध कराता है, जो मल्टीमोडल इनपुट को हैंडल कर सकते हैं (Gemini 1.5 मॉडल) ताकि आप दोनों टेक्स्ट इनपुट कर सकें और इमेज. कृपया प्रॉम्प्ट के लिए इमेज से जुड़ी ज़रूरी शर्तें.

अगर प्रॉम्प्ट वाले इनपुट में टेक्स्ट और इमेज, दोनों शामिल हैं, तो Gemini के 1.5 मॉडल का इस्तेमाल करें इसका इस्तेमाल करके, टेक्स्ट आउटपुट जनरेट करने के लिए generateContent तरीके का इस्तेमाल किया जा सकता है:

import GoogleGenerativeAI

// The Gemini 1.5 models are versatile and work with both text-only and multimodal prompts
// Access your API key from your on-demand resource .plist file (see "Set up your API key" above)
let model = GenerativeModel(name: "gemini-1.5-flash", apiKey: APIKey.default)

let image1 = UIImage(...)
let image2 = UIImage(...)

let prompt = "What's different between these pictures?"

let response = try await model.generateContent(prompt, image1, image2)
if let text = response.text {
  print(text)
}

बार-बार होने वाली बातचीत (चैट) की सुविधा तैयार करें

Gemini की मदद से, अलग-अलग मौकों पर फ़्रीफ़ॉर्म तरीके से बातचीत की जा सकती है. कॉन्टेंट बनाने SDK टूल, बातचीत की प्रोसेस को मैनेज करके इस प्रक्रिया को आसान बनाता है. यह प्रोसेस को आसान बनाता है generateContent के साथ, आपको बातचीत के इतिहास को सेव करने की ज़रूरत नहीं होती है खुद को बेहतर बनाएं.

कई चरणों में होने वाली बातचीत (जैसे, चैट) शुरू करने के लिए, Gemini के 1.5 मॉडल या Gemini 1.0 Pro मॉडल का इस्तेमाल करें और startChat() को कॉल करके चैट शुरू करें. इसके बाद, उपयोगकर्ता को नया मैसेज भेजने के लिए sendMessage() का इस्तेमाल करें. इससे, यह भी जुड़ जाएगा मैसेज और चैट के इतिहास पर दिया गया जवाब.

इसमें मौजूद कॉन्टेंट से जुड़े role के लिए दो विकल्प हो सकते हैं: बातचीत:

• user: वह भूमिका जो प्रॉम्प्ट देती है. यह मान इसके लिए डिफ़ॉल्ट है: sendMessage कॉल.

• model: वह भूमिका जो जवाब देती है. इस भूमिका का इस्तेमाल तब किया जा सकता है, जब मौजूदा history से startChat() को कॉल किया जा रहा है.

import GoogleGenerativeAI

let config = GenerationConfig(
  maxOutputTokens: 100
)

// The Gemini 1.5 models are versatile and work with multi-turn conversations (like chat)
// Access your API key from your on-demand resource .plist file (see "Set up your API key" above)
let model = GenerativeModel(
  name: "gemini-1.5-flash",
  apiKey: APIKey.default,
  generationConfig: config
)

let history = [
  ModelContent(role: "user", parts: "Hello, I have 2 dogs in my house."),
  ModelContent(role: "model", parts: "Great to meet you. What would you like to know?"),
]

// Initialize the chat
let chat = model.startChat(history: history)
let response = try await chat.sendMessage("How many paws are in my house?")
if let text = response.text {
  print(text)
}

तेज़ी से इंटरैक्शन करने के लिए स्ट्रीमिंग का इस्तेमाल करें

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

नीचे दिया गया उदाहरण, टेक्स्ट और इमेज इनपुट से टेक्स्ट जनरेट करने का generateContentStream तरीका प्रॉम्प्ट.

import GoogleGenerativeAI

// The Gemini 1.5 models are versatile and work with both text-only and multimodal prompts
// Access your API key from your on-demand resource .plist file (see "Set up your API key" above)
let model = GenerativeModel(name: "gemini-1.5-flash", apiKey: APIKey.default)

let image1 = UIImage(named: "")!
let image2 = UIImage(named: "")!

let prompt = "What's different between these pictures?"
var fullResponse = ""
let contentStream = model.generateContentStream(prompt, image1, image2)
for try await chunk in contentStream {
  if let text = chunk.text {
    print(text)
    fullResponse += text
  }
}
print(fullResponse)

सिर्फ़ टेक्स्ट इनपुट और चैट के इस्तेमाल के लिए, इसी तरीके का इस्तेमाल किया जा सकता है.

// Use streaming with text-only input
let contentStream = model.generateContentStream(prompt)

// Use streaming with multi-turn conversations (like chat)
let responseStream = chat.sendMessageStream(message)

इस्तेमाल के बेहतर उदाहरण लागू करना

इस ट्यूटोरियल सहायता के पिछले सेक्शन में, इस्तेमाल के जिन सामान्य उदाहरणों के बारे में बताया गया है तो आपको Gemini API का इस्तेमाल करने में कोई दिक्कत नहीं है. इस सेक्शन में, कुछ ऐसी जिन्हें ज़्यादा बेहतर माना जा सकता है.

फ़ंक्शन कॉलिंग

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

टोकन गिनें

लंबे प्रॉम्प्ट का इस्तेमाल करते समय, किसी भी मैसेज को भेजने से पहले टोकन की गिनती करना मददगार हो सकता है मॉडल के लिए कॉन्टेंट उपलब्ध कराता है. नीचे दिए गए उदाहरणों में, countTokens() को इस्तेमाल करने का तरीका बताया गया है इस तरह की जानकारी:

// For text-only input
let response = try await model.countTokens("Why is the sky blue?")
print(response.totalTokens)

// For text-and-image input (multi-modal)
let response = try await model.countTokens(prompt, image1, image2)
print(response.totalTokens)

// For multi-turn conversations (like chat)
let chat = model.startChat()
let history = chat.history
let message = try ModelContent(role: "user", "Why is the sky blue?")
let contents = history + [message]
let response = try await model.countTokens(contents)
print(response.totalTokens)

कॉन्टेंट जनरेट करने की प्रोसेस को कंट्रोल करने के विकल्प

मॉडल पैरामीटर कॉन्फ़िगर करके और इनका इस्तेमाल करके, कॉन्टेंट जनरेट होने की प्रोसेस को कंट्रोल किया जा सकता है सुरक्षा सेटिंग.

मॉडल पैरामीटर कॉन्फ़िगर करें

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

let config = GenerationConfig(
  temperature: 0.9,
  topP: 0.1,
  topK: 16,
  maxOutputTokens: 200,
  stopSequences: ["red"]
)

// Access your API key from your on-demand resource .plist file (see "Set up your API key" above)
let model = GenerativeModel(
  // The Gemini 1.5 models are versatile and work with most use cases
  name: "gemini-1.5-flash",
  apiKey: APIKey.default,
  generationConfig: config
)

सुरक्षा सेटिंग का इस्तेमाल करना

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

यहां एक सुरक्षा सेटिंग सेट करने का तरीका बताया गया है:

// Access your API key from your on-demand resource .plist file (see "Set up your API key" above)
let model = GenerativeModel(
  // The Gemini 1.5 models are versatile and work with most use cases
  name: "gemini-1.5-flash",
  apiKey: APIKey.default,
  safetySettings: [
    SafetySetting(harmCategory: .harassment, threshold: .blockOnlyHigh)
  ]
)

आप एक से ज़्यादा सुरक्षा सेटिंग भी सेट कर सकते हैं:

let harassmentSafety = SafetySetting(harmCategory: .harassment, threshold: .blockOnlyHigh)
let hateSpeechSafety = SafetySetting(harmCategory: .hateSpeech, threshold: .blockMediumAndAbove)

// Access your API key from your on-demand resource .plist file (see "Set up your API key" above)
let model = GenerativeModel(
  // The Gemini 1.5 models are versatile and work with most use cases
  name: "gemini-1.5-flash",
  apiKey: APIKey.default,
    safetySettings: [harassmentSafety, hateSpeechSafety]
)

आगे क्या करना है

• प्रॉम्प्ट डिज़ाइन ऐसे प्रॉम्प्ट बनाने की प्रोसेस है जो आपके काम के लैंग्वेज मॉडल से मिले रिस्पॉन्स. अच्छी तरह से स्ट्रक्चर किए गए प्रॉम्प्ट लिखना बहुत ज़रूरी है यह पक्का किया जा सकता है कि किसी भाषा के मॉडल से सही और अच्छी क्वालिटी के जवाब मिले हैं. प्रॉम्प्ट लिखने के सबसे सही तरीके जानें.

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