Google ADK की मदद से एआई एजेंट बनाना

1. परिचय

इस कोडलैब में, Google के Agent Development Kit (ADK) और Gemini का इस्तेमाल करके, अपना पहला एआई एजेंट बनाने का तरीका बताया गया है. आपको एक बुनियादी ब्लॉग-लेखन एजेंट बनाना होगा. यह एजेंट, कॉन्टेंट की योजना बनाता है और उसे लिखता है. साथ ही, इसमें तर्क करने और कार्रवाई करने के मुख्य सिद्धांतों को दिखाया जाता है.

आपको क्या करना होगा

• ADK के लिए डेवलपमेंट एनवायरमेंट सेट अप करें.
• प्लानर और राइटर की मदद से मल्टी-एजेंट सिस्टम बनाएं.
• एजेंट को स्थानीय तौर पर चलाएं और ADK के वेब यूज़र इंटरफ़ेस (यूआई) के ज़रिए उससे इंटरैक्ट करें.

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

• कोई वेब ब्राउज़र, जैसे कि Chrome.
• आपकी मशीन पर Python 3.10 या इसके बाद का वर्शन इंस्टॉल होना चाहिए.
• Google AI Studio API कुंजी.

यह कोडलैब, सभी लेवल के डेवलपर के लिए है. इसमें शुरुआती डेवलपर भी शामिल हैं.

अनुमानित अवधि: 30 मिनट.

2. विज़ुअल गाइड: एआई एजेंट क्या होते हैं?

बनाना शुरू करने से पहले, आइए जानते हैं कि एआई एजेंट क्या होते हैं और वे किन सामान्य पैटर्न को फ़ॉलो करते हैं.

एआई एजेंट क्या है?

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

इस बारे में सबसे सटीक जानकारी, ReAct: Synergizing Reasoning and Acting in Language Models रिसर्च पेपर में दी गई है. उस पेपर में बताया गया आइडिया आसान होने के साथ-साथ असरदार भी था: भाषा मॉडल को सिर्फ़ एक बार में टेक्स्ट जनरेट नहीं करना चाहिए. वे असल में, एक-एक करके तर्क दे सकते हैं. साथ ही, टूल या एपीआई को कॉल करने जैसा कोई ऐक्शन ले सकते हैं, नतीजे देख सकते हैं, और फिर यह तय कर सकते हैं कि आगे क्या करना है.

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

एजेंट के व्यवहार के तीन पैटर्न

सभी एजेंट एक जैसा व्यवहार नहीं करते. इनके बारे में सोचने का एक अच्छा तरीका यह है कि इन्हें तीन मुख्य पैटर्न में बांटा जाए:

1. सीक्वेंशियल एजेंट: ये एक के बाद एक काम करते हैं, जैसे कि असेंबली लाइन: पहला चरण, फिर दूसरा चरण, फिर तीसरा चरण. इनके बारे में अनुमान लगाया जा सकता है, लेकिन ये स्थिर होते हैं.
2. सजग एजेंट: ये एजेंट, तुरंत फ़ैसला लेते हैं. वे मौजूदा स्थिति को देखते हैं और पूछते हैं कि ‘मुझे आगे क्या करना चाहिए?' ऐसा हो सकता है कि एक बार टूल A का इस्तेमाल किया जाए और अगली बार टूल B का. ये लचीले होते हैं, लेकिन पहले से कोई प्लान नहीं बनाते.
3. सोच-विचार करने वाले या प्लान बनाने वाले एजेंट: ये किसी प्लान को बनाने के लिए कुछ समय लेते हैं. इसके बाद, उसे लागू करते हैं. यात्रा की बुकिंग के बारे में सोचें — आप सिर्फ़ फ़्लाइट की टिकट नहीं खरीदते हैं, बल्कि तारीखें चुनते हैं, होटल चुनते हैं, चरणों को क्रम में लगाते हैं, और फिर उन्हें पूरा करते हैं.

