איך בונים מערכת מרובת סוכנים

1. מבוא

בשיעור ה-Lab הזה תלמדו איך ליצור מערכת מבוזרת עם כמה סוכנים, ולא רק צ'אטבוטים פשוטים.

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

תבנו מערכת ליצירת קורסים שתכלול:

  • סוכן המחקר: שימוש ב-google_search כדי למצוא מידע עדכני.
  • סוכן שופט: מבקר את המחקר כדי לבדוק את האיכות והשלמות שלו.
  • סוכן ליצירת תוכן: הופך את המחקר לקורס מובנה.
  • Orchestrator Agent: ניהול תהליך העבודה והתקשורת בין המומחים האלה.

מה תלמדו

  • הגדרת סוכן (חוקר) שמשתמש בכלים ויכול לחפש באינטרנט.
  • הטמעה של פלט מובנה באמצעות Pydantic בשביל השופט.
  • התחברות לסוכנים מרוחקים באמצעות פרוטוקול Agent-to-Agent‏ (A2A).
  • בונים LoopAgent כדי ליצור לולאת משוב בין החוקר לבין השופט.
  • מריצים את המערכת המבוזרת באופן מקומי באמצעות ADK.
  • פורסים את המערכת מרובת הסוכנים ב-Google Cloud Run.
  • שימוש במודל Gemma ב-GPU של Cloud Run לסוכן ליצירת תוכן.

הדרישות

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

2. עקרונות של ארכיטקטורה ותזמור

קודם כל, נסביר איך הסוכנים האלה עובדים יחד. אנחנו מפתחים צינור ליצירת קורסים.

עיצוב המערכת

תרשים ארכיטקטורה

תזמור באמצעות סוכנים

סוכנים רגילים (כמו חוקר) מבצעים עבודה. סוכני תזמור (כמו LoopAgent או SequentialAgent) מנהלים סוכנים אחרים. אין להם כלים משלהם, והכלי שלהם הוא הקצאת הרשאות.

  1. ‫LoopAgent: הפעולה הזו דומה ללולאת while בקוד. הוא מריץ רצף של סוכנים שוב ושוב עד שתנאי מסוים מתקיים (או עד שמגיעים למספר המקסימלי של איטרציות). אנחנו משתמשים בזה בלולאת המחקר:
    • חוקר מוצא מידע.
    • ‫Judge (שופט) נותן ביקורת.
    • אם Judge אומר 'Fail', ‏ EscalationChecker מאפשר ללולאה להמשיך.
    • אם Judge אומר 'Pass', ‏ EscalationChecker מפסיק את הלולאה.
  2. ‫SequentialAgent: הפעולה הזו דומה להרצת סקריפט רגיל. הוא מפעיל סוכנים אחד אחרי השני. אנחנו משתמשים בזה בפייפליין ברמה גבוהה:
    • קודם מריצים את Research Loop (עד שהוא מסתיים עם נתונים טובים).
    • לאחר מכן, מפעילים את כלי יצירת התוכן (כדי לכתוב את הקורס).

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

3. הגדרה

הגדרת הפרויקט

יצירת פרויקט ב-Google Cloud

  1. במסוף Google Cloud, בדף לבחירת הפרויקט, בוחרים פרויקט ב-Google Cloud או יוצרים פרויקט.
  2. הקפידו לוודא שהחיוב מופעל בפרויקט שלכם ב-Cloud. כך בודקים אם החיוב מופעל בפרויקט

הפעלת Cloud Shell

‫Cloud Shell היא סביבת שורת פקודה שפועלת ב-Google Cloud וכוללת מראש את הכלים הנדרשים.

  1. לוחצים על Activate Cloud Shell בחלק העליון של מסוף Google Cloud.
  2. אחרי שמתחברים ל-Cloud Shell, מאמתים את האימות:
    gcloud auth list
  3. מוודאים שהפרויקט מוגדר:
    gcloud config get project
  4. אם הפרויקט לא מוגדר כמו שציפיתם, מגדירים אותו:
    export PROJECT_ID=<YOUR_PROJECT_ID>
