Cloud Run पर Gemini + MCP की मदद से, नैचुरल लैंग्वेज को Google Cloud की कार्रवाइयों में बदलना

1. परिचय

इस कोडलैब में, Python का इस्तेमाल करके कस्टम एमसीपी (मॉडल कॉन्टेक्स्ट प्रोटोकॉल) सर्वर बनाने, उसे Google Cloud Run पर डिप्लॉय करने, और उसे Gemini CLI से कनेक्ट करने का तरीका बताया गया है. इससे, नैचुरल लैंग्वेज का इस्तेमाल करके Google Cloud Storage की असली कार्रवाइयां की जा सकती हैं.

आर्किटेक्चर फ़्लो: Gemini CLI → Cloud Run → MCP

मान लें कि आपने अपना टर्मिनल खोला और एआई एजेंट में एक सामान्य प्रॉम्प्ट टाइप किया. जैसे, यहां दिखाए गए प्रॉम्प्ट:

• List my GCS buckets
• Create a GCS bucket named <bucket-name>
• Tell me about the metadata of my GCS object

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

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

आपको एक कस्टम एमसीपी सर्वर बनाना और उसे डिप्लॉय करना होगा. यह सर्वर, Gemini सीएलआई को Google Cloud Storage से कनेक्ट करता है.

आपको:

• Python पर आधारित एमसीपी सर्वर बनाना
• ऐप्लिकेशन को कंटेनर में बदलना
• इसे Cloud Run पर डिप्लॉय करें
• इसे IAM और आइडेंटिटी टोकन का इस्तेमाल करके सुरक्षित करें
• इसे Gemini CLI से कनेक्ट करना
• नैचुरल लैंग्वेज का इस्तेमाल करके, GCS की लाइव कार्रवाइयां करना

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

• एमसीपी (मॉडल कॉन्टेक्स्ट प्रोटोकॉल) क्या है और यह कैसे काम करता है
• Python का इस्तेमाल करके, टूल कॉल करने की सुविधाएं बनाने का तरीका
• कंटेनर वाले ऐप्लिकेशन को Cloud Run पर डिप्लॉय करने का तरीका
• Gemini CLI, बाहरी एमसीपी सर्वर के साथ कैसे इंटिग्रेट होता है
• Cloud Run सेवाओं की सुरक्षित तरीके से पुष्टि करने का तरीका
• एआई का इस्तेमाल करके, Google Cloud Storage की असली कार्रवाइयां कैसे की जाती हैं

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

• Chrome वेब ब्राउज़र
• Gmail खाता
• बिलिंग की सुविधा वाला Google Cloud प्रोजेक्ट
• Gemini CLI (यह Google Cloud Shell में पहले से इंस्टॉल होता है)
• Python और Google Cloud के बारे में बुनियादी जानकारी

इस कोडलैब में यह माना गया है कि उपयोगकर्ता को Python की बुनियादी जानकारी है

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

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

1. Google Cloud Console में, प्रोजेक्ट चुनने वाले पेज पर, Google Cloud प्रोजेक्ट चुनें या बनाएं.
2. पक्का करें कि आपके Cloud प्रोजेक्ट के लिए बिलिंग चालू हो. किसी प्रोजेक्ट के लिए बिलिंग चालू है या नहीं, यह देखने का तरीका जानें .
3. आपको Cloud Shell का इस्तेमाल करना होगा. यह Google Cloud में चलने वाला कमांड-लाइन एनवायरमेंट है. इसमें bq पहले से लोड होता है. Google Cloud Console में सबसे ऊपर मौजूद, Cloud Shell चालू करें पर क्लिक करें.

4. Cloud Shell से कनेक्ट होने के बाद, यह देखने के लिए कि आपकी पुष्टि हो चुकी है और प्रोजेक्ट को आपके प्रोजेक्ट आईडी पर सेट किया गया है, इस कमांड का इस्तेमाल करें:

gcloud auth list

5. यह पुष्टि करने के लिए कि gcloud कमांड को आपके प्रोजेक्ट के बारे में पता है, Cloud Shell में यह कमांड चलाएं.

