תחילת העבודה עם MCP, ‏ ADK ו-A2A

1. סקירה כללית

הפופולריות של סוכני AI גדלה במהירות, והם משנים את האופן שבו משימות מבוצעות באופן אוטומטי וההחלטות מתקבלות. הם יכולים לפעול באופן אוטונומי, ללמוד ולקיים אינטראקציה עם הסביבה כדי להשיג יעדים.

אבל איך בדיוק בונים סוכן? ב-Codelab הזה נדגים איך ליצור סוכן מטבע שיכול להמיר בין מטבעות שונים של מדינות שונות. לאחר מכן תיצרו סוכן נסיעות ותקשרו אותו לסוכן המטבע. המטרה היא להסביר לכם על הטכנולוגיות העדכניות ביותר, כדי שתבינו את ראשי התיבות שראיתם באינטרנט (MCP,‏ ADK,‏ A2A) ותדעו איך הם משתלבים יחד.

Model Context Protocol (MCP)

‫Model Context Protocol‏ (MCP) הוא פרוטוקול פתוח שקובע סטנדרט לאופן שבו אפליקציות מספקות הקשר למודלים של LLM. ‫MCP מספק דרך סטנדרטית לחבר מודלים של AI למשאבים, להנחיות ולכלים.

ערכה לפיתוח סוכנים (ADK)

הערכה לפיתוח סוכנים (ADK) היא מסגרת גמישה לניהול תהליכים, שמאפשרת לפתח ולפרוס סוכני AI. ה-ADK מתאים לכל המודלים, לא תלוי בפריסה, והוא מיועד לתאימות למסגרות אחרות. ה-ADK נועד להפוך את פיתוח הסוכנים לתהליך שדומה יותר לפיתוח תוכנה, כדי להקל על מפתחים ליצור, לפרוס ולתזמר ארכיטקטורות אג'נטיות שמתאימות למשימות פשוטות ולתהליכי עבודה מורכבים.

פרוטוקול Agent2Agent‏ (A2A)

‫Agent2Agent (A2A) Protocol הוא תקן פתוח שנועד לאפשר תקשורת ושיתוף פעולה חלקים בין סוכני AI. בדומה ל-MCP, שמאפשרת גישה סטנדרטית של מודלים גדולים של שפה (LLM) לנתונים ולכלים, A2A מאפשרת לסוכנים לתקשר עם סוכנים אחרים בצורה סטנדרטית. בעולם שבו סוכנים נבנים באמצעות מסגרות מגוונות ועל ידי ספקים שונים, A2A מספקת שפה משותפת, מבטלת את הניתוק בין מערכות שונות ומקדמת יכולת פעולה הדדית.

מה תלמדו

• איך יוצרים שרת MCP מקומי
• פריסת שרת ה-MCP ב-Cloud Run
• איך ליצור סוכן באמצעות ערכה לפיתוח סוכנים שמשתמש בכלי MCP
• איך חושפים סוכן ADK כשרת A2A
• בדיקת שרת A2A באמצעות לקוח A2A
• איך יוצרים סוכן שיכול לדבר עם סוכן אחר באמצעות פרוטוקול A2A

הדרישות

• דפדפן, כמו Chrome או Firefox
• פרויקט ב-Google Cloud שהחיוב בו מופעל.

‫2. לפני שמתחילים

יצירת פרויקט

אם אין לכם פרויקט בענן ב-Google Cloud, צרו אחד.

במסוף Google Cloud, בדף לבחירת הפרויקט, בוחרים או יוצרים פרויקט ב-Google Cloud.

צריך גם לוודא שהחיוב מופעל בפרויקט בענן שלכם. כך בודקים אם החיוב מופעל בפרויקט

הפעלת Cloud Shell

‫Google Cloud Shell היא סביבת פיתוח אינטראקטיבית מבוססת-דפדפן שזמינה ישירות ב-Google Cloud Console. זו הדרך הכי קלה להתחיל להשתמש ב-Google Cloud בלי להתקין כלים באופן מקומי.

לוחצים על הקישור כדי להפעיל את Cloud Shell. אפשר לעבור בין Cloud Shell Terminal (כדי להפעיל פקודות בענן) לבין Editor (כדי ליצור פרויקטים) בלחיצה על הכפתור המתאים ב-Cloud Shell.

