ट्यूटोरियल: 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()

// The Gemini 1.5 models are versatile and work with most use cases
model := client.GenerativeModel("gemini-1.5-flash")

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

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

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

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

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

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

अगर प्रॉम्प्ट इनपुट में सिर्फ़ टेक्स्ट शामिल है, तो टेक्स्ट आउटपुट जनरेट करने के लिए, Gemini के 1.5 मॉडल या generateContent के साथ Gemini 1.0 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()

// The Gemini 1.5 models are versatile and work with both text-only and multimodal prompts
model := client.GenerativeModel("gemini-1.5-flash")
resp, err := model.GenerateContent(ctx, genai.Text("Write a story about a magic backpack."))
if err != nil {
  log.Fatal(err)
}

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

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

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

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()

// The Gemini 1.5 models are versatile and work with both text-only and multimodal prompts
model := client.GenerativeModel("gemini-1.5-flash")

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 के 1.5 मॉडल या Gemini 1.0 Pro मॉडल का इस्तेमाल करें. इसके बाद, startChat() पर कॉल करके चैट शुरू करें. इसके बाद, उपयोगकर्ता को नया मैसेज भेजने के लिए sendMessage() का इस्तेमाल करें. इसमें मैसेज के साथ-साथ चैट के इतिहास में जवाब भी शामिल हो जाएगा.

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

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

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

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()

// The Gemini 1.5 models are versatile and work with multi-turn conversations (like chat)
model := client.GenerativeModel("gemini-1.5-flash")
// 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()

// The Gemini 1.5 models are versatile and work with both text-only and multimodal prompts
model := client.GenerativeModel("gemini-1.5-flash")

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 की मदद से, टेक्स्ट (शब्द, वाक्य, और टेक्स्ट के ब्लॉक) को वेक्टर के हिसाब से दिखाया जा सकता है. इससे, एम्बेड किए गए कॉन्टेंट की तुलना करना और कंट्रास्ट करना आसान हो जाता है. उदाहरण के लिए, एक जैसे विषय या भावनाओं वाले दो टेक्स्ट में एक जैसी एम्बेडिंग होनी चाहिए. इसकी पहचान, कोसाइन (cos) जैसी गणित की तुलना की तकनीकों से की जा सकती है.

एम्बेड करने की सुविधा जनरेट करने के लिए, 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()
// For embeddings, use the embedding-001 model
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)

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

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

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

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

// ...

// The Gemini 1.5 models are versatile and work with most use cases
model := client.GenerativeModel("gemini-1.5-flash")

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

// ...

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

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

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

// ...

// The Gemini 1.5 models are versatile and work with most use cases
model := client.GenerativeModel("gemini-1.5-flash")

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

// ...

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

// ...

// The Gemini 1.5 models are versatile and work with most use cases
model := client.GenerativeModel("gemini-1.5-flash")

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

// ...

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

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

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