इनमें से कौनसा तरीका ‘सही' है? यह समस्या पर निर्भर करता है. आसान और अनुमानित फ़्लो के लिए, क्रम से काम करने वाला तरीका ठीक है. डाइनैमिक टास्क के लिए, प्रतिक्रिया देने वाला तरीका बेहतर काम करता है. एक से ज़्यादा चरणों वाले ऐसे लक्ष्यों के लिए जिनमें निर्भरताएं होती हैं, आपको प्लानिंग एजेंट की ज़रूरत होती है.

इस लैब में, हम एक सोच-विचार/प्लानिंग करने वाला एजेंट बना रहे हैं. यह एजेंट, पहले एक आउटलाइन बनाता है और फिर ब्लॉग पोस्ट लिखता है!

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

Google Cloud खाता और प्रोजेक्ट बनाना

इस लैब में बाद में अपने एजेंट को Google Cloud Run पर डिप्लॉय करने के लिए, आपके पास Google Cloud खाता और बिलिंग की सुविधा चालू वाला प्रोजेक्ट होना चाहिए.

1. Google Cloud Console में साइन इन करें. कोई नया प्रोजेक्ट बनाएं या किसी मौजूदा प्रोजेक्ट का फिर से इस्तेमाल करें. अगर आपके पास Google खाता नहीं है, तो आपको एक खाता बनाना होगा.
2. इसके बाद, Cloud संसाधनों का इस्तेमाल करने के लिए, आपको Cloud Console में बिलिंग चालू करनी होगी. इस कोडलैब को पूरा करने में कुछ सेंट से ज़्यादा खर्च नहीं होना चाहिए. Google Cloud के नए उपयोगकर्ताओं को, मुफ़्त में आज़माने के लिए 300 डॉलर का क्रेडिट भी मिल सकता है.
3. अपना प्रोजेक्ट आईडी नोट करें. यह सभी Google Cloud प्रोजेक्ट के लिए यूनीक नाम होता है. आपको एजेंट को कॉन्फ़िगर और डिप्लॉय करने के लिए इसकी ज़रूरत होगी.

Google AI Studio का एपीआई पासकोड पाना

Gemini मॉडल का इस्तेमाल करने के लिए, आपको Google AI Studio से एपीआई पासकोड की ज़रूरत होगी.

1. Google AI Studio पर जाएं.
2. एपीआई पासकोड पाएं पर क्लिक करें.
3. नई कुंजी बनाएं या किसी मौजूदा कुंजी का इस्तेमाल करें. बाद में इस्तेमाल करने के लिए, कुंजी को कॉपी करें.

4. ब्लॉग लिखने वाले एजेंट के प्रोजेक्ट का स्ट्रक्चर बनाना

इस चरण में, आपको अपनी लोकल मशीन पर डायरेक्ट्री और फ़ाइलें सेट अप करनी होंगी. इनमें आपके ब्लॉग लिखने वाले एजेंट का कोड होगा.

1. ब्लॉग लिखने वाले एजेंट का वर्कस्पेस बनाना

अपने टर्मिनल को खोलें और अपने ब्लॉग-राइटर एजेंट के लिए एक डायरेक्ट्री बनाने के लिए, यहां दिए गए निर्देशों को चलाएं. इसके बाद, उस डायरेक्ट्री पर जाएं:

mkdir bloggeragent
cd bloggeragent

2. एजेंट की फ़ाइलें शुरू करना

Google ADK फ़्रेमवर्क, एजेंट के वर्कफ़्लो को सीधे तौर पर आपकी प्रोजेक्ट डायरेक्ट्री से लोड करता है. ज़रूरी फ़ाइलें सीधे तौर पर bloggeragent की रूट डायरेक्ट्री में बनाएं:

touch requirements.txt .env __init__.py agent.py