gcloud config list project

6. अगर आपका प्रोजेक्ट सेट नहीं है, तो इसे सेट करने के लिए इस निर्देश का इस्तेमाल करें:

gcloud config set project <YOUR_PROJECT_ID>

7. नीचे दिए गए निर्देश का इस्तेमाल करके, ज़रूरी एपीआई चालू करें. इसमें कुछ मिनट लग सकते हैं. इसलिए, कृपया इंतज़ार करें.

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

अगर अनुमति देने के लिए कहा जाए, तो जारी रखने के लिए 'अनुमति दें' पर क्लिक करें.

कमांड के सही तरीके से लागू होने पर, आपको यहां दिखाए गए मैसेज जैसा मैसेज दिखेगा:

Operation "operations/..." finished successfully.

अगर कोई एपीआई छूट जाता है, तो उसे लागू करने के दौरान कभी भी चालू किया जा सकता है.

gcloud कमांड और उनके इस्तेमाल के बारे में जानने के लिए, दस्तावेज़ देखें.

अपना Python प्रोजेक्ट तैयार करना

इस सेक्शन में, आपको Python प्रोजेक्ट बनाना होगा. यह प्रोजेक्ट, आपके एमसीपी सर्वर को होस्ट करेगा. साथ ही, Cloud Run पर डिप्लॉय करने के लिए, इसकी डिपेंडेंसी को कॉन्फ़िगर करेगा.

प्रोजेक्ट डायरेक्ट्री बनाना

सोर्स कोड सेव करने के लिए, mcp-on-cloudrun नाम का नया फ़ोल्डर बनाएं:

mkdir gcs-mcp-server && cd gcs-mcp-server

requirements.txt फ़ाइल बनाना

touch requirements.txt
cloudshell edit ~/gcs-mcp-server/requirements.txt

फ़ाइल में यह कॉन्टेंट जोड़ें:

fastmcp
google-cloud-storage
google-api-core
pydantic

फ़ाइल सेव करें.

3. एमसीपी सर्वर बनाना

इस सेक्शन में, आपको एमसीपी सर्वर बनाना होगा. यह सर्वर, Google Cloud Storage की कार्रवाइयों को कॉल किए जा सकने वाले टूल के तौर पर दिखाता है.

यह सर्वर:

• एमसीपी टूल रजिस्टर करना
• Google Cloud Storage से कनेक्ट करना
• एचटीटीपी पर रन करना
• Cloud Run पर डिप्लॉय किया जा सकता हो

अब main.py में, एमसीपी का मुख्य लॉजिक बनाते हैं.

यहां पूरा कोड दिया गया है. इसमें Google Cloud Storage को मैनेज करने के लिए कई टूल के बारे में बताया गया है. जैसे, बकेट की सूची बनाना और उन्हें बनाना, बकेट में डेटा अपलोड करना और डाउनलोड करना, और बकेट में मौजूद डेटा को मैनेज करना

ऐप्लिकेशन की मुख्य फ़ाइल बनाना

mcp-on-cloudrun डायरेक्ट्री में, main.py नाम की एक नई फ़ाइल बनाएं:

touch main.py

Cloud Shell Editor का इस्तेमाल करके फ़ाइल खोलें:

cloudshell edit ~/gcs-mcp-server/main.py

main.py फ़ाइल के कॉन्टेंट में यह सोर्स जोड़ें:

import asyncio
import logging
import os
from datetime import timedelta
from typing import List, Dict, Any
from fastmcp import FastMCP
from google.cloud import storage
from google.api_core import exceptions

# ---------------------------------------------------------
# 🌐 Initialize MCP
# ---------------------------------------------------------
logging.basicConfig(format="[%(levelname)s]: %(message)s", level=logging.INFO)
logger = logging.getLogger(__name__)

