एआई मॉडल की मदद से कॉन्टेंट जनरेट करना

संग्रह की मदद से व्यवस्थित रहें अपनी प्राथमिकताओं के आधार पर, कॉन्टेंट को सेव करें और कैटगरी में बांटें.

जनरेटिव एआई के मुख्य हिस्से में एआई मॉडल होते हैं. जनरेटिव मॉडल के दो सबसे प्रमुख उदाहरण, लार्ज लैंग्वेज मॉडल (एलएलएम) और इमेज जनरेशन मॉडल हैं. ये मॉडल प्रॉम्प्ट (आम तौर पर टेक्स्ट, इमेज या दोनों का कॉम्बिनेशन) नाम का इनपुट लेते हैं. इसके बाद, इनपुट से टेक्स्ट, इमेज, ऑडियो या वीडियो के तौर पर आउटपुट देते हैं.

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

इसके अलावा, एलएलएम की मदद से, टेक्स्ट जनरेट करने के अलावा और भी काम किए जा सकते हैं:

• कंप्यूटर प्रोग्राम लिखना.
• बड़े टास्क को पूरा करने के लिए, छोटे टास्क की प्लानिंग करना.
• व्यवस्थित नहीं किए गए डेटा को व्यवस्थित करना.
• टेक्स्ट के कॉर्पस से जानकारी का डेटा समझना और निकालना.
• गतिविधि की टेक्स्ट जानकारी के आधार पर, ऑटोमेट की गई गतिविधियों को फ़ॉलो करना और उन्हें पूरा करना.

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

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

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

शुरू करने से पहले

अगर आपको इस पेज पर दिए गए कोड के उदाहरण चलाने हैं, तो पहले शुरू करने के लिए दी गई गाइड में दिया गया तरीका अपनाएं. सभी उदाहरणों में यह माना गया है कि आपने अपने प्रोजेक्ट में, Genkit को डिपेंडेंसी के तौर पर पहले ही इंस्टॉल कर लिया है.

Genkit के साथ काम करने वाले मॉडल

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

Genkit टीम, Vertex AI, Google जनरेटिव एआई, और Ollama के उपलब्ध कराए गए मॉडल के साथ काम करने के लिए प्लग इन मैनेज करती है:

• Google Cloud Vertex AI प्लग इन की मदद से, एलएलएम की Gemini फ़ैमिली.
• Google के एआई प्लगिन की मदद से, एलएलएम की Gemini फ़ैमिली.
• Ollama प्लग इन के ज़रिए, Gemma 3, Llama 4, और कई अन्य ओपन मॉडल इस्तेमाल किए जा सकते हैं. इसके लिए, आपको Ollama सर्वर को खुद होस्ट करना होगा.

मॉडल प्लग इन लोड और कॉन्फ़िगर करना

कॉन्टेंट जनरेट करने के लिए Genkit का इस्तेमाल करने से पहले, आपको एक मॉडल प्लगिन लोड और कॉन्फ़िगर करना होगा. अगर आपने'शुरू करें' गाइड देखी है, तो आपने यह काम पहले ही कर लिया है. अगर ऐसा नहीं है, तो शुरू करें गाइड या अलग-अलग प्लग इन के दस्तावेज़ देखें. इसके बाद, आगे बढ़ने से पहले वहां दिया गया तरीका अपनाएं.

genkit.Generate() फ़ंक्शन

Genkit में, genkit.Generate() फ़ंक्शन वह मुख्य इंटरफ़ेस है जिसकी मदद से जनरेटिव एआई मॉडल के साथ इंटरैक्ट किया जाता है.

सबसे आसान genkit.Generate() कॉल में, आपको जिस मॉडल का इस्तेमाल करना है उसके साथ-साथ टेक्स्ट प्रॉम्प्ट की जानकारी भी दी जाती है:

import (
    "context"
    "log"

    "github.com/firebase/genkit/go/ai"
    "github.com/firebase/genkit/go/genkit"
    "github.com/firebase/genkit/go/plugins/googlegenai"
)

