Dotprompt की मदद से प्रॉम्प्ट मैनेज करना

Firebase Genkit, लिखने में आपकी मदद करने के लिए, Dotprompt प्लगिन और टेक्स्ट फ़ॉर्मैट उपलब्ध कराता है और अपने जनरेटिव एआई प्रॉम्प्ट को व्यवस्थित करें.

Dotprompt को इस आधार पर डिज़ाइन किया गया है कि प्रॉम्प्ट, कोड होते हैं. आपने लिखा और अपने प्रॉम्प्ट को विशेष फ़ॉर्मैट वाली फ़ाइलों में बनाए रखें. इन्हें dotprompt फ़ाइलें कहा जाता है, ट्रैक करें, उसी वर्शन कंट्रोल सिस्टम का इस्तेमाल करके उनमें बदलाव किए जा सकते हैं जिसका इस्तेमाल और आप उन्हें उस कोड के साथ डिप्लॉय कर सकते हैं जो आपके जनरेटिव एआई को कॉल करता है मॉडल.

Dotprompt का इस्तेमाल करने के लिए, सबसे पहले अपने प्रोजेक्ट के रूट में prompts डायरेक्ट्री बनाएं और फिर उस डायरेक्ट्री में एक .prompt फ़ाइल बनाएं. यहाँ आपके लिए एक आसान सा उदाहरण दिया गया है, greeting.prompt को कॉल कर सकते हैं:

---
model: vertexai/gemini-1.5-flash
config:
  temperature: 0.9
input:
  schema:
    location: string
    style?: string
    name?: string
  default:
    location: a restaurant
---

You are the world's most welcoming AI assistant and are currently working at {{location}}.