gcloud config set project $PROJECT_ID

הגדרת הסביבה

  1. פותחים את Cloud Shell: לוחצים על הסמל Activate Cloud Shell (הפעלת Cloud Shell) בפינה הימנית העליונה של מסוף Google Cloud.

קבלת קוד לתחילת הדרך

  1. משכפלים את מאגר המתחילים לספריית הבית:עוברים לספריית הבית
    ‫
      cd ~
    משכפלים רק את הקוד שנדרש ל-Codelab הזה מתיקיית ההדגמות של Google Cloud DevRel.
    ‫
    git clone --depth 1 --filter=blob:none --sparse https://github.com/GoogleCloudPlatform/devrel-demos.git temp-repo && cd temp-repo && git sparse-checkout set agents/multi-agent-system && cd .. && mv temp-repo/agents/multi-agent-system . && rm -rf temp-repo
    עוברים לתיקייה שמכילה את הקוד של ה-Codelab הזה
    cd multi-agent-system
  2. מפעילים ממשקי API: מריצים את הפקודה הבאה כדי להפעיל את שירותי Google Cloud הנדרשים:
    gcloud services enable \
    run.googleapis.com \
    artifactregistry.googleapis.com \
    cloudbuild.googleapis.com \
    aiplatform.googleapis.com \
    compute.googleapis.com
  3. פותחים את התיקייה הזו בכלי העריכה.
    cloudshell edit .

הגדרת הסביבה

  1. מגדירים משתני סביבה.ניצור קובץ .env לאחסון המשתנים האלה כדי שתוכלו לטעון אותם מחדש בקלות אם הסשן יתנתק.
    cat <<EOF > .env
export GOOGLE_CLOUD_PROJECT=$(gcloud config get-value project)
export GOOGLE_CLOUD_LOCATION=europe-west4
export GOOGLE_GENAI_USE_VERTEXAI=true
EOF
  2. מפעילים את משתני הסביבה:
    source .env

4. ‫🕵️ סוכן המחקר

סוכן מחקר

החוקר הוא מומחה. התפקיד היחיד שלו הוא למצוא מידע. כדי לעשות את זה, היא צריכה גישה לכלי: חיפוש Google.

למה כדאי להפריד את הכלי 'חוקר'?

ניתוח מעמיק: למה לא להשתמש רק בסוכן אחד שיעשה הכול?

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

  1. אם אתם עובדים ב-Cloud Shell, מריצים את הפקודה הבאה כדי לפתוח את Cloud Shell Editor:
    cloudshell workspace .
  2. פתיחת agents/researcher/agent.py.
  3. בודקים את הקוד הבא שמגדיר את סוכן researcher:
    # ... existing imports ...

# Define the Researcher Agent
researcher = Agent(
    name="researcher",
    model=MODEL,
    description="Gathers information on a topic using Google Search.",
    instruction="""
    You are an expert researcher. Your goal is to find comprehensive and accurate information on the user's topic.
    Use the `google_search` tool to find relevant information.
    Summarize your findings clearly.
    If you receive feedback that your research is insufficient, use the feedback to refine your next search.
    """,
    tools=[google_search],
)

root_agent = researcher

מושג מפתח: שימוש בכלי

שימו לב שאנחנו מעבירים את tools=[google_search]. ה-ADK מטפל במורכבות של תיאור הכלי הזה ל-LLM. כשהמודל מחליט שהוא צריך מידע, הוא יוצר קריאה מובנית לכלי, ה-ADK מפעיל את פונקציית Python‏ google_search ומחזיר את התוצאה למודל.

5. ‫⚖️ סוכן השופט

נציג שופט

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

פלט מובנה

הסבר מפורט: כדי להפוך תהליכי עבודה לאוטומטיים, אנחנו צריכים פלט צפוי. קשה לנתח ביקורת טקסט ארוכה ומבולבלת באופן אוטומטי. על ידי אכיפה של סכימת JSON (באמצעות Pydantic), אנחנו מוודאים שהרכיב Judge מחזיר ערך בוליאני pass או fail שהקוד שלנו יכול לפעול על פיו באופן מהימן.

  1. פתיחת agents/judge/agent.py.
  2. בודקים את הקוד הבא שמגדיר את סכימת JudgeFeedback ואת סוכן judge.
    # 1. Define the Schema