func main() {
    ctx := context.Background()

    g, err := genkit.Init(ctx,
        genkit.WithPlugins(&googlegenai.GoogleAI{}),
        genkit.WithDefaultModel("googleai/gemini-2.0-flash"),
    )
    if err != nil {
        log.Fatal(err)
    }

    resp, err := genkit.Generate(ctx, g,
        ai.WithPrompt("Invent a menu item for a pirate themed restaurant."),
    )
    if err != nil {
        log.Fatal(err)
    }

    log.Println(resp.Text())
}

इस छोटे उदाहरण को चलाने पर, यह डीबग करने से जुड़ी कुछ जानकारी को प्रिंट करेगा. इसके बाद, genkit.Generate() कॉल का आउटपुट दिखेगा. आम तौर पर, यह Markdown टेक्स्ट होता है, जैसा कि इस उदाहरण में दिखाया गया है:

## The Blackheart's Bounty

**A hearty stew of slow-cooked beef, spiced with rum and molasses, served in a
hollowed-out cannonball with a side of crusty bread and a dollop of tangy
pineapple salsa.**

**Description:** This dish is a tribute to the hearty meals enjoyed by pirates
on the high seas. The beef is tender and flavorful, infused with the warm spices
of rum and molasses. The pineapple salsa adds a touch of sweetness and acidity,
balancing the richness of the stew. The cannonball serving vessel adds a fun and
thematic touch, making this dish a perfect choice for any pirate-themed
adventure.

स्क्रिप्ट को फिर से चलाएं और आपको एक अलग आउटपुट मिलेगा.

ऊपर दिए गए कोड सैंपल में, जनरेट करने का अनुरोध डिफ़ॉल्ट मॉडल को भेजा गया है. इस मॉडल को Genkit इंस्टेंस को कॉन्फ़िगर करते समय तय किया जाता है.

किसी एक genkit.Generate() कॉल के लिए भी मॉडल तय किया जा सकता है:

resp, err := genkit.Generate(ctx, g,
    ai.WithModelName("googleai/gemini-2.5-pro"),
    ai.WithPrompt("Invent a menu item for a pirate themed restaurant."),
)

मॉडल स्ट्रिंग आइडेंटिफ़ायर providerid/modelid जैसा दिखता है. इसमें, प्रोवाइडर आईडी (इस मामले में, googleai) प्लग इन की पहचान करता है और मॉडल आईडी, प्लग इन के हिसाब से किसी मॉडल के खास वर्शन के लिए स्ट्रिंग आइडेंटिफ़ायर होता है.

इन उदाहरणों से एक अहम बात भी पता चलती है: जनरेटिव एआई मॉडल कॉल करने के लिए genkit.Generate() का इस्तेमाल करने पर, जिस मॉडल का इस्तेमाल करना है उसे बदलने के लिए, मॉडल पैरामीटर में कोई दूसरी वैल्यू पास करनी होती है. नेटिव मॉडल के SDK टूल के बजाय genkit.Generate() का इस्तेमाल करने पर, आपको अपने ऐप्लिकेशन में कई अलग-अलग मॉडल का आसानी से इस्तेमाल करने की सुविधा मिलती है. साथ ही, आने वाले समय में मॉडल बदलने में भी आसानी होती है.

अब तक, आपको सिर्फ़ सबसे आसान genkit.Generate() कॉल के उदाहरण दिखे हैं. हालांकि, genkit.Generate() जनरेटिव मॉडल के साथ ज़्यादा बेहतर इंटरैक्शन के लिए भी एक इंटरफ़ेस उपलब्ध कराता है. आपको यह इंटरफ़ेस, आगे दिए गए सेक्शन में दिखेगा.

सिस्टम से मिलने वाले निर्देश

कुछ मॉडल में सिस्टम प्रॉम्प्ट की सुविधा होती है. इससे मॉडल को निर्देश मिलते हैं कि उपयोगकर्ता के मैसेज का जवाब कैसे देना है. सिस्टम प्रॉम्प्ट का इस्तेमाल करके, मॉडल की विशेषताओं के बारे में बताया जा सकता है. जैसे, आपको मॉडल को किस तरह का व्यक्तित्व देना है, उसके जवाबों का टोन कैसा होना चाहिए, और उसके जवाबों का फ़ॉर्मैट कैसा होना चाहिए.