Greet a guest{{#if name}} named {{name}}{{/if}}{{#if style}} in the style of {{style}}{{/if}}.

इस प्रॉम्प्ट का इस्तेमाल करने के लिए, dotprompt प्लगिन को इंस्टॉल करें. इसके बाद, prompt फ़ंक्शन को यहां से इंपोर्ट करें @genkit-ai/dotprompt लाइब्रेरी:

import { dotprompt, prompt } from '@genkit-ai/dotprompt';

configureGenkit({ plugins: [dotprompt()] });

इसके बाद, prompt('file_name') का इस्तेमाल करके प्रॉम्प्ट लोड करें:

const greetingPrompt = await prompt('greeting');

const result = await greetingPrompt.generate({
  input: {
    location: 'the beach',
    style: 'a fancy pirate',
  },
});

console.log(result.text());

डॉटप्रॉम्प्ट का सिंटैक्स हैंडलबार पर आधारित होता है के हिसाब से बनाया गया है. जोड़ने के लिए, if, unless, और each हेल्पर का इस्तेमाल किया जा सकता है अपने प्रॉम्प्ट में शर्त वाले हिस्से जोड़ें या स्ट्रक्चर्ड कॉन्टेंट के ज़रिए इसे दोहराएं. कॉन्टेंट बनाने फ़ाइल फ़ॉर्मैट, प्रॉम्प्ट इनलाइन के लिए मेटाडेटा देने के लिए YAML फ़्रंटमैटर का इस्तेमाल करता है टेम्प्लेट के साथ.

इनपुट/आउटपुट स्कीमा तय किए जा रहे हैं

Dotprompt में एक छोटा, YAML-ऑप्टिमाइज़ किया गया स्कीमा डेफ़िनिशन फ़ॉर्मैट शामिल होता है, जिसे Picoschema की मदद से, स्कीमा की सबसे अहम विशेषताएं आसानी से तय की जा सकती हैं एलएलएम इस्तेमाल कर सकते हैं. यहां किसी लेख के स्कीमा का उदाहरण दिया गया है:

schema:
  title: string # string, number, and boolean types are defined like this
  subtitle?: string # optional fields are marked with a `?`
  draft?: boolean, true when in draft state
  status?(enum, approval status): [PENDING, APPROVED]
  date: string, the date of publication e.g. '2024-04-09' # descriptions follow a comma
  tags(array, relevant tags for article): string # arrays are denoted via parentheses
  authors(array):
    name: string
    email?: string
  metadata?(object): # objects are also denoted via parentheses
    updatedAt?: string, ISO timestamp of last update
    approvedBy?: integer, id of approver
  extra?: any, arbitrary extra data
  (*): string, wildcard field

ऊपर दिया गया स्कीमा, नीचे दिए गए TypeScript इंटरफ़ेस के जैसा है:

interface Article {
  title: string;
  subtitle?: string | null;
  /** true when in draft state */
  draft?: boolean | null;
  /** approval status */
  status?: 'PENDING' | 'APPROVED' | null;
  /** the date of publication e.g. '2024-04-09' */
  date: string;
  /** relevant tags for article */
  tags: string[];
  authors: {
    name: string;
    email?: string | null;
  }[];
  metadata?: {
    /** ISO timestamp of last update */
    updatedAt?: string | null;
    /** id of approver */
    approvedBy?: number | null;
  } | null;
  /** arbitrary extra data */
  extra?: any;
  /** wildcard field */

}

Picoschema, स्केलर टाइप string, integer, number, boolean, और any के साथ काम करता है. ऑब्जेक्ट, अरे, और ईनम के लिए, उन्हें फ़ील्ड के नाम के बाद ब्रैकेट में दिखाया जाता है.

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

किसी ऑब्जेक्ट की परिभाषा में, "वाइल्डकार्ड" का एलान करने के लिए खास कुंजी (*) का इस्तेमाल किया जा सकता है फ़ील्ड की परिभाषा. यह उन सभी अतिरिक्त प्रॉपर्टी से मेल खाएगा, जिन्हें साफ़ तौर पर बताएं.

Picoschema, पूरी JSON स्कीमा की कई सुविधाओं के साथ काम नहीं करता. अगर आपको ज़्यादा मज़बूत स्कीमा की ज़रूरत होती है, तो इसके बजाय एक JSON स्कीमा दिया जा सकता है:

output:
  schema:
    type: object
    properties:
      field1:
        type: number
        minimum: 20

फिर से इस्तेमाल किए जा सकने वाले स्कीमा का इस्तेमाल करना

.prompt फ़ाइल में सीधे तौर पर स्कीमा तय करने के अलावा, आपके पास defineSchema का नाम से रजिस्टर किया गया स्कीमा. स्कीमा रजिस्टर करने के लिए:

import { defineSchema } from '@genkit-ai/core';
import { z } from 'zod';

const MySchema = defineSchema(
  'MySchema',
  z.object({
    field1: z.string(),
    field2: z.number(),
  })
);

अपने प्रॉम्प्ट में, रजिस्टर किए गए स्कीमा का नाम दिया जा सकता है:

# myPrompt.prompt
---
model: vertexai/gemini-1.5-flash
output:
  schema: MySchema
---

Dotprompt लाइब्रेरी में, नाम को दिए गए टाइटल के साथ अपने-आप रिज़ॉल्व कर दिया जाएगा रजिस्टर किया गया Zod स्कीमा. इसके बाद आप स्कीमा का इस्तेमाल करके डॉटप्रॉम्प्ट का आउटपुट:

import { prompt } from "@genkit-ai/dotprompt";

const myPrompt = await prompt("myPrompt");

const result = await myPrompt.generate<typeof MySchema>({...});

// now strongly typed as MySchema
result.output();

प्रॉम्प्ट मेटाडेटा बदलना

.prompt फ़ाइलें आपको, मॉडल कॉन्फ़िगरेशन जैसे मेटाडेटा को फ़ाइल से, आप प्रति-कॉल आधार पर इन मानों को भी ओवरराइड कर सकते हैं:

const result = await greetingPrompt.generate({
  model: 'vertexai/gemini-1.5-pro',
  config: {
    temperature: 1.0,
  },
  input: {
    location: 'the beach',
    style: 'a fancy pirate',
  },
});

स्ट्रक्चर्ड आउटपुट

किसी प्रॉम्प्ट के फ़ॉर्मैट और आउटपुट स्कीमा को, JSON में इस्तेमाल करने के लिए सेट किया जा सकता है:

---
model: vertexai/gemini-1.5-flash
input:
  schema:
    theme: string
output:
  format: json
  schema:
    name: string
    price: integer
    ingredients(array): string
---

Generate a menu item that could be found at a {{theme}} themed restaurant.

स्ट्रक्चर्ड आउटपुट वाला प्रॉम्प्ट जनरेट करते समय, output() हेल्पर का इस्तेमाल करें, ताकि फिर से पाएं और पुष्टि करें:

const createMenuPrompt = await prompt('create_menu');

const menu = await createMenuPrompt.generate({
  input: {
    theme: 'banana',
  },
});

console.log(menu.output());

आउटपुट के लिए, नियमों के पालन को प्रॉम्प्ट. डिफ़ॉल्ट रूप से, इसे जनरेट किए गए आखिरी मैसेज के आखिर में जोड़ा जाता है प्रॉम्प्ट के हिसाब से फ़िल्टर करें. {{section "output"}} का इस्तेमाल करके, इसकी जगह मैन्युअल तरीके से बदली जा सकती है सहायक.

This is a prompt that manually positions output instructions.

== Output Instructions

{{section "output"}}

== Other Instructions

This will come after the output instructions.

एक से ज़्यादा मैसेज वाले प्रॉम्प्ट

डिफ़ॉल्ट रूप से, Dotprompt "user" भूमिका वाला एक मैसेज बनाता है. कुछ सूचनाएं मिल रही हैं प्रॉम्प्ट को कई मैसेज को मिलाकर सबसे अच्छे तरीके से दिखाया जाता है. जैसे सिस्टम प्रॉम्प्ट.

{{role}} हेल्पर, एक से ज़्यादा मैसेज वाले प्रॉम्प्ट बनाने का आसान तरीका है:

---
model: vertexai/gemini-1.5-flash
input:
  schema:
    userQuestion: string
---

{{role "system"}}
You are a helpful AI assistant that really loves to talk about food. Try to work
food items into all of your conversations.
{{role "user"}}
{{userQuestion}}

मल्टी-टर्न प्रॉम्प्ट और इतिहास

Dotprompt में history विकल्प को पास करके, एक से ज़्यादा मोड़ों वाले प्रॉम्प्ट को generate तरीका:

const result = await multiTurnPrompt.generate({
  history: [
    { role: 'user', content: [{ text: 'Hello.' }] },
    { role: 'model', content: [{ text: 'Hi there!' }] },
  ],
});

डिफ़ॉल्ट रूप से, इतिहास को आखिरी मैसेज जनरेट किए जाने से पहले शामिल किया जाएगा प्रॉम्प्ट. हालांकि, {{history}} का इस्तेमाल करके मैन्युअल तरीके से इतिहास की जगह की जानकारी का पता लगाया जा सकता है हेल्पर:

{{role "system"}}
This is the system prompt.
{{history}}
{{role "user"}}
This is a user message.
{{role "model"}}
This is a model message.
{{role "user"}}
This is the final user message.

मल्टी-मोडल प्रॉम्प्ट

टेक्स्ट के साथ इमेज जैसे मल्टीमोडल इनपुट का इस्तेमाल करने वाले मॉडल के लिए, ये काम किए जा सकते हैं {{media}} हेल्पर का इस्तेमाल करें:

---
model: vertexai/gemini-1.5-flash
input:
  schema:
    photoUrl: string
---

Describe this image in a detailed paragraph:

{{media url=photoUrl}}

"इनलाइन" के लिए, यूआरएल https:// या base64 कोड में बदले गए data: यूआरआई हो सकता है इमेज इस्तेमाल. कोड में, यह होगा:

const describeImagePrompt = await prompt('describe_image');

const result = await describeImagePrompt.generate({
  input: {
    photoUrl: 'https://example.com/image.png',
  },
});

console.log(result.text());

कुछ हद तक

पार्शियल, फिर से इस्तेमाल किए जा सकने वाले ऐसे टेंप्लेट होते हैं जिन्हें किसी भी प्रॉम्प्ट में शामिल किया जा सकता है. कुछ हद तक खास तौर पर, ऐसे मिलते-जुलते प्रॉम्प्ट के लिए मददगार हो सकती है जिनका व्यवहार एक जैसा होता है.

प्रॉम्प्ट डायरेक्ट्री लोड करते समय, _ से शुरू की गई किसी भी फ़ाइल को आंशिक. इसलिए, फ़ाइल _personality.prompt में ये शामिल हो सकते हैं:

You should speak like a {{#if style}}{{style}}{{else}}helpful assistant.{{/else}}.

इसके बाद, इसे अन्य प्रॉम्प्ट में शामिल किया जा सकता है:

---
model: vertexai/gemini-1.5-flash
input:
  schema:
    name: string
    style?: string
---

{{ role "system" }}
{{>personality style=style}}

{{ role "user" }}
Give the user a friendly greeting.

User's Name: {{name}}

कुछ हिस्से डालने के लिए, {{>NAME_OF_PARTIAL args...}} सिंटैक्स का इस्तेमाल किया जाता है. अगर नहीं आर्ग्युमेंट को आंशिक तौर पर दिया जाता है, इसलिए यह उसी कॉन्टेक्स्ट के साथ काम करता है जिसमें पैरंट प्रॉम्प्ट.

पार्शियल, ऊपर दिए गए नाम वाले दोनों आर्ग्युमेंट या किसी एक पोज़िशनल आर्ग्युमेंट को स्वीकार करते हैं संदर्भ का इस्तेमाल कर रहा है. यह कुछ के लिए मददगार हो सकता है, जैसे कि सूची के सदस्यों को रेंडर करना.

# _destination.prompt
- {{name}} ({{country}})

# chooseDestination.prompt
Help the user decide between these vacation destinations:
{{#each destinations}}
{{>destination this}}{{/each}}

कोड में पार्शियल तय करना

definePartial का इस्तेमाल करके भी कोड में पार्शियल तय किया जा सकता है:

import { definePartial } from '@genkit-ai/dotprompt';

definePartial(
  'personality',
  'Talk like a {{#if style}}{{style}}{{else}}helpful assistant{{/if}}.'
);

कोड से तय किए गए पार्शियल, सभी प्रॉम्प्ट में उपलब्ध होते हैं.

प्रॉम्प्ट के वैरिएंट

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

वैरिएंट बनाने के लिए, [name].[variant].prompt फ़ाइल बनाएं. उदाहरण के लिए, अगर आपने प्रॉम्प्ट में Gemini 1.5 Flash का इस्तेमाल किया था, लेकिन आपको यह देखना था कि Gemini 1.5 फ़्लैश का इस्तेमाल किया जा रहा है या नहीं Pro की परफ़ॉर्मेंस बेहतर होगी, इसलिए दो फ़ाइलें बनाई जा सकती हैं:

• my_prompt.prompt: "बेसलाइन" मैसेज
• my_prompt.gemini15pro.prompt: "gemini15pro" नाम का एक वैरिएंट

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

const myPrompt = await prompt('my_prompt', { variant: 'gemini15pro' });

वैरिएंट का नाम जनरेशन ट्रेस के मेटाडेटा में शामिल होता है, इसलिए आपको Genkit ट्रेस में वैरिएंट की असल परफ़ॉर्मेंस की तुलना और उसके बीच अंतर कर सकता है इंस्पेक्टर

कस्टम हेल्पर की परिभाषा

किसी प्रॉम्प्ट में मौजूद डेटा को प्रोसेस और मैनेज करने के लिए, कस्टम हेल्पर तय किए जा सकते हैं. हेल्पर defineHelper का इस्तेमाल करके, दुनिया भर में रजिस्टर किए जाते हैं:

import { defineHelper } from '@genkit-ai/dotprompt';

defineHelper('shout', (text: string) => text.toUpperCase());

हेल्पर के बारे में तय होने के बाद, इसका इस्तेमाल किसी भी प्रॉम्प्ट में किया जा सकता है:

---
model: vertexai/gemini-1.5-flash
input:
  schema:
    name: string
---

HELLO, {{shout name}}!!!

हेल्पर में दिए गए आर्ग्युमेंट के बारे में ज़्यादा जानने के लिए, यह देखें हैंडलबार से जुड़े दस्तावेज़: कस्टम हेल्पर.

प्रॉम्प्ट को लोड करने और उनके बारे में बताने के दूसरे तरीके

डॉटप्रॉम्प्ट को प्रॉम्प्ट डायरेक्ट्री में संगठन के लिए ऑप्टिमाइज़ किया गया है. हालांकि, प्रॉम्प्ट को लोड करने और तय करने के कुछ और तरीके भी हैं:

• loadPromptFile: प्रॉम्प्ट डायरेक्ट्री में मौजूद किसी फ़ाइल से प्रॉम्प्ट लोड करें.
• loadPromptUrl: यूआरएल से प्रॉम्प्ट लोड करें.
• defineDotprompt: कोड में प्रॉम्प्ट तय करें.

उदाहरण:

import {
  loadPromptFile,
  loadPromptUrl,
  defineDotprompt,
} from '@genkit-ai/dotprompt';
import path from 'path';
import { z } from 'zod';

// Load a prompt from a file
const myPrompt = await loadPromptFile(
  path.resolve(__dirname, './path/to/my_prompt.prompt')
);

// Load a prompt from a URL
const myPrompt = await loadPromptUrl('https://example.com/my_prompt.prompt');

// Define a prompt in code
const myPrompt = defineDotprompt(
  {
    model: 'vertexai/gemini-1.5-flash',
    input: {
      schema: z.object({
        name: z.string(),
      }),
    },
  },
  `Hello {{name}}, how are you today?`
);