Genkit के प्लगिन लिखने में

Firebase Genkit की सुविधाओं को इस तरह से डिज़ाइन किया गया है कि उन्हें प्लगिन की मदद से बढ़ाया जा सके. Genkit प्लगिन कॉन्फ़िगर किए जा सकने वाले ऐसे मॉड्यूल होते हैं जो मॉडल, रिट्रीवर, इंडेक्सर, ट्रेस स्टोर वगैरह की सुविधाएं देते हैं. आपने Genkit का इस्तेमाल करके प् लग इन को काम करते हुए देखा है:

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

configureGenkit({
  plugins: [vertexAI({ projectId: 'my-project' })],
});

Vertex AI प्लगिन, कॉन्फ़िगरेशन (जैसे कि उपयोगकर्ता का Google Cloud प्रोजेक्ट आईडी) को कॉन्फ़िगर करता है. साथ ही, Genkit रजिस्ट्री के साथ कई तरह के नए मॉडल, एम्बेडर वगैरह रजिस्टर करता है. यह रजिस्ट्री, Genkit के लोकल यूज़र इंटरफ़ेस (यूआई) को चालू करती है. इससे, मॉडल, प्रॉम्प्ट वगैरह को चलाने और उनकी जांच करने में मदद मिलती है. साथ ही, रनटाइम के दौरान नाम वाली कार्रवाइयों को खोजने की सुविधा भी मिलती है.

प्लग इन बनाना

प्लगिन बनाने के लिए, आम तौर पर आपको एक नया एनपीएम पैकेज बनाना होता है. इसके लिए:

mkdir genkitx-my-plugin
cd genkitx-my-plugin
npm init -y
npm i --save @genkit-ai/core
npm i --save-dev typescript
npx tsc --init

इसके बाद, अपने मुख्य एंट्री पॉइंट से प्लगिन तय करें और उसे एक्सपोर्ट करें:

import { genkitPlugin } from '@genkit-ai/core';

interface MyPluginOptions {
  // add any plugin configuration here
}

export const myPlugin = genkitPlugin(
  'my-plugin',
  async (options: MyPluginOptions) => {
    // initialize your plugin here...
  }
);

प्लग इन के विकल्पों के बारे में सलाह

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

import { genkitPlugin, GenkitError } from '@genkit-ai/core';

interface MyPluginOptions {
  apiKey?: string;
}

export const myPlugin = genkitPlugin(
  'my-plugin',
  async (options: MyPluginOptions) => {
    const apiKey = options.apiKey || process.env.MY_PLUGIN_API_KEY;
    if (!apiKey)
      throw new GenkitError({
        source: 'my-plugin',
        status: 'INVALID_ARGUMENT',
        message:
          'Must supply either `options.apiKey` or set `MY_PLUGIN_API_KEY` environment variable.',
      });
    // ... continue initialization
  }
);

आपका प्लग इन बनाया जा रहा है

एक प्लगिन से Genkit में कई नई सुविधाएं चालू हो सकती हैं. उदाहरण के लिए, Vertex AI प्लगिन, कई नए मॉडल के साथ-साथ एक एम्बेडर को भी चालू करता है.

मॉडल प्लगिन

Genkit मॉडल के प्लगिन, Genkit रजिस्ट्री में एक या उससे ज़्यादा जनरेटिव एआई मॉडल जोड़ते हैं. मॉडल ऐसे किसी भी जनरेटिव मॉडल को दिखाता है जिसमें इनपुट के तौर पर प्रॉम्प्ट मिल सकता हो और उसमें टेक्स्ट, मीडिया या डेटा को आउटपुट के तौर पर जनरेट किया जा सकता हो. आम तौर पर, मॉडल प्लगिन अपने इनिशलाइज़ेशन फ़ंक्शन में एक या उससे ज़्यादा defineModel कॉल करेगा.

कस्टम मॉडल में आम तौर पर तीन कॉम्पोनेंट होते हैं:

1. मॉडल की क्षमताओं को तय करने वाला मेटाडेटा.
2. मॉडल के साथ काम करने वाले किसी खास पैरामीटर वाला कॉन्फ़िगरेशन स्कीमा.
3. ऐसा फ़ंक्शन जो GenerateRequest को स्वीकार करने वाले मॉडल और GenerateResponse मिलने वाले मॉडल को लागू करता है.

मॉडल प्लगिन बनाने के लिए, आपको @genkit-ai/ai पैकेज का इस्तेमाल करना होगा:

npm i --save @genkit-ai/ai

हाई लेवल पर, मॉडल प्लगिन कुछ ऐसा दिख सकता है:

import { genkitPlugin, GenkitError } from '@genkit-ai/core';
import { defineModel, GenerationCommonConfigSchema } from '@genkit-ai/ai/model';
import { simulateSystemPrompt } from '@genkit-ai/ai/model/middleware';
import { z } from 'zod';

export const myPlugin = genkitPlugin('my-plugin', async (options: {apiKey?: string}) => {
  defineModel({
    // be sure to include your plugin as a provider prefix
    name: 'my-plugin/my-model',
    // label for your model as shown in Genkit Developer UI
    label: 'My Awesome Model',
    // optional list of supported versions of your model
    versions: ['my-model-001', 'my-model-001'],
    // model support attributes
    supports: {
      multiturn: true, // true if your model supports conversations
      media: true, // true if your model supports multimodal input
      tools: true, // true if your model supports tool/function calling
      systemRole: true, // true if your model supports the system role
      output: ['text', 'media', 'json'], // types of output your model supports
    },
    // Zod schema for your model's custom configuration
    configSchema: GenerationCommonConfigSchema.extend({
      safetySettings: z.object({...}),
    }),
    // list of middleware for your model to use
    use: [simulateSystemPrompt()]
  }, async request => {
    const myModelRequest = toMyModelRequest(request);
    const myModelResponse = await myModelApi(myModelRequest);
    return toGenerateResponse(myModelResponse);
  });
});

अनुरोधों और जवाबों में बदलाव करना

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

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

मॉडल संदर्भ

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

import { modelRef } from "@genkit-ai/ai/model";

export myModelRef = modelRef({
  name: "my-plugin/my-model",
  configSchema: MyConfigSchema,
  info: {
    // ... model-specific info
  },
})

generate() को कॉल करते समय, मॉडल रेफ़रंस और स्ट्रिंग मॉडल के नामों का इस्तेमाल एक-दूसरे की जगह पर किया जा सकता है:

import { myModelRef } from 'genkitx-my-plugin';
import { generate } from '@genkit-ai/ai';

generate({ model: myModelRef });
// is equivalent to
generate({ model: 'my-plugin/my-model' });

टेलीमेट्री प्लग इन

Genkit Telemetry प्लगिन लिखना देखें.

प्लगिन पब्लिश करना

Genkit प्लगिन को सामान्य NPM पैकेज के तौर पर पब्लिश किया जा सकता है. ज़्यादा से ज़्यादा खोज करने और एक जैसा अनुभव पाने के लिए, आपके पैकेज को genkitx-{name} नाम देना चाहिए. इससे पता चलता है कि वह Genkit प्लगिन है. साथ ही, आपको अपने package.json में इनमें से कई keywords शामिल करने चाहिए, क्योंकि वे आपके प्लगिन के लिए काम के हैं:

• genkit-plugin: इस कीवर्ड को हमेशा अपने पैकेज में शामिल करें, ताकि यह पता चल सके कि यह एक Genkit प्लगिन है.
• genkit-model: अगर आपके पैकेज में किसी भी मॉडल के बारे में बताया गया है, तो इस कीवर्ड को शामिल करें.
• genkit-retriever: अगर आपका पैकेज किसी भी रिट्रीवर को तय करता है, तो इस कीवर्ड को शामिल करें.
• genkit-indexer: अगर आपका पैकेज किसी इंडेक्सर के बारे में बताता है, तो यह कीवर्ड शामिल करें.
• genkit-embedder: अगर आपका पैकेज किसी इंडेक्सर के बारे में बताता है, तो यह कीवर्ड शामिल करें.
• genkit-tracestore: अगर आपका पैकेज किसी ट्रेस स्टोर के बारे में बताता है, तो यह कीवर्ड शामिल करें.
• genkit-statestore: अगर आपका पैकेज किसी राज्य के स्टोर के बारे में बताता है, तो यह कीवर्ड शामिल करें.
• genkit-telemetry: अगर आपका पैकेज टेलीमेट्री की सेवा देने वाली कंपनी के बारे में बताता है, तो यह कीवर्ड शामिल करें.
• genkit-deploy: अगर आपके पैकेज में जेनकिट ऐप्लिकेशन को क्लाउड सेवा देने वाली कंपनियों के साथ डिप्लॉय करने के लिए हेल्पर शामिल हैं, तो इस कीवर्ड को शामिल करें.
• genkit-flow: अगर आपका पैकेज जेनकिट फ़्लो को बेहतर बनाता है, तो इस कीवर्ड को शामिल करें.

रिट्रीवर, एम्बेडर, और मॉडल उपलब्ध कराने वाले प्लगिन में, ऐसा package.json हो सकता है जो:

{
  "name": "genkitx-my-plugin",
  "keywords": ["genkit-plugin", "genkit-retriever", "genkit-embedder", "genkit-model"],
  // ... dependencies etc.
}