अगर इस्तेमाल किया जा रहा मॉडल, सिस्टम प्रॉम्प्ट के साथ काम करता है, तो WithSystem() विकल्प की मदद से कोई प्रॉम्प्ट दिया जा सकता है:

resp, err := genkit.Generate(ctx, g,
    ai.WithSystem("You are a food industry marketing consultant."),
    ai.WithPrompt("Invent a menu item for a pirate themed restaurant."),
)

जिन मॉडल में सिस्टम प्रॉम्प्ट काम नहीं करते उनके लिए, WithSystem() अनुरोध में बदलाव करके उसे सिस्टम प्रॉम्प्ट की तरह दिखाता है.

मॉडल के पैरामीटर

genkit.Generate() फ़ंक्शन में WithConfig() विकल्प का इस्तेमाल किया जाता है. इसकी मदद से, वैकल्पिक सेटिंग तय की जा सकती हैं. इनसे यह कंट्रोल किया जा सकता है कि मॉडल, कॉन्टेंट कैसे जनरेट करता है:

resp, err := genkit.Generate(ctx, g,
    ai.WithModelName("googleai/gemini-2.0-flash"),
    ai.WithPrompt("Invent a menu item for a pirate themed restaurant."),
    ai.WithConfig(&googlegenai.GeminiConfig{
        MaxOutputTokens: 500,
        StopSequences:   ["<end>", "<fin>"],
        Temperature:     0.5,
        TopP:            0.4,
        TopK:            50,
    }),
)

कौनसे पैरामीटर काम करते हैं, यह मॉडल और मॉडल एपीआई पर निर्भर करता है. हालांकि, पिछले उदाहरण में दिए गए पैरामीटर, ज़्यादातर मॉडल के लिए सामान्य होते हैं. इन पैरामीटर के बारे में यहां बताया गया है:

आउटपुट की लंबाई को कंट्रोल करने वाले पैरामीटर

MaxOutputTokens

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

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

जैसा कि पहले बताया गया है, हो सकता है कि कुछ टोकन, वर्ण क्रम में मैप न हों. उदाहरण के लिए, अक्सर एक टोकन होता है जो क्रम के आखिर में दिखता है: जब कोई एलएलएम यह टोकन जनरेट करता है, तो वह ज़्यादा जनरेट करना बंद कर देता है. इसलिए, यह मुमकिन है और अक्सर ऐसा होता है कि एलएलएम, ज़्यादा से ज़्यादा टोकन के मुकाबले कम टोकन जनरेट करता है, क्योंकि उसने "स्टॉप" टोकन जनरेट किया है.

StopSequences

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

ध्यान दें कि आपने वर्ण क्रम तय किए हैं, न कि टोकन. ज़्यादातर मामलों में, आपको एक कैरेक्टर सीक्वेंस तय करना होगा, जिसे मॉडल का टोकेनेटर एक टोकन पर मैप करता है.

"क्रिएटिविटी" को कंट्रोल करने वाले पैरामीटर

तापमान, top-p, और top-k पैरामीटर, यह कंट्रोल करते हैं कि आपको मॉडल कितना "क्रिएटिव" चाहिए. इस सेक्शन में, इन पैरामीटर के बारे में कम शब्दों में जानकारी दी गई है. हालांकि, सबसे अहम बात यह है कि इन पैरामीटर का इस्तेमाल, एलएलएम के आउटपुट के कैरेक्टर में बदलाव करने के लिए किया जाता है. इनके लिए सबसे सही वैल्यू, आपके लक्ष्यों और प्राथमिकताओं पर निर्भर करती हैं. साथ ही, ये वैल्यू सिर्फ़ एक्सपेरिमेंट के ज़रिए मिल सकती हैं.

तापमान

