Vertex AI प्लगिन

Vertex AI प्लग इन, एआई की कई सेवाओं के इंटरफ़ेस उपलब्ध कराता है:

• Google के जनरेटिव एआई मॉडल:
  • Gemini की टेक्स्ट जनरेशन सुविधा
  • Imagen2 और Imagen3 की मदद से इमेज जनरेट करना
  • टेक्स्ट एम्बेड करने की सुविधा
• Vertex AI Rapid Evaluation API की मदद से, आकलन मेट्रिक का सबसेट:
  • BLEU
  • ROUGE
  • फ़्लूएंसी
  • सुरक्षा
  • भरोसेमंद स्रोतों से जानकारी लेना (Groundeness)
  • खास जानकारी देने की क्वालिटी
  • खास जानकारी देने की सुविधा कितनी मददगार है
  • खास जानकारी देने के लिए ज़्यादा शब्दों का इस्तेमाल करना
• वेक्टर सर्च

इंस्टॉल करना

npm i --save @genkit-ai/vertexai

अगर आपको इस प्लग इन का इस्तेमाल करके, फ़्लो को स्थानीय तौर पर चलाना है, तो आपको Google Cloud CLI टूल भी इंस्टॉल करना होगा.

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

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

import { genkit } from 'genkit';
import { vertexAI } from '@genkit-ai/vertexai';

const ai = genkit({
  plugins: [
    vertexAI({ location: 'us-central1' }),
  ],
});

प्लग इन के लिए, आपको अपना Google Cloud प्रोजेक्ट आईडी, वह इलाका बताना होगा जहां आपको Vertex API के अनुरोध करने हैं. साथ ही, आपको अपने Google Cloud प्रोजेक्ट के क्रेडेंशियल भी देने होंगे.

• vertexAI() कॉन्फ़िगरेशन में projectId सेट करके या GCLOUD_PROJECT एनवायरमेंट वैरिएबल सेट करके, Google Cloud प्रोजेक्ट आईडी की जानकारी दी जा सकती है. अगर आपका फ़्लो, Google Cloud के किसी एनवायरमेंट (Cloud Functions, Cloud Run वगैरह) से चल रहा है, तो GCLOUD_PROJECT अपने-आप एनवायरमेंट के प्रोजेक्ट आईडी पर सेट हो जाता है.
• एपीआई की जगह की जानकारी देने के लिए, vertexAI() कॉन्फ़िगरेशन में location सेट करें या GCLOUD_LOCATION एनवायरमेंट वैरिएबल सेट करें.

• एपीआई क्रेडेंशियल देने के लिए, आपको Google Cloud ऐप्लिकेशन के डिफ़ॉल्ट क्रेडेंशियल सेट अप करने होंगे.

  1. अपने क्रेडेंशियल डालने के लिए:

     • अगर आपका फ़्लो, Google Cloud के किसी एनवायरमेंट (Cloud Functions, Cloud Run वगैरह) से चल रहा है, तो यह अपने-आप सेट हो जाता है.

     • अपने स्थानीय डेवलपर एनवायरमेंट में, यह करने के लिए:

       gcloud auth application-default login

     • अन्य एनवायरमेंट के लिए, ऐप्लिकेशन के डिफ़ॉल्ट क्रेडेंशियल दस्तावेज़ देखें.

  2. इसके अलावा, पक्का करें कि खाते को Vertex AI उपयोगकर्ता आईएएम भूमिका (roles/aiplatform.user) दी गई हो. Vertex AI के ऐक्सेस कंट्रोल दस्तावेज़ देखें.

इस्तेमाल

जनरेटिव एआई मॉडल

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

import { gemini15Flash, gemini15Pro, imagen3 } from '@genkit-ai/vertexai';

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

const ai = genkit({
  plugins: [vertexAI({ location: 'us-central1' })],
});

const llmResponse = await ai.generate({
  model: gemini15Flash,
  prompt: 'What should I do when I visit Melbourne?',
});

यह प्लग इन, Google Search या आपके डेटा का इस्तेमाल करके, Gemini के टेक्स्ट जवाबों को बेहतर बनाने में भी मदद करता है.

उदाहरण:

const ai = genkit({
  plugins: [vertexAI({ location: 'us-central1' })],
});

await ai.generate({
  model: gemini15Flash,
  prompt: '...',
  config: {
    googleSearchRetrieval: {
      disableAttribution: true,
    }
    vertexRetrieval: {
      datastore: {
        projectId: 'your-cloud-project',
        location: 'us-central1',
        collection: 'your-collection',
      },
      disableAttribution: true,
    }
  }
})

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

import { textEmbedding004 } from '@genkit-ai/vertexai';

इस रेफ़रंस का इस्तेमाल करके, यह बताया जा सकता है कि इंडेक्सर या रीट्रिवर किस एम्बेडर का इस्तेमाल करता है. उदाहरण के लिए, अगर Chroma DB का इस्तेमाल किया जाता है, तो:

const ai = genkit({
  plugins: [
    chroma([
      {
        embedder: textEmbedding004,
        collectionName: 'my-collection',
      },
    ]),
  ],
});

इसके अलावा, सीधे तौर पर भी एम्बेड करने का कोड जनरेट किया जा सकता है:

const ai = genkit({
  plugins: [vertexAI({ location: 'us-central1' })],
});

const embedding = await ai.embed({
  embedder: textEmbedding004,
  content: 'How many widgets do you have in stock?',
});

Imagen3 मॉडल की मदद से, उपयोगकर्ता के प्रॉम्प्ट से इमेज जनरेट की जा सकती हैं:

import { imagen3 } from '@genkit-ai/vertexai';

const ai = genkit({
  plugins: [vertexAI({ location: 'us-central1' })],
});

const response = await ai.generate({
  model: imagen3,
  output: { format: 'media' },
  prompt: 'a banana riding a bicycle',
});

return response.media();

साथ ही, मौजूदा इमेज में बेहतर तरीके से बदलाव किया जा सकता है:

const ai = genkit({
  plugins: [vertexAI({ location: 'us-central1' })],
});

const baseImg = fs.readFileSync('base.png', { encoding: 'base64' });
const maskImg = fs.readFileSync('mask.png', { encoding: 'base64' });

const response = await ai.generate({
  model: imagen3,
  output: { format: 'media' },
  prompt: [
    { media: { url: `data:image/png;base64,${baseImg}` }},
    {
      media: { url: `data:image/png;base64,${maskImg}` },
      metadata: { type: 'mask' },
    },
    { text: 'replace the background with foo bar baz' },
  ],
  config: {
    editConfig: {
      editMode: 'outpainting',
    },
  },
});

return response.media();

ज़्यादा विकल्पों के बारे में जानने के लिए, Imagen मॉडल का दस्तावेज़ देखें.

Vertex AI Model Garden पर Anthropic Claude 3

अगर आपके पास Vertex AI Model Garden में Claude 3 मॉडल (haiku, sonnet या opus) का ऐक्सेस है, तो उनका इस्तेमाल Genkit के साथ किया जा सकता है.

Vertex AI Model Garden मॉडल चालू करने के लिए, यहां कॉन्फ़िगरेशन का सैंपल दिया गया है:

import { genkit } from 'genkit';
import {
  claude3Haiku,
  claude3Sonnet,
  claude3Opus,
  vertexAIModelGarden,
} from '@genkit-ai/vertexai/modelgarden';

const ai = genkit({
  plugins: [
    vertexAIModelGarden({
      location: 'us-central1',
      models: [claude3Haiku, claude3Sonnet, claude3Opus],
    }),
  ],
});

इसके बाद, उन्हें रेगुलर मॉडल के तौर पर इस्तेमाल करें:

const llmResponse = await ai.generate({
  model: claude3Sonnet,
  prompt: 'What should I do when I visit Melbourne?',
});

Vertex AI Model Garden पर Llama 3.1 405b

सबसे पहले, आपको Vertex AI Model Garden में Llama 3.1 API Service चालू करनी होगी.

Vertex AI प्लग इन में Llama 3.1 405b के लिए, कॉन्फ़िगरेशन का सैंपल यहां दिया गया है:

import { genkit } from 'genkit';
import { llama31, vertexAIModelGarden } from '@genkit-ai/vertexai/modelgarden';

