Genkit Go और Nano Banana Pro का इस्तेमाल करके, फ़ोटो ठीक करने वाला ऐप्लिकेशन बनाना

1. परिचय

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

ऐप्लिकेशन लॉजिक को लागू करने के लिए, Genkit Go का इस्तेमाल किया जाएगा. साथ ही, फ़ोटो को प्रोसेस करने के लिए Gemini 3 Pro Image (इसे Nano Banana Pro भी कहा जाता है) का इस्तेमाल किया जाएगा.

ज़रूरी शर्तें

Go प्रोग्रामिंग लैंग्वेज की बुनियादी जानकारी
Google Cloud Console की बुनियादी जानकारी

आपको क्या सीखने को मिलेगा

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

आपको किन चीज़ों की ज़रूरत होगी

इस वर्कशॉप को पूरी तरह से Google Cloud Shell में किया जा सकता है. इसमें सभी ज़रूरी डिपेंडेंसी (gcloud सीएलआई, कोड एडिटर, Go, Gemini सीएलआई) पहले से इंस्टॉल होती हैं.

इसके अलावा, अगर आपको अपनी मशीन पर काम करना है, तो आपको इनकी ज़रूरत होगी:

Go टूलचेन (1.24 या इसके बाद का वर्शन)
Node.js v20 या इसके बाद का वर्शन (genkit CLI के लिए)
gcloud सीएलआई इंस्टॉल किया गया टर्मिनल
आपके पास अपने कोड में बदलाव करने के लिए, VS Code या इसी तरह का कोई IDE होना चाहिए
सुझाया गया: कोडिंग एजेंट, जैसे कि Gemini CLI या Antigravity

मुख्य टेक्नोलॉजी

हम जिन टेक्नोलॉजी का इस्तेमाल करेंगे उनके बारे में ज़्यादा जानकारी यहां दी गई है:

Gemini Nano Banana Pro (Gemini 3 Pro Image): यह मॉडल, इमेज को पहले जैसा करने की प्रोसेस को बेहतर बनाता है
Genkit Go: मॉडल कॉल को व्यवस्थित करने के लिए हमारी टूलकिट

2. एनवायरमेंट सेटअप करना

इनमें से कोई एक विकल्प चुनें: अगर आपको इस कोडलैब को अपनी मशीन पर चलाना है, तो अपने हिसाब से एनवायरमेंट सेटअप करें विकल्प चुनें. अगर आपको इस कोडलैब को पूरी तरह से क्लाउड में चलाना है, तो Cloud Shell शुरू करें विकल्प चुनें.

अपने हिसाब से एनवायरमेंट सेट अप करना

Google Cloud Console में साइन इन करें और नया प्रोजेक्ट बनाएं या किसी मौजूदा प्रोजेक्ट का फिर से इस्तेमाल करें. अगर आपके पास पहले से कोई Gmail या Google Workspace खाता नहीं है, तो आपको एक खाता बनाना होगा.

प्रोजेक्ट का नाम, इस प्रोजेक्ट में हिस्सा लेने वाले लोगों के लिए डिसप्ले नेम होता है. यह एक वर्ण स्ट्रिंग है, जिसका इस्तेमाल Google API नहीं करते. इसे कभी भी अपडेट किया जा सकता है.
प्रोजेक्ट आईडी, सभी Google Cloud प्रोजेक्ट के लिए यूनीक होता है. साथ ही, इसे बदला नहीं जा सकता. Cloud Console, यूनीक स्ट्रिंग को अपने-आप जनरेट करता है. आम तौर पर, आपको इससे कोई फ़र्क़ नहीं पड़ता कि यह क्या है. ज़्यादातर कोडलैब में, आपको अपने प्रोजेक्ट आईडी (आम तौर पर PROJECT_ID के तौर पर पहचाना जाता है) का रेफ़रंस देना होगा. अगर आपको जनरेट किया गया आईडी पसंद नहीं है, तो कोई दूसरा रैंडम आईडी जनरेट किया जा सकता है. इसके अलावा, आपके पास अपना नाम आज़माने का विकल्प भी है. इससे आपको पता चलेगा कि वह नाम उपलब्ध है या नहीं. इस चरण के बाद, इसे बदला नहीं जा सकता. यह प्रोजेक्ट की अवधि तक बना रहता है.
आपकी जानकारी के लिए बता दें कि एक तीसरी वैल्यू भी होती है, जिसे प्रोजेक्ट नंबर कहते हैं. इसका इस्तेमाल कुछ एपीआई करते हैं. इन तीनों वैल्यू के बारे में ज़्यादा जानने के लिए, दस्तावेज़ देखें.

