Google का जनरेटिव एआई प्लगिन

Google का जनरेटिव एआई प्लग इन, Gemini API की मदद से, Google के Gemini मॉडल के इंटरफ़ेस उपलब्ध कराता है.

इंस्टॉल करना

npm i --save @genkit-ai/googleai

कॉन्फ़िगरेशन

इस प्लग इन का इस्तेमाल करने के लिए, Genkit को शुरू करते समय इसकी जानकारी दें:

import { genkit } from 'genkit';
import { googleAI } from '@genkit-ai/googleai';

const ai = genkit({
  plugins: [googleAI()],
});

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

अपनी एपीआई कुंजी का इस्तेमाल करने के लिए, प्लग इन को कॉन्फ़िगर करें. इसके लिए, इनमें से कोई एक तरीका अपनाएं:

  • GOOGLE_GENAI_API_KEY एनवायरमेंट वैरिएबल को अपनी एपीआई पासकोड पर सेट करें.
  • प्लग इन को शुरू करते समय, एपीआई पासकोड डालें:

    googleAI({ apiKey: yourKey });
    

    हालांकि, अपनी एपीआई पासकोड को सीधे कोड में एम्बेड न करें! इस सुविधा का इस्तेमाल सिर्फ़ Cloud Secret Manager या ऐसी ही किसी सेवा के साथ करें.

इस्तेमाल

यह प्लग इन, काम करने वाले मॉडल के रेफ़रंस को स्टैटिक तौर पर एक्सपोर्ट करता है:

import {
  gemini15Flash,
  gemini15Pro,
  textEmbedding004,
} from '@genkit-ai/googleai';

इन रेफ़रंस का इस्तेमाल करके, यह बताया जा सकता है कि generate() किस मॉडल का इस्तेमाल करता है:

const ai = genkit({
  plugins: [googleAI()],
  model: gemini15Flash,
});

const llmResponse = await ai.generate('Tell me a joke.');

या एम्बेडर का इस्तेमाल करें (उदाहरण के लिए, textEmbedding004) के साथ embed या retrievers:

const ai = genkit({
  plugins: [googleAI()],
});

const embedding = await ai.embed({
  embedder: textEmbedding004,
  content: input,
});

Gemini Files API

Genkit की मदद से, Gemini Files API में अपलोड की गई फ़ाइलों का इस्तेमाल किया जा सकता है:

import { GoogleAIFileManager } from '@google/generative-ai/server';
import { genkit } from 'genkit';
import { googleAI } from '@genkit-ai/googleai';

const ai = genkit({
  plugins: [googleAI()],
});

const fileManager = new GoogleAIFileManager(process.env.GOOGLE_GENAI_API_KEY);
const uploadResult = await fileManager.uploadFile(
  'path/to/file.jpg',
  {
    mimeType: 'image/jpeg',
    displayName: 'Your Image',
  }
);

const response = await ai.generate({
  model: gemini15Flash,
  prompt: [
    {text: 'Describe this image:'},
    {media: {contentType: uploadResult.file.mimeType, url: uploadResult.file.uri}}
  ]
});

बेहतर किए गए मॉडल

Google Gemini API की मदद से बेहतर बनाए गए मॉडल का इस्तेमाल किया जा सकता है. Gemini API के निर्देशों का पालन करें या AI Studio का इस्तेमाल करके, मॉडल को बेहतर बनाएं.

ट्यूनिंग की प्रोसेस में, किसी बेस मॉडल का इस्तेमाल किया जाता है. उदाहरण के लिए, Gemini 1.5 Flash. साथ ही, ट्यून किया गया नया मॉडल बनाने के लिए, आपके दिए गए उदाहरणों का इस्तेमाल किया जाता है. जिस बुनियादी मॉडल का इस्तेमाल किया गया था उसे याद रखें और नए मॉडल का आईडी कॉपी करें.

Genkit में ट्यून किए गए मॉडल को कॉल करते समय, model पैरामीटर के तौर पर बेस मॉडल का इस्तेमाल करें. साथ ही, ट्यून किए गए मॉडल का आईडी, config ब्लॉक के हिस्से के तौर पर पास करें. उदाहरण के लिए, अगर आपने बेस मॉडल के तौर पर Gemini 1.5 Flash का इस्तेमाल किया है और आपको मॉडल आईडी tunedModels/my-example-model-apbm8oqbvuv2 मिला है, तो इसे इनके साथ कॉल किया जा सकता है:

const ai = genkit({
  plugins: [googleAI()],
});

const llmResponse = await ai.generate({
  prompt: `Suggest an item for the menu of fish themed restruant`,
  model: gemini15Flash.withConfig({
    version: "tunedModels/my-example-model-apbm8oqbvuv2",
  }),
});

कॉन्टेक्स्ट कैश मेमोरी

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

कॉन्टेक्स्ट कैश मेमोरी का इस्तेमाल करने का तरीका

कॉन्टेक्स्ट कैश मेमोरी चालू करने के लिए, पक्का करें कि आपका मॉडल इस सुविधा के साथ काम करता हो. उदाहरण के लिए, gemini15Flash और gemini15Pro ऐसे मॉडल हैं जो कॉन्टेक्स्ट कैश मेमोरी का इस्तेमाल करते हैं.