אחרי שמתחברים ל-Cloud Shell, בודקים שכבר בוצע אימות ושהפרויקט מוגדר למזהה הפרויקט שלכם באמצעות הפקודה הבאה:

gcloud auth list

מריצים את הפקודה הבאה ב-Cloud Shell כדי לוודא שפקודת gcloud מכירה את הפרויקט.

gcloud config list project

משתמשים בפקודה הבאה כדי להגדיר את הפרויקט:

export PROJECT_ID=<YOUR_PROJECT_ID>
gcloud config set project $PROJECT_ID

הפעלת ממשקי Cloud API

מפעילים את ממשקי ה-API הנדרשים באמצעות הפקודה הבאה. הפעולה עשויה להימשך כמה דקות.

gcloud services enable cloudresourcemanager.googleapis.com \
                       servicenetworking.googleapis.com \
                       run.googleapis.com \
                       cloudbuild.googleapis.com \
                       artifactregistry.googleapis.com \
                       aiplatform.googleapis.com \
                       compute.googleapis.com

אפשר לעיין במאמרי העזרה בנושא פקודות gcloud ושימוש בהן.

קבל את הקוד

משכפלים את המאגר:

git clone https://github.com/jackwotherspoon/currency-agent.git
cd currency-agent

משתמשים ב-uv כדי לנהל תלות, והוא כבר מותקן ב-Cloud Shell. אבל אם מריצים את ה-codelab באופן מקומי, אפשר להתקין אותו כך:

# macOS and Linux
curl -LsSf https://astral.sh/uv/install.sh | sh

# Windows (uncomment below line)
# powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

NOTE יכול להיות שתצטרכו להפעיל מחדש את הטרמינל או לפתוח טרמינל חדש אחרי התקנת uv אם מופיעה השגיאה uv not found.

כדי להגדיר משתני סביבה באמצעות קובץ .env, מריצים את הפקודה הבאה:

echo "GOOGLE_GENAI_USE_ENTERPRISE=TRUE" >> .env \
&& echo "GOOGLE_CLOUD_PROJECT=$PROJECT_ID" >> .env \
&& echo "GOOGLE_CLOUD_LOCATION=global" >> .env

3. יצירת שרת MCP מקומי

לפני שתתחילו לתזמן את סוכן המטבעות, תצטרכו ליצור שרת MCP כדי לחשוף את הכלים שהסוכן יצטרך.

שרת MCP מאפשר לכם לכתוב תוכניות קלות משקל כדי לחשוף יכולות ספציפיות (כמו אחזור של שערי חליפין) ככלים. לאחר מכן, סוכן אחד או כמה סוכנים יכולים לגשת לכלים האלה באמצעות Model Context Protocol (MCP)‎ סטנדרטי.

אפשר להשתמש בחבילת Python‏ FastMCP כדי ליצור שרת MCP שחושף כלי יחיד בשם get_exchange_rate. הכלי get_exchange_rate שולח קריאה באינטרנט אל Frankfurter API כדי לקבל את שער החליפין הנוכחי בין שני מטבעות.

הקוד של שרת ה-MCP נמצא בקובץ mcp-server/server.py:

import logging
import os

import httpx
from fastmcp import FastMCP

# Set up logging
logger = logging.getLogger(__name__)
logging.basicConfig(format="[%(levelname)s]: %(message)s", level=logging.INFO)

mcp = FastMCP("Currency MCP Server 💵")

@mcp.tool()
def get_exchange_rate(
    currency_from: str = 'USD',
    currency_to: str = 'EUR',
    currency_date: str = 'latest',
):
    """Use this to get current exchange rate.

    Args:
        currency_from: The currency to convert from (e.g., "USD").
        currency_to: The currency to convert to (e.g., "EUR").
        currency_date: The date for the exchange rate or "latest". Defaults to "latest".

    Returns:
        A dictionary containing the exchange rate data, or an error message if the request fails.
    """
    logger.info(f"--- 🛠️ Tool: get_exchange_rate called for converting {currency_from} to {currency_to} ---")
    try:
        response = httpx.get(
            f'https://api.frankfurter.app/{currency_date}',
            params={'from': currency_from, 'to': currency_to},
        )
        response.raise_for_status()

        data = response.json()
        if 'rates' not in data:
            return {'error': 'Invalid API response format.'}
        logger.info(f'✅ API response: {data}')
        return data
    except httpx.HTTPError as e:
        return {'error': f'API request failed: {e}'}
    except ValueError:
        return {'error': 'Invalid JSON response from API.'}