class JudgeFeedback(BaseModel):
    """Structured feedback from the Judge agent."""
    status: Literal["pass", "fail"] = Field(
        description="Whether the research is sufficient ('pass') or needs more work ('fail')."
    )
    feedback: str = Field(
        description="Detailed feedback on what is missing. If 'pass', a brief confirmation."
    )

# 2. Define the Agent
judge = Agent(
    name="judge",
    model=MODEL,
    description="Evaluates research findings for completeness and accuracy.",
    instruction="""
    You are a strict editor.
    Evaluate the 'research_findings' against the user's original request.
    If the findings are missing key info, return status='fail'.
    If they are comprehensive, return status='pass'.
    """,
    output_schema=JudgeFeedback,
    # Disallow delegation because it should only output the schema
    disallow_transfer_to_parent=True,
    disallow_transfer_to_peers=True,
)

root_agent = judge

מושג מרכזי: הגבלת התנהגות הסוכן

הגדרנו את disallow_transfer_to_parent=True ואת disallow_transfer_to_peers=True. הפעולה הזו גורמת ל-Judge להחזיר רק את הנתונים המובנים JudgeFeedback. הוא לא יכול להחליט 'לשוחח' עם המשתמש או להעביר את הטיפול לסוכן אחר. כך הוא הופך לרכיב דטרמיניסטי בתהליך הלוגי שלנו.

6. ✍️ סוכן ליצירת תוכן

הכלי ליצירת תוכן

כלי יצירת התוכן הוא הכותב היצירתי. הוא לוקח את המחקר שאושר והופך אותו לקורס. הוא משתמש במודל Gemma שמופעל על ידי Cloud Run.

קודם נסתכל על שירות Cloud Run שמארח את המודל

  1. פתיחה של ollama_backend/Dockerfile
  2. כאן אפשר לראות איך קובץ ה-Dockerfile משתמש בקובץ אימג' של Ollama, מקשיב לבקשות ביציאה 8080 ומאחסן את המודל המבוקש בתיקייה ‎ /model.
FROM ollama/ollama:latest

# Listen on all interfaces, port 8080 (Cloud Run default)
ENV OLLAMA_HOST 0.0.0.0:8080

# Store model weight files in /models
ENV OLLAMA_MODELS /models

⚙️ כשפורסים את האפליקציה, מגדירים את ההגדרות הבאות:

  • ‫GPU: נבחר NVIDIA L4 בגלל יחס המחיר-ביצועים המצוין שלו לעומסי עבודה של הסקת מסקנות. ה-L4 מספק זיכרון GPU של 24GB ופעולות טנסור שעברו אופטימיזציה, ולכן הוא אידיאלי למודלים עם 270 מיליון פרמטרים כמו Gemma
  • זיכרון: זיכרון מערכת בנפח 16GB לטיפול בטעינת המודל, בפעולות CUDA ובניהול הזיכרון של Ollama
  • מעבד (CPU): 8 ליבות לטיפול אופטימלי בקלט/פלט ובמשימות עיבוד מקדים
  • בו-זמניות (concurrency): 4 בקשות לכל מכונה מאזנות את התפוקה עם השימוש בזיכרון ה-GPU
  • ‫Timeout: ‏600 שניות, כדי לאפשר טעינה ראשונית של המודל והפעלה של הקונטיינר

עכשיו נסתכל על סוכן ליצירת תוכן שמשתמש במודל Gemma.

  1. פתיחת agents/content_builder/agent.py.
  2. מעיינים בקוד הבא שמגדיר את סוכן content_builder.
# the `ollama-gemma-gpu` Cloud Run service URL which hosts the Gemma model
target_url = os.environ.get("OLLAMA_API_BASE")

# ... existing code ...

