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

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

मॉडल

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

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

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

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

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

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

import { geminiPro } 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, Mintral वगैरह शामिल हैं

सेटअप और इस्तेमाल की जानकारी के लिए हर प्लगिन के लिए दस्तावेज़ देखें.

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

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

सिर्फ़ मॉडल को कॉल करने के लिए:

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

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

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

इस मॉडल के लिए कई मॉडल विकल्प पास किए जा सकते हैं. इनमें खास एलएलएम के लिए कस्टम मॉडल तय करना भी शामिल है.

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

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

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

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

const result = await generate({
  model: geminiProVision,
  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: geminiPro,
  prompt: 'Tell me a joke.',
  tools: [myTool],
  config: {
    temperature: 0.5,
  },
});

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

टूल कॉलिंग को मैन्युअल कंट्रोल करने के लिए, returnToolRequests: true तय किया जा सकता है.

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

इसके साथ काम करने वाले मॉडल से आउटपुट को स्ट्रीम किया जा सकता है:

await generate({
  model: geminiPro,
  prompt: 'Tell me a very long joke.',
  streamingCallback: (chunk) => {
    console.log(chunk);
  },
});

रिट्रीवर का कॉन्टेक्स्ट जोड़ना

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

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

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

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

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

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

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

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

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

response = await generate({
  model: geminiPro,
  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: geminiPro,
  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: geminiPro,
  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());