if __name__ == "__main__":
    logger.info(f"🚀 MCP server started on port {os.getenv('PORT', 8080)}")
    # Could also use 'sse' transport, host="0.0.0.0" required for Cloud Run.
    asyncio.run(
        mcp.run_async(
            transport="http",
            host="0.0.0.0",
            port=os.getenv("PORT", 8080),
        )
    )

כדי להפעיל את שרת ה-MCP באופן מקומי, פותחים טרמינל ומריצים את הפקודה הבאה (השרת יופעל בכתובת http://localhost:8080):

uv run mcp-server/server.py

בודקים ששרת ה-MCP פועל בצורה תקינה ושניתן לגשת לכלי get_exchange_rate באמצעות Model Context Protocol.

בחלון טרמינל חדש (כדי לא להפסיק את שרת ה-MCP המקומי), מריצים את הפקודה הבאה:

uv run mcp-server/test_server.py

אמור להופיע שער החליפין הנוכחי של 1 דולר ארה"ב לאירו:

--- 🛠️ Tool found: get_exchange_rate ---
--- 🪛 Calling get_exchange_rate tool for USD to EUR ---
--- ✅ Success: {
  "amount": 1.0,
  "base": "USD",
  "date": "2025-05-26",
  "rates": {
    "EUR": 0.87866
  }
} ---

מדהים! יש לכם שרת MCP פעיל עם כלי שהסוכן יוכל לגשת אליו.

לפני שעוברים לתחנה הבאה, עוצרים את שרת ה-MCP שפועל באופן מקומי על ידי הפעלת הפקודה Ctrl+C (או Command+C ב-Mac) במסוף שבו הפעלתם אותו.

4. פריסת שרת ה-MCP ב-Cloud Run

עכשיו אפשר לפרוס את שרת ה-MCP כשרת MCP מרוחק ב-Cloud Run 🚀☁️

היתרונות בהפעלת שרת MCP מרחוק

להרצת שרת MCP מרחוק ב-Cloud Run יש כמה יתרונות:

• 📈יכולת הרחבה: Cloud Run מתוכנן להרחבה מהירה כדי לטפל בכל הבקשות הנכנסות. Cloud Run יתאים את שרת ה-MCP שלך באופן אוטומטי בהתאם לדרישה.
• 👥שרת מרכזי: אתם יכולים לשתף גישה לשרת MCP מרכזי עם חברי הצוות באמצעות הרשאות IAM, וכך לאפשר להם להתחבר אליו מהמחשבים המקומיים שלהם במקום להריץ שרתים משלהם באופן מקומי. אם יבוצע שינוי בשרת ה-MCP, כל חברי הצוות ייהנו ממנו.
• 🔐אבטחה: Cloud Run מספק דרך קלה לאכיפת בקשות מאומתות. כך אפשר לאפשר רק חיבורים מאובטחים לשרת ה-MCP ולמנוע גישה לא מורשית.

חשוב: היבט האבטחה שצוין קודם הוא קריטי. אם לא תאכפו אימות, כל אחד באינטרנט הציבורי יוכל לגשת לשרת ה-MCP שלכם ולהתקשר אליו.

עוברים לספרייה mcp-server:

cd mcp-server

פורסים את שרת ה-MCP ב-Cloud Run:

gcloud run deploy mcp-server --no-allow-unauthenticated --region=us-central1 --source .

אם הפריסה של השירות הושלמה בהצלחה, תוצג הודעה כמו זו:

Service [mcp-server] revision [mcp-server-12345-abc] has been deployed and is serving 100 percent of traffic.

אימות לקוחות MCP

מכיוון שציינתם --no-allow-unauthenticated כדי לדרוש אימות, כל לקוח MCP שמתחבר לשרת ה-MCP המרוחק יצטרך לעבור אימות.

במסמכים הרשמיים בנושא אירוח שרתי MCP ב-Cloud Run יש מידע נוסף על הנושא הזה, בהתאם למקום שבו מריצים את לקוח ה-MCP.

תצטרכו להריץ את Cloud Run proxy כדי ליצור במחשב המקומי מנהרה מאומתת לשרת ה-MCP המרוחק.

כברירת מחדל, כדי לגשת לכתובת ה-URL של שירותי Cloud Run, צריך לאשר את כל הבקשות באמצעות תפקיד ה-IAM‏ Cloud Run Invoker‏ (roles/run.invoker). הקישור הזה של מדיניות IAM מבטיח שמנגנון אבטחה חזק ישמש לאימות של לקוח ה-MCP המקומי.

צריך לוודא שלכם או לכל חבר צוות שמנסה לגשת לשרת ה-MCP המרוחק יש את תפקיד ה-IAM‏ roles/run.invoker שמשויך לישות ה-IAM (חשבון Google Cloud).

הערה: יכול להיות שתתבקשו להוריד את ה-proxy של Cloud Run אם הוא עדיין לא מותקן. פועלים לפי ההנחיות כדי להוריד ולהתקין אותו.

gcloud run services proxy mcp-server --region=us-central1

הפלט הבא אמור להתקבל:

Proxying to Cloud Run service [mcp-server] in project [<YOUR_PROJECT_ID>] region [us-central1]
http://127.0.0.1:8080 proxies to https://mcp-server-abcdefgh-uc.a.run.app

כל התנועה אל http://127.0.0.1:8080 תאומת ותועבר לשרת ה-MCP המרוחק.

בדיקת שרת ה-MCP המרוחק

בטרמינל חדש, חוזרים לתיקיית הבסיס ומריצים מחדש את קובץ mcp-server/test_server.py כדי לוודא ששרת ה-MCP המרוחק פועל.

הערה: חשוב להשאיר את ה-proxy של Cloud Run פועל למשך שאר ה-codelab.

cd ..
uv run mcp-server/test_server.py

הפלט שיוצג יהיה דומה לזה שהוצג כשמריצים את השרת באופן מקומי:

--- 🛠️ Tool found: get_exchange_rate ---
--- 🪛 Calling get_exchange_rate tool for USD to EUR ---
--- ✅ Success: {
  "amount": 1.0,
  "base": "USD",
  "date": "2025-05-26",
  "rates": {
    "EUR": 0.87866
  }
} ---

אתם יכולים להריץ שאילתה ביומנים של שרת ה-MCP של Cloud Run שנפרס כדי לוודא שהשרת המרוחק אכן נקרא:

gcloud run services logs read mcp-server --region us-central1 --limit 5

הפלט הבא אמור להופיע ביומנים:

2025-06-04 14:28:29,871 [INFO]: --- 🛠️ Tool: get_exchange_rate called for converting USD to EUR ---
2025-06-04 14:28:30,610 [INFO]: HTTP Request: GET https://api.frankfurter.app/latest?from=USD&to=EUR "HTTP/1.1 200 OK"
2025-06-04 14:28:30,611 [INFO]: ✅ API response: {'amount': 1.0, 'base': 'USD', 'date': '2025-06-03', 'rates': {'EUR': 0.87827}}

עכשיו, אחרי שיש לכם שרת MCP מרוחק, אפשר להמשיך ליצירת סוכן. 🤖

5. יצירת סוכן באמצעות ADK

אחרי שפרסתם שרת MCP, הגיע הזמן ליצור את סוכן המטבע באמצעות ערכה לפיתוח סוכנים (ADK).

ה-ADK מאפשר ליצור סוכנים בקלות רבה, והוא כולל תמיכה מובנית ב-MCP Tools, כך שהסוכנים יכולים להתחבר לשרתי MCP. סוכן המטבע יגש לכלי get_exchange_rate באמצעות המחלקה MCPToolset של ADK.

הקוד של סוכן המטבע נמצא ב-currency_agent/agent.py:

import logging
import os

from dotenv import load_dotenv
from google.adk.agents import LlmAgent
from google.adk.a2a.utils.agent_to_a2a import to_a2a
from google.adk.tools.mcp_tool import MCPToolset, StreamableHTTPConnectionParams

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

load_dotenv()

SYSTEM_INSTRUCTION = (
    "You are a specialized assistant for currency conversions. "
    "Your sole purpose is to use the 'get_exchange_rate' tool to answer questions about currency exchange rates. "
    "If the user asks about anything other than currency conversion or exchange rates, "
    "politely state that you cannot help with that topic and can only assist with currency-related queries. "
    "Do not attempt to answer unrelated questions or use tools for other purposes."
)

logger.info("--- 🔧 Loading MCP tools from MCP Server... ---")
logger.info("--- 🤖 Creating ADK Currency Agent... ---")

root_agent = LlmAgent(
    model="gemini-3.7-flash",
    name="currency_agent",
    description="An agent that can help with currency conversions",
    instruction=SYSTEM_INSTRUCTION,
    tools=[
        MCPToolset(
            connection_params=StreamableHTTPConnectionParams(
                url=os.getenv("MCP_SERVER_URL", "http://localhost:8080/mcp")
            )
        )
    ],
)

כדי לבדוק במהירות את סוכן המטבעות, אפשר להשתמש בממשק המשתמש למפתחים של ADK. כדי לגשת אליו, מריצים את הפקודה adk web:

uv run adk web --allow_origins "regex:https://.*\.cloudshell\.dev"

בדפדפן, עוברים אל http://localhost:8000 כדי לראות את הסוכן ולבדוק אותו.

מוודאים שהסמל currency_agent נבחר כסוכן בפינה הימנית העליונה של ממשק המשתמש האינטרנטי.

אפשר לשאול את הנציג באזור הצ'אט שאלה כמו "What is 250 CAD to USD?" (מה שווה 250 דולר קנדי לעומת דולר אמריקאי?). לפני שהנציג ייתן תשובה, תוכלו לראות שהוא מתקשר לכלי get_exchange_rate MCP שלנו.

הסוכן עובד! הוא יכול לטפל בשאילתות שקשורות להמרות מטבעות 💸.

6. פרוטוקול Agent2Agent‏ (A2A)

‫Agent2Agent (A2A) Protocol הוא תקן פתוח שנועד לאפשר תקשורת ושיתוף פעולה חלקים בין סוכני AI. הפלטפורמה מאפשרת לסוכנים שנבנו באמצעות מסגרות מגוונות ועל ידי ספקים שונים לתקשר זה עם זה בשפה משותפת, ובכך לשבור את המחסומים ולעודד פעולה הדדית.

התכונה A2A מאפשרת לסוכנים:

• גילוי: אפשר למצוא סוכנים אחרים וללמוד על הכישורים שלהם (AgentSkill) ועל היכולות שלהם (AgentCapabilities) באמצעות כרטיסי סוכנים סטנדרטיים.
• תקשורת: החלפת הודעות ונתונים באופן מאובטח.
• שיתוף פעולה: הקצאת משימות ותיאום פעולות להשגת יעדים מורכבים.

פרוטוקול A2A מאפשר את התקשורת הזו באמצעות מנגנונים כמו 'כרטיסי סוכן' שמשמשים ככרטיסי ביקור דיגיטליים שסוכנים יכולים להשתמש בהם כדי לפרסם את היכולות שלהם ואת פרטי החיבור שלהם.

עכשיו צריך לחשוף את סוכן המטבע באמצעות A2A כדי שסוכנים ולקוחות אחרים יוכלו לקרוא לו.

A2A Python SDK

‫A2A Python SDK מספק מודלים של Pydantic לכל אחד מהמשאבים שצוינו למעלה: AgentSkill, ‏ AgentCapabilities ו-AgentCard. הכלי מספק ממשק להאצת הפיתוח והשילוב עם פרוטוקול A2A.

AgentSkill היא הדרך שבה תפרסמו לסוכנים אחרים שלסוכן המטבע יש כלי לget_exchange_rate:

# A2A Agent Skill definition
skill = AgentSkill(
    id='get_exchange_rate',
    name='Currency Exchange Rates Tool',
    description='Helps with exchange values between various currencies',
    tags=['currency conversion', 'currency exchange'],
    examples=['What is exchange rate between USD and GBP?'],
)

לאחר מכן, כחלק מAgentCard, יפורטו הכישורים והיכולות של הסוכן לצד פרטים נוספים כמו מצבי קלט ופלט שהסוכן יכול לטפל בהם:

# A2A Agent Card definition
agent_card = AgentCard(
    name='Currency Agent',
    description='Helps with exchange rates for currencies',
    url=f'http://{host}:{port}/',
    version='1.0.0',
    defaultInputModes=["text"],
    defaultOutputModes=["text"],
    capabilities=AgentCapabilities(streaming=True),
    skills=[skill],
)

הגיע הזמן לשלב את הכול עם סוכן המטבעות ולהציג את העוצמה של A2A!

7. חשיפת סוכן המטבע כשרת A2A

ה-ADK מפשט את התהליך של בניית סוכנים וקישור שלהם באמצעות פרוטוקול A2A. כדי להפוך סוכן ADK קיים לנגיש (חשיפה) כשרת A2A, משתמשים בפונקציה to_a2a(root_agent) של ADK (פרטים מלאים מופיעים במסמכי ADK).

הפונקציה to_a2a ממירה סוכן קיים לעבודה עם A2A, ומאפשרת לחשוף אותו כשרת באמצעות uvicorn. זה אומר שיש לכם יותר שליטה על מה שאתם רוצים לחשוף אם אתם מתכננים להעביר את הסוכן לשלב הייצור. הפונקציה to_a2a() יוצרת באופן אוטומטי כרטיס סוכן על סמך קוד הסוכן באמצעות A2A Python SDK.

אם בודקים את הקובץ currency_agent/agent.py, אפשר לראות את השימוש ב-to_a2a ואיך סוכן המטבע מוצג כשרת A2A עם שתי שורות קוד בלבד.

from google.adk.a2a.utils.agent_to_a2a import to_a2a
# ... see file for full code

# Make the agent A2A-compatible
a2a_app = to_a2a(root_agent, port=10000)

כדי להריץ את שרת A2A, מריצים את הפקודה הבאה בטרמינל חדש:

uv run uvicorn currency_agent.agent:a2a_app --host localhost --port 10000

אם השרת יופעל בהצלחה, הפלט ייראה כך ויציין שהוא פועל ביציאה 10000:

[INFO]: --- 🔧 Loading MCP tools from MCP Server... ---
[INFO]: --- 🤖 Creating ADK Currency Agent... ---
INFO:     Started server process [45824]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
INFO:     Uvicorn running on http://localhost:10000 (Press CTRL+C to quit)

סוכן המטבעות פועל עכשיו בהצלחה כשרת A2A, ויש לו אפשרות לקבל קריאות מסוכנים או מלקוחות אחרים באמצעות פרוטוקול A2A.

אימות שהסוכן המרוחק פועל

כדי לוודא שהסוכן פועל, אפשר להיכנס לכתובת ה-URL של כרטיס הסוכן של סוכן המטבע שנוצר אוטומטית באמצעות הפונקציה to_a2a().

בדפדפן, נכנסים לכתובת http://localhost:10000/.well-known/agent-card.json

יוצג לכם כרטיס הנציג הבא:

{
  "capabilities": {

  },
  "defaultInputModes": [
    "text/plain"
  ],
  "defaultOutputModes": [
    "text/plain"
  ],
  "description": "An agent that can help with currency conversions",
  "name": "currency_agent",
  "preferredTransport": "JSONRPC",
  "protocolVersion": "0.3.0",
  "skills": [
    {
      "description": "An agent that can help with currency conversions I am a specialized assistant for currency conversions. my sole purpose is to use the 'get_exchange_rate' tool to answer questions about currency exchange rates. If the user asks about anything other than currency conversion or exchange rates, politely state that I cannot help with that topic and can only assist with currency-related queries. Do not attempt to answer unrelated questions or use tools for other purposes.",
      "id": "currency_agent",
      "name": "model",
      "tags": [
        "llm"
      ]
    },
    {
      "description": "Use this to get current exchange rate.\n\nArgs:\n    currency_from: The currency to convert from (e.g., \"USD\").\n    currency_to: The currency to convert to (e.g., \"EUR\").\n    currency_date: The date for the exchange rate or \"latest\". Defaults to \"latest\".\n\nReturns:\n    A dictionary containing the exchange rate data, or an error message if the request fails.",
      "id": "currency_agent-get_exchange_rate",
      "name": "get_exchange_rate",
      "tags": [
        "llm",
        "tools"
      ]
    }
  ],
  "supportsAuthenticatedExtendedCard": false,
  "url": "http://localhost:10000",
  "version": "0.0.1"
}

בדיקת שרת A2A

עכשיו אפשר לבדוק את השרת על ידי שליחת כמה בקשות באמצעות A2A.

‫A2A Python SDK מספק מחלקה a2a.client.Client שמפשטת את התהליך.

הקובץ currency_agent/test_a2aclient.py מכיל קוד שמראה איך לאחזר את כרטיס הנציג ולשלוח הודעה לשרת A2A.

# ... see file for full code

async def get_agent_card():
    """Get the agent card."""
    print(f"🔄 Fetching the agent card at {AGENT_URL}")

    async with httpx.AsyncClient() as httpx_client:
        resolver = A2ACardResolver(
            httpx_client=httpx_client,
            base_url=AGENT_URL,
        )
        public_agent_card = await resolver.get_agent_card()
        print("✅ Successfully fetched the agent card")
    return public_agent_card


async def send_message(text_query: str) -> None:
    """
    Send a text query to the agent and print the response.
    """
    public_agent_card = await get_agent_card()

    print("🔄 Initializing a non-streaming client")
    config = ClientConfig(streaming=False)
    client = await create_client(agent=public_agent_card, client_config=config)

    message = new_text_message(text_query, role=Role.ROLE_USER)
    print("Sending request:")
    request = SendMessageRequest(message=message)
    print(request)

    print("Response:")
    async for chunk in client.send_message(request):
        print(chunk)
    await client.close()

מריצים את הבדיקות באמצעות הפקודה הבאה:

uv run currency_agent/test_a2aclient.py

אם בדיקת הטריגר תצליח, יקרו הדברים הבאים:

🔄 Fetching the agent card at http://localhost:10000
✅ Successfully fetched the agent card
====================================================
                     AgentCard                      
====================================================
--- General ---
Name        : currency_agent
Description : An agent that can help with currency conversions
Version     : 0.0.1

--- Interfaces ---
  [0] http://localhost:10000  (JSONRPC 1.0)

--- Capabilities ---
Streaming           : False
Push notifications  : False
Extended agent card : False

--- I/O Modes ---
Input  : text/plain
Output : text/plain

--- Skills ---
----------------------------------------------------
  ID          : currency_agent
  Name        : model
  Description : An agent that can help with currency conversions
  Tags        : llm
----------------------------------------------------
  ID          : currency_agent-get_exchange_rate
  Name        : get_exchange_rate
  Description : Use this to get current exchange rate.
  Tags        : llm, tools
====================================================
🔄 Fetching the agent card at http://localhost:10000
✅ Successfully fetched the agent card
🔄 Initializing a non-streaming client
Sending request:
message {
  message_id: "5d190c88-336e-4a22-925d-e2af49cf4bad"
  role: ROLE_USER
  parts {
    text: "how much is 100 USD in GBP?"
  }
}

Response:
task {
  id: "e6f311bb-654a-477f-82a9-81c7a48f7b81"
  context_id: "672e351b-0ff3-4aed-a059-868b383c41a0"
  status {
    state: TASK_STATE_COMPLETED
    timestamp {
      seconds: 1787836031
      nanos: 994786000
    }
  }
  artifacts {
    artifact_id: "e0a05ac8-25c7-471c-a33c-1073fe48cbb8"
    parts {
      text: "100 USD is currently equal to approximately **73.37 GBP** (at an exchange rate of 1 USD = 0.73368 GBP)."
    }
  }
  ...

זה עובד! הבדיקה הושלמה בהצלחה. אפשר לתקשר עם סוכן המטבע באמצעות פרוטוקול A2A עם לקוח A2A. 🎉

במאגר a2a-samples ב-GitHub אפשר למצוא דוגמאות נוספות ל-A2A.

8. שימוש בסוכן המטבעות המרוחק באמצעות A2A

בשלב הקודם השתמשתם בלקוח A2A כדי לתקשר עם סוכן המטבע באמצעות A2A.

בשלב הזה נראה איך אפשר להשתמש בסוכן המטבעות כסוכן מרוחק מסוכן נסיעות אחר.

קוד סוכן הנסיעות הוא travel_agent/agent.py:

import logging
import os

from dotenv import load_dotenv
from google.adk.agents import LlmAgent
from google.adk.tools.agent_tool import AgentTool
from google.adk.agents.remote_a2a_agent import RemoteA2aAgent, AGENT_CARD_WELL_KNOWN_PATH

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

load_dotenv()

SYSTEM_INSTRUCTION = (
    "You are a helpful travel assistant. You help users plan trips, recommend places, "
    "and answer travel-related questions. "
    "Whenever a user asks about currency exchange rates or money conversions, "
    "delegate the request to the 'currency_agent' sub-agent."
)

CURRENCY_AGENT_URL = os.getenv("CURRENCY_AGENT_URL", "http://localhost:10000")

logger.info(
    "--- 🔗 Connecting to Remote A2A Currency Agent at %s... ---",
    CURRENCY_AGENT_URL,
)

currency_remote_agent = RemoteA2aAgent(
    name="currency_agent",
    agent_card=f"{CURRENCY_AGENT_URL}{AGENT_CARD_WELL_KNOWN_PATH}",
    description="An agent that can help with currency conversions and exchange rates.",
)

logger.info("--- 🤖 Creating ADK Travel Agent... ---")

root_agent = LlmAgent(
    model="gemini-3.7-flash",
    name="travel_agent",
    description="A travel assistant that can help plan trips and convert currencies via the remote currency agent.",
    instruction=SYSTEM_INSTRUCTION,
    tools=[AgentTool(agent=currency_remote_agent)],
)

שימו לב איך ניגשים לסוכן המטבעות באמצעות RemoteA2aAgent.

מריצים את adk web כדי לבדוק את סוכן הנסיעות:

uv run adk web --allow_origins "regex:https://.*\.cloudshell\.dev"

בדפדפן, עוברים אל http://localhost:8000 כדי לראות את הסוכן ולבדוק אותו.

מוודאים שהסמל travel_agent נבחר כסוכן בפינה הימנית העליונה של ממשק המשתמש האינטרנטי.

אפשר לשאול את הנציג באזור הצ'אט שאלה כמו "What is 250 CAD to USD?" (מה שווה 250 דולר קנדי לעומת דולר אמריקאי?).

לפני שהסוכן ייתן תשובה, אתם אמורים לראות את השיחות עם סוכן הנסיעות currency_agent מרחוק.

הסוכן עובד! הוא יכול לטפל בשאילתות שקשורות להמרות מטבע 💸 באמצעות הפעלת סוכן מרוחק באמצעות A2A!

9. מזל טוב

מעולה! יצרתם ופרסתם בהצלחה שרת MCP מרוחק, יצרתם סוכן מטבע באמצעות ערכה לפיתוח סוכנים (ADK) שמתחבר לכלים באמצעות MCP, וחשפתם את הסוכן באמצעות פרוטוקול Agent2Agent‏ (A2A). לאחר מכן יצרתם סוכן נסיעות כדי לדבר עם סוכן המטבע מרחוק באמצעות A2A!

כאן אפשר למצוא קישור לתיעוד המלא של הקוד.

רוצים לפרוס את הסוכן? ‫Agent Runtime ב-Gemini Enterprise Agent Platform מספק חוויה מנוהלת לפריסת סוכני AI בסביבת הייצור.

מה נכלל

• איך יוצרים שרת MCP מקומי
• פריסת שרת ה-MCP ב-Cloud Run
• איך ליצור סוכן באמצעות ערכה לפיתוח סוכנים שמשתמש בכלי MCP
• איך חושפים סוכן ADK כשרת A2A
• בדיקת שרת A2A באמצעות לקוח A2A
• איך יוצרים סוכן שיכול לדבר עם סוכן אחר באמצעות פרוטוקול A2A

הסרת המשאבים

כדי לא לצבור חיובים לחשבון Google Cloud על המשאבים שבהם השתמשתם במעבדה הזו:

1. במסוף Google Cloud, עוברים לדף Manage resources.
2. ברשימת הפרויקטים, בוחרים את הפרויקט שרוצים למחוק ולוחצים על Delete.
3. כדי למחוק את הפרויקט, כותבים את מזהה הפרויקט בתיבת הדו-שיח ולוחצים על Shut down.