एलएलएम, टोकन का अनुमान लगाने वाली मशीनें हैं. टोकन के किसी दिए गए क्रम (जैसे, प्रॉम्प्ट) के लिए, एलएलएम अपनी शब्दावली में मौजूद हर टोकन के लिए यह अनुमान लगाता है कि क्रम में अगला टोकन कौनसा हो सकता है. तापमान, स्केलिंग फ़ैक्टर होता है. इन अनुमानों को 0 से 1 के बीच की संभावना के लिए सामान्य बनाने से पहले, इनमें तापमान का इस्तेमाल किया जाता है.

कम तापमान की वैल्यू, 0.0 से 1.0 के बीच होती हैं. इनसे, टोकन के बीच संभावनाओं में अंतर बढ़ जाता है. इस वजह से, मॉडल के लिए ऐसा टोकन जनरेट करने की संभावना और भी कम हो जाती है जिसका पहले ही आकलन किया जा चुका है कि वह जनरेट नहीं होगा. इसे अक्सर कम क्रिएटिव आउटपुट माना जाता है. तकनीकी तौर पर, 0.0 एक मान्य वैल्यू नहीं है. हालांकि, कई मॉडल इसे इस तरह से इस्तेमाल करते हैं कि मॉडल को तय तरीके से काम करना चाहिए और सिर्फ़ सबसे संभावित टोकन को ध्यान में रखना चाहिए.

1.0 से ज़्यादा की टेंपरेचर वैल्यू, टोकन के बीच संभावनाओं में अंतर को कम कर देती हैं. इस वजह से, मॉडल के टोकन जनरेट करने की संभावना ज़्यादा हो जाती है, जिनके लिए पहले यह अनुमान लगाया गया था कि वे जनरेट नहीं होंगे. इसे अक्सर ज़्यादा क्रिएटिव आउटपुट माना जाता है. कुछ मॉडल एपीआई, तापमान की सबसे ज़्यादा वैल्यू तय करते हैं. आम तौर पर, यह वैल्यू 2.0 होती है.

TopP

Top-p, 0.0 से 1.0 के बीच की वैल्यू होती है. यह उन संभावित टोक़न की संख्या को कंट्रोल करती है जिन्हें आपको मॉडल में शामिल करना है. इसके लिए, यह टोक़न की कुल संभावना तय करती है. उदाहरण के लिए, 1.0 की वैल्यू का मतलब है कि हर संभावित टोक़न को ध्यान में रखें. हालांकि, हर टोक़न की संभावना को भी ध्यान में रखें. 0.4 की वैल्यू का मतलब है कि सिर्फ़ उन सबसे संभावित टोकन को शामिल करना जिनकी संभावनाएं 0.4 तक जोड़ती हैं. साथ ही, बाकी टोकन को शामिल नहीं करना.

TopK

Top-k एक पूर्णांक वैल्यू है. यह उन संभावित टोकन की संख्या को भी कंट्रोल करती है जिन्हें आपको मॉडल में शामिल करना है. हालांकि, इस बार टोकन की ज़्यादा से ज़्यादा संख्या को साफ़ तौर पर बताकर ऐसा किया जाता है. वैल्यू 1 डालने का मतलब है कि मॉडल का व्यवहार तय होना चाहिए.

मॉडल पैरामीटर के साथ एक्सपेरिमेंट करना

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

मॉडल को उसके कॉन्फ़िगरेशन से जोड़ना

हर सेवा देने वाली कंपनी या किसी खास मॉडल का अपना कॉन्फ़िगरेशन स्कीमा या कुछ सेटिंग हो सकती हैं. इसलिए, WithModelName() और WithConfig() का इस्तेमाल करके अलग-अलग विकल्प सेट करने पर गड़बड़ी हो सकती है. ऐसा इसलिए, क्योंकि WithConfig() को WithModelName() के लिए स्ट्रॉन्ग टाइप नहीं किया गया है.

किसी मॉडल को उसके कॉन्फ़िगरेशन के साथ जोड़ने के लिए, मॉडल का रेफ़रंस बनाया जा सकता है. इस रेफ़रंस को जनरेट कॉल में पास किया जा सकता है:

model := googlegenai.GoogleAIModelRef("gemini-2.0-flash", &googlegenai.GeminiConfig{
    MaxOutputTokens: 500,
    StopSequences:   ["<end>", "<fin>"],
    Temperature:     0.5,
    TopP:            0.4,
    TopK:            50,
})