const ai = genkit({
  plugins: [
    vertexAIModelGarden({
      location: 'us-central1',
      models: [llama31],
    }),
  ],
});

इसके बाद, इसे सामान्य मॉडल के तौर पर इस्तेमाल करें:

const llmResponse = await ai.generate({
  model: llama31,
  prompt: 'Write a function that adds two numbers together',
});

Vertex AI Model Garden पर Mistral मॉडल

अगर आपके पास Vertex AI Model Garden में Mistral मॉडल (Mistral Large, Mistral Nemo या Codestral) का ऐक्सेस है, तो उनका इस्तेमाल Genkit के साथ किया जा सकता है.

Vertex AI Model Garden मॉडल चालू करने के लिए, यहां कॉन्फ़िगरेशन का सैंपल दिया गया है:

import { genkit } from 'genkit';
import {
  mistralLarge,
  mistralNemo,
  codestral,
  vertexAIModelGarden,
} from '@genkit-ai/vertexai/modelgarden';

const ai = genkit({
  plugins: [
    vertexAIModelGarden({
      location: 'us-central1',
      models: [mistralLarge, mistralNemo, codestral],
    }),
  ],
});

इसके बाद, उन्हें रेगुलर मॉडल के तौर पर इस्तेमाल करें:

const llmResponse = await ai.generate({
  model: mistralLarge,
  prompt: 'Write a function that adds two numbers together',
  config: {
    version: 'mistral-large-2411', // Optional: specify model version
    temperature: 0.7,              // Optional: control randomness (0-1)
    maxOutputTokens: 1024,         // Optional: limit response length
    topP: 0.9,                     // Optional: nucleus sampling parameter
    stopSequences: ['###'],        // Optional: stop generation at sequences
  }
});

ये मॉडल इनके साथ काम करते हैं: - mistralLarge: फ़ंक्शन कॉल करने की सुविधाओं वाला नया Mistral लार्ज मॉडल - mistralNemo: बेहतर परफ़ॉर्मेंस और तेज़ी के लिए ऑप्टिमाइज़ किया गया - codestral: कोड जनरेशन टास्क के लिए खास तौर पर बनाया गया

हर मॉडल, स्ट्रीमिंग रिस्पॉन्स और फ़ंक्शन कॉलिंग के साथ काम करता है:

const response = await ai.generateStream({
  model: mistralLarge,
  prompt: 'What should I cook tonight?',
  tools: ['recipe-finder'],
  config: {
    version: 'mistral-large-2411',
    temperature: 1,
  },
});

for await (const chunk of response.stream) {
  console.log(chunk.text);
}

मूल्यांकन करने वाले

Vertex AI के रैपिड इवैल्यूएशन टूल से एवैल्यूएटर का इस्तेमाल करने के लिए, अपने vertexAI प्लग इन कॉन्फ़िगरेशन में evaluation ब्लॉक जोड़ें.

import { genkit } from 'genkit';
import {
  vertexAIEvaluation,
  VertexAIEvaluationMetricType,
} from '@genkit-ai/vertexai/evaluation';

const ai = genkit({
  plugins: [
    vertexAIEvaluation({
      location: 'us-central1',
      metrics: [
        VertexAIEvaluationMetricType.SAFETY,
        {
          type: VertexAIEvaluationMetricType.ROUGE,
          metricSpec: {
            rougeType: 'rougeLsum',
          },
        },
      ],
    }),
  ],
});

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

दोनों एवैल्यूएटर को, काम करने वाले डेटासेट के साथ genkit eval:run कमांड का इस्तेमाल करके चलाया जा सकता है. इसका मतलब है कि output और reference फ़ील्ड वाला डेटासेट. Safety एवैल्यूएटर को genkit eval:flow -e vertexai/safety कमांड का इस्तेमाल करके भी चलाया जा सकता है, क्योंकि इसके लिए सिर्फ़ output की ज़रूरत होती है.

इंडेक्स करने वाले और डेटा वापस लाने वाले टूल

