कॉन्टेंट जनरेट किया जा रहा है

Firebase Genkit, एलएलएम की मदद से कॉन्टेंट जनरेट करने के लिए एक आसान इंटरफ़ेस उपलब्ध कराता है.

मॉडल

Firebase Genkit में मॉडल, लाइब्रेरी और ऐब्स्ट्रैक्ट होते हैं. इनकी मदद से, Google और Google से बाहर के एलएलएम.

मॉडल, जांच के लिए पूरी तरह से इंस्ट्रुमेंट किए जाते हैं और टूलिंग के साथ आते हैं Genkit Developer के यूज़र ��ं��रफ़ेस (यूआई) से मिले इंटिग्रेशन -- आपके पास इनका इस्तेमाल करके किसी भी मॉडल को आज़माने का विकल्प है को भी चुन सकते हैं.

Genkit में मॉडल का इस्तेमाल करते समय, आपको सबसे पहले वह मॉडल कॉन्फ़िगर करना होगा काम करना चाहते हैं. मॉडल कॉन्फ़िगरेशन, प्लगिन सिस्टम की मदद से किया जाता है. तय सीमा में इस उदाहरण में, Vertex AI प्लगिन को कॉन्फ़िगर किया जा रहा है, जो Gemini को मॉडल.

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

configureGenkit({
  plugins: [vertexAI()],
});

प्लग इन से मिले मॉडल का इस्तेमाल करने के लिए, आप या तो उन्हें नाम दे सकते हैं (उदाहरण के लिए, 'vertexai/gemini-1.5-flash') या कुछ प्लगिन, मॉडल के रेफ़रंस ऑब्जेक्ट एक्सपोर्ट करते हैं मॉडल की क्षमताओं और विकल्पों के बारे में ज़्यादा जानकारी दें.

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

इस्तेमाल किए जा सकने वाले मॉडल

Genkit अपने प्लगिन सिस्टम की मदद से, मॉडल से जुड़ी सहायता उपलब्ध कराता है. नीचे दिए गए प्लग इन आधिकारिक रूप से समर्थित हैं:

प्लग इन	मॉडल
Google का जनरेटिव एआई	Gemini Pro और Gemini Pro Vision
Google Vertex AI	Gemini Pro, Gemini Pro Vision, Gemini 1.5 Flash, Gemini 1.5 Pro, Imagen2
ओलामा	कई लोकल मॉडल, जैसे कि Gemma, Llama 2, Mistral वगैरह

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

कॉन्टेंट जनरेट करने का तरीका

generate, मॉडल के साथ काम करने के लिए एक हेल्पर फ़ंक्शन है.

केवल मॉडल को कॉल करने के लिए:

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

(async () => {
  const llmResponse = await generate({
    model: gemini15Flash,
    prompt: 'Tell me a joke.',
  });

  console.log(await llmResponse.text());
})();

उस मॉडल के लिए अलग-अलग विकल्प दिए जा सकते हैं. इसमें, एलएलएम के लिए कस्टम मॉडल की ज़रूरत होती है.

const response = await generate({
  model: gemini15Flash,
  prompt,
  config: {
    temperature: 1,
    stopSequences: ['abc'],
  },
});

अगर मॉडल मल्टीमॉडल इनपुट के साथ काम करता है, तो इमेज को इनपुट के तौर पर पास किया जा सकता है:

const result = await generate({
  model: gemini15Flash,
  prompt: [
    { text: 'describe the following image:' },
    { media: { url: imageUrl, contentType: 'image/jpeg' } },
  ],
});

या किसी लोकल फ़ाइल से:

const result = await generate({
  model: gemini15Flash,
  prompt: [
    { text: 'describe the following image:' },
    {
      data: {
        url: fs.readFileSync(__dirname + '/image.jpeg', {
          encoding: 'base64',
          flag: 'r',
        }),
        contentType: 'image/jpeg',
      },
    },
  ],
});

टूल और फ़ंक्शन कॉलिंग

Model में टूल और फ़ंक्शन कॉलिंग की सुविधा भी काम करती है. टूल पर सहायता पाने की सुविधा इन पर निर्भर करती है खास मॉडल की ज़रूरत होती है.

const myTool = action(
  {
    name: 'myJoke',
    description: 'useful when you need a joke to tell.',
    inputSchema: z.object({ subject: z.string() }),
    outputSchema: z.string(),
  },
  async (input) => 'haha Just kidding no joke! got you'
);

const llmResponse = await generate({
  model: gemini15Flash,
  prompt: 'Tell me a joke.',
  tools: [myTool],
  config: {
    temperature: 0.5,
  },
});

इससे उपयोगकर्ता के प्रॉम्प्ट को पूरा करने के लिए, टूल को अपने-आप कॉल कर दिया जाएगा.

टूल कॉलिंग के मैन्युअल नियंत्रण के लिए आप returnToolRequests: true तय कर सकते हैं.

const llmResponse = await generate({
  model: gemini15Flash,
  prompt: 'Tell me a joke.',
  tools: [myTool],
  returnToolRequests: true,
  config: {
    temperature: 0.5,
  },
});

रिट्रीवर संदर्भ जोड़ा जा रहा है

रिट्रीवर से दस्तावेज़ सीधे generate को भेजे जा सकते हैं, ताकि तथ्यों के साथ जानकारी:

const docs = await companyPolicyRetriever({ query: question });

await generate({
  model: gemini15Flash,
  prompt: `Answer using the available context from company policy: ${question}`,
  context: docs,
});

प्रॉम्प्ट के कॉन्टेंट में दस्तावेज़ का कॉन्टेक्स्ट अपने-आप जुड़ जाता है मॉडल को भेजा गया.

मैसेज का इतिहास रिकॉर्ड किया जा रहा है

Genkit मॉडल, मॉडल को भेजे गए मैसेज के इतिहास को बनाए रखने में मदद करता है और उसके जवाब, जिनका इस्तेमाल इंटरैक्टिव अनुभव तैयार करने में किया जा सकता है, जैसे कि चैटबॉट.

मॉडल के जवाब से मैसेज का इतिहास जनरेट करने के लिए, toHistory() पर कॉल करें तरीका:

let response = await generate({
  model: gemini15Flash,
  prompt: "How do you say 'dog' in French?",
});
let history = response.toHistory();

इस इतिहास को क्रम से लगाया जा सकता है और इसे किसी डेटाबेस या सेशन स्टोरेज में सेव किया जा सकता है. इसके बाद, आने वाले समय में generate() पर किए जाने वाले कॉल के इतिहास के साथ प्रॉम्प्ट शेयर करें:

response = await generate({
  model: gemini15Flash,
  prompt: 'How about in Spanish?',
  history,
});
history = response.toHistory();

अगर इस्तेमाल किया जा रहा मॉडल system रोल के साथ काम करता है, तो आपके पास इतिहास देखें:

let history: MessageData[] = [
  { role: 'system', content: [{ text: 'Talk like a pirate.' }] },
];
let response = await generate({
  model: gemini15Flash,
  prompt: "How do you say 'dog' in French?",
  history,
});
history = response.toHistory();

जवाब स्ट्रीम किए जा रहे हैं

Genkit, generateStream() तरीके से मॉडल के जवाबों को एक हिस्से में स्ट्रीम करने की सुविधा देता है:

// import { generateStream } from '@genkit-ai/ai';
const { response, stream } = await generateStream({
  model: gemini15Flash,
  prompt: 'Tell a long story about robots and ninjas.',
});

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

// you can also await the full response
console.log((await response()).text());