resp, err := genkit.Generate(ctx, g,
    ai.WithModel(model),
    ai.WithPrompt("Invent a menu item for a pirate themed restaurant."),
)
if err != nil {
    log.Fatal(err)
}

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

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

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

Genkit में, genkit.Generate() को कॉल करते समय आउटपुट टाइप तय करके, किसी मॉडल से स्ट्रक्चर्ड आउटपुट का अनुरोध किया जा सकता है:

type MenuItem struct {
    Name        string   `json:"name"`
    Description string   `json:"description"`
    Calories    int      `json:"calories"`
    Allergens   []string `json:"allergens"`
}

resp, err := genkit.Generate(ctx, g,
    ai.WithPrompt("Invent a menu item for a pirate themed restaurant."),
    ai.WithOutputType(MenuItem{}),
)
if err != nil {
  log.Fatal(err) // One possible error is that the response does not conform to the type.
}

मॉडल के आउटपुट टाइप, invopop/jsonschema पैकेज का इस्तेमाल करके JSON स्कीमा के तौर पर तय किए जाते हैं. इससे रनटाइम टाइप की जांच की सुविधा मिलती है. यह स्टैटिक Go टाइप और जनरेटिव एआई मॉडल के अप्रत्याशित आउटपुट के बीच के अंतर को कम करती है. इस सिस्टम की मदद से, ऐसा कोड लिखा जा सकता है जो इस बात पर भरोसा कर सकता है कि जनरेट कॉल के कामयाब होने पर, हमेशा ऐसा आउटपुट मिलेगा जो आपके Go टाइप के मुताबिक होगा.

genkit.Generate() में आउटपुट टाइप तय करने पर, Genkit कई काम करता है:

• चुने गए आउटपुट फ़ॉर्मैट के बारे में ज़्यादा जानकारी के साथ प्रॉम्प्ट को बेहतर बनाता है. इससे मॉडल को यह बताने में भी मदद मिलती है कि आपको किस तरह का कॉन्टेंट जनरेट करना है. उदाहरण के लिए, सिर्फ़ मेन्यू आइटम का सुझाव देना ही नहीं, बल्कि उसकी जानकारी, एलर्जी वाले आइटम की सूची वगैरह जनरेट करना.
• यह पुष्टि करता है कि आउटपुट, स्कीमा के मुताबिक है या नहीं.
• मॉडल के आउटपुट को Go टाइप में मार्शल करता है.

जनरेट कॉल के सही तरीके से काम करने पर स्ट्रक्चर्ड आउटपुट पाने के लिए, मॉडल के जवाब पर Output() को इस टाइप की खाली वैल्यू के साथ कॉल करें:

var item MenuItem
if err := resp.Output(&item); err != nil {
    log.Fatalf(err)
}

log.Printf("%s (%d calories, %d allergens): %s\n",
    item.Name, item.Calories, len(item.Allergens), item.Description)

इसके अलावा, कम शब्दों में कॉल करने के लिए genkit.GenerateData() का इस्तेमाल किया जा सकता है:

item, resp, err := genkit.GenerateData[MenuItem](ctx, g,
    ai.WithPrompt("Invent a menu item for a pirate themed restaurant."),
)
if err != nil {
  log.Fatal(err)
}

log.Printf("%s (%d calories, %d allergens): %s\n",
    item.Name, item.Calories, len(item.Allergens), item.Description)

इस फ़ंक्शन के लिए, आउटपुट टाइप पैरामीटर की ज़रूरत होती है. हालांकि, यह वैल्यू दिखाने से पहले, WithOutputType() विकल्प को अपने-आप सेट करता है और resp.Output() को कॉल करता है.

गड़बड़ियों को मैनेज करना

पिछले उदाहरण में ध्यान दें कि genkit.Generate() कॉल से गड़बड़ी हो सकती है. जब मॉडल, स्कीमा के मुताबिक आउटपुट जनरेट नहीं कर पाता है, तो एक संभावित गड़बड़ी हो सकती है. ऐसी गड़बड़ियों को ठीक करने के लिए सबसे सही तरीका, आपके इस्तेमाल के उदाहरण पर निर्भर करेगा. हालांकि, यहां कुछ सामान्य सुझाव दिए गए हैं:

• कोई दूसरा मॉडल आज़माएं. स्ट्रक्चर्ड आउटपुट पाने के लिए, मॉडल को JSON में आउटपुट जनरेट करने की सुविधा होनी चाहिए. Gemini जैसे सबसे बेहतर एलएलएम, ऐसा करने के लिए काफ़ी बेहतर हैं. हालांकि, हो सकता है कि छोटे मॉडल, जैसे कि Ollama के साथ इस्तेमाल किए जाने वाले कुछ लोकल मॉडल, भरोसेमंद स्ट्रक्चर्ड आउटपुट जनरेट न कर पाएं. ऐसा तब तक होगा, जब तक उन्हें ऐसा करने के लिए खास तौर पर ट्रेन नहीं किया जाता.

• स्कीमा को आसान बनाएं. एलएलएम को जटिल या बहुत गहरे नेस्ट किए गए टाइप जनरेट करने में समस्या हो सकती है. अगर आपको स्ट्रक्चर्ड डेटा जनरेट करने में समस्या आ रही है, तो साफ़ नाम, कम फ़ील्ड या फ़्लैट किए गए स्ट्रक्चर का इस्तेमाल करें.

• genkit.Generate() पर फिर से कॉल करें. अगर आपने जो मॉडल चुना है वह कभी-कभी ही ज़रूरी शर्तें पूरी करने वाला आउटपुट जनरेट नहीं कर पाता है, तो इस गड़बड़ी को नेटवर्क से जुड़ी गड़बड़ी की तरह ही माना जा सकता है. साथ ही, धीरे-धीरे बैक-ऑफ़ करने की किसी रणनीति का इस्तेमाल करके, अनुरोध को फिर से आज़माया जा सकता है.

स्ट्रीमिंग

ज़्यादा टेक्स्ट जनरेट करते समय, आउटपुट को जनरेट होते ही दिखाकर, अपने उपयोगकर्ताओं के अनुभव को बेहतर बनाया जा सकता है. इसके लिए, आउटपुट को स्ट्रीम करें. स्ट्रीमिंग की सुविधा का उदाहरण, एलएलएम वाले ज़्यादातर चैट ऐप्लिकेशन में देखा जा सकता है: उपयोगकर्ता अपने मैसेज के जवाब को मॉडल के जनरेट होने के दौरान पढ़ सकते हैं. इससे, ऐप्लिकेशन के जवाब देने की क्षमता बेहतर होती है और उपयोगकर्ता को यह एहसास होता है कि वह किसी स्मार्ट चैट बॉट से बात कर रहा है.

Genkit में, WithStreaming() विकल्प का इस्तेमाल करके आउटपुट स्ट्रीम किया जा सकता है:

resp, err := genkit.Generate(ctx, g,
    ai.WithPrompt("Suggest a complete menu for a pirate themed restaurant."),
    ai.WithStreaming(func(ctx context.Context, chunk *ai.ModelResponseChunk) error {
        // Do something with the chunk...
        log.Println(chunk.Text())
        return nil
    }),
)
if err != nil {
    log.Fatal(err)
}

log.Println(resp.Text())

मल्टीमोडल इनपुट

अब तक देखे गए उदाहरणों में, मॉडल प्रॉम्प्ट के तौर पर टेक्स्ट स्ट्रिंग का इस्तेमाल किया गया है. जनरेटिव एआई मॉडल को प्रॉम्प्ट करने का यह सबसे सामान्य तरीका है. हालांकि, कई मॉडल में प्रॉम्प्ट के तौर पर अन्य मीडिया भी इस्तेमाल किए जा सकते हैं. मीडिया प्रॉम्प्ट का इस्तेमाल, अक्सर टेक्स्ट प्रॉम्प्ट के साथ किया जाता है. टेक्स्ट प्रॉम्प्ट, मॉडल को मीडिया पर कोई कार्रवाई करने का निर्देश देते हैं. जैसे, किसी इमेज का कैप्शन लिखना या ऑडियो रिकॉर्डिंग को लिखाई में बदलना.