Genkit Vertex AI प्लग इन में, इंडेक्सर और रीट्रिवर लागू करने की सुविधा शामिल है. यह सुविधा, Vertex AI की वेक्टर सर्च सेवा के साथ काम करती है.

(RAG लागू करने में इंडेक्सर और रीट्रिवर का इस्तेमाल कैसे किया जाता है, यह जानने के लिए Retrieval-augmented generation पेज देखें.)

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

Vertex AI प्लग इन की मदद से, दस्तावेज़ों को इंडेक्स करने और उन्हें वापस पाने की सुविधा, दस्तावेज़ों को स्टोर करने के लिए Cloud Firestore या BigQuery का इस्तेमाल करती है. इस प्लग इन में ऐसे इंटरफ़ेस भी शामिल हैं जिन्हें अन्य दस्तावेज़ स्टोर के साथ काम करने के लिए लागू किया जा सकता है.

Vertex AI वेक्टर सर्च का इस्तेमाल करने के लिए:

1. एम्बेड करने का कोई मॉडल चुनें. यह मॉडल, टेक्स्ट से वेक्टर एम्बेड बनाने के लिए ज़िम्मेदार है. बेहतर उपयोगकर्ता, अपने खास डेटा सेट के लिए ऑप्टिमाइज़ किए गए एम्बेडिंग मॉडल का इस्तेमाल कर सकते हैं. हालांकि, ज़्यादातर उपयोगकर्ताओं के लिए, अंग्रेज़ी टेक्स्ट के लिए Vertex AI का text-embedding-004 मॉडल और कई भाषाओं के टेक्स्ट के लिए text-multilingual-embedding-002 मॉडल एक अच्छा विकल्प है.

2. Google Cloud Console के वेक्टर सर्च सेक्शन में, एक नया इंडेक्स बनाएं. सबसे ज़रूरी सेटिंग ये हैं:

   • डाइमेंशन: चुने गए एम्बेडिंग मॉडल से जनरेट किए गए वेक्टर के डाइमेंशन की जानकारी दें. text-embedding-004 और text-multilingual-embedding-002 मॉडल, 768 डाइमेंशन के वेक्टर बनाते हैं.
   • अपडेट करने का तरीका: स्ट्रीमिंग से जुड़े अपडेट चुनें.

   इंडेक्स बनाने के बाद, उसे स्टैंडर्ड (सार्वजनिक) एंडपॉइंट पर डिप्लॉय करें.

3. आपको जिस दस्तावेज़ स्टोर का इस्तेमाल करना है उसके लिए दस्तावेज़ का इंडेक्स करने और उसे वापस पाने वाला टूल पाएं:

   Cloud Firestore

   import { getFirestoreDocumentIndexer, getFirestoreDocumentRetriever } from '@genkit-ai/vertexai/vectorsearch';
   
   import { initializeApp } from 'firebase-admin/app';
   import { getFirestore } from 'firebase-admin/firestore';
   
   initializeApp({ projectId: PROJECT_ID });
   const db = getFirestore();
   
   const firestoreDocumentRetriever = getFirestoreDocumentRetriever(db, FIRESTORE_COLLECTION);
   const firestoreDocumentIndexer = getFirestoreDocumentIndexer(db, FIRESTORE_COLLECTION);
   

   BigQuery

   import { getBigQueryDocumentIndexer, getBigQueryDocumentRetriever } from '@genkit-ai/vertexai/vectorsearch';
   import { BigQuery } from '@google-cloud/bigquery';
   
   const bq = new BigQuery({ projectId: PROJECT_ID });
   
   const bigQueryDocumentRetriever = getBigQueryDocumentRetriever(bq, BIGQUERY_TABLE, BIGQUERY_DATASET);
   const bigQueryDocumentIndexer = getBigQueryDocumentIndexer(bq, BIGQUERY_TABLE, BIGQUERY_DATASET);
   

   अन्य

   दस्तावेज़ों के अन्य स्टोर के साथ काम करने के लिए, DocumentRetriever और DocumentIndexer को लागू करने के तरीके खुद तय किए जा सकते हैं:

   const myDocumentRetriever = async (neighbors) => {
     // Return the documents referenced by `neighbors`.
     // ...
   }
   const myDocumentIndexer = async (documents) => {
     // Add `documents` to storage.
     // ...
   }
   

   उदाहरण के लिए, स्थानीय फ़ाइल के साथ Vertex AI प्लग इन रीट्रिवर और इंडेक्सर का सैंपल देखें.