# (Note: We use 'ollama/gemma3:270m' to align with ADK's expected prefix)
gemma_model_name = os.environ.get("GEMMA_MODEL_NAME", "gemma3:270m")
model = LiteLlm(
    model=f"ollama_chat/{gemma_model_name}",
    api_base=target_url
)

# 5. Define the Agent
content_builder = Agent(
    name="content_builder",
    model=model,
    description="Transforms research findings into a structured course.",
    instruction="""
    You are an expert course creator.
    Take the approved 'research_findings' and transform them into a well-structured, engaging course module.

    **Formatting Rules:**
    1. Start with a main title using a single `#` (H1).
    2. Use `##` (H2) for main section headings. These will be used for the Table of Contents.
    3. Use `###` (H3) for sub-sections within main sections.
    4. Use bullet points and clear paragraphs.
    5. Maintain a professional but engaging tone.

    **Structure Requirements:**
    - Begin with a brief Introduction section explaining what the learner will gain.
    - Organize content into 3-5 main sections with clear headings.
    - Include Key Takeaways at the end as a bulleted summary.
    - Keep each section focused and concise.

    Ensure the content directly addresses the user's original request.
    Do not include any preamble or explanation outside the course content itself.
    """,
)

root_agent = content_builder

מושג מפתח: העברת הקשר

יכול להיות שתשאלו: "איך כלי יצירת התוכן יודע מה כלי המחקר מצא?" ב-ADK, סוכנים בצינור משתפים session.state. בהמשך, ב-Orchestrator, נגדיר את Researcher ואת Judge כך שישמרו את התוצאות שלהם במצב המשותף הזה. ההיסטוריה הזו נגישה להנחיה בכלי ליצירת תוכן.

7. ‫🎻 כלי התזמור

סוכן תזמור

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

🌐 הארכיטקטורה: סוכן לסוכן (A2A)

ארכיטקטורת A2A

בשיעור ה-Lab הזה נבנה מערכת מבוזרת. במקום להפעיל את כל הסוכנים בתהליך Python יחיד, אנחנו פורסים אותם כמיקרו-שירותים עצמאיים. כך כל סוכן יכול להתרחב באופן עצמאי ולהיכשל בלי לגרום לקריסה של המערכת כולה.

כדי לאפשר את זה, אנחנו משתמשים בפרוטוקול Agent-to-Agent (A2A).

פרוטוקול A2A

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

  1. פתיחת agents/orchestrator/agent.py.
  2. כדאי לעיין בקוד הבא שמגדיר את החיבורים.
    # ... existing code ...

# Connect to the Researcher (Localhost port 8001)
researcher_url = os.environ.get("RESEARCHER_AGENT_CARD_URL", "http://localhost:8001/a2a/agent/.well-known/agent-card.json")
researcher = RemoteA2aAgent(
    name="researcher",
    agent_card=researcher_url,
    description="Gathers information using Google Search.",
    # IMPORTANT: Save the output to state for the Judge to see
    after_agent_callback=create_save_output_callback("research_findings"),
    # IMPORTANT: Use authenticated client for communication
    httpx_client=create_authenticated_client(researcher_url)
)

# Connect to the Judge (Localhost port 8002)
judge_url = os.environ.get("JUDGE_AGENT_CARD_URL", "http://localhost:8002/a2a/agent/.well-known/agent-card.json")
judge = RemoteA2aAgent(
    name="judge",
    agent_card=judge_url,
    description="Evaluates research.",
    after_agent_callback=create_save_output_callback("judge_feedback"),
    httpx_client=create_authenticated_client(judge_url)
)

# Content Builder (Localhost port 8003)
content_builder_url = os.environ.get("CONTENT_BUILDER_AGENT_CARD_URL", "http://localhost:8003/a2a/agent/.well-known/agent-card.json")
content_builder = RemoteA2aAgent(
    name="content_builder",
    agent_card=content_builder_url,
    description="Builds the course.",
    httpx_client=create_authenticated_client(content_builder_url)
)

8. 🛑 הכלי לבדיקת העברה לטיפול ברמה גבוהה יותר

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

לוגיקה מותאמת אישית עם BaseAgent