मीडिया इनपुट स्वीकार करने की सुविधा और इस्तेमाल किए जा सकने वाले मीडिया टाइप, पूरी तरह से मॉडल और उसके एपीआई पर निर्भर करते हैं. उदाहरण के लिए, Gemini 2.0 के मॉडल, प्रॉम्प्ट के तौर पर इमेज, वीडियो, और ऑडियो स्वीकार कर सकते हैं.

अगर आपको किसी ऐसे मॉडल को मीडिया प्रॉम्प्ट देना है जिसमें यह सुविधा काम करती है, तो genkit.Generate() को टेक्स्ट प्रॉम्प्ट देने के बजाय, मीडिया और टेक्स्ट, दोनों वाले कलेक्शन को पास करें. इस उदाहरण में, सार्वजनिक तौर पर ऐक्सेस किए जा सकने वाले एचटीटीपीएस यूआरएल का इस्तेमाल करके इमेज को दिखाया गया है.

resp, err := genkit.Generate(ctx, g,
    ai.WithModelName("googleai/gemini-2.0-flash"),
    ai.WithMessages(
        NewUserMessage(
            NewMediaPart("image/jpeg", "https://example.com/photo.jpg"),
            NewTextPart("Compose a poem about this image."),
        ),
    ),
)

मीडिया डेटा को डेटा यूआरएल के तौर पर कोड करके, उसे सीधे तौर पर भी पास किया जा सकता है. उदाहरण के लिए:

image, err := ioutil.ReadFile("photo.jpg")
if err != nil {
    log.Fatal(err)
}

resp, err := genkit.Generate(ctx, g,
    ai.WithModelName("googleai/gemini-2.0-flash"),
    ai.WithMessages(
        NewUserMessage(
            NewMediaPart("image/jpeg", "data:image/jpeg;base64," + base64.StdEncoding.EncodeToString(image)),
            NewTextPart("Compose a poem about this image."),
        ),
    ),
)

मीडिया इनपुट की सुविधा वाले सभी मॉडल, डेटा यूआरएल और एचटीटीपीएस यूआरएल, दोनों के साथ काम करते हैं. कुछ मॉडल प्लग इन, अन्य मीडिया सोर्स के साथ काम करते हैं. उदाहरण के लिए, Vertex AI प्लग इन की मदद से, Cloud Storage (gs://) के यूआरएल भी इस्तेमाल किए जा सकते हैं.

अगले चरण

Genkit के बारे में ज़्यादा जानें

• ऐप्लिकेशन डेवलपर के तौर पर, प्रॉम्प्ट की मदद से जनरेटिव एआई मॉडल के आउटपुट पर असर डाला जा सकता है. Dotprompt की मदद से प्रॉम्प्ट मैनेज करना लेख पढ़ें. इससे आपको यह जानने में मदद मिलेगी कि Genkit, असरदार प्रॉम्प्ट बनाने और उन्हें अपने कोडबेस में मैनेज करने में कैसे मदद करता है.
• genkit.Generate(), जनरेटिव एआई की मदद से काम करने वाले हर ऐप्लिकेशन का मुख्य हिस्सा होता है. हालांकि, असल ज़िंदगी के ऐप्लिकेशन के लिए, जनरेटिव एआई मॉडल को चालू करने से पहले और बाद में, आम तौर पर ज़्यादा काम करना पड़ता है. इसे दिखाने के लिए, Genkit में फ़्लो का कॉन्सेप्ट जोड़ा गया है. इसे फ़ंक्शन की तरह ही परिभाषित किया जाता है. हालांकि, इसमें निगरानी और आसानी से डिप्लॉय करने जैसी अन्य सुविधाएं भी जोड़ी गई हैं. ज़्यादा जानने के लिए, एआई वर्कफ़्लो तय करना लेख पढ़ें.

LLM का बेहतर इस्तेमाल

एलएलएम से ज़्यादा फ़ायदा पाने के लिए, आपके ऐप्लिकेशन में कुछ तकनीकों का इस्तेमाल किया जा सकता है.

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