अपने ऐप्लिकेशन में कैश मेमोरी का इस्तेमाल करने का तरीका इस तरह से तय किया जा सकता है:

const ai = genkit({
  plugins: [googleAI()],
});

const llmResponse = await ai.generate({
  messages: [
    {
      role: 'user',
      content: [{ text: 'Here is the relevant text from War and Peace.' }],
    },
    {
      role: 'model',
      content: [
        {
          text: 'Based on War and Peace, here is some analysis of Pierre Bezukhov’s character.',
        },
      ],
      metadata: {
        cache: {
          ttlSeconds: 300, // Cache this message for 5 minutes
        },
      },
    },
  ],
  model: gemini15Flash,
  config: {
    version: 'gemini-1.5-flash-001', // Only 001 currently supports context caching
  },
  prompt: 'Describe Pierre’s transformation throughout the novel.',
});

इस सेटअप में: - messages: इसकी मदद से, बातचीत का इतिहास पास किया जा सकता है. - metadata.cache.ttlSeconds: किसी खास रिस्पॉन्स को कैश मेमोरी में सेव रखने के लिए, टाइम-टू-लाइव (टीटीएल) की जानकारी देता है.

उदाहरण: कॉन्टेक्स्ट के साथ बड़े टेक्स्ट का इस्तेमाल करना

War and Peace या Lord of the Rings जैसे लंबे दस्तावेज़ों का रेफ़रंस देने वाले ऐप्लिकेशन के लिए, कैश मेमोरी में सेव किए गए कॉन्टेक्स्ट का फिर से इस्तेमाल करने के लिए, अपनी क्वेरी को स्ट्रक्चर किया जा सकता है:

const fs = require('fs/promises');

const textContent = await fs.readFile('path/to/war_and_peace.txt', 'utf-8');

const llmResponse = await ai.generate({
  messages: [
    {
      role: 'user',
      content: [{ text: textContent }], // Include the large text as context
    },
    {
      role: 'model',
      content: [
        {
          text: 'This analysis is based on the provided text from War and Peace.',
        },
      ],
      metadata: {
        cache: {
          ttlSeconds: 300, // Cache the response to avoid reloading the full text
        },
      },
    },
  ],
  model: gemini15Flash,
  config: {
    version: 'gemini-1.5-flash-001', // Only 001 currently supports context caching
  },
  prompt: 'Analyze the relationship between Pierre and Natasha.',
});

कॉन्टेंट के अन्य मोड को कैश मेमोरी में सेव करना

Gemini मॉडल कई मोड में काम करते हैं. साथ ही, कॉन्टेंट के अन्य मोड को भी कैश मेमोरी में सेव किया जा सकता है.

उदाहरण के लिए, लंबी अवधि के वीडियो कॉन्टेंट को कैश मेमोरी में सेव करने के लिए, आपको पहले Google AI SDK टूल के फ़ाइल मैनेजर का इस्तेमाल करके उसे अपलोड करना होगा:

import { GoogleAIFileManager } from '@google/generative-ai/server';

const fileManager = new GoogleAIFileManager(
  process.env.GOOGLE_GENAI_API_KEY
);

// Upload video to Google AI using the Gemini Files API
const uploadResult = await fileManager.uploadFile(videoFilePath, {
  mimeType: 'video/mp4', // Adjust according to the video format
  displayName: 'Uploaded Video for Analysis',
});

const fileUri = uploadResult.file.uri;

अब कॉल में कैश मेमोरी को ai.generate पर कॉन्फ़िगर किया जा सकता है:

const analyzeVideoResponse = await ai.generate({
  messages: [
    {
      role: 'user',
      content: [
        {
          media: {
            url: fileUri, // Use the uploaded file URL
            contentType: 'video/mp4',
          },
        },
      ],
    },
    {
      role: 'model',
      content: [
        {
          text: 'This video seems to contain several key moments. I will analyze it now and prepare to answer your questions.',
        },
      ],
      // Everything up to (including) this message will be cached.
      metadata: {
        cache: true,
      },
    },
  ],
  config: {
    version: 'gemini-1.5-flash-001', // Only 001 versions support context caches
  },
  model: gemini15Flash,
  prompt: query,
});

कॉन्टेक्स्ट कैश मेमोरी में सेव करने की सुविधा के साथ काम करने वाले मॉडल

कॉन्टेक्स्ट कैश मेमोरी की सुविधा, सिर्फ़ कुछ मॉडल पर काम करती है. जैसे, gemini15Flash और gemini15Pro. अगर किसी ऐसे मॉडल का इस्तेमाल किया जाता है जो काम नहीं करता, तो गड़बड़ी का एक मैसेज दिखेगा. इसमें बताया जाएगा कि कैश मेमोरी में सेव करने की सुविधा लागू नहीं की जा सकती.

इसके बारे में और पढ़ें

Google के एआई पर कॉन्टेक्स्ट कैश मेमोरी से जुड़ी ज़्यादा जानकारी के लिए, उसका दस्तावेज़ देखें.