Swift ऐप्लिकेशन में Gemini API का इस्तेमाल शुरू करना

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

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

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

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

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

इस ट्यूटोरियल में यह माना गया है कि आपको Swift ऐप्लिकेशन बनाने के लिए Xcode का इस्तेमाल करना है.

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

• Xcode 15.0 या उसके बाद का वर्शन
• आपके Swift ऐप्लिकेशन को iOS 15 या उसके बाद के वर्शन या macOS 12 या उसके बाद के वर्शन को टारगेट करना होगा.

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

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

अपनी एपीआई कुंजी सेट अप करें

Gemini API का इस्तेमाल करने के लिए, आपको एपीआई पासकोड की ज़रूरत होगी. अगर आपके पास पहले से कोई कुंजी नहीं है, तो 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)
   let model = GenerativeModel(name: "MODEL_NAME", apiKey: APIKey.default)
   

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

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

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

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

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

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

जब प्रॉम्प्ट इनपुट में सिर्फ़ टेक्स्ट शामिल हो, तो टेक्स्ट आउटपुट जनरेट करने के लिए, generateContent तरीके के साथ gemini-pro मॉडल का इस्तेमाल करें:

import GoogleGenerativeAI

// For text-only input, use the gemini-pro model
// Access your API key from your on-demand resource .plist file (see "Set up your API key" above)
let model = GenerativeModel(name: "gemini-pro", 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-pro-vision) उपलब्ध कराता है, ताकि आप टेक्स्ट और इमेज दोनों इनपुट कर सकें. प्रॉम्प्ट के लिए इमेज से जुड़ी ज़रूरी शर्तों को ज़रूर देखें.

जब प्रॉम्प्ट इनपुट में टेक्स्ट और इमेज, दोनों शामिल हों, तो टेक्स्ट आउटपुट जनरेट करने के लिए, generateContent तरीके के साथ gemini-pro-vision मॉडल का इस्तेमाल करें:

import GoogleGenerativeAI

// For text-and-image input (multimodal), use the gemini-pro-vision model
// Access your API key from your on-demand resource .plist file (see "Set up your API key" above)
let model = GenerativeModel(name: "gemini-pro-vision", 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-pro मॉडल का इस्तेमाल करें और startChat() पर कॉल करके चैट शुरू करें. इसके बाद, नए व्यक्ति को मैसेज भेजने के लिए sendMessage() का इस्तेमाल करें. इससे नए मैसेज और चैट के इतिहास में जवाब भी जुड़ जाएगा.

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

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

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

import GoogleGenerativeAI

let config = GenerationConfig(
  maxOutputTokens: 100
)

// For text-only input, use the gemini-pro model
// Access your API key from your on-demand resource .plist file (see "Set up your API key" above)
let model = GenerativeModel(
  name: "gemini-pro",
  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

// For text-and-image input (multimodal), use the gemini-pro-vision model
// Access your API key from your on-demand resource .plist file (see "Set up your API key" above)
let model = GenerativeModel(name: "gemini-pro-vision", 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 = ModelContent(role: "user", "Why is the sky blue?")
let contents = history + [message]
let response = try await model.countTokens(contents)
print(response.totalTokens)

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

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

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

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

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(
  name: "MODEL_NAME",
  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(
  name: "MODEL_NAME",
  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(
  name: "MODEL_NAME",
  apiKey: APIKey.default,
    safetySettings: [harassmentSafety, hateSpeechSafety]
)

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

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

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

• Gemini, अनुरोध की दर की सीमा बढ़ाने का अनुरोध करने के विकल्प देता है. Gemini Pro मॉडल के लिए, हर मिनट 60 अनुरोध प्रति मिनट (आरपीएम) की दर तय की जा सकती है.