4. अपने vertexAI प्लग इन कॉन्फ़िगरेशन में vectorSearchOptions ब्लॉक जोड़ें:

   import { genkit } from 'genkit';
   import { textEmbedding004 } from '@genkit-ai/vertexai';
   import { vertexAIVectorSearch } from '@genkit-ai/vertexai/vectorsearch';
   
   const ai = genkit({
     plugins: [
       vertexAIVectorSearch({
         projectId: PROJECT_ID,
         location: LOCATION,
         vectorSearchOptions: [
           {
             indexId: VECTOR_SEARCH_INDEX_ID,
             indexEndpointId: VECTOR_SEARCH_INDEX_ENDPOINT_ID,
             deployedIndexId: VECTOR_SEARCH_DEPLOYED_INDEX_ID,
             publicDomainName: VECTOR_SEARCH_PUBLIC_DOMAIN_NAME,
             documentRetriever: firestoreDocumentRetriever,
             documentIndexer: firestoreDocumentIndexer,
             embedder: textEmbedding004,
           },
         ],
       }),
     ],
   });
   

   पहले चरण में चुना गया एम्बेडर और पिछले चरण में बनाया गया दस्तावेज़ इंडेक्सर और रीट्रिवर दें.

   पहले से बनाए गए वेक्टर सर्च इंडेक्स का इस्तेमाल करने के लिए, प्लग इन को कॉन्फ़िगर करने के लिए आपको कई वैल्यू देनी होंगी. ये वैल्यू, Google Cloud Console के वेक्टर सर्च सेक्शन में मिल सकती हैं:

   • indexId: इंडेक्स टैब में दिखता है
   • indexEndpointId: इंडेक्स एंडपॉइंट टैब में मौजूद है
   • deployedIndexId और publicDomainName: ये "डिप्लॉय किए गए इंडेक्स की जानकारी" पेज पर मौजूद हैं. इसे खोलने के लिए, पहले बताए गए किसी भी टैब पर, डिप्लॉय किए गए इंडेक्स के नाम पर क्लिक करें

5. अब जब सब कुछ कॉन्फ़िगर हो गया है, तो अपने Genkit ऐप्लिकेशन में इंडेक्सर और रीट्रिवर का इस्तेमाल किया जा सकता है:

   import {
     vertexAiIndexerRef,
     vertexAiRetrieverRef,
   } from '@genkit-ai/vertexai/vectorsearch';
   
   // ... inside your flow function:
   
   await ai.index({
     indexer: vertexAiIndexerRef({
       indexId: VECTOR_SEARCH_INDEX_ID,
     }),
     documents,
   });
   
   const res = await ai.retrieve({
     retriever: vertexAiRetrieverRef({
       indexId: VECTOR_SEARCH_INDEX_ID,
     }),
     query: queryDocument,
   });
   

इनके लिए कोड सैंपल देखें:

• Vertex Vector Search + BigQuery
• Vertex Vector Search + Firestore
• Vertex Vector Search + कस्टम डीबी

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

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

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

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

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

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,
  prompt: 'Describe Pierre’s transformation throughout the novel.',
});

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

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

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

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,
  prompt: 'Analyze the relationship between Pierre and Natasha.',
});

कॉन्टेक्स्ट कैश मेमोरी के फ़ायदे

1. बेहतर परफ़ॉर्मेंस: इससे बड़े इनपुट को बार-बार प्रोसेस करने की ज़रूरत कम हो जाती है.
2. लागत में कमी: यह ग़ैर-ज़रूरी डेटा के लिए एपीआई के इस्तेमाल को कम करता है. इससे टोकन के इस्तेमाल को ऑप्टिमाइज़ किया जाता है.
3. इंतज़ार का कम समय: इससे बार-बार पूछी जाने वाली या मिलती-जुलती क्वेरी के लिए, जवाब मिलने में लगने वाला समय कम हो जाता है.

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

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

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

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