इसके बाद, आपको Cloud Console में बिलिंग चालू करनी होगी, ताकि Cloud संसाधनों/एपीआई का इस्तेमाल किया जा सके. इस कोडलैब को पूरा करने में ज़्यादा समय नहीं लगेगा. इस ट्यूटोरियल के बाद बिलिंग से बचने के लिए, संसाधनों को बंद किया जा सकता है. इसके लिए, बनाए गए संसाधनों को मिटाएं या प्रोजेक्ट को मिटाएं. Google Cloud के नए उपयोगकर्ताओं को, 300 डॉलर का क्रेडिट मिलेगा. वे इसे मुफ़्त में आज़मा सकते हैं.

Cloud Shell शुरू करें

Google Cloud को अपने लैपटॉप से रिमोटली ऐक्सेस किया जा सकता है. हालांकि, इस कोडलैब में Google Cloud Shell का इस्तेमाल किया जाएगा. यह क्लाउड में चलने वाला कमांड लाइन एनवायरमेंट है.

Google Cloud Console में, सबसे ऊपर दाएं कोने में मौजूद टूलबार पर, Cloud Shell आइकॉन पर क्लिक करें:

Cloud Shell चालू करें

इसे चालू करने और एनवायरमेंट से कनेक्ट करने में सिर्फ़ कुछ सेकंड लगेंगे. यह प्रोसेस पूरी होने के बाद, आपको कुछ ऐसा दिखेगा:

Google Cloud Shell टर्मिनल का स्क्रीनशॉट. इसमें दिखाया गया है कि एनवायरमेंट कनेक्ट हो गया है

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

3. प्रोजेक्ट सेटअप करना

प्रोजेक्ट बनाना

सबसे पहले, हमें आपके प्रोजेक्ट के लिए एक नई डायरेक्ट्री बनानी होगी और Go मॉड्यूल को शुरू करना होगा. अपने टर्मिनल में, ये कमांड चलाएं:

mkdir -p glowup && cd glowup
go mod init glowup

Genkit CLI इंस्टॉल करना

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

curl -sL cli.genkit.dev | bash

एनवायरमेंट वैरिएबल कॉन्फ़िगर करना

पक्का करें कि आपने Google Cloud के क्रेडेंशियल सही तरीके से सेट अप किए हों. your-project-id की जगह अपना असल प्रोजेक्ट आईडी डालें. Gemini 3 Pro Preview मॉडल (Nano Banana Pro उनमें से एक है) का इस्तेमाल करते समय, जगह की जानकारी global होनी चाहिए.

export GOOGLE_CLOUD_PROJECT=$(gcloud config get project)
export GOOGLE_CLOUD_LOCATION=global

Vertex AI API चालू करने के लिए, शेल मोड में यह कमांड चलाएं:

gcloud services enable aiplatform.googleapis.com

अगर इसे CloudShell पर नहीं, बल्कि अपनी लोकल मशीन पर चलाया जा रहा है, तो आपको gcloud कमांड का इस्तेमाल करके पुष्टि करनी होगी:

gcloud auth application-default login

4. अपना पहला Genkit ऐप्लिकेशन बनाना

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

Genkit की शब्दावली

Genkit का इस्तेमाल शुरू करने से पहले, कुछ मुख्य शब्दों को समझना ज़रूरी है:

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

एआई मॉडल से कनेक्ट करना

Genkit, प्लगिन का इस्तेमाल करके, आपके कोड को मॉडल उपलब्ध कराने वाली कंपनियों से कनेक्ट करता है. Google, Anthropic, और OpenAI जैसी सभी मुख्य मॉडल प्रोवाइडर कंपनियों के लिए प्लगिन उपलब्ध हैं. प्लगिन का इस्तेमाल, लोकल मॉडल (जैसे, Ollama का इस्तेमाल करके) से कनेक्ट करने या Genkit की क्षमताओं को बढ़ाने (जैसे, MCP सर्वर से कनेक्ट करने) के लिए भी किया जा सकता है.