5. डिपेंडेंसी इंस्टॉल करना और एनवायरमेंट सेट अप करना

इस चरण में, आपको Python वर्चुअल एनवायरमेंट सेट अप करना होगा. साथ ही, Google ADK फ़्रेमवर्क इंस्टॉल करना होगा. इसके अलावा, आपको एनवायरमेंट वैरिएबल कॉन्फ़िगर करने होंगे, ताकि Gemini मॉडल के साथ अपने ब्लॉग एजेंट की पुष्टि की जा सके.

1. एजेंट से जुड़ी ज़रूरी शर्तें कॉन्फ़िगर करना

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

google-adk==2.2.0
python-dotenv

2. एजेंट के लिए वर्चुअल एनवायरमेंट बनाना

एजेंट के पैकेज को अलग करने के लिए, bloggeragent डायरेक्ट्री में Python का वर्चुअल एनवायरमेंट बनाएं और उसे चालू करें:

python3 -m venv .venv
source .venv/bin/activate

3. ADK फ़्रेमवर्क इंस्टॉल करना

Google ADK को अपने लोकल वर्कस्पेस में इस्तेमाल करने के लिए, requirements.txt में तय की गई डिपेंडेंसी इंस्टॉल करें:

pip install -r requirements.txt

4. एजेंट के एपीआई क्रेडेंशियल कॉन्फ़िगर करना

प्रोजेक्ट रूट में बनाई गई .env फ़ाइल खोलें और उसमें Gemini API का पासकोड जोड़ें:

GOOGLE_API_KEY=your_api_key

your_api_key की जगह, Google AI Studio से कॉपी किया गया पासकोड डालें.

मॉडल के नाम और एंडपॉइंट के बारे में जानकारी:

मॉडल चुनना: agent.py में मौजूद एजेंट कोड, डिफ़ॉल्ट रूप से gemini-flash-latest का इस्तेमाल करता है. Google ADK के दस्तावेज़ में "शुरू करें" सेक्शन में बताया गया है कि इस सिलेक्टर एलियास की मदद से, आपका ऐप्लिकेशन Gemini Flash के सबसे नए स्टेबल मॉडल का इस्तेमाल अपने-आप कर सकता है. अगर आपको किसी दूसरे मॉडल (जैसे कि Pro मॉडल या वर्शन वाला कोई मॉडल) का इस्तेमाल करना है, तो इस डिफ़ॉल्ट सेटिंग को बदला जा सकता है. इसके लिए, अपने टर्मिनल या कंटेनर की सेटिंग में MODEL एनवायरमेंट वैरिएबल सेट करें. इसे .env फ़ाइल में रखने की ज़रूरत नहीं है, क्योंकि कोड सीधे सिस्टम एनवायरमेंट वैरिएबल को पढ़ता है.

एंडपॉइंट और लेटेन्सी: डिफ़ॉल्ट रूप से, यह सेटअप Google AI Studio के ग्लोबल एंडपॉइंट का इस्तेमाल करता है. प्रोडक्शन वर्कलोड के लिए, लेटेन्सी बहुत ज़रूरी होती है. इसलिए, आपको जनरेटिव एआई कॉल को अपने वर्कलोड के आस-पास के Gemini Enterprise के रीजनल एंडपॉइंट (जैसे, us-east1 या us-west1) के ज़रिए रूट करना चाहिए. रीजनल उपलब्धता और कुछ मॉडल के होस्ट किए जाने की जगह के बारे में ज़्यादा जानने के लिए, Gemini Enterprise Agent Platform के मॉडल से जुड़ी गाइड देखें.

6. मल्टी-एजेंट ब्लॉग राइटर बनाना

इस चरण में, आपको ब्लॉग लिखने वाले एजेंट सिस्टम के मुख्य वर्कफ़्लो को लागू करना होगा.