mcp = FastMCP(name="MyEnhancedGCSMCPServer")
# ---------------------------------------------------------
# 1️⃣ Simple Greeting
# ---------------------------------------------------------
@mcp.tool
def sayhi(name: str) -> str:
  """Returns a friendly greetings"""
  return f"Hello {name}! It's a pleasure to connect from your enhanced MCP Server."

# ---------------------------------------------------------
# 2️⃣ List all GCS buckets
# ---------------------------------------------------------
@mcp.tool
def list_gcs_buckets() -> List[str]:
  """Lists all GCS buckets in the project."""
  try:
      storage_client = storage.Client()
      buckets = storage_client.list_buckets()
      return [bucket.name for bucket in buckets]
  except exceptions.Forbidden as e:
      return [f"Error: Permission denied to list buckets. Details: {e}"]
  except Exception as e:
      return [f"An unexpected error occurred: {e}"]

# ---------------------------------------------------------
# 3️⃣ Create a new bucket
# ---------------------------------------------------------
@mcp.tool
def create_bucket(bucket_name: str, location: str = "US") -> str:
  """Creates a new GCS bucket. Bucket names must be globally unique."""
  try:
      storage_client = storage.Client()
      bucket = storage_client.bucket(bucket_name)
      bucket.location = location
      storage_client.create_bucket(bucket)
      return f"✅ Bucket '{bucket_name}' created successfully in '{location}'."
  except exceptions.Conflict:
      return f"⚠️ Error: Bucket '{bucket_name}' already exists."
  except exceptions.Forbidden as e:
      return f"❌ Error: Permission denied to create bucket. Details: {e}"
  except Exception as e:
      return f"❌ Unexpected error: {e}"

# ---------------------------------------------------------
# 4️⃣ Delete a bucket
# ---------------------------------------------------------
@mcp.tool
def delete_bucket(bucket_name: str) -> str:
  """Deletes a GCS bucket."""
  try:
      storage_client = storage.Client()
      bucket = storage_client.bucket(bucket_name)
      bucket.delete(force=True)
      return f"🗑️ Bucket '{bucket_name}' deleted successfully."
  except exceptions.NotFound:
      return f"⚠️ Error: Bucket '{bucket_name}' not found."
  except exceptions.Forbidden as e:
      return f"❌ Error: Permission denied to delete bucket. Details: {e}"
  except Exception as e:
      return f"❌ Unexpected error: {e}"

# ---------------------------------------------------------
# 5️⃣ List objects in a bucket
# ---------------------------------------------------------
@mcp.tool
def list_objects(bucket_name: str) -> List[str]:
  """Lists all objects in a specified GCS bucket."""
  try:
      storage_client = storage.Client()
      blobs = storage_client.list_blobs(bucket_name)
      return [blob.name for blob in blobs]
  except exceptions.NotFound:
      return [f"⚠️ Error: Bucket '{bucket_name}' not found."]
  except Exception as e:
      return [f"❌ Unexpected error: {e}"]
# ---------------------------------------------------------
# Delete file from a bucket
# ---------------------------------------------------------
@mcp.tool
def delete_blob(bucket_name: str, blob_name: str) -> str:
  """Deletes a blob from a GCS bucket."""
  try:
      storage_client = storage.Client()
      bucket = storage_client.bucket(bucket_name)
      blob = bucket.blob(blob_name)
      blob.delete()
      return f"🗑️ Blob '{blob_name}' deleted from bucket '{bucket_name}'."
  except exceptions.NotFound:
      return f"⚠️ Error: Bucket '{bucket_name}' or blob '{blob_name}' not found."
  except exceptions.Forbidden as e:
      return f" Permission denied. Details: {e}"
  except Exception as e:
      return f" Unexpected error: {e}"

