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

इस ट्यूटोरियल में बताया गया है कि Google AI Go SDK का इस्तेमाल करके, Go ऐप्लिकेशन के लिए Gemini API को कैसे ऐक्सेस किया जा सकता है.

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

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

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

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

यह ट्यूटोरियल यह मानता है कि आपको Go के साथ ऐप्लिकेशन बनाने की जानकारी है.

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

• 1.20 या इसके बाद के वर्शन पर जाएं

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

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

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

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

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

अपनी एपीआई कुंजी सुरक्षित करें

हमारा सुझाव है कि आप अपने वर्शन कंट्रोल सिस्टम में एपीआई पासकोड की जांच न करें. इसके बजाय, आपको अपनी एपीआई पासकोड के लिए सीक्रेट स्टोर का इस्तेमाल करना चाहिए.

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

SDK टूल पैकेज इंस्टॉल करें

अपने ऐप्लिकेशन में Gemini API का इस्तेमाल करने के लिए, आपको अपनी मॉड्यूल डायरेक्ट्री में Go SDK पैकेज get करना होगा:

go get github.com/google/generative-ai-go

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

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

import "github.com/google/generative-ai-go/genai"
import "google.golang.org/api/option"

ctx := context.Background()
// Access your API key as an environment variable (see "Set up your API key" above)
client, err := genai.NewClient(ctx, option.WithAPIKey(os.Getenv("API_KEY")))
if err != nil {
  log.Fatal(err)
}
defer client.Close()

model := client.GenerativeModel("MODEL_NAME")

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

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

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

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

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

बेहतर इस्तेमाल के उदाहरण वाले सेक्शन में, आपको Gemini API और एम्बेड करने के बारे में जानकारी मिलेगी.

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

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

ctx := context.Background()
// Access your API key as an environment variable (see "Set up your API key" above)
client, err := genai.NewClient(ctx, option.WithAPIKey(os.Getenv("API_KEY")))
if err != nil {
  log.Fatal(err)
}
defer client.Close()

// For text-only input, use the gemini-pro model
model := client.GenerativeModel("gemini-pro")
resp, err := model.GenerateContent(ctx, genai.Text("Write a story about a magic backpack."))
if err != nil {
  log.Fatal(err)
}

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

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

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

ctx := context.Background()
// Access your API key as an environment variable (see "Set up your API key" above)
client, err := genai.NewClient(ctx, option.WithAPIKey(os.Getenv("API_KEY")))
if err != nil {
  log.Fatal(err)
}
defer client.Close()

// For text-and-image input (multimodal), use the gemini-pro-vision model
model := client.GenerativeModel("gemini-pro-vision")

imgData1, err := os.ReadFile(pathToImage1)
if err != nil {
  log.Fatal(err)
}

imgData2, err := os.ReadFile(pathToImage1)
if err != nil {
  log.Fatal(err)
}

prompt := []genai.Part{
  genai.ImageData("jpeg", imgData1),
  genai.ImageData("jpeg", imgData2),
  genai.Text("What's different between these two pictures?"),
}
resp, err := model.GenerateContent(ctx, prompt...)

if err != nil {
  log.Fatal(err)
}

एक से ज़्यादा टर्न वाली बातचीत (चैट) तैयार करना

Gemini का इस्तेमाल करके, अलग-अलग बारी-बारी से बातचीत करें. SDK टूल, बातचीत की स्थिति को मैनेज करके प्रोसेस को आसान बनाता है. GenerateContent के उलट, आपको बातचीत का इतिहास सेव करने की ज़रूरत नहीं होती.

बातचीत (जैसे कि चैट) के हिसाब से बातचीत करने के लिए, gemini-pro मॉडल का इस्तेमाल करें और StartChat() पर कॉल करके चैट शुरू करें. इसके बाद, नए व्यक्ति को मैसेज भेजने के लिए SendMessage() का इस्तेमाल करें. इससे नए मैसेज और चैट के इतिहास में जवाब भी जुड़ जाएगा.

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

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

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

ctx := context.Background()
// Access your API key as an environment variable (see "Set up your API key" above)
client, err := genai.NewClient(ctx, option.WithAPIKey(os.Getenv("API_KEY")))
if err != nil {
  log.Fatal(err)
}
defer client.Close()