Google के मॉडल ऐक्सेस करने के लिए, आपको googlegenai प्लगिन का इस्तेमाल करना चाहिए. यह दो बैकएंड के साथ काम करता है:

Google AI: प्रोटोटाइप बनाने के लिए सबसे अच्छा है. यह कुकी, एपीआई पासकोड का इस्तेमाल करती है.
Vertex AI (Google Cloud): प्रोडक्शन के लिए इसका सुझाव दिया जाता है. यह कुकी, प्रोजेक्ट आईडी और जगह की जानकारी का इस्तेमाल करती है.

इस कोडलैब में, हम Vertex AI की पुष्टि करने के लिए उस प्रोजेक्ट का इस्तेमाल करेंगे जिसे आपने लैब की शुरुआत में बनाया था.

अभिवादन वाला फ़्लो बनाना

फ़ोटो को बेहतर बनाने की सुविधा के बारे में ज़्यादा जानने से पहले, आइए एक बुनियादी फ़्लो तैयार करें. इससे हमें इस सुविधा के कॉन्सेप्ट के बारे में जानने में मदद मिलेगी. साथ ही, यह पक्का किया जा सकेगा कि हमारा सेटअप ठीक से काम कर रहा है.

फ़्लो, Genkit का एक खास फ़ंक्शन है. यह आपके एआई लॉजिक को रैप करता है, ताकि ये सुविधाएं मिल सकें:

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

अपना IDE खोलें और अपने प्रोजेक्ट डायरेक्ट्री में main.go फ़ाइल बनाएं. Cloud Shell का इस्तेमाल करने पर, यह निर्देश इस्तेमाल किया जा सकता है:

cloudshell edit main.go

इसके बाद, यह कोड जोड़ें:

main.go

package main