# ---------------------------------------------------------
# Get bucket metadata
# ---------------------------------------------------------
@mcp.tool
def get_bucket_metadata(bucket_name: str) -> Dict[str, Any]:
  """Retrieves metadata for a GCS bucket."""
  try:
      storage_client = storage.Client()
      bucket = storage_client.get_bucket(bucket_name)
      return {
          "id": bucket.id,
          "name": bucket.name,
          "location": bucket.location,
          "storage_class": bucket.storage_class,
          "created": bucket.time_created.isoformat() if bucket.time_created else None,
          "updated": bucket.updated.isoformat() if bucket.updated else None,
          "versioning_enabled": bucket.versioning_enabled,
      }
  except exceptions.NotFound:
      return {"error": f" Bucket '{bucket_name}' not found."}
  except Exception as e:
      return {"error": f" Unexpected error: {e}"}

# ---------------------------------------------------------
# Get object metadata
# ---------------------------------------------------------
@mcp.tool
def get_blob_metadata(bucket_name: str, blob_name: str) -> Dict[str, Any]:
  """Retrieves metadata for a specific blob."""
  try:
      storage_client = storage.Client()
      bucket = storage_client.bucket(bucket_name)
      blob = bucket.get_blob(blob_name)
      if not blob:
          return {"error": f" Blob '{blob_name}' not found in '{bucket_name}'."}
      return {
          "name": blob.name,
          "bucket": blob.bucket.name,
          "size": blob.size,
          "content_type": blob.content_type,
          "updated": blob.updated.isoformat() if blob.updated else None,
          "storage_class": blob.storage_class,
          "crc32c": blob.crc32c,
          "md5_hash": blob.md5_hash,
      }
  except exceptions.NotFound:
      return {"error": f" Bucket '{bucket_name}' not found."}
  except Exception as e:
      return {"error": f" Unexpected error: {e}"}

# ---------------------------------------------------------
# 🚀 Entry Point
# ---------------------------------------------------------
if __name__ == "__main__":
  port = int(os.getenv("PORT", 8080))
  logger.info(f"🚀 Starting Enhanced GCS MCP Server on port {port}")
  asyncio.run(
      mcp.run_async(
          transport="http",
          host="0.0.0.0",
          port=port,
      )
  )

कोड जोड़ने के बाद, फ़ाइल सेव करें.

आपका प्रोजेक्ट स्ट्रक्चर अब ऐसा दिखना चाहिए:

gcs-mcp-server/
├── requirements.txt
└── main.py

आइए, कोड के बारे में कम शब्दों में जानते हैं:

इंपोर्ट और सेटअप:

कोड, ज़रूरी लाइब्रेरी इंपोर्ट करके शुरू होता है.

• स्टैंडर्ड लाइब्रेरी: asyncio एसिंक्रोनस एक्ज़ीक्यूशन के लिए, logging स्टेटस मैसेज आउटपुट करने के लिए, और os एनवायरमेंट वैरिएबल के लिए.
• FastMCP: यह मॉडल कॉन्टेक्स्ट प्रोटोकॉल सर्वर बनाने के लिए इस्तेमाल किया जाने वाला मुख्य फ़्रेमवर्क है.
• Google Cloud Storage: GCS के साथ इंटरैक्ट करने के लिए, google.cloud.storage लाइब्रेरी इंपोर्ट की जाती है. साथ ही, गड़बड़ी को ठीक करने के लिए exceptions लाइब्रेरी इंपोर्ट की जाती है.

शुरू करना:

हम लॉगिंग फ़ॉर्मैट को कॉन्फ़िगर करते हैं, ताकि सर्वर की पहचान को डीबग और ट्रैक किया जा सके. इसके अलावा, हम FastMCP के एक इंस्टेंस को कॉन्फ़िगर करते हैं. इसका नाम MyEnhancedGCSMCPServer है. इस ऑब्जेक्ट (mcp) का इस्तेमाल, सर्वर के ज़रिए उपलब्ध कराए गए सभी टूल (फ़ंक्शन) को रजिस्टर करने के लिए किया जाएगा. हम इन टूल के बारे में जानकारी दे रहे हैं:

• list_gcs_buckets: इससे, Google Cloud से जुड़े प्रोजेक्ट में मौजूद सभी स्टोरेज बकेट की सूची मिलती है.
• create_bucket: इससे किसी खास नाम और जगह के साथ नया बकेट बनाया जाता है.
• delete_bucket: इससे मौजूदा बकेट मिट जाती है.
• list_objects: किसी बकेट में मौजूद सभी फ़ाइलों (ब्लॉब) की सूची बनाता है.
• delete_blob: किसी बकेट से कोई फ़ाइल मिटाता है.
• get_bucket_metadata: यह किसी बकेट के बारे में तकनीकी जानकारी दिखाता है. जैसे, लोकेशन, स्टोरेज क्लास, वर्शनिंग की स्थिति, और बनाने का समय.
• get_blob_metadata: इससे किसी फ़ाइल की तकनीकी जानकारी मिलती है. जैसे, फ़ाइल का साइज़, कॉन्टेंट टाइप, MD5 हैश, और फ़ाइल को आखिरी बार कब अपडेट किया गया था.

Entry Point:

इससे पोर्ट कॉन्फ़िगर होता है. अगर इसे सेट नहीं किया जाता है, तो डिफ़ॉल्ट रूप से 8080 लागू हो जाता है. इसके बाद, यह asyncio.run() का इस्तेमाल करके, mcp.run_async के साथ सर्वर को एसिंक्रोनस तरीके से शुरू करता है. आखिर में, यह सर्वर को एचटीटीपी (host 0.0.0.0) पर चलाने के लिए कॉन्फ़िगर करता है, ताकि आने वाले नेटवर्क अनुरोधों के लिए इसे ऐक्सेस किया जा सके.

4. एमसीपी सर्वर को कंटेनर में रखना

इस सेक्शन में, Dockerfile बनाया जाएगा, ताकि आपके एमसीपी सर्वर को Cloud Run पर डिप्लॉय किया जा सके.

Cloud Run के लिए, कंटेनर में मौजूद ऐप्लिकेशन की ज़रूरत होती है. आपको यह तय करना होगा कि आपका ऐप्लिकेशन कैसे बनाया और शुरू किया जाता है.

Dockerfile बनाना

Dockerfile नाम की नई फ़ाइल बनाएं:

touch Dockerfile

इसे Cloud Shell Editor में खोलें:

cloudshell edit ~/gcs-mcp-server/Dockerfile

Docker कॉन्फ़िगरेशन जोड़ना

इस कॉन्टेंट को Dockerfile में चिपकाएं:

FROM python:3.11-slim
ENV PYTHONDONTWRITEBYTECODE=1
ENV PYTHONUNBUFFERED=1
WORKDIR /app
RUN apt-get update && apt-get install -y \
   build-essential \
   gcc \
   && rm -rf /var/lib/apt/lists/*
RUN pip install --upgrade pip
COPY . .
RUN pip install -r requirements.txt
ENV PORT=8080
EXPOSE 8080
CMD ["python", "main.py"]

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

gcs-mcp-server/
├── requirements.txt
├── main.py
└── Dockerfile

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

अब सोर्स से सीधे तौर पर अपना एमसीपी सर्वर डिप्लॉय करें.

Cloud Shell में यह कमांड चलाएं:

gcloud run deploy gcs-mcp-server \
   --no-allow-unauthenticated \
   --region=us-central1 \
   --source=. \
   --labels=session=buildersdayblr

जब आपको

• क्या पुष्टि न किए गए अनुरोधों को अनुमति देनी है? → नहीं

Cloud Build ये काम करेगा:

• कंटेनर इमेज बनाना
• इसे Artifact Registry में पुश करें
• इसे Cloud Run पर डिप्लॉय करें

Artifact Registry में डेटाबेस बनाया जा सकता है, इसकी पुष्टि करने के लिए Y डालें.

Deploying from source requires an Artifact Registry Docker repository to store built containers. A repository named [cloud-run-source-deploy] in region [us-central1] will be created.

Do you want to continue (Y/n)?  Y

⚠️ ध्यान दें: प्रोडक्शन एनवायरमेंट के लिए, हमेशा --no-allow-unauthenticated फ़्लैग का इस्तेमाल करें, ताकि अनधिकृत ऐक्सेस को रोका जा सके.अगले चरण में, आपको आइडेंटिटी टोकन का इस्तेमाल करके Gemini CLI की पुष्टि करनी होगी.

डप्लॉयमेंट पूरा होने के बाद, आपको Cloud Run सेवा के यूआरएल के साथ एक मैसेज दिखेगा.

Cloud Run → Services में जाकर, Google Cloud Console से भी डिप्लॉयमेंट की पुष्टि की जा सकती है.

6. Gemini CLI कॉन्फ़िगरेशन

अब तक, हमने Cloud Run पर अपना एमसीपी सर्वर बनाया और उसे डिप्लॉय किया है.

अब मज़ेदार हिस्सा शुरू होता है. इसे Gemini CLI से कनेक्ट करें और अपने नैचुरल अंदाज़ में दिए गए प्रॉम्प्ट को क्लाउड ऐक्शन में बदलें.

Cloud Run Invoker की अनुमति देना

हमारी Cloud Run सेवा निजी है. इसलिए, हम पहचान टोकन का इस्तेमाल करके पुष्टि करेंगे और सही IAM अनुमतियां असाइन करेंगे.

हमने --no-allow-unauthenticated के साथ सेवा को डिप्लॉय किया है. इसलिए, आपको इसे शुरू करने की अनुमति देनी होगी.

अपना प्रोजेक्ट आईडी सेट करें:

export GOOGLE_CLOUD_PROJECT=$(gcloud config get-value project)

खुद को Cloud Run Invoker की भूमिका असाइन करें:

gcloud projects add-iam-policy-binding $GOOGLE_CLOUD_PROJECT \
  --member=user:$(gcloud config get-value account) \
  --role='roles/run.invoker'

इससे आपका खाता, Cloud Run सेवा को सुरक्षित तरीके से चालू कर पाता है.

पहचान टोकन जनरेट करना

Cloud Run को पुष्टि किए गए ऐक्सेस के लिए, Identity Token की ज़रूरत होती है.

एक जनरेट करें:

export PROJECT_NUMBER=$(gcloud projects describe $GOOGLE_CLOUD_PROJECT --format="value(projectNumber)")
export ID_TOKEN=$(gcloud auth print-identity-token)

इसकी पुष्टि करें:

echo $PROJECT_NUMBER
echo $ID_TOKEN

इस टोकन का इस्तेमाल, Gemini CLI के कॉन्फ़िगरेशन में किया जाएगा.

Gemini CLI में एमसीपी सर्वर को कॉन्फ़िगर करना

Gemini CLI की सेटिंग वाली फ़ाइल खोलें:

cloudshell edit ~/.gemini/settings.json

यह कॉन्फ़िगरेशन जोड़ें:

{
 "ide": {
   "enabled": true,
   "hasSeenNudge": true
 },
 "mcpServers": {
   "my-cloudrun-server": {
     "httpUrl": "https://gcs-mcp-server-$PROJECT_NUMBER.asia-south1.run.app/mcp",
     "headers": {
       "Authorization": "Bearer $ID_TOKEN"
     }
   }
 },
 "security": {
   "auth": {
     "selectedType": "cloud-shell"
   }
 }
}

Gemini CLI में कॉन्फ़िगर किए गए एमसीपी सर्वर की पुष्टि करना

Cloud Shell टर्मिनल में Gemini सीएलआई लॉन्च करने के लिए, यह कमांड चलाएं:

gemini

आपको नीचे दिया गया आउटपुट दिखेगा

Gemini CLI में जाकर, यह कमांड चलाएं:

/mcp refresh
/mcp list

अब आपको gcs-cloudrun-serve रजिस्टर किया गया दिखेगा. यहाँ एक सैंपल स्क्रीनशॉट दिखाया गया है:

7. नैचुरल लैंग्वेज का इस्तेमाल करके, Google Storage Operations को चालू करना

⚠️ नीचे दिए गए प्रॉम्प्ट में, my-ai-bucket नाम को ऐसे बकेट के नाम से बदलें जो दुनिया भर में यूनीक हो. ऐसा इसलिए, क्योंकि Google Cloud Storage में सिर्फ़ दुनिया भर में यूनीक नाम इस्तेमाल किए जा सकते हैं. अगर आपको यह गड़बड़ी का मैसेज मिलता है कि बकेट पहले से मौजूद है, तो कोई दूसरा नाम आज़माएं.

बकेट बनाएं

Create a bucket named my-ai-bucket in asia-south1 region

इससे आपको एक प्रॉम्प्ट दिखेगा. इसमें एमसीपी सर्वर से create_bucket टूल को चालू करने की अनुमति मांगी जाएगी.

'एक बार अनुमति दें' पर क्लिक करें. इसके बाद, आपकी बकेट उस क्षेत्र में बन जाएगी जिसके लिए आपने अनुरोध किया था.

बकेट की सूची बनाना

बकेट की सूची बनाने के लिए, यह प्रॉम्प्ट डालें:

List all my GCS buckets

बकेट मिटाएं

किसी बकेट को मिटाने के लिए, नीचे दिया गया प्रॉम्प्ट डालें (<your_bucket_name> की जगह अपनी बकेट का नाम डालें):

Delete the bucket <your_bucket_name>

बकेट का मेटाडेटा पाना

किसी बकेट का मेटाडेटा पाने के लिए, नीचे दिया गया प्रॉम्प्ट डालें (<your_bucket_name> की जगह अपनी बकेट का नाम डालें):

Give me metadata of the <your_bucket_name>

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

Google Cloud प्रोजेक्ट को मिटाने का फ़ैसला लेने से पहले, इस पूरे सेक्शन को पढ़ें. ऐसा इसलिए, क्योंकि इस कार्रवाई को आम तौर पर वापस नहीं किया जा सकता.

इस कोडलैब में इस्तेमाल किए गए संसाधनों के लिए, अपने Google Cloud खाते से शुल्क न लिए जाने के लिए, यह तरीका अपनाएं:

• Google Cloud Console में, 'संसाधन मैनेज करें' पेज पर जाएं.
• प्रोजेक्ट की सूची में जाकर, वह प्रोजेक्ट चुनें जिसे मिटाना है.
• मिटाएं पर क्लिक करें.

डायलॉग बॉक्स में, प्रोजेक्ट आईडी डालें. इसके बाद, प्रोजेक्ट को हमेशा के लिए मिटाने के लिए, बंद करें पर क्लिक करें.

प्रोजेक्ट मिटाने पर, उस प्रोजेक्ट में इस्तेमाल किए गए सभी संसाधनों के लिए बिलिंग बंद हो जाती है. इनमें Cloud Run सेवाएं और Artifact Registry में सेव की गई कंटेनर इमेज शामिल हैं.

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

1. Google Cloud Console में Cloud Run पर जाएं.
2. gcs-mcp-server सेवा को चुनें.
3. सेवा को हटाने के लिए, मिटाएं पर क्लिक करें..

इसके अलावा, Cloud Shell टर्मिनल में यह gcloud कमांड भी दी जा सकती है.

gcloud run services delete gcs-mcp-server --region=us-central1

9. नतीजा

🎉 बधाई हो! आपने अभी-अभी एआई की मदद से काम करने वाला पहला क्लाउड वर्कफ़्लो बनाया है!

आपने ये लागू किए हैं:

• Python पर आधारित कस्टम एमसीपी सर्वर
• Google Cloud Storage के लिए टूल कॉल करने की सुविधाएं
• Docker का इस्तेमाल करके कंटेनर बनाना
• Cloud Run पर सुरक्षित तरीके से डिप्लॉय करना
• पहचान के आधार पर पुष्टि करने की सुविधा
• Gemini CLI के साथ इंटिग्रेशन

अब इस आर्किटेक्चर को BigQuery, Pub/Sub या Compute Engine जैसी अन्य Google Cloud सेवाओं के साथ इस्तेमाल किया जा सकता है.

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