// For text-only input, use the gemini-pro model
model := client.GenerativeModel("gemini-pro")
// Initialize the chat
cs := model.StartChat()
cs.History = []*genai.Content{
  &genai.Content{
    Parts: []genai.Part{
      genai.Text("Hello, I have 2 dogs in my house."),
    },
    Role: "user",
  },
  &genai.Content{
    Parts: []genai.Part{
      genai.Text("Great to meet you. What would you like to know?"),
    },
    Role: "model",
  },
}

resp, err := cs.SendMessage(ctx, genai.Text("How many paws are in my house?"))
if err != nil {
  log.Fatal(err)
}

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

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

इस उदाहरण में, टेक्स्ट और इमेज इनपुट प्रॉम्प्ट से टेक्स्ट जनरेट करने के लिए, GenerateContentStream तरीके की मदद से स्ट्रीमिंग लागू करने का तरीका बताया गया है.

ctx := context.Background()
// Access your API key as an environment variable (see "Set up your API key" above)
client, err := genai.NewClient(ctx, option.WithAPIKey(os.Getenv("API_KEY")))
if err != nil {
  log.Fatal(err)
}
defer client.Close()

// For text-and-image input (multimodal), use the gemini-pro-vision model
model := client.GenerativeModel("gemini-pro-vision")

imageBytes, err := os.ReadFile(pathToImage)

img := genai.ImageData("jpeg", imageBytes)
prompt := genai.Text("Tell me a story about this animal")
iter := model.GenerateContentStream(ctx, img, prompt)

for {
  resp, err := iter.Next()
  if err == iterator.Done {
    break
  }
  if err != nil {
    log.Fatal(err)
  }

  // ... print resp
}

इसी तरह, सिर्फ़ टेक्स्ट इनपुट और चैट के इस्तेमाल के उदाहरणों के लिए भी यही तरीका अपनाया जा सकता है.

prompt := genai.Text("Tell me a story about a lumberjack and his giant ox")
iter := model.GenerateContentStream(ctx, prompt)

prompt := genai.Text("And how do you feel about that?")
iter := cs.SendMessageStream(ctx, prompt)

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

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

एम्बेड करने की सुविधा का इस्तेमाल करना

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

एम्बेड करने की प्रोसेस जनरेट करने के लिए, EmbedContent तरीके या BatchEmbedContent तरीके के साथ embedding-001 मॉडल का इस्तेमाल करें. यहां दिया गया उदाहरण, सिंगल स्ट्रिंग के लिए एम्बेडिंग जनरेट करता है:

ctx := context.Background()
// Access your API key as an environment variable (see "Set up your API key" above)
client, err := genai.NewClient(ctx, option.WithAPIKey(os.Getenv("API_KEY")))
if err != nil {
  log.Fatal(err)
}
defer client.Close()
em := client.EmbeddingModel("embedding-001")
res, err := em.EmbedContent(ctx, genai.Text("The quick brown fox jumps over the lazy dog."))

if err != nil {
  panic(err)
}
fmt.Println(res.Embedding.Values)

फ़ंक्शन कॉल करने की सुविधा

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

टोकन गिनें

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

// For text-only input
text := "Parrots can be green and live a long time."
resp, err := model.CountTokens(ctx, genai.Text(text))
if err != nil {
  log.Fatal(err)
}
fmt.Println(resp.TotalTokens)

// For text-and-image input (multimodal)
text := "Parrots can be green and live a long time."
imageBytes, err := os.ReadFile(pathToImage)
if err != nil {
  log.Fatal(err)
}

resp, err := model.CountTokens(
    ctx,
    genai.Text(text),
    genai.ImageData("png", imageBytes))
  if err != nil {
    log.Fatal(err)
}
fmt.Println(resp.TotalTokens)

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

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

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

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

// ...

model := client.GenerativeModel("MODEL_NAME")

// Configure model parameters by invoking Set* methods on the model.
model.SetTemperature(0.9)
model.SetTopK(1)

// ...

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

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

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

// ...

model := client.GenerativeModel("MODEL_NAME")

model.SafetySettings = []*genai.SafetySetting{
  {
    Category:  genai.HarmCategoryHarassment,
    Threshold: genai.HarmBlockOnlyHigh,
  },
}

// ...

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

// ...

model := client.GenerativeModel("MODEL_NAME")

model.SafetySettings = []*genai.SafetySetting{
  {
    Category:  genai.HarmCategoryHarassment,
    Threshold: genai.HarmBlockOnlyHigh,
  },
  {
    Category:  genai.HarmCategoryHateSpeech,
    Threshold: genai.HarmBlockMediumAndAbove,
  },
}

// ...

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

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

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

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