import (
        "context"
        "log"
        "os"
        "os/signal"
        "syscall"

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

func main() {
        ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
        defer cancel()

        // Initialize Genkit with the Vertex AI plugin
        g := genkit.Init(ctx,
                genkit.WithPlugins(&googlegenai.VertexAI{}),
        )

        // Define the greeter flow
        genkit.DefineFlow(g, "greeter", func(ctx context.Context, name string) (string, error) {
                text, err := genkit.GenerateText(ctx, g,
                        ai.WithModelName("vertexai/gemini-2.5-pro"),
                        ai.WithPrompt("Say a warm and creative hello to %s", name),
                )
                if err != nil {
                        return "", err
                }

                return text, nil
        })

        // Register the flow here in the next steps
        log.Println("GlowUp initialized. Ready for flows.")
        <-ctx.Done()
}

फ़ाइल सेव करें. इसके बाद, अपनी डिपेंडेंसी अपडेट करने के लिए, go mod tidy चलाएं:

go mod tidy

ऊपर दिए गए कोड में, VertexAI प्लगिन के साथ Genkit को शुरू किया गया है. इसमें "greeter" नाम का फ़्लो तय किया गया है. इसके बाद, यह <-ctx.Done() पर हमेशा के लिए इंतज़ार करता है. हम इस प्रोग्राम को तुरंत बंद नहीं कर रहे हैं, क्योंकि हमने इसे फ़्लो को लागू करने के लिए कोई निर्देश नहीं दिया है.

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

genkit CLI को इसलिए डेवलप किया गया है, ताकि हम Genkit स्टैक के मॉडल, प्रॉम्प्ट, फ़्लो, और अन्य कॉम्पोनेंट की जाँच कर सकें. इसमें ट्रेसिंग की सुविधा भी उपलब्ध है. इससे यह समझने में आसानी होती है कि ऐप्लिकेशन कैसे काम कर रहा है. genkit CLI का इस्तेमाल करके, greeter फ़्लो लॉन्च करने के लिए यह कमांड चलाएं:

genkit start -- go run main.go

इससे Telemetry API और डेवलपर यूज़र इंटरफ़ेस (यूआई) के एंडपॉइंट शुरू हो जाएंगे. आपको कुछ ऐसा दिखेगा:

$ genkit start -- go run main.go
Telemetry API running on http://localhost:4033
Project root: /home/daniela/glowup
Genkit Developer UI: http://localhost:4000

अगर आपने Dev-UI लॉन्च करने के लिए, अपने ब्राउज़र पर localhost:4000 खोला है. आपको इस तरह की स्क्रीन दिखेगी:

Dev UI को एक्सप्लोर करने के लिए, समय निकालें. सिर्फ़ एक बार "ग्रीटर" फ़्लो को ट्रिगर करें, ताकि यह देखा जा सके कि यह कैसे काम करता है.

प्रॉम्प्ट टेंप्लेट का इस्तेमाल करना

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

प्रॉम्प्ट टेंप्लेट तय करने के लिए, Genkit ओपन सोर्स dotprompt फ़ॉर्मैट का इस्तेमाल करता है. इन्हें *.prompt फ़ाइलों के तौर पर सेव किया जाता है. .prompt फ़ाइल में दो हिस्से होते हैं:

फ़्रंटमैटर: यह एक YAML ब्लॉक होता है. इसमें मॉडल, मॉडल पैरामीटर, और इनपुट और आउटपुट, दोनों के स्कीमा तय किए जाते हैं
मुख्य हिस्सा: यह प्रॉम्प्ट का मुख्य हिस्सा होता है. इसे "हैंडलबार" सिंटैक्स का इस्तेमाल करके टेंप्लेट बनाया जा सकता है. उदाहरण के लिए, अगर आपने variable-name नाम का इनपुट तय किया है, तो उसे बॉडी में {{variable-name}} के तौर पर रेफ़रंस किया जा सकता है.

प्रोजेक्ट की डायरेक्ट्री का स्ट्रक्चर कुछ ऐसा दिखेगा:

glowup/
 ├── main.go        
 └── prompts/
      └── greeter.prompt

आइए, इसे इस्तेमाल करके देखते हैं. सबसे पहले, अपने प्रॉम्प्ट सेव करने के लिए फ़ोल्डर बनाएं:

mkdir -p prompts

इसके बाद, greeter.prompt फ़ाइल बनाएं:

cloudshell edit prompts/greeter.prompt

इसके बाद, यह कॉन्टेंट डालें:

greeter.prompt

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

कॉन्फ़िगरेशन सेक्शन की मदद से, मॉडल के पैरामीटर कॉन्फ़िगर किए जा सकते हैं. हम मॉडल को ज़्यादा क्रिएटिव बनाने के लिए, टेंपरेचर 1.9 का इस्तेमाल कर रहे हैं. तापमान 0 (ज़्यादा मिलते-जुलते आउटपुट) से लेकर 2 (ज़्यादा क्रिएटिव आउटपुट) तक होता है. इस और अन्य मॉडल पैरामीटर को आम तौर पर मॉडल की मॉडल शीट में पब्लिश किया जाता है. उदाहरण के लिए, यहां gemini-2.5-flash के लिए मॉडल शीट दी गई है.

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

अब, हम greeter फ़्लो को अडैप्ट करके, अभी बनाए गए प्रॉम्प्ट का इस्तेमाल करेंगे:

main.go

package main

import (
        "context"
        "os"
        "os/signal"
        "syscall"

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

func main() {
        ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
        defer cancel()

        // Initialize Genkit with the Vertex AI plugin
        g := genkit.Init(ctx,
                genkit.WithPlugins(&googlegenai.VertexAI{}),
                genkit.WithDefaultModel("vertexai/gemini-2.5-flash"),
        )

        // Define the greeter flow
        genkit.DefineFlow(g, "greeter", func(ctx context.Context, name *string) (string, error) {
                prompt := genkit.LookupPrompt(g, "greeter")

                input := map[string]any{
                        "name": name,
                }

                resp, err := prompt.Execute(ctx, ai.WithInput(input))
                if err != nil {
                        return "", err
                }
                return resp.Text(), nil
        })

        <-ctx.Done()
}

फ़र्क़ देखने के लिए, कमांड-लाइन से फ़्लो को नाम के साथ और नाम के बिना चलाकर देखें. बिना नाम के चल रहा है:

genkit flow:run greeter

आउटपुट का उदाहरण:

$ genkit flow:run greeter
Telemetry API running on http://localhost:4035
Running '/flow/greeter' (stream=false)...
Result:
"Hello there, absolutely delightful human!\n\nThe very moment your message arrived, the day instantly sparkled a little brighter. It's not just nice, it's genuinely **wonderful** to meet you!\n\nMay your entire day be filled with unexpected pockets of joy, effortless triumphs, and all the happiness you truly deserve! We're thrilled to have you here!"

साथ ही, नाम के साथ:

genkit flow:run greeter '{"name":"Daniela"}'

आउटपुट का उदाहरण:

$ genkit flow:run greeter '{"name":"Daniela"}'
Telemetry API running on http://localhost:4035
Running '/flow/greeter' (stream=false)...
Result:
"Well hello there, Daniela! What a truly beautiful name, and what an absolute pleasure it is to meet you!\n\nRight from this moment, I just know your day is going to be brimming with positive energy and wonderful surprises. May it be filled with brilliant ideas, joyful moments, and the delightful realization that you're an amazing person doing incredible things. So glad you're here!"

यहां देखा जा सकता है कि टेंप्लेट ने उम्मीद के मुताबिक काम किया. हम इस प्रोजेक्ट को अगले लेवल पर ले जाने के लिए तैयार हैं!

5. Nano Banana Pro की मदद से इमेज वापस लाना

घर पहले जैसा करने के लिए प्रॉम्प्ट

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

prompts डायरेक्ट्री में glowup.prompt नाम की फ़ाइल बनाएं और उसमें यह कॉन्टेंट चिपकाएं:

glowup.prompt

डेटा वापस लाने का अनुरोध करने वाला प्रॉम्प्ट, "ग्रीटर" प्रॉम्प्ट की तरह ही होता है. हालांकि, इन दोनों में कुछ खास अंतर होते हैं:

इमेज का साइज़: imageConfig की imageSize प्रॉपर्टी, Nano Banana Pro का मॉडल-स्पेसिफ़िक पैरामीटर है. इसकी मदद से, आउटपुट साइज़ को 1K, 2K या 4K के तौर पर सेट किया जा सकता है.
मीडिया इनपुट: हम {{ media }} टेम्पलेट का इस्तेमाल करके, उपयोगकर्ता के प्रॉम्प्ट में फ़ोटो जोड़ रहे हैं. इस तकनीक की मदद से, हम मॉडल को मल्टी-मॉडल प्रॉम्प्ट (टेक्स्ट + इमेज) भेज पाते हैं.

इस प्रॉम्प्ट को Dev UI पर टेस्ट किया जा सकता है. इसमें बदलाव करके देखें कि इससे आउटपुट पर क्या असर पड़ता है.

इमेज को वापस लाने का तरीका

डेटा वापस लाने का प्रॉम्प्ट तैयार होने के बाद, अब हम अपना सीएलआई ऐप्लिकेशन बनाएंगे. main.go के कॉन्टेंट की जगह नीचे दिया गया कोड डालें:

main.go

package main

import (
        "context"
        "encoding/base64"
        "errors"
        "flag"
        "fmt"
        "log"
        "mime"
        "os"
        "os/signal"
        "strings"
        "syscall"

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

func main() {
        url := flag.String("url", "", "url of the image to restore")
        contentType := flag.String("contentType", "image/jpeg", "content type of the image (default: image/jpeg)")
        flag.Parse()

        ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
        defer cancel()

        // Initialize Genkit with the Vertex AI plugin
        g := genkit.Init(ctx,
                genkit.WithPlugins(&googlegenai.VertexAI{}),
        )

        // Input schema for the glowUp flow
        type Input struct {
                URL         string `json:"url,omitempty"`
                ContentType string `json:"contentType,omitempty"`
        }

        glowup := genkit.DefineFlow(g, "glowUp", func(ctx context.Context, input Input) (string, error) {
                // 1. Retrieve prompt
                prompt := genkit.LookupPrompt(g, "glowup")
                if prompt == nil {
                        return "", errors.New("prompt 'glowup' not found")
                }

                resp, err := prompt.Execute(ctx, ai.WithInput(input))
                if err != nil {
                        return "", fmt.Errorf("generation failed: %w", err)
                }

                return resp.Media(), nil
        })

        // triggers the flow and returns the encoded response from the model
        out, err := glowup.Run(ctx, Input{URL: *url, ContentType: *contentType})
        if err != nil {
                log.Fatalln(err)
        }

        // decodes image data and returns the appropriate file extension
        data, ext, err := decode(out)
        if err != nil {
                log.Fatalln(err)
        }

        // writes restored file to disk
        filename := "restored" + ext
        if err := os.WriteFile(filename, data, 0644); err != nil {
                log.Fatalln(err)
        }
}

// decode returns the decoded data and the file extension appropriate for the mime type
func decode(text string) ([]byte, string, error) {
        if !strings.HasPrefix(text, "data:") {
                return nil, "", errors.New("unsupported enconding format")
        }
        text = strings.TrimPrefix(text, "data:")
        parts := strings.Split(text, ";base64,")

        mimeType := parts[0]
        decoded, err := base64.StdEncoding.DecodeString(parts[1])
        if err != nil {
                return nil, "", err
        }

        ext, err := mime.ExtensionsByType(mimeType)
        if err != nil {
                return nil, "", err
        }

        return decoded, ext[0], nil
}

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

हमें आउटपुट को डिकोड करना होगा, क्योंकि मॉडल इमेज डेटा को इस फ़ॉर्मैट में दिखाता है:

data:<mime type>;base64,<base64 encoded image>

decode फ़ंक्शन में देखा जा सकता है कि हम माइम टाइप और कोड में बदली गई इमेज के हिस्सों को अलग करने के लिए, स्ट्रिंग में बदलाव करने की सुविधा का इस्तेमाल कर रहे हैं. इसके बाद, हम mime.ExtensionByType और base64.DecodeString फ़ंक्शन का इस्तेमाल करके, फ़ाइल को सेव करने के लिए ज़रूरी जानकारी निकालते हैं.

डेटा वापस लाने के फ़्लो की जांच करना

अब इस फ़्लो को किसी असली फ़ोटो के साथ चलाने का समय आ गया है! अगर आपके पास कोई ऐसी पुरानी फ़ोटो नहीं है जिसे ठीक करने की ज़रूरत है, तो इस सार्वजनिक डोमेन वाली फ़ोटो को आज़माएं. इसे Library of Congress की वेबसाइट से लिया गया है:

फ़्लो में फ़ोटोग्राफ़ को पास करने के लिए, यहां उसका डायरेक्ट लिंक दिया गया है: https://tile.loc.gov/storage-services/service/pnp/fsa/8c01000/8c01700/8c01765v.jpg

export IMAGE_URL="https://tile.loc.gov/storage-services/service/pnp/fsa/8c01000/8c01700/8c01765v.jpg"
go run main.go --url $IMAGE_URL

यहां रंगीन किया गया और पहले जैसा किया गया आउटपुट दिया गया है:

हो गया!

6. glowUp को वेब सेवा के तौर पर डिप्लॉय करना

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

इन्हें सामान्य एचटीटीपी सर्वर के साथ दिखाया जा सकता है. इसके लिए, आपको स्टैंडर्ड लाइब्रेरी से http पैकेज का इस्तेमाल करना होगा. हालांकि, Genkit एक server प्लगिन भी उपलब्ध कराता है. यह प्लगिन, सर्वर के कुछ सामान्य बॉयलरप्लेट में मदद करता है. जैसे, शटडाउन सिग्नल को आसानी से हैंडल करना.

अपना वेब सर्वर बनाने के लिए, main.go के कॉन्टेंट को नीचे दिए गए कोड से बदलें.

package main

import (
        "context"
        "errors"
        "fmt"
        "log"
        "net/http"
        "os"

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

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

        PORT := os.Getenv("PORT")
        if PORT == "" {
                PORT = "8080"
        }

        listenAddr := ":" + PORT

        // Initialize Genkit with the Vertex AI plugin
        g := genkit.Init(ctx,
                genkit.WithPlugins(&googlegenai.VertexAI{}),
        )

        // Input schema for the glowUp flow
        type Input struct {
                URL         string `json:"url,omitempty"`
                ContentType string `json:"contentType,omitempty"`
        }

        genkit.DefineFlow(g, "glowUp", func(ctx context.Context, input Input) (string, error) {
                prompt := genkit.LookupPrompt(g, "glowup")
                if prompt == nil {
                        return "", errors.New("prompt 'glowup' not found")
                }

                resp, err := prompt.Execute(ctx, ai.WithInput(input))
                if err != nil {
                        return "", fmt.Errorf("generation failed: %w", err)
                }

                return resp.Media(), nil
        })

        log.Printf("GlowUp Flow Server started. Listening on %s", listenAddr)
        mux := http.NewServeMux()
        for _, flow := range genkit.ListFlows(g) {
                mux.HandleFunc("POST /"+flow.Name(), genkit.Handler(flow))
        }

        if err := server.Start(ctx, listenAddr, mux); err != nil {
                // Check if the error is due to context cancellation
                if ctx.Err() != nil {
                        log.Println("GlowUp server shutting down gracefully...")
                        return
                }
                log.Fatal(err)
        }
}

इस सेवा को स्थानीय तौर पर या क्लाउड में चलाया जा सकता है. इसे स्थानीय तौर पर चलाने के लिए, फ़ाइल को सीधे तौर पर चलाया जा सकता है. ऐसा इसलिए, क्योंकि अब प्रोग्राम पूरा हो गया है. इसलिए, हमें इसे genkit CLI के ज़रिए लॉन्च करने की ज़रूरत नहीं है. उदाहरण के लिए:

go run main.go

यह एक ब्लॉकिंग ऑपरेशन है. इसलिए, इसे आज़माने के लिए आपको दूसरा टर्मिनल लॉन्च करना होगा. curl कमांड का इस्तेमाल करके, इसे तुरंत किया जा सकता है:

curl -sS -X POST http://localhost:8080/glowUp \
     -H "Content-Type: application/json" \
     -d '{"data":{"url": $IMAGE_URL, "contentType":"image/jpeg"}}' \
     > result.json

यह सर्वर का जवाब है. इसलिए, हमें base64 इमेज को डिकोड करना होगा:

cat result.json | jq -r '.result' | awk -F ',' '{print $2}' | base64 -d > restored.png

वेब सेवा को Cloud Run पर डिप्लॉय करना

यह ठीक है कि यह सर्वर "मेरी मशीन पर काम करता है". हालांकि, हम इसे किसी ऐसी जगह पर डिप्लॉय करेंगे जहां हमारे सभी उपयोगकर्ता इसे ऐक्सेस कर सकें. इस तरह की सेवाओं को डिप्लॉय करने का सबसे आसान तरीका, Cloud Run की 'सोर्स से डिप्लॉय करें' सुविधा का इस्तेमाल करना है. इस सुविधा की मदद से, आपको कंटेनर बनाने की भी ज़रूरत नहीं होती. सब कुछ अपने-आप होता है.

सोर्स से डिप्लॉयमेंट का इस्तेमाल करके, इस सेवा को Cloud Run पर डिप्लॉय करने के लिए, यह निर्देश चलाएं. प्रोजेक्ट आईडी की जगह अपना प्रोजेक्ट आईडी डालें:

gcloud run deploy glowup --source . --region us-central1 --no-allow-unauthenticated --set-env-vars GOOGLE_GENAI_USE_VERTEXAI=True,GOOGLE_CLOUD_LOCATION=$GOOGLE_CLOUD_LOCATION,GOOGLE_CLOUD_PROJECT=$GOOGLE_CLOUD_PROJECT

इस प्रोसेस को पूरा होने में कुछ मिनट लग सकते हैं. इसके बाद, curl के ज़रिए दूसरा अनुरोध भेजकर, एंडपॉइंट की जांच की जा सकती है:

GLOWUP_URL=$(gcloud run services describe glowup --region us-central1 --format='value(status.url)')

curl -X POST "$GLOWUP_URL/glowUp" \
     -H "Authorization: Bearer $(gcloud auth print-identity-token)" \
     -H "Content-Type: application/json" \
     -d "{\"data\":{\"url\":\"$IMAGE_URL\", \"contentType\":\"image/jpeg\"} }" \
     > result.json

हमें base64 इमेज को फिर से डिकोड करना होगा:

cat result.json | jq -r '.result' | awk -F ',' '{print $2}' | base64 -d > restored_cloudrun.png

अब हमारे पास फ़ोटो वापस लाने वाला वेब सर्वर पूरी तरह से काम कर रहा है!

ज़रूरी नहीं: क्लाइंट ऐप्लिकेशन की "वाइब कोडिंग" करना

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

इस चरण में, हम खुद कोड लिखने के बजाय, Gemini CLI (या आपके पसंदीदा कोडिंग एजेंट) से यह काम करने के लिए कहेंगे. इस प्रॉम्प्ट का इस्तेमाल करें:

GlowUp is a photo restoration service that takes a restoration request as input and returns a restored picture as output. Your task is to create a client application that uses this server to process image urls and save a restored file locally.

TODO:
- Write a CLI application that receives three arguments: an url (required), content type (optional, defaults to image/jpeg) and addr (server address, optional, defaults to localhost:8080)
- The CLI should send a POST request to the /glowUp endpoint in the server with the body '{"data":{"url": <url>, "contentType": <contentType>} }'
- The server response should be parsed by stripping the "data:" prefix. The remainder will have the format <mimeType>;base64,<encoded imageData>
- Extract the mime type and convert to a file extension using the mime package
- Extract the image data and decode it using the base64 package
Save a file named "restored" + the detected file extension

Acceptance Criteria:
- The client builds successfully
- Use the client to restore the image https://tile.loc.gov/storage-services/service/pnp/fsa/8c01000/8c01700/8c01765v.jpg
- Check that restored.png exists after processing the image above

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

लैब के बाद की सफ़ाई

7. नतीजा

बधाई हो! आपने Genkit और Nano Banana Pro का इस्तेमाल करके, फ़ोटो को बेहतर बनाने वाला ऐप्लिकेशन बना लिया है,

इस कोडलैब में, आपने इन कामों को करने का तरीका सीखा:

Genkit Go ऐप्लिकेशन डेवलप करने के लिए, अपना एनवायरमेंट कॉन्फ़िगर करना
dotprompt की मदद से मल्टी-मॉडल प्रॉम्प्ट बनाना
प्रॉम्प्ट टेंप्लेट का इस्तेमाल करके Genkit फ़्लो बनाना
इमेज प्रोसेस करने के लिए, Nano Banana Pro का इस्तेमाल करना
Genkit फ़्लो को कमांड-लाइन ऐप्लिकेशन और वेब सेवाओं के तौर पर पैकेज करना
Genkit ऐप्लिकेशन को Cloud Run पर डिप्लॉय करना

जांच पूरी होने के बाद, एनवायरमेंट को साफ़ करना न भूलें.

अगले चरण

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

अगर आपको बेहतर बनाने से जुड़े कुछ आइडिया चाहिए, तो ये तरीके आज़माएं:

लोकल फ़ाइलों को वापस लाने के लिए, glowUp CLI को चालू करें
GlowUp वेब सेवा के लिए फ़्रंटएंड बनाएं
डेटा से MIME टाइप का अपने-आप पता लगाना
इमेज प्रोसेसिंग के अन्य काम करना. जैसे, फ़ोटो को ड्रॉइंग में बदलना, ड्रॉइंग को फ़ोटो में बदलना, स्केच को फ़ाइनल आर्ट में बदलना वगैरह.
क्लाइंट बनाना या उसे बेहतर बनाना (क्या कोई स्मार्टफ़ोन ऐप्लिकेशन बनाया जा सकता है?)

खरीदारी की सुविधा वाले कई तरह के वीडियो बनाए जा सकते हैं! अगर आपको खुद से कोडिंग करने में मुश्किल हो रही है, तो Gemini CLI या Antigravity जैसे कोडिंग एजेंट की मदद ली जा सकती है. अगर आपको Genkit का ज़्यादा से ज़्यादा फ़ायदा पाना है, तो कोडिंग एजेंट के साथ Genkit MCP Server का इस्तेमाल करें. इससे आपको काफ़ी मदद मिलेगी.

आखिर में, अगर आपको इस रेपो का पूरा कोड ऐक्सेस करना है, तो इसे यहां देखा जा सकता है.

कोडिंग करते रहें!