הסבר מפורט: לא כל הנציגים משתמשים ב-LLM. לפעמים צריך לוגיקה פשוטה של Python. ‫BaseAgent מאפשר לכם להגדיר סוכן שמריץ רק קוד. במקרה הזה, אנחנו בודקים את מצב הסשן ומשתמשים ב-EventActions(escalate=True) כדי לסמן ל-LoopAgent להפסיק.

  1. עדיין ב-agents/orchestrator/agent.py.
  2. הקוד הבא בודק את המשוב של השופט ועובר לשלב הבא כשהוא מוכן
    class EscalationChecker(BaseAgent):
    """Checks the judge's feedback and escalates (breaks the loop) if it passed."""

    async def _run_async_impl(
        self, ctx: InvocationContext
    ) -> AsyncGenerator[Event, None]:
        # Retrieve the feedback saved by the Judge
        feedback = ctx.session.state.get("judge_feedback")
        print(f"[EscalationChecker] Feedback: {feedback}")

        # Check for 'pass' status
        is_pass = False
        if isinstance(feedback, dict) and feedback.get("status") == "pass":
            is_pass = True
        # Handle string fallback if JSON parsing failed
        elif isinstance(feedback, str) and '"status": "pass"' in feedback:
            is_pass = True

        if is_pass:
            # 'escalate=True' tells the parent LoopAgent to stop looping
            yield Event(author=self.name, actions=EventActions(escalate=True))
        else:
            # Continue the loop
            yield Event(author=self.name)

escalation_checker = EscalationChecker(name="escalation_checker")

מושג מרכזי: בקרה על זרימת נתונים באמצעות אירועים

הסוכנים מתקשרים לא רק באמצעות טקסט, אלא גם באמצעות אירועים. על ידי הפקת אירוע עם escalate=True, הסוכן הזה שולח אות אל ההורה שלו (LoopAgent). הסוכן LoopAgent מתוכנת לזהות את האות הזה ולסיים את הלולאה.

9. 🔁 מחזור המחקר

מחקר בלולאה

אנחנו צריכים לולאת משוב: מחקר -> שיפוט -> (כישלון) -> מחקר -> ...

  1. ב-agents/orchestrator/agent.py.
  2. כדאי לעיין בקוד הבא כדי להבין איך מוגדרת ההגדרה research_loop.
    research_loop = LoopAgent(
    name="research_loop",
    description="Iteratively researches and judges until quality standards are met.",
    sub_agents=[researcher, judge, escalation_checker],
    max_iterations=3,
)

מושג מרכזי: LoopAgent

האפשרות LoopAgent עוברת בין sub_agents לפי הסדר.

  1. ‫researcher: חיפוש נתונים.
  2. ‫judge: הערכת נתונים.
  3. escalation_checker: קובע אם yield Event(escalate=True). אם מתרחש escalate=True, הלולאה נשברת מוקדם. אחרת, הוא יופעל מחדש אצל החוקר (עד max_iterations).

10. 🔗 צינור עיבוד הנתונים הסופי

פייפליין סופי

מסכמים את כל המידע...

  1. ב-agents/orchestrator/agent.py.
  2. בודקים איך root_agent מוגדר בחלק התחתון של הקובץ.
    root_agent = SequentialAgent(
    name="course_creation_pipeline",
    description="A pipeline that researches a topic and then builds a course from it.",
    sub_agents=[research_loop, content_builder],
)

מושג מרכזי: קומפוזיציה היררכית

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

11. 🚀 פריסה ב-Cloud Run

נפרוס כל סוכן כשירות נפרד ב-Cloud Run, כולל שירות Cloud Run לממשק המשתמש של יוצר הקורס ושירות Cloud Run שמשתמש ב-GPU למודל Gemma.

הסבר על הגדרת התצורה של פריסה

