1. परिचय
Google Workspace में काम किया जाता है. Docs में रिपोर्ट का ड्राफ़्ट बनाने से लेकर, Sheets में डेटा का विश्लेषण करने और Gmail और Meet में एक साथ काम करने तक.
अब सोचें कि अगर आपके Docs, Sheets, और Gmail सिर्फ़ टूल न होकर, सहयोगी हों, तो क्या होगा.
Google के एजेंट डेवलपमेंट किट (एडीके) और Vertex AI के एजेंट इंजन की मदद से, अब यह सिर्फ़ एक आइडिया नहीं है. हम इन फ़्रेमवर्क का इस्तेमाल करके, एक इंटेलिजेंट एजेंट बनाएंगे. साथ ही, इसे बड़े पैमाने पर डिप्लॉय करेंगे और Google Workspace के टूल में आसानी से इंटिग्रेट करेंगे. इससे, एजेंट की मदद से काम करने की एक नई शुरुआत होगी.
इस कोडलैब में, आपको यहां दिया गया तरीका अपनाना होगा:
- एजेंट डेवलपमेंट किट का इस्तेमाल करके, एआई फ़ैक्ट चेक करने वाला एजेंट डेवलप करें.
- एजेंट को Agent Engine में डिप्लॉय करें. यह एक पूरी तरह से मैनेज किया गया एनवायरमेंट है, ताकि एजेंट को बड़े पैमाने पर चलाया जा सके.
- इस एजेंट को Google Docs में इंटिग्रेट करें, ताकि दस्तावेज़ में मौजूद टेक्स्ट के तथ्यों की जांच की जा सके.
यहां एक कॉन्सेप्ट वाला डायग्राम दिया गया है. इसमें बताया गया है कि फ़ाइनल समाधान कैसे काम करता है:
यहां Google दस्तावेज़ में, तथ्यों की जांच करने वाले एजेंट के काम करने का फ़ाइनल आउटपुट दिया गया है. इसमें ओरिजनल टेक्स्ट में कुछ स्टेटमेंट शामिल हैं. साथ ही, दस्तावेज़ में मौजूद हर स्टेटमेंट के तथ्यों की जांच की गई है. लाल रंग के कोने वाले बॉक्स में मौजूद आउटपुट, एजेंट से मिला आउटपुट है.
आपको क्या करना होगा
- एक ऐसा एजेंट डिज़ाइन करें, बनाएं, और डिप्लॉय करें जो Google दस्तावेज़ में तथ्यों की जांच कर सके.
आपको क्या सीखने को मिलेगा
- एजेंट डेवलपमेंट किट (एके) का इस्तेमाल करके, एजेंट डेवलप करें.
- एजेंट को स्थानीय तौर पर आज़माएं और उसे Agent Engine पर डिप्लॉय करें.
- एजेंट को Google Workspace दस्तावेज़ (Google दस्तावेज़) में इंटिग्रेट करें.
आपको इन चीज़ों की ज़रूरत होगी
- Chrome वेब ब्राउज़र
- Gmail खाता
- ऐसा Cloud प्रोजेक्ट जिसमें बिलिंग की सुविधा चालू हो
यह कोडलैब, सभी लेवल के डेवलपर (शुरुआती डेवलपर भी शामिल हैं) के लिए बनाया गया है. इसमें सैंपल कोड के तौर पर Python और Apps Script का इस्तेमाल किया गया है. हालांकि, इन प्रोग्रामिंग भाषाओं की जानकारी होना ज़रूरी नहीं है. साथ ही, पेश किए गए कॉन्सेप्ट को समझने के लिए, कोड को पढ़ने की बुनियादी क्षमता काफ़ी होगी.
2. शुरू करने से पहले
प्रोजेक्ट बनाना
- Google Cloud Console में, प्रोजेक्ट चुनने वाले पेज पर जाकर, Google Cloud प्रोजेक्ट चुनें या बनाएं.
- पक्का करें कि आपके Cloud प्रोजेक्ट के लिए बिलिंग चालू हो. किसी प्रोजेक्ट के लिए बिलिंग चालू है या नहीं, यह देखने का तरीका जानें .
- आपको Cloud Shell का इस्तेमाल करना होगा. यह Google Cloud में चलने वाला कमांड-लाइन एनवायरमेंट है. इसमें bq पहले से लोड होता है. Google Cloud Console में सबसे ऊपर मौजूद, Cloud Shell चालू करें पर क्लिक करें.
- Cloud Shell से कनेक्ट होने के बाद, यह देखने के लिए कि आपकी पुष्टि हो चुकी है और प्रोजेक्ट को आपके प्रोजेक्ट आईडी पर सेट किया गया है, इस कमांड का इस्तेमाल करें:
gcloud auth list
- यह पुष्टि करने के लिए कि gcloud कमांड को आपके प्रोजेक्ट के बारे में पता है, Cloud Shell में यह कमांड चलाएं.
gcloud config list project
- अगर आपका प्रोजेक्ट सेट नहीं है, तो इसे सेट करने के लिए इस निर्देश का इस्तेमाल करें:
gcloud config set project <YOUR_PROJECT_ID>
- नीचे दिए गए निर्देश का इस्तेमाल करके, ज़रूरी एपीआई चालू करें. इसमें कुछ मिनट लग सकते हैं. इसलिए, कृपया इंतज़ार करें.
gcloud services enable cloudresourcemanager.googleapis.com \
servicenetworking.googleapis.com \
aiplatform.googleapis.com \
discoveryengine.googleapis.com
कमांड के सही तरीके से लागू होने पर, आपको यहां दिखाए गए मैसेज जैसा मैसेज दिखेगा:
Operation "operations/..." finished successfully.
अगर कोई एपीआई छूट जाता है, तो उसे लागू करने के दौरान कभी भी चालू किया जा सकता है.
gcloud कमांड और उनके इस्तेमाल के बारे में जानने के लिए, दस्तावेज़ देखें.
3. ADK एजेंट बनाना
आइए, ADK एजेंट (Document Fact Checker Agent) बनाते हैं. यह एआई पर आधारित ऑडिटर है, जो टेक्स्ट में मौजूद तथ्यों की जांच करता है. यह Google के फ़ैक्ट-चेक कस्टम फ़ंक्शन सैंपल से मिलता-जुलता है. सैंपल में एक ही चरण का इस्तेमाल किया गया है. हालांकि, हमारा एजेंट दावा निकालने, google_search की मदद से उनकी पुष्टि करने, और स्ट्रक्चर्ड JSON को आउटपुट करने के लिए, कई चरणों में तर्क का इस्तेमाल करता है.
पहला चरण : एजेंट डेवलपमेंट किट इंस्टॉल करना
Cloud Shell में नया टर्मिनल टैब खोलें और नीचे दिए गए तरीके से my-agents नाम का फ़ोल्डर बनाएं. my-agents फ़ोल्डर पर भी जाएं.
mkdir workspace-agents
cd workspace-agents
अब हम venv का इस्तेमाल करके, वर्चुअल Python एनवायरमेंट बनाते हैं. इसके लिए, यह तरीका अपनाएं:
python -m venv .venv
वर्चुअल एनवायरमेंट को इस तरह चालू करें:
source .venv/bin/activate
ADK को इस तरह इंस्टॉल करें:
pip install google-adk
अब adk यूटिलिटी को इस तरह से चालू किया जा सकेगा.
adk
इससे आपको निर्देशों की एक सूची दिखेगी.
$ adk
Usage: adk [OPTIONS] COMMAND [ARGS]...
Agent Development Kit CLI tools.
Options:
--version Show the version and exit.
--help Show this message and exit.
Commands:
api_server Starts a FastAPI server for agents.
conformance Conformance testing tools for ADK.
create Creates a new app in the current folder with prepopulated agent template.
deploy Deploys agent to hosted environments.
eval Evaluates an agent given the eval sets.
eval_set Manage Eval Sets.
run Runs an interactive CLI for a certain agent.
web Starts a FastAPI server with Web UI for agents.
दूसरा चरण : ADK का इस्तेमाल करके, दस्तावेज़ की जानकारी की पुष्टि करने वाले एजेंट को डेवलप करना
अब हम adk का इस्तेमाल करके, अपने एजेंट के लिए एक स्केफ़ोल्डिंग बनाएंगे. इसके लिए, हम adk create कमांड का इस्तेमाल करेंगे. इसमें ऐप्लिकेशन का नाम **(docfactcheckeragent)**होगा. यह नीचे दिया गया है.
adk create docfactcheckeragent
यह तरीका अपनाएं और यह चुनें:
- रूट एजेंट के लिए मॉडल चुनने के लिए Gemini मॉडल.
- बैकएंड के लिए Vertex AI को चुनें.
- आपको अपना डिफ़ॉल्ट Google प्रोजेक्ट आईडी और क्षेत्र दिखेगा. डिफ़ॉल्ट सेटिंग को ही चुनें.
Choose a model for the root agent:
1. gemini-2.5-flash
2. Other models (fill later)
Choose model (1, 2): 1
1. Google AI
2. Vertex AI
Choose a backend (1, 2): 2
You need an existing Google Cloud account and project, check out this link for details:
https://google.github.io/adk-docs/get-started/quickstart/#gemini---google-cloud-vertex-ai
Enter Google Cloud project ID [YOUR_PROJECT_ID]:
Enter Google Cloud region [us-central1]:
Agent created in <YOUR_HOME_FOLDER>/workspace-agents/docfactcheckeragent:
- .env
- __init__.py
- agent.py
उस फ़ोल्डर को देखें जिसमें एजेंट के लिए डिफ़ॉल्ट टेंप्लेट और ज़रूरी फ़ाइलें बनाई गई हैं.
सबसे पहले, .env फ़ाइल है. जिसका कॉन्टेंट यहां दिया गया है:
GOOGLE_GENAI_USE_VERTEXAI=1
GOOGLE_CLOUD_PROJECT=YOUR_GOOGLE_PROJECT_ID
GOOGLE_CLOUD_LOCATION=YOUR_GOOGLE_PROJECT_REGION
इन वैल्यू से पता चलता है कि हम Gemini का इस्तेमाल Vertex AI के ज़रिए करेंगे. साथ ही, Google Cloud प्रोजेक्ट आईडी और जगह की जानकारी के लिए, इनसे जुड़ी वैल्यू का इस्तेमाल करेंगे.
इसके बाद, हमारे पास __init__.py फ़ाइल है. यह फ़ोल्डर को मॉड्यूल के तौर पर मार्क करती है. इसमें एक ऐसा स्टेटमेंट होता है जो agent.py फ़ाइल से एजेंट को इंपोर्ट करता है.
from . import agent
आखिर में, agent.py फ़ाइल है. आपको इस agent.py फ़ाइल के कॉन्टेंट को नीचे दिए गए कोड से बदलना होगा:
from google.adk.agents import Agent
from google.adk.tools import google_search
root_agent = Agent(
name='ai_auditor',
model='gemini-2.5-flash',
description="Fact-checks statements from a document and provides citations.",
instruction="""
You are an AI Auditor specialized in factual verification and evidence-based reasoning.
Your goal is to analyze text from a Google Doc, identify verifiable factual claims, and produce a concise, source-backed audit report.
### 🔍 TASK FLOW
1. **Extract Claims**
- Analyze the input text and identify factual claims that can be objectively verified.
- A factual claim is any statement that can be proven true or false with external evidence.
- Skip opinions, vague generalizations, or speculative language.
- List each claim as a string in a JSON array.
2. **Verify Claims**
- For each extracted claim:
- Use the `google_search` tool to find relevant, credible results.
- Evaluate at least the top 3 relevant URLs to determine the claim's accuracy.
- Cross-check multiple sources when possible to ensure confidence.
3. **Classify Findings**
- For each claim, determine one of the following verdicts:
- ✅ **True:** Supported by multiple reputable sources.
- ⚠️ **Misleading / Partially True:** Contains partially correct or context-dependent information.
- ❌ **False:** Contradicted by credible evidence.
- ❓ **Unverifiable:** Insufficient information to confirm or deny.
- Provide a **confidence score (0–100)** reflecting the strength of evidence.
4. **Record Evidence**
- For each claim, include:
- The **verdict**
- **Reasoning summary** (1–2 sentences)
- **List of citation URLs** used for verification
5. **Summarize Results**
- Compile a final report including:
- Total number of claims analyzed
- Distribution of verdicts (True / False / Misleading / Unverifiable)
- Brief overall conclusion (e.g., "Most claims are accurate but some lack supporting evidence.")
### 🧾 OUTPUT FORMAT
Return your final response in structured JSON format as follows:
{
"claims": [
{
"claim": "...",
"verdict": "True | False | Misleading | Unverifiable",
"confidence": 0-100,
"reasoning": "...",
"sources": ["https://...", "https://..."]
}
],
"summary": {
"total_claims": X,
"verdict_breakdown": {
"True": X,
"False": X,
"Misleading": X,
"Unverifiable": X
},
"overall_summary": "..."
}
}
### 🧠 ADDITIONAL INSTRUCTIONS
- Always prefer authoritative domains (.gov, .edu, .org, or major media).
- Avoid low-quality or user-generated content as primary sources.
- Be concise, accurate, and transparent about uncertainty.
""",
tools=[google_search], # Only use the search tool
)
ऊपर दिए गए सोर्स कोड के बारे में अहम जानकारी:
- हम एआई एजेंट को एक नाम देते हैं. इसके बाद, मॉडल, ब्यौरा, और निर्देशों का एक बहुत ही ज़्यादा जानकारी वाला सेट देते हैं.
- निर्देशों का सेट सबसे अहम हिस्सा होता है. इससे यह तय होता है कि एजेंट को किस तरह से सोचना और काम करना चाहिए. यह स्ट्रक्चर, पेशेवर फ़ैक्ट-चेकर के काम करने के तरीके को दिखाता है. इससे एआई, अपने-आप ऑडिट करने वाली पाइपलाइन में बदल जाता है.
- एजेंट के बारे में जानकारी देने के बाद, हम एजेंट को
Google Search toolके ज़रिए असल दुनिया की जानकारी ऐक्सेस करने की अनुमति देते हैं. पहले से ट्रेन किए गए डेटा पर भरोसा करने के बजाय, एजेंट लाइव खोज कर सकता है, नतीजों का आकलन कर सकता है, और अप-टू-डेट उद्धरण दे सकता है.
इसी वजह से, इस सिस्टम को एजेंटिक कहा जाता है. मॉडल सिर्फ़ जवाब जनरेट नहीं करता, बल्कि जानकारी की पुष्टि करने के लिए टूल का इस्तेमाल करता है.
तीसरा चरण : एजेंट को स्थानीय तौर पर टेस्ट करना
मौजूदा टर्मिनल विंडो से, यह कमांड दें. पक्का करें कि आप (workspace-agents) पैरंट फ़ोल्डर में हों. इस फ़ोल्डर में docfactcheckeragent फ़ोल्डर मौजूद होना चाहिए.
adk web
यहां एक सैंपल दिखाया गया है:
INFO: Started server process [1478]
INFO: Waiting for application startup.
+-----------------------------------------------------------------------------+
| ADK Web Server started |
| |
| For local testing, access at http://127.0.0.1:8000. |
+-----------------------------------------------------------------------------+
INFO: Application startup complete.
INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
आखिरी लिंक पर क्लिक करें. इससे एजेंट की जांच करने के लिए, वेब कंसोल खुल जाएगा. हमारा पहला इंटरैक्शन बुनियादी है: यह समझना कि एजेंट असल में क्या कर सकता है. इससे एजेंट की, description और instruction text की क्षमता का पता चलता है.
एजेंट, अपनी क्षमताओं के बारे में कम शब्दों में जानकारी देता है. यह जानकारी, एजेंट के ब्यौरे और निर्देश सेट से ली जाती है.
इसके बाद, हमने इसे दो स्टेटमेंट (The sky is blue due to Rayleigh scattering. The Earth is flat.) दिए. इसने कॉन्टेंट की जांच की और अच्छी तरह से स्ट्रक्चर किया गया JSON रिस्पॉन्स दिया.
बारीकियों के बारे में जानकारी:
- google_search टूल, वेब से काम के पेज फ़ेच करता है.
- Gemini 2.5 Flash मॉडल, उन स्निपेट को पार्स करता है और यह पता लगाता है कि उनमें दी गई जानकारी सही है या नहीं.
- ADK, तर्क के आधार पर फ़ैसले लेने की प्रोसेस को मैनेज करता है. साथ ही, यह पक्का करता है कि हर चरण में लॉजिक का पालन किया जाए.
स्थानीय तौर पर टेस्ट करने की इस प्रोसेस से, एजेंट के वर्कफ़्लो की पुष्टि करने में मदद मिलती है. इससे पहले कि आप इसे Vertex AI Agent Engine पर डिप्लॉय करें, जहां इसे Google Workspace के टूल, जैसे कि Docs या Sheets से कनेक्ट किया जा सकता है.
कुल मिलाकर, हमने Google के एजेंट डेवलपमेंट किट (एडीके) का इस्तेमाल करके, एक असरदार एआई ऑडिटर एजेंट बनाया है. हमारा एजेंट टेक्स्ट पढ़ सकता है, तथ्यों के आधार पर किए गए दावों की पहचान कर सकता है, भरोसेमंद सोर्स खोज सकता है (google_search टूल का इस्तेमाल करके), और साफ़ तौर पर फ़ैसला दे सकता है.
हमने ADK के वेब इंटरफ़ेस के ज़रिए, सभी चीज़ों को स्थानीय तौर पर बनाया और उनकी जांच की. साथ ही, हमने देखा कि एजेंट ने इस तरह के स्टेटमेंट का विश्लेषण कैसे किया:
The sky is blue due to Rayleigh scattering. The Earth is flat.
एजेंट ने एक दावे की पुष्टि true के तौर पर की और दूसरे को false के तौर पर फ़्लैग किया. यह इस बात का छोटा, लेकिन सटीक सबूत है कि हमारा लोकल सेटअप सही तरीके से काम करता है.
अब अगला बड़ा कदम उठाने का समय आ गया है. यानी, लोकल से क्लाउड पर माइग्रेट करने का. चलिए, अब यह काम करते हैं.
4. एजेंट को Vertex AI Agent Engine पर डिप्लॉय करना
असली एजेंट को सिर्फ़ लैपटॉप पर टेस्ट नहीं किया जाता. इसे बड़े पैमाने पर चलाया जा सकता है, अन्य सिस्टम के साथ इंटिग्रेट किया जा सकता है, और अपने सभी ऐप्लिकेशन में प्रोडक्शन के लिए डिप्लॉय किया जा सकता है.
डिप्लॉय क्यों करें?
अपने एजेंट को क्लाउड में डिप्लॉय करने की कुछ वजहें यहां दी गई हैं.
- स्केलेबिलिटी: लोकल रनटाइम की सीमाओं के बिना, ज़्यादा अनुरोधों को मैनेज करें.
- भरोसेमंद: इसमें निगरानी और अपने-आप स्केल होने की सुविधा पहले से मौजूद होती है. साथ ही, इसमें 18 अक्टूबर, 2025 को ADK टूल कॉन्फ़िगरेशन अपडेट जैसे फ़िक्स शामिल होते हैं.
- इंटिग्रेशन के लिए तैयार: Workspace कॉल को आसानी से मैनेज करने के लिए, एक एपीआई एंडपॉइंट उपलब्ध कराएं.
Vertex AI Agent Engine क्यों?
Vertex AI Agent Engine को, डिप्लॉय किए गए ADK एजेंट के लिए होम के तौर पर माना जा सकता है. यह एक मैनेज किया गया एनवायरमेंट है, जिसे भरोसेमंद, स्केलेबल, और इंटिग्रेशन के लिए बनाया गया है.
इससे आपके एजेंट को ये सुविधाएं मिलती हैं:
- परसिस्टेंट स्टेट और मेमोरी
- इंटिग्रेट किए गए टूल का इस्तेमाल करना (जैसे, Google Search, Vertex AI Models)
- बाहरी कॉल के लिए सुरक्षित एपीआई एंडपॉइंट
- Cloud Logging की मदद से लॉगिंग और जांच करने की क्षमता
- मल्टी-एजेंट ऑर्केस्ट्रेशन के लिए नेटिव सपोर्ट
कम शब्दों में कहें, तो ADK की मदद से एक बार कॉन्टेंट लिखें. इसके बाद, एजेंट इंजन का इस्तेमाल करके इसे बड़ा करें.
पहला चरण : डिप्लॉयमेंट के लिए सेट अप करना
Vertex AI Agent Engine एजेंट को डिप्लॉय करने से पहले, हमें कुछ काम करने होंगे. डिप्लॉयमेंट प्रोसेस के लिए, एजेंट आर्टफ़ैक्ट के लिए Google Cloud Storage बकेट बनाना ज़रूरी है. साथ ही, हमें requirements.txt फ़ाइल भी उपलब्ध करानी होगी, ताकि एजेंट कोड को चलाने के लिए ज़रूरी सभी डिपेंडेंसी, एजेंट इंजन के रनटाइम एनवायरमेंट के लिए उपलब्ध हों.
बकेट बनाने के लिए, अपने Cloud Shell टर्मिनल में यह कमांड डालें. YOUR_BUCKET_NAME, YOUR_PROJECT_ID, और YOUR_PROJECT_REGION की जगह अपने प्रोजेक्ट के हिसाब से सही वैल्यू डालना न भूलें:
gcloud storage buckets create gs://YOUR_BUCKET_NAME \
--project=YOUR_PROJECT_ID \
--location=YOUR_PROJECT_REGION
इसके बाद, रूट फ़ोल्डर (workspace-agents) में यह requirements.txt फ़ाइल बनाएं. इसका कॉन्टेंट यहां दिया गया है:
google-cloud-aiplatform
google-adk
requests
दूसरा चरण : एजेंट को डिप्लॉय करना
अगला चरण, adk deploy कमांड का इस्तेमाल करके, अपने एजेंट को Vertex AI Agent Engine पर डिप्लॉय करना है.
adk deploy agent_engine \
--project=YOUR_PROJECT_ID \
--region=YOUR_PROJECT_REGION \
--display_name "Doc Fact Checker" \
--staging_bucket gs://YOUR_BUCKET_NAME \
--requirements_file requirements.txt \
docfactcheckeragent/
इससे, हमारे एजेंट को एजेंट इंजन में डिप्लॉय करने की प्रोसेस शुरू हो जाएगी. इस प्रोसेस में समय लगता है. इसमें करीब पांच मिनट लग सकते हैं. बड़े लेवल पर, यहां बताया गया है कि क्या हो रहा है:
- एजेंट बनाना शुरू हो जाता है - ADK CLI आपके कोड को पैकेज करता है, उसे आपके Cloud Storage बकेट में अपलोड करता है, और Vertex AI को नया एजेंट इंजन इंस्टेंस बनाने के लिए ट्रिगर करता है.
- आपको लॉग का लिंक दिया जाता है. इस लिंक पर जाकर, अपने प्रोजेक्ट के लिए Cloud Logs Explorer देखा जा सकता है. इस पर क्लिक करके, सेटअप के चरणों, डिपेंडेंसी इंस्टॉलेशन, और मॉडल के शुरू होने की प्रोसेस के बारे में ज़्यादा जानकारी देखें. अगर कोई गड़बड़ी होती है (जैसे, कोई ज़रूरी कॉम्पोनेंट मौजूद नहीं है या अनुमति से जुड़ी कोई समस्या है), तो आपको यहां गड़बड़ी का मैसेज दिखेगा.
- डिप्लॉयमेंट पूरा होने का मैसेज - डिप्लॉयमेंट पूरा होने के बाद, आपको टर्मिनल में पुष्टि करने वाला मैसेज दिखेगा. इसमें आपका रीज़निंग इंजन आईडी होगा. इसका एक सैंपल यहां दिया गया है:
AgentEngine created. Resource name: projects/SOME_ID/locations/REGION/reasoningEngines/SOME_ID
तीसरा चरण : Cloud Console (Agent Engine) में एजेंट की पुष्टि करना
डप्लॉयमेंट पूरा होने के बाद, अपनी Google Cloud Console के Vertex AI → Agent Engine सेक्शन पर जाएं. आपको कंसोल में, डिप्लॉय किया गया एजेंट दिखना चाहिए. जैसा कि यहां दिखाया गया है:
🎉 बस हो गया! आपका एजेंट अब Vertex AI पर लाइव है. इसे सीधे तौर पर Google Workspace में इंटिग्रेट किया जा सकता है या इसकी जांच की जा सकती है.
चौथा चरण : डिप्लॉयमेंट एजेंट की जांच करना
बधाई हो - आपका एजेंट अब Vertex AI Agent Engine पर लाइव है! अगला चरण यह जांच करना है कि इसे सही तरीके से डिप्लॉय किया गया है और यह अनुरोधों का जवाब दे रहा है.
आपके काम करने के तरीके के हिसाब से, ऐसा करने के कई तरीके हैं:
- Google Cloud Console के ज़रिए: यह एक विज़ुअल इंटरफ़ेस है. इसकी मदद से, सीधे तौर पर डिप्लॉय किए गए एजेंट देखे, मैनेज किए, और टेस्ट किए जा सकते हैं.
- REST API (cURL) का इस्तेमाल करना: यह उन डेवलपर के लिए सबसे सही है जो मैन्युअल तरीके से अनुरोध भेजना और जवाबों की जांच करना चाहते हैं.
- Python के लिए Vertex AI SDK टूल की मदद से: यह टेस्टिंग को अपने डेवलपमेंट वर्कफ़्लो में इंटिग्रेट करने का एक ज़्यादा प्रोग्रामैटिक विकल्प है.
हर तरीके से आपको यह जानकारी मिलती है कि डिप्लॉय होने के बाद आपका एजेंट कैसा व्यवहार करता है. जैसे, वह क्वेरी प्रोसेस कर रहा है या नहीं, सेशन मैनेज कर रहा है या नहीं या जवाब दे रहा है या नहीं. हर तरीके के बारे में पूरी जानकारी, उदाहरण, और ऐडवांस कॉन्फ़िगरेशन देखने के लिए, आधिकारिक दस्तावेज़ यहां देखें.
आपका एआई ऑडिटर अब क्लाउड पर काम करने वाला एजेंट है. इसे Vertex AI Agent Engine पर डिप्लॉय किया गया है. यह google_search की मदद से, बड़े पैमाने पर तथ्यों की जांच करने के लिए तैयार है. यह एक भरोसेमंद, एपीआई पर आधारित डिजिटल कंपैनियन में बदल जाता है. यह JSON को इस तरह से जनरेट करता है:
{ "claims": [{"claim": "The sky is blue...", "verdict": "True", "confidence": 95}] }
हम अगले सेक्शन में सीधे तौर पर इसकी जांच करेंगे. इसमें, हम एजेंट को Google दस्तावेज़ में इंटिग्रेट करेंगे और दस्तावेज़ में बताए गए तथ्यों की पुष्टि करेंगे.
5. तथ्यों की जांच करने वाले एजेंट को Google Docs में इंटिग्रेट करना
इस सेक्शन में, हम सभी चीज़ों को एक साथ कनेक्ट करेंगे. इससे, Google Docs में आपका डिप्लॉय किया गया एजेंट काम करने लगेगा. Apps Script की कुछ लाइनों की मदद से, स्टैंडर्ड Google दस्तावेज़ को एआई की मदद से काम करने वाले एडिटर में बदला जा सकता है. यह एडिटर, आपके डिप्लॉय किए गए एजेंट का इस्तेमाल करके, कॉन्टेंट का विश्लेषण कर सकता है और तथ्यों की जांच अपने-आप कर सकता है.
पहला चरण: Google Docs का एनवायरमेंट सेट अप करना
इसके लिए, कोई नया या मौजूदा Google दस्तावेज़ (docs.new) खोलें.
इस ट्यूटोरियल के लिए इस्तेमाल किए जा रहे Google दस्तावेज़ में यह कॉन्टेंट शामिल है. इसका इस्तेमाल किया जा सकता है. इसके अलावा, अपने उस कॉन्टेंट का भी इस्तेमाल किया जा सकता है जिसकी आपको तथ्यों की जांच करनी है:
Climate change is mainly caused by solar activity cycles, not human activities. The Earth's temperature has not increased significantly in the last 100 years. Wind energy now produces more electricity than coal in every country in Europe. In 2015, nearly all world nations signed the Paris Agreement to limit global warming.
दूसरा चरण: अपना Apps Script प्रोजेक्ट और फ़ाइलें सेट अप करना
इस सेटअप के लिए, आपको अपने Apps Script प्रोजेक्ट में दो फ़ाइलों की ज़रूरत होगी:
AIVertex.gs– यह Vertex AI और ADK एजेंट के साथ सभी कम्यूनिकेशन को मैनेज करता है.Code.gs– इससे Google Docs के इंटरफ़ेस, मेन्यू, और दस्तावेज़ से जुड़ी कार्रवाइयों को कंट्रोल किया जाता है.
एडिटर खोलने के लिए, मेन्यू में जाकर Extensions -> Apps Script पर जाएं. हम इस स्पेस का इस्तेमाल, डिप्लॉय किए गए ADK एजेंट से कनेक्ट करने के लिए करेंगे. आपको पहले से बनाई गई Code.gs फ़ाइल दिखेगी. आपको इसके कॉन्टेंट को अगले सेक्शन में दिए गए Code.gs कोड से बदलना होगा.
आइए, इन सभी के बारे में जानते हैं.
AIVertex.gs
बाईं ओर मौजूद फ़ाइलें सेक्शन के बगल में मौजूद + चिह्न का इस्तेमाल करके, नई फ़ाइल बनाएं. इसे Script के तौर पर चुनें और इसमें यहां दिया गया कॉन्टेंट कॉपी करें.
const LOCATION = PropertiesService.getScriptProperties().getProperty('LOCATION');
const GEMINI_MODEL_ID = PropertiesService.getScriptProperties().getProperty('GEMINI_MODEL_ID');
const REASONING_ENGINE_ID = PropertiesService.getScriptProperties().getProperty('REASONING_ENGINE_ID');
const SERVICE_ACCOUNT_KEY = PropertiesService.getScriptProperties().getProperty('SERVICE_ACCOUNT_KEY');
const credentials = credentialsForVertexAI();
/**
* @param {string} statement The statement to fact-check.
*/
function requestLlmAuditorAdkAiAgent(statement) {
return UrlFetchApp.fetch(
`https://${LOCATION}-aiplatform.googleapis.com/v1/projects/${credentials.projectId}/locations/${LOCATION}/reasoningEngines/${REASONING_ENGINE_ID}:streamQuery?alt=sse`,
{
method: 'post',
headers: { 'Authorization': `Bearer ${credentials.accessToken}` },
contentType: 'application/json',
muteHttpExceptions: true,
payload: JSON.stringify({
"class_method": "async_stream_query",
"input": {
"user_id": "google_sheets_custom_function_fact_check",
"message": statement,
}
})
}
).getContentText();
}
/**
* @param {string} prompt The Gemini prompt to use.
*/
function requestOutputFormatting(prompt) {
const response = UrlFetchApp.fetch(
`https://${LOCATION}-aiplatform.googleapis.com/v1/projects/${credentials.projectId}/locations/${LOCATION}/publishers/google/models/${GEMINI_MODEL_ID}:generateContent`,
{
method: 'post',
headers: { 'Authorization': `Bearer ${credentials.accessToken}` },
contentType: 'application/json',
muteHttpExceptions: true,
payload: JSON.stringify({
"contents": [{
"role": "user",
"parts": [{ "text": prompt }]
}],
"generationConfig": { "temperature": 0.1, "maxOutputTokens": 2048 },
"safetySettings": [
{
"category": "HARM_CATEGORY_HARASSMENT",
"threshold": "BLOCK_NONE"
},
{
"category": "HARM_CATEGORY_HATE_SPEECH",
"threshold": "BLOCK_NONE"
},
{
"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
"threshold": "BLOCK_NONE"
},
{
"category": "HARM_CATEGORY_DANGEROUS_CONTENT",
"threshold": "BLOCK_NONE"
}
]
})
}
);
return JSON.parse(response).candidates[0].content.parts[0].text
}
/**
* Gets credentials required to call Vertex API using a Service Account.
* Requires use of Service Account Key stored with project.
*
* @return {!Object} Containing the Google Cloud project ID and the access token.
*/
function credentialsForVertexAI() {
const credentials = SERVICE_ACCOUNT_KEY;
if (!credentials) {
throw new Error("service_account_key script property must be set.");
}
const parsedCredentials = JSON.parse(credentials);
const service = OAuth2.createService("Vertex")
.setTokenUrl('https://oauth2.googleapis.com/token')
.setPrivateKey(parsedCredentials['private_key'])
.setIssuer(parsedCredentials['client_email'])
.setPropertyStore(PropertiesService.getScriptProperties())
.setScope("https://www.googleapis.com/auth/cloud-platform");
return {
projectId: parsedCredentials['project_id'],
accessToken: service.getAccessToken(),
}
}
फ़ाइल सेव करना न भूलें.
यह फ़ाइल ये काम करती है:
- यह सेवा खाते की कुंजी का इस्तेमाल करके, Vertex AI से सुरक्षित तरीके से पुष्टि करता है. यह आपके डिप्लॉय किए गए ADK एजेंट को चालू करता है, ताकि वह दस्तावेज़ के टेक्स्ट का विश्लेषण कर सके या तथ्यों की जांच कर सके.
- यह स्मार्ट जवाब फ़ॉर्मैट करने के लिए Gemini का इस्तेमाल करता है , ताकि नतीजे आसानी से पढ़े जा सकें.
Code.gs
/**
* Adds a custom menu in Google Docs to run the AI Audit directly.
*/
function onOpen() {
DocumentApp.getUi()
.createMenu('AI Audit Tools')
.addItem('Run AI Audit', 'runAuditAndInsert')
.addToUi();
}
/**
* Returns the entire text content of the document.
*/
function getDocumentText() {
const doc = DocumentApp.getActiveDocument();
const body = doc.getBody();
let text = body.getText();
return text.trim();
}
/**
* Runs the AI Audit and inserts the result as text at the end of the document.
*/
function runAuditAndInsert() {
const docText = getDocumentText();
const result = runAudit(docText);
if (result) {
const doc = DocumentApp.getActiveDocument();
const body = doc.getBody();
// Append the audit result as a new paragraph at the end of the document
body.appendParagraph('AI Audit Result: ' + result);
}
}
/**
* Runs the AI Audit using ADK Agent and Gemini formatting.
*/
function runAudit(docText) {
console.log('[INFO] Starting AI audit process...');
if (!docText) {
console.log('[WARN] No text in document.');
return '⚠️ The document is empty. Please add some text to audit.';
}
// Check for excessive document length to avoid token limits
if (docText.length > 10000) {
console.log('[WARN] Document too long.');
return '⚠️ Document exceeds 10,000 characters. Please shorten the text.';
}
console.log('[STEP] Sending text to ADK Agent...');
const rawAudit = requestLlmAuditorAdkAiAgent(docText);
// Check if rawAudit is an error message
if (rawAudit.startsWith('ERROR:')) {
console.error('[ERROR] ADK Agent returned error:', rawAudit);
return rawAudit;
}
console.log('[STEP] Formatting AI response...');
let formatted;
try {
formatted = requestOutputFormatting(
`Here is a fact-checking result: ${rawAudit}.
Summarize it. Keep the main verdict and reasoning. Remove markdown and make it concise.`
);
} catch (error) {
console.error('[ERROR] Formatting failed:', error.toString());
return `ERROR: Failed to format audit result - ${error.toString()}`;
}
console.log('[SUCCESS] Audit completed successfully.');
console.log('[RESULT] Final Output:', formatted);
return formatted;
}
यह फ़ाइल, आपके Docs के यूज़र इंटरफ़ेस (यूआई) को ऊपर दिए गए एडीके लॉजिक से कनेक्ट करती है. इससे, कस्टम Docs मेन्यू से सीधे ऑडिट को ट्रिगर किया जा सकता है. बड़े लेवल पर, यह इन कामों को करता है:
- यह Google Docs में, एआई ऑडिट टूल नाम का कस्टम मेन्यू जोड़ता है.
- यह आपके दस्तावेज़ के टेक्स्ट को इकट्ठा करता है और विश्लेषण के लिए, इसे आपके एडीके एजेंट को भेजता है.
- एआई से जनरेट किए गए ऑडिट के नतीजों को वापस दस्तावेज़ में दिखाता है.
तीसरा चरण : सेवा खाता बनाना
Google दस्तावेज़ में एजेंट कॉलिंग की सुविधा को इंटिग्रेट करने पर, हमें Google दस्तावेज़ को एक पहचान देनी होगी, ताकि उसके पास एजेंट इंजन में डिप्लॉय किए गए एजेंट को शुरू करने की सही भूमिका हो. इसके लिए, हम एक सेवा खाते का इस्तेमाल करेंगे. इसमें सही भूमिका होगी: roles/aiplatform.user.
Cloud Shell में, यहां दी गई स्क्रिप्ट को एक-एक करके चलाएं:
export PROJECT_ID="YOUR_PROJECT_ID"
export SA_NAME="docfactcheckeragentsa"
gcloud iam service-accounts create $SA_NAME \
--project=$PROJECT_ID \
--display-name="Doc Fact Checker Agent Service Account"
gcloud projects add-iam-policy-binding $PROJECT_ID \
--member="serviceAccount:${SA_NAME}@${PROJECT_ID}.iam.gserviceaccount.com" \
--role="roles/aiplatform.user"
gcloud projects add-iam-policy-binding $PROJECT_ID \
--member="serviceAccount:${SA_NAME}@${PROJECT_ID}.iam.gserviceaccount.com" \
--role="roles/iam.serviceAccountTokenCreator"
इससे सही अनुमतियों वाला सेवा खाता बन जाएगा.
हम सेवा खाते के लिए एक JSON कुंजी जनरेट करेंगे. Apps Script प्रोजेक्ट, पुष्टि करने के लिए इसका इस्तेमाल करेगा. कुंजी पाने का तरीका:
- Google Cloud Console में, आईएएम और एडमिन > सेवा खाते पर जाएं.
- उस सेवा खाते पर क्लिक करें जिसे आपने अभी बनाया है.
- कुंजियां टैब पर जाएं.
- कुंजी जोड़ें → नई कुंजी बनाएं पर क्लिक करें.
- JSON चुनें. इसके बाद, 'बनाएं' पर क्लिक करें.
- एक JSON फ़ाइल अपने-आप डाउनलोड हो जाएगी. आपको इसे सुरक्षित रखना चाहिए. अगले सेक्शन में, आपको इस फ़ाइल के कॉन्टेंट को अपनी स्क्रिप्ट की प्रॉपर्टी में चिपकाना होगा.
चौथा चरण : स्क्रिप्ट प्रॉपर्टी जोड़ना
Google दस्तावेज़ में Apps Script एडिटर पर वापस जाएं.
अपनी स्क्रिप्ट को डिप्लॉय किए गए संसाधनों से कनेक्ट करने के लिए, Project Settings → Script Properties → Add Script Property पर जाएं.
अपनी स्क्रिप्ट प्रॉपर्टी में यह जोड़ें:
LOCATION: Vertex AI को डिप्लॉय करने का क्षेत्र. उदाहरण के लिए,us-central1GEMINI_MODEL_ID: इस्तेमाल किया जाने वाला Gemini मॉडल. इस वैल्यू का इस्तेमाल करें:gemini-2.5-flashREASONING_ENGINE_ID: डिप्लॉय किया गया ADK एजेंट आईडी. इसे उस एजेंट की कंसोल में मौजूद एजेंट इंजन विकल्प से पाया जा सकता है जिसे आपने डिप्लॉय किया है. आपको डिप्लॉय किए गए एजेंट का संसाधन नाम दिखेगा. एजेंट आईडी, संसाधन के नाम में मौजूद आखिरी संख्यात्मक वैल्यू होती है. जैसे,RESOURCE_ID. उदाहरण के लिए,projects/SOME_ID/locations/REGION/reasoningEngines/RESOURCE_IDSERVICE_ACCOUNT_KEY: उस सेवा खाते के लिए डाउनलोड की गई JSON कुंजी का पूरा कॉन्टेंट कॉपी करें जिसे हमने पिछले चरण में बनाया था.
स्क्रिप्ट प्रॉपर्टी सेव करें पर क्लिक करें.
पांचवां चरण : OAuth2 लाइब्रेरी जोड़ना
हमारे Apps Script प्रोजेक्ट को एपीआई कॉल की पुष्टि करने के लिए, OAuth2 लाइब्रेरी की ज़रूरत होती है.
इसे जोड़ने के लिए:
Services → Librariesपर जाएंAdd a Libraryपर क्लिक करें- स्क्रिप्ट आईडी डालें:
1B7FSrk5Zi6L1rSxxTDgDEUsPzlukDsi4KGuTMorsTQHhGBzBkMun4iDF
छठा चरण : Google Docs में, तथ्यों की जांच करने वाले Doc एजेंट को आज़माना
हम Google Docs में एजेंट की जांच करने के आखिरी चरण में हैं. इसके लिए, यह तरीका अपनाएं:
- Apps Script एडिटर में,
onOpen()फ़ंक्शन को एक बार चलाएं. इससे Google Docs में, एआई ऑडिट टूल का एक नया मेन्यू जुड़ जाएगा. - अपने दस्तावेज़ पर वापस जाएं. आपको मुख्य मेन्यू में
AI Audit Toolsनाम का एक और मेन्यू आइटम दिखेगा. उस पर क्लिक करें. इसके बाद,Run AI Auditपर क्लिक करें.
यहां एक सैंपल रन दिया गया है:
6. साफ़-सफ़ाई सेवा
अपने Google Cloud खाते से शुल्क लिए जाने से बचने के लिए, इस वर्कशॉप के दौरान बनाई गई संसाधनों को मिटाना ज़रूरी है.
अगर आपको एजेंट को अब एजेंट इंजन में डिप्लॉय नहीं करना है, तो यहां दिया गया तरीका अपनाकर उसे मिटाया जा सकता है:
- Google Cloud Console में, Vertex AI Agent Engine पेज पर जाएं.
- तैनात किए गए एजेंट की सूची में से, उस एजेंट को ढूंढें जिसे आपको मिटाना है.
- एजेंट के नाम के बगल में मौजूद, तीन बिंदु वाले मेन्यू (ज़्यादा कार्रवाइयां) पर क्लिक करें.
- ड्रॉपडाउन मेन्यू से, मिटाएं चुनें.
- पुष्टि करने वाले डायलॉग बॉक्स में, एजेंट मिटाएं पर क्लिक करके, मिटाने की पुष्टि करें.
हमारा सुझाव है कि आप सेवा खाते को भी मिटा दें.
gcloud iam service-accounts delete ${SA_NAME}@${PROJECT_ID}.iam.gserviceaccount.com
7. बधाई हो
आपने अब अपने एआई एजेंट को डिप्लॉय कर दिया है. साथ ही, इसे Google Docs से कनेक्ट कर दिया है. आपने इसे काम करते हुए भी देख लिया है. यह आपके कॉन्टेंट का विश्लेषण करता है, उसके बारे में तर्क देता है, और उसे छोटा करके दिखाता है. हमने यहां सिर्फ़ एक डेमो नहीं बनाया है. यह Google Workspace में, एजेंट की मदद से बेहतर तरीके से मिलकर काम करने की सुविधा देता है.
ADK की तर्क करने की क्षमताओं को Gemini के जनरेटिव मॉडल के साथ मिलाकर, हमने Google Docs को एक ऐसी सहायक के तौर पर बदल दिया है जो आपके साथ बातचीत कर सकती है और सोच-समझकर काम कर सकती है. यह सहायक, कॉन्टेक्स्ट के साथ आपके टेक्स्ट को पढ़ सकती है, उसकी जांच कर सकती है, और उसे बेहतर बना सकती है.
एक ही ब्लूप्रिंट को Sheets, Slides, Drive, और Gmail में आसानी से इस्तेमाल किया जा सकता है. ऐसे एजेंटों के बारे में सोचें जो:
- वित्तीय डेटा का ऑडिट करना और Sheets में मौजूद गड़बड़ियों के बारे में सूचना देना
- Slides में पिच डेक और खास जानकारी अपने-आप जनरेट करना
- Drive में मौजूद दस्तावेज़ों को लेबल करना और उन्हें व्यवस्थित करना
- इसके अलावा, सीधे Gmail में ईमेल ड्राफ़्ट किए जा सकते हैं और उनमें मौजूद तथ्यों की जांच की जा सकती है
इस डेमो में, एजेंटिक वर्कफ़्लो बनाने के बारे में बताया गया है. ये वर्कफ़्लो, आपके रोज़ के Workspace टूल के साथ आसानी से इंटिग्रेट हो जाते हैं. साथ ही, ये स्टैटिक दस्तावेज़ों को डाइनैमिक एआई सहयोगी में बदल देते हैं.