इस कोर्स में, आपको एक सामान्य चैटबॉट बनाने के बजाय, एक जटिल मल्टी-एजेंट सिस्टम बनाना होगा. यह सिस्टम, खुद को ठीक करने वाले लूप और आउटलाइन की पुष्टि करने की सुविधा का इस्तेमाल करके, बेहतरीन क्वालिटी वाली तकनीकी पोस्ट लिखता है. यह सोच-विचार करने/प्लान बनाने के उस पैटर्न पर आधारित है जिसके बारे में हमने पहले चर्चा की थी.

आर्किटेक्चर के बारे में खास जानकारी

यहां बताया गया है कि आपके सिस्टम में विशेषज्ञ एजेंट कैसे इंटरैक्ट करते हैं:

init.py को कॉन्फ़िगर करना

अपने टेक्स्ट एडिटर में __init__.py खोलें और एजेंट के वर्कफ़्लो को रनर के लिए उपलब्ध कराने के लिए, यह इंपोर्ट जोड़ें:

from . import agent

ब्लॉग लिखने वाले एजेंट का वर्कफ़्लो लिखो

अपने कोड एडिटर में agent.py खोलें और यहां दिया गया कोड जोड़ें. यह कोड, प्लानर, राइटर, पुष्टि करने वाले टूल, और मुख्य ब्लॉगर एजेंट के बारे में बताता है:

import os
import sys
from pathlib import Path
import datetime

from dotenv import load_dotenv
from google.adk.agents import Agent, LoopAgent
from google.adk.tools import agent_tool

# env config
load_dotenv()

MODEL = os.getenv("MODEL", "gemini-flash-latest")

# Sub-Agent: Planner
blog_planner = Agent(
   name="BlogPlanner",
   model=MODEL,
   description="Creates a practical, skimmable outline in Markdown.",
   instruction="""
You are a technical content strategist. Produce a clear Markdown outline with:
- Title
- Short intro
- 4–6 main sections (each with 2–3 bullets)
- Conclusion

If `codebase_context` exists in state, weave in specific sections/snippets.
Return only the outline in Markdown.
""",
   output_key="blog_outline",
)

class OutlineValidationChecker(Agent):
   def __init__(self):
       super().__init__(
           name="OutlineValidationChecker",
           model=MODEL,
           description="Validates that the outline is usable.",
           instruction="""
Check the outline in state `blog_outline`. If it has a title, intro, 4–6 sections, and a conclusion, respond exactly "ok".
Otherwise respond exactly "retry" and list missing pieces.
""",
           output_key="validation_result",
       )

robust_blog_planner = LoopAgent(
   name="RobustBlogPlanner",
   description="Retries planning if validation fails.",
   sub_agents=[blog_planner, OutlineValidationChecker()],
   max_iterations=3,
)

# Sub-Agent: Writer
blog_writer = Agent(
   name="BlogWriter",
   model=MODEL,
   description="Writes a technical blog post from the outline.",
   instruction="""
Write a complete Markdown article from the outline in `blog_outline`.

Guidelines:
- Audience: software engineers; skip basics and focus on practical insight.
- Explain both the 'how' and 'why'.
- Include concise code snippets when helpful.
- Follow the outline's structure (H2/H3).
- Output only the final article in Markdown (no fence around the whole post).
""",
   output_key="blog_post",
)

class BlogPostValidationChecker(Agent):
   def __init__(self):
       super().__init__(
           name="BlogPostValidationChecker",
           model=MODEL,
           description="Validates the final post.",
           instruction="""
Check `blog_post` for: intro, clear sections matching the outline, conclusion, and technical clarity.
If passes, respond "ok". Else respond "retry" with the specific fixes.
""",
           output_key="validation_result",
       )

robust_blog_writer = LoopAgent(
   name="RobustBlogWriter",
   description="Retries writing if validation fails.",
   sub_agents=[blog_writer, BlogPostValidationChecker()],
   max_iterations=3,
)

