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 CLI, कोड एडिटर, Go, Gemini CLI) पहले से इंस्टॉल होती हैं.

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

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

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

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

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

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

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

अपनी रफ़्तार से एनवायरमेंट सेटअप करना

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

295004821bab6a87.png37d264871000675d.png96d86d3d5655cdbe.png

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

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

curl -sL cli.genkit.dev | bash

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

पक्का करें कि आपने Google Cloud के सही क्रेडेंशियल सेट अप किए हों. 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 एक ओपन-सोर्स फ़्रेमवर्क है. इसे डेवलपर की मदद करने के लिए डिज़ाइन किया गया है, ताकि वे एआई की मदद से काम करने वाले ऐप्लिकेशन बना सकें, उन्हें डिप्लॉय कर सकें, और मॉनिटर कर सकें. इस सेक्शन में, हम एक आसान "नमस्ते" ऐप्लिकेशन बनाएंगे. इससे आपको फ़ोटो को बेहतर बनाने के लॉजिक के बारे में जानने से पहले, फ़्रेमवर्क को समझने में मदद मिलेगी.

Genkit की शब्दावली

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

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

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

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

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

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

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

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

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

फ़्लो, 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 सीएलआई को Genkit स्टैक के मॉडल, प्रॉम्प्ट, फ़्लो, और अन्य कॉम्पोनेंट की जांच करने के लिए डेवलप किया गया था. इसमें ट्रेस के लिए भी पूरा सपोर्ट मिलता है. इससे यह समझने में आसानी होती है कि ऐप्लिकेशन कैसे काम कर रहा है. genkit सीएलआई का इस्तेमाल करके, हमारा ग्रीटर फ़्लो लॉन्च करने के लिए, यह कमांड चलाएं:

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 खोला जाता है. आपको कुछ इस तरह की स्क्रीन दिखेगी:

93d9bd9e1bd6627d.png

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

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

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

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

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

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

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

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

mkdir -p prompts

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

cloudshell edit prompts/greeter.prompt

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

greeter.prompt

ec9fc82a98604123.png

इस प्रॉम्प्ट में, टेंप्लेट की भाषा की कुछ सुविधाओं के बारे में बताया गया है. सबसे पहले, हम फ़्रंटमैटर में मॉडल 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 '"Daniela"'

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

$ genkit flow:run greeter '"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 की मदद से इमेज वापस लाना

The Restoration Prompt

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

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

glowup.prompt

fd0f1551466c8138.png

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

  • इमेज का साइज़: 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 वेबसाइट से ली गई इस सार्वजनिक डोमेन फ़ोटो का इस्तेमाल करके देखें:

f0fc83a81e88052a.png

फ़्लो में पास करने के लिए, फ़ोटो का डायरेक्ट लिंक यहां दिया गया है: 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

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

5ed7bfcf6d26313c.png

हो गया!

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

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

इन्हें सामान्य एचटीटीपी सर्वर के साथ एक्सपोज़ किया जा सकता है. इसके लिए, स्टैंडर्ड लाइब्रेरी से 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 सीएलआई के ज़रिए लॉन्च करने की ज़रूरत नहीं है. उदाहरण के लिए:

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

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

लैब के बाद क्लीनअप करना

7. नतीजा

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

इस कोडलैब में आपने ये चीज़ें सीखी हैं:

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

टेस्टिंग पूरी होने के बाद, एनवायरमेंट को क्लीन अप करना न भूलें.

अगले चरण

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

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

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

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

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

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