כשפורסים סוכנים ב-Cloud Run, אנחנו מעבירים כמה משתני סביבה כדי להגדיר את ההתנהגות והקישוריות שלהם:

  • ‫GOOGLE_CLOUD_PROJECT: מוודא שהנציג משתמש בפרויקט הנכון ב-Google Cloud לרישום ביומן ולקריאות ל-Vertex AI.
  • ‫GOOGLE_GENAI_USE_VERTEXAI: מציין ל-Agent Development Kit (ערכת פיתוח סוכנים, ADK) להשתמש ב-Vertex AI להסקת מסקנות ממודלים במקום להפעיל ישירות את Gemini API.
  • ‫[AGENT]_AGENT_CARD_URL: זה קריטי ל-Orchestrator. הוא מציין ל-Orchestrator איפה נמצאים הסוכנים המרוחקים. אם מגדירים את הערך הזה לכתובת ה-URL של Cloud Run שנפרסה (במיוחד הנתיב של כרטיס הסוכן), המארגן יכול לגלות את החוקר, השופט ויוצר התוכן ולתקשר איתם באינטרנט.

כדי לפרוס את כל הסוכנים לשירותי Cloud Run, מריצים את הסקריפט הבא.

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

chmod u+x ~/multi-agent-system/deploy.sh

הערה: התהליך יימשך כמה דקות כי כל שירות נפרס ברצף.

~/multi-agent-system/deploy.sh

12. יוצרים קורס!

פותחים את האתר של הכלי ליצירת קורסים. שירות Cloud Run ליצירת קורסים הוא השירות האחרון שנפרס מהסקריפט. אפשר לזהות את כתובת ה-URL של יוצר הקורס כ-https://course-creator-..run.app, שצריכה להיות שורת הפלט הסופית מסקריפט הפריסה.

מקלידים רעיון לקורס, למשל "אלגברה לינארית".

הסוכנים יתחילו לעבוד על הקורס.

פייפליין סופי

13. הסרת המשאבים

כדי לא לצבור חיובים לחשבון Google Cloud על המשאבים שבהם השתמשתם ב-codelab הזה, צריך למחוק את השירותים ואת קובצי האימג' של הקונטיינרים.

1. מחיקת שירותי Cloud Run

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

# Delete the main agent and app services
gcloud run services delete researcher content-builder judge orchestrator course-creator \
    --region $REGION --quiet

# Delete the GPU backend (Ollama)
gcloud run services delete ollama-gemma-gpu \
    --region $OLLAMA_REGION --quiet

2. מחיקת תמונות מ-Artifact Registry

כשמשתמשים בדגל --source לפריסה, Google Cloud יוצר מאגר ב-Artifact Registry כדי לאחסן את קובצי האימג' בקונטיינר. כדי להסיר את הנתונים האלה ולחסוך בעלויות האחסון, צריך למחוק את המאגר:

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

3. הסרת קבצים מקומיים וסביבה

כדי לשמור על סביבת Cloud Shell נקייה, מסירים את תיקיית הפרויקט ואת ההגדרות המקומיות:

cd ~
rm -rf multi-agent-system

4. (אופציונלי) מחיקת הפרויקט

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

14. מעולה!

יצרתם ופרסתם בהצלחה מערכת מבוזרת מרובת סוכנים שמוכנה לייצור.

ההישגים שלכם

  • פירוק משימה מורכבת: במקום הנחיה אחת גדולה, פיצלנו את העבודה לתפקידים מיוחדים (חוקר, שופט, יוצר תוכן).
  • הטמענו בקרת איכות: השתמשנו בLoopAgent ובJudge מובנה כדי להבטיח שרק מידע באיכות גבוהה יגיע לשלב הסופי.
  • מיועד לשימוש בסביבת ייצור: באמצעות פרוטוקול Agent-to-Agent (A2A) ו-Cloud Run, יצרנו מערכת שבה כל סוכן הוא מיקרו-שירות עצמאי שניתן להרחבה. השיטה הזו הרבה יותר חזקה מאשר הפעלה של הכול בסקריפט Python יחיד.
  • תיאום: השתמשנו ב-SequentialAgent וב-LoopAgent כדי להגדיר דפוסי זרימת בקרה ברורים. ‫*. Cloud Run GPUs: פריסת מודל Gemma ב-Cloud Run GPU