# Expose planner/writer as tools so the root agent can call them explicitly
planner_tool = agent_tool.AgentTool(agent=robust_blog_planner)
writer_tool  = agent_tool.AgentTool(agent=robust_blog_writer)

# Root Agent: Plan → Write 
root_agent = Agent(
   name="Blogger",
   model=MODEL,
   description="Minimal multi-agent blogger that plans and writes.",
   instruction=f"""
If the user gives a topic:
1) Call the planner tool to generate the outline.
2) Call the writer tool to produce the full draft.
3) End with 3 alternate titles and 2 tweet-length hooks.

Date: {datetime.datetime.now().strftime("%Y-%m-%d")}
""",
   tools=[
       planner_tool, # calls RobustBlogPlanner
       writer_tool,  # calls RobustBlogWriter
   ],
)

एजेंट के आर्किटेक्चर के बारे में जानकारी

आइए, agent.py में जोड़े गए कोड के मुख्य कॉम्पोनेंट के बारे में जानते हैं. इससे आपको यह समझने में मदद मिलेगी कि यह कोड, मल्टी-एजेंट प्लानिंग और लिखने के वर्कफ़्लो को कैसे लागू करता है:

1. The BlogPlanner Sub-Agent

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

2. The OutlineValidationChecker

OutlineValidationChecker एजेंट, क्वालिटी गेट के तौर पर काम करता है. यह स्थिति में जनरेट किए गए "blog_outline" की समीक्षा करता है. अगर आउटलाइन मान्य है, तो यह "ok" के साथ जवाब देता है. अगर ऐसा नहीं होता है, तो यह "retry" के साथ-साथ, उन चीज़ों की सूची दिखाता है जो मौजूद नहीं हैं.

3. RobustBlogPlanner लूप

एजेंट को खराब आउटलाइन बनाने से रोकने के लिए, हम प्लानर और पुष्टि करने वाले टूल को LoopAgent में रैप करते हैं. इसे robust_blog_planner कहा जाता है. अगर पुष्टि नहीं हो पाती है और "retry" दिखता है, तो लूप, प्लानर को अपने-आप तीन बार चलाता है. इससे यह पक्का होता है कि अगले चरण पर जाने से पहले, गड़बड़ी ठीक हो गई है.

4. The BlogWriter Sub-Agent

आउटलाइन फ़ाइनल होने के बाद, blog_writer एजेंट, स्थिति से "blog_outline" को पढ़ता है. इसके बाद, वह पूरी तकनीकी जानकारी वाला लेख Markdown फ़ॉर्मैट में जनरेट करता है. यह लेख, आउटलाइन के स्ट्रक्चर से मेल खाता है और इसे सॉफ़्टवेयर इंजीनियर के हिसाब से तैयार किया जाता है.

5. BlogPostValidationChecker और RobustBlogWriter लूप

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

6. लूप को टूल के तौर पर इस्तेमाल करना

हम AgentTool का इस्तेमाल करके, प्लानर लूप (robust_blog_planner) और राइटर लूप (robust_blog_writer) को टूल (planner_tool और writer_tool) के तौर पर रैप करते हैं. इससे अन्य एजेंट, इन जटिल वर्कफ़्लो को ऐसे कॉल कर सकते हैं जैसे वे सामान्य टूल हों.

7. Blogger का रूट एजेंट

root_agent (नाम Blogger) पूरे वर्कफ़्लो को व्यवस्थित करता है. किसी विषय के बारे में निर्देश मिलने पर, Gemini इन कामों को पूरा करता है:

1. पुष्टि की गई आउटलाइन जनरेट करने के लिए, planner_tool को कॉल करें.
2. writer_tool से उस आउटलाइन के आधार पर ड्राफ़्ट लिखने के लिए कहें.
3. इसके बाद, तीन वैकल्पिक टाइटल और दो ट्वीट हुक जनरेट करें.

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

7. एजेंट को चलाना और उसकी जांच करना

अब समय आ गया है कि आप अपने एजेंट को काम करते हुए देखें!

1. ADK वेब यूज़र इंटरफ़ेस (यूआई) शुरू करना

पक्का करें कि आप अपने टर्मिनल में bloggeragent प्रोजेक्ट की रूट डायरेक्ट्री में हों और आपका वर्चुअल एनवायरमेंट चालू हो (source .venv/bin/activate). इसके बाद, वेब इंटरफ़ेस शुरू करें:

adk web

अगर पोर्ट 8000 पहले से इस्तेमाल किया जा रहा है, तो --port 8001 का इस्तेमाल करके कोई दूसरा पोर्ट तय किया जा सकता है. अगर adk कमांड नहीं मिलती है, तो पक्का करें कि आपका वर्चुअल एनवायरमेंट चालू हो और पैकेज सही तरीके से इंस्टॉल किया गया हो.

2. एजेंट के साथ इंटरैक्ट करना

1. अपना ब्राउज़र खोलें और http://127.0.0.1:8000 (या आपने जो पोर्ट तय किया है) पर जाएं.
2. आपको ADK का वेब यूज़र इंटरफ़ेस (यूआई) दिखेगा. इसमें Blogger एजेंट लोड किया गया होगा और उसका विज़ुअल लेआउट दिखेगा. इसमें Blogger के रूट एजेंट को RobustBlogPlanner और RobustBlogWriter टूल की ओर पॉइंट करते हुए दिखाया गया है:
3. मैसेज बॉक्स में कोई तकनीकी विषय टाइप करें और Enter दबाएं. यहां कुछ दिलचस्प टेस्ट प्रॉम्प्ट दिए गए हैं. इनका इस्तेमाल करके, अपने एजेंट का आकलन किया जा सकता है:
   • How to build an AI agent using planning loops
   • Explain the difference between REST and gRPC in microservices
   • A guide to using Python's asyncio for backend concurrency
   • Why developers should use Docker for local database setups
4. यूज़र इंटरफ़ेस (यूआई) में, स्क्रिप्ट के एक्ज़ीक्यूशन का ट्रेस देखें. आपको दिखेगा कि BlogPlanner आउटलाइन बनाता है, OutlineValidationChecker उसकी पुष्टि करता है, और BlogWriter आउटलाइन के आधार पर फ़ाइनल ड्राफ़्ट लिखता है:

8. Cloud Run पर डिप्लॉय करना

आपने पुष्टि कर ली है कि एजेंट स्थानीय तौर पर काम करता है. अब इसे Google Cloud Run पर डिप्लॉय करते हैं, ताकि दूसरे लोग इसका इस्तेमाल कर सकें!

Google Cloud Run, मैनेज किया गया कंप्यूट प्लैटफ़ॉर्म है. इसकी मदद से, बिना किसी स्टेटस वाले कंटेनर चलाए जा सकते हैं. इन्हें वेब अनुरोधों या Pub/Sub इवेंट के ज़रिए शुरू किया जा सकता है.

1. डिप्लॉयमेंट से जुड़ी ज़रूरी शर्तें

ब्लॉग लिखने वाले एजेंट को Cloud Run पर डिप्लॉय करने के लिए, आपको अपनी लोकल मशीन पर Google Cloud सीएलआई (gcloud) को इंस्टॉल और पुष्टि करनी होगी:

1. Google Cloud CLI इंस्टॉल करें: अगर आपने इसे इंस्टॉल नहीं किया है, तो अपने ऑपरेटिंग सिस्टम (macOS, Windows या Linux) के लिए, Google Cloud CLI को इंस्टॉल करने का तरीका बताने वाली गाइड पढ़ें.
2. अपने लोकल टर्मिनल की पुष्टि करें: इंस्टॉल हो जाने के बाद, अपने Google Cloud खाते में लॉग इन करने के लिए, अपने टर्मिनल में यह कमांड चलाएं:

   gcloud auth login
   

3. पुष्टि करें कि आपने सही खाते से लॉग इन किया है: पुष्टि करें कि आपने अपने खाते में लॉग इन कर लिया है और आपके पास Google Cloud संसाधनों को ऐक्सेस करने की अनुमति है:

   gcloud auth list
   

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

2. Google Cloud प्रोजेक्ट सेट अप करना

टर्मिनल में अपना ऐक्टिव प्रोजेक्ट सेट करें:

gcloud config set project <YOUR_PROJECT_ID>

कंटेनर वाले एजेंट को बनाने और डिप्लॉय करने के लिए, Google Cloud की ज़रूरी सेवाएं चालू करें:

gcloud services enable \
  run.googleapis.com \
  artifactregistry.googleapis.com \
  cloudbuild.googleapis.com

ADK की डिप्लॉय कमांड, बिल्ड प्रोसेस को अपने-आप पूरा करने के लिए Google Cloud Build का इस्तेमाल करती है. इसलिए, आपको डिफ़ॉल्ट कंप्यूट सेवा खाते को Cloud Build का इस्तेमाल करने की अनुमति देनी होगी.

यह कमांड चलाकर, अपना प्रोजेक्ट नंबर ढूंढें:

gcloud projects describe <YOUR_PROJECT_ID> --format="value(projectNumber)"

ज़रूरी IAM भूमिकाओं को बाइंड करने के लिए, यहां दिए गए निर्देश चलाएं. की जगह अपना प्रोजेक्ट आईडी और की जगह ऊपर दिए गए निर्देश से मिला नंबर डालें.

1. Cloud Build को कंटेनर बनाने की अनुमति दें:

gcloud projects add-iam-policy-binding <YOUR_PROJECT_ID> \
  --member="serviceAccount:<PROJECT_NUMBER>[e-mail]" \
  --role="roles/cloudbuild.builds.builder"

2. Gemini Enterprise को ऐक्सेस करने की अनुमति दें, ताकि डिप्लॉय किया गया एजेंट, एपीआई पासकोड की ज़रूरत के बिना Gemini मॉडल को चालू कर सके:

gcloud projects add-iam-policy-binding <YOUR_PROJECT_ID> \
  --member="serviceAccount:<PROJECT_NUMBER>[e-mail]" \
  --role="roles/aiplatform.user"

3. लोकल एनवायरमेंट वैरिएबल सेट अप करना

डिप्लॉयमेंट कमांड को आसान बनाने और टाइपिंग की गलतियों को रोकने के लिए, अपने टर्मिनल सेशन में प्रोजेक्ट आईडी को एनवायरमेंट वैरिएबल के तौर पर सेट करें:

export PROJECT_ID="<YOUR_PROJECT_ID>"

4. ADK CLI का इस्तेमाल करके डिप्लॉय करना

ADK CLI, Cloud Run पर एजेंट को डिप्लॉय करने के लिए एक आसान कमांड उपलब्ध कराता है.

पक्का करें कि आपका वर्चुअल एनवायरमेंट चालू हो और आप bloggeragent प्रोजेक्ट डायरेक्ट्री में हों. इसके बाद, डिप्लॉयमेंट कमांड चलाएं:

# Deploy using ADK
adk deploy cloud_run \
  --project=$PROJECT_ID \
  --region=us-east1 \
  --service_name=bloggeragent \
  --with_ui \
  . \
  -- \
  --set-env-vars GOOGLE_GENAI_USE_VERTEXAI=TRUE,MODEL=gemini-3.5-flash,GOOGLE_CLOUD_LOCATION=global

डप्लॉयमेंट की प्रोसेस के दौरान, आपको अपने टर्मिनल में ये दो सवाल दिखेंगे:

1. रिपॉज़िटरी बनाने की पुष्टि करें:

   Deploying from source requires an Artifact Registry Docker repository to store built containers. A repository named [cloud-run-source-deploy] in region [us-east1] will be created.
   
   Do you want to continue (Y/n)?
   

   Y लिखें और Enter दबाएं.
2. पुष्टि न किए गए उपयोगकर्ताओं को सेवाओं के इस्तेमाल की अनुमति दें:

   Allow unauthenticated invocations to [bloggeragent] (y/N)?
   

   y टाइप करें और Enter दबाएं. इससे, आपको अपने ब्राउज़र में ADK के वेब यूज़र इंटरफ़ेस (यूआई) को सार्वजनिक तौर पर ऐक्सेस करने की अनुमति मिलती है.

Cloud Run के लिए एनवायरमेंट वैरिएबल सेट करना

एजेंट को स्थानीय तौर पर चलाने के दौरान, एनवायरमेंट वैरिएबल मैनेज करने के लिए .env फ़ाइल का इस्तेमाल किया जाता था. हालांकि, डिप्लॉयमेंट के दौरान, स्थानीय .env फ़ाइल को अपने-आप अनदेखा कर दिया जाता है. ऐसा .gcloudignore का इस्तेमाल करके किया जाता है, ताकि स्थानीय सीक्रेट या कॉन्फ़िगरेशन अपलोड न किए जा सकें. इसके बजाय, --set-env-vars पैरामीटर (फ़्लैग नहीं) का इस्तेमाल करके, एनवायरमेंट वैरिएबल (जैसे कि MODEL और GOOGLE_CLOUD_LOCATION) को Cloud Run सेवा के एनवायरमेंट में साफ़ तौर पर इंजेक्ट किया जाता है. पुष्टि करने की प्रोसेस को Cloud Run सेवा खाता अपने-आप मैनेज करता है. इसके लिए, वह ऐप्लिकेशन के डिफ़ॉल्ट क्रेडेंशियल (एडीसी) का इस्तेमाल करता है. इसलिए, आपको अपनी एपीआई कुंजी को कॉन्फ़िगर या अपलोड करने की ज़रूरत नहीं है.

5. डिप्लॉय किए गए एजेंट को ऐक्सेस करना

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

9. व्यवस्थित करें

अपने Google Cloud खाते से लगातार शुल्क लिए जाने से बचने के लिए, इस कोडलैब के दौरान बनाई गई संसाधन मिटाएं.

1. Cloud Run सेवा मिटाना

डिप्लॉय की गई bloggeragent सेवा मिटाने के लिए:

gcloud run services delete bloggeragent --region=us-east1 --quiet

2. Artifact Registry रिपॉज़िटरी मिटाना

बनाई गई कंटेनर इमेज को सेव करने के लिए बनाई गई Docker रिपॉज़िटरी मिटाएं:

gcloud artifacts repositories delete cloud-run-source-deploy --location=us-east1 --quiet

3. लोकल सर्वर को बंद करना

लोकल एडीके सर्वर को बंद करने के लिए, उस टर्मिनल में CTRL+C दबाएं जहां यह चल रहा है. इसके बाद, वर्चुअल एनवायरमेंट को बंद करें:

deactivate

10. बधाई हो

बधाई हो! आपने Google के ADK और Gemini का इस्तेमाल करके, अपना पहला एआई एजेंट बनाया है.

आपने क्या सीखा

• एआई एजेंट के मुख्य सिद्धांत (सोचने और काम करने की क्षमता).
• मल्टी-एजेंट सिस्टम बनाने के लिए, Google ADK का इस्तेमाल कैसे करें.
• वेब यूज़र इंटरफ़ेस का इस्तेमाल करके, एजेंट को चलाने और उसकी जांच करने का तरीका.

अगले चरण

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

रेफ़रंस दस्तावेज़

• Google ADK के बारे में दस्तावेज़
• Gemini के बारे में जानकारी देने वाला दस्तावेज़