1. 📖 Introduzione
Nel precedente codelab , hai imparato a progettare un'interazione con dati multimodali in ADK. Ora faremo un ulteriore passo avanti su come progettare un'interazione di dati multimodale con il server MCP utilizzando il set di strumenti MCP. Amplieremo le funzionalità dell'agente di editing delle foto dei prodotti sviluppato in precedenza con la possibilità di generare brevi video utilizzando il modello Veo che utilizza il server Veo MCP
Nel codelab, seguirai un approccio passo passo come segue:
- Prepara il progetto Google Cloud e la directory dell'agente di base
- Configura un server MCP che richiede dati di file come input
- Dotare l'agente ADK della possibilità di connettersi al server MCP
- Progettare una strategia di prompt e una funzione di callback per modificare la richiesta di chiamata di funzione in MCP Toolset
- Progettare una funzione di callback per gestire la risposta dei dati multimodali dal set di strumenti MCP
Panoramica dell'architettura
L'interazione complessiva in questo codelab è mostrata nel seguente diagramma
Prerequisiti
- Avere familiarità con Python
- (Facoltativo) Codelab di base su Agent Development Kit (ADK)
- (Facoltativo) Codelab Parte 1 dello strumento multimodale ADK : goo.gle/adk-multimodal-tool-1
Cosa imparerai a fare
- Come creare video brevi utilizzando Veo 3.1 con prompt e immagini iniziali
- Come sviluppare il server MCP multimodale utilizzando FastMCP
- Come configurare ADK per utilizzare MCP Toolset
- Come modificare la chiamata allo strumento in MCP Toolset tramite il callback dello strumento
- Come modificare la risposta dello strumento dal toolset MCP tramite il callback dello strumento
Che cosa ti serve
- Browser web Chrome
- Un account Gmail
- Un progetto cloud con un account di fatturazione abilitato
Questo codelab, progettato per sviluppatori di tutti i livelli (inclusi i principianti), utilizza Python nella sua applicazione di esempio. Tuttavia, la conoscenza di Python non è necessaria per comprendere i concetti presentati.
2. 🚀 ( Facoltativo) Preparazione della configurazione di sviluppo del workshop
Passaggio 1: seleziona Progetto attivo nella console Cloud
Nella console Google Cloud, nella pagina di selezione del progetto, seleziona o crea un progetto Google Cloud (vedi la sezione in alto a sinistra della console).
Fai clic e vedrai l'elenco di tutti i tuoi progetti, come in questo esempio:
Il valore indicato dal riquadro rosso è l'ID PROGETTO e verrà utilizzato in tutto il tutorial.
Verifica che la fatturazione sia attivata per il tuo progetto Cloud. Per verificarlo, fai clic sull'icona a forma di hamburger ☰ nella barra in alto a sinistra, che mostra il menu di navigazione, e trova il menu Fatturazione.
Se vedi "Account di fatturazione di prova di Google Cloud Platform" sotto il titolo Fatturazione / Panoramica ( sezione in alto a sinistra della console cloud ), il tuo progetto è pronto per essere utilizzato per questo tutorial. In caso contrario, torna all'inizio di questo tutorial e riscatta l'account di fatturazione di prova
Passaggio 2: acquisisci familiarità con Cloud Shell
Utilizzerai Cloud Shell per la maggior parte dei tutorial. Fai clic su Attiva Cloud Shell nella parte superiore della console Google Cloud. Se ti viene chiesto di autorizzare, fai clic su Autorizza.
Una volta connesso a Cloud Shell, dobbiamo verificare se la shell ( o il terminale) è già autenticata con il nostro account
gcloud auth list
Se vedi il tuo Gmail personale come nell'esempio di output riportato di seguito, va tutto bene.
Credentialed Accounts
ACTIVE: *
ACCOUNT: alvinprayuda@gmail.com
To set the active account, run:
$ gcloud config set account `ACCOUNT`
In caso contrario, prova ad aggiornare il browser e assicurati di fare clic su Autorizza quando richiesto ( l'operazione potrebbe essere interrotta a causa di un problema di connessione).
Successivamente, dobbiamo anche verificare se la shell è già configurata con l'ID PROGETTO corretto. Se vedi un valore tra parentesi ( ) prima dell'icona $ nel terminale ( nello screenshot riportato di seguito, il valore è "adk-multimodal-tool"), questo valore mostra il progetto configurato per la sessione shell attiva.
Se il valore mostrato è già corretto, puoi saltare il comando successivo. Tuttavia, se non è corretto o è mancante, esegui il seguente comando
gcloud config set project <YOUR_PROJECT_ID>
Quindi, clona la directory di lavoro del modello per questo codelab da GitHub eseguendo il seguente comando. Verrà creata la directory di lavoro nella directory adk-multimodal-tool
git clone https://github.com/alphinside/adk-mcp-multimodal.git adk-multimodal-tool
Passaggio 3: familiarizza con l'editor di Cloud Shell e configura la directory di lavoro dell'applicazione
Ora possiamo configurare l'editor di codice per svolgere alcune attività di programmazione. Per questo utilizzeremo l'editor di Cloud Shell
Fai clic sul pulsante Apri editor per aprire un editor di Cloud Shell 
.
Dopodiché, vai alla sezione superiore dell'editor di Cloud Shell e fai clic su File->Apri cartella, trova la directory username e la directory adk-multimodal-tool, quindi fai clic sul pulsante OK. In questo modo, la directory scelta diventerà la directory di lavoro principale. In questo esempio, il nome utente è alvinprayuda, quindi il percorso della directory è mostrato di seguito
Ora, la directory di lavoro dell'editor di Cloud Shell dovrebbe essere simile a questa ( all'interno di adk-multimodal-tool):
Ora apri il terminale per l'editor. Puoi farlo facendo clic su Terminale -> Nuovo terminale nella barra dei menu oppure utilizzando Ctrl + Maiusc + C. Si aprirà una finestra del terminale nella parte inferiore del browser.
Il terminale attivo corrente deve trovarsi all'interno della directory di lavoro adk-multimodal-tool. In questo codelab utilizzeremo Python 3.12 e uv python project manager per semplificare la necessità di creare e gestire la versione di Python e l'ambiente virtuale. Questo pacchetto uv è già preinstallato su Cloud Shell.
Esegui questo comando per installare le dipendenze richieste nell'ambiente virtuale nella directory .venv
uv sync --frozen
Controlla il file pyproject.toml per visualizzare le dipendenze dichiarate per questo tutorial, ovvero google-adk, and python-dotenv.
Ora dobbiamo abilitare le API richieste tramite il comando mostrato di seguito. L'operazione potrebbe richiedere qualche istante.
gcloud services enable aiplatform.googleapis.com
Se il comando viene eseguito correttamente, dovresti visualizzare un messaggio simile a quello mostrato di seguito:
Operation "operations/..." finished successfully.
La struttura dell'agente modello è già fornita nella directory part2_starter_agent del repository clonato. Ora, per prepararlo per questo tutorial, dobbiamo prima rinominarlo
mv part1_ckpt_agent product_photo_editor
Dopodiché, copia product_photo_editor/.env.example in product_photo_editor/.env
cp product_photo_editor/.env.example product_photo_editor/.env
Quando apri il file product_photo_editor/.env, vedrai contenuti come quelli mostrati di seguito
GOOGLE_GENAI_USE_VERTEXAI=1
GOOGLE_CLOUD_PROJECT=your-project-id
GOOGLE_CLOUD_LOCATION=global
Dopodiché, dovrai aggiornare il valore your-project-id con l'ID del tuo progetto corretto. Ora siamo pronti per il passaggio successivo.
3. 🚀 Inizializza il server MCP di Veo
Innanzitutto, creiamo la directory dei servizi MCP utilizzando questo comando
mkdir veo_mcp
Quindi, crea veo_mcp/main.py utilizzando questo comando
touch veo_mcp/main.py
Dopodiché, copia il seguente codice nel file veo_mcp/main.py
from fastmcp import FastMCP
from typing import Annotated
from pydantic import Field
import base64
import asyncio
import os
from google import genai
from google.genai import types
from dotenv import load_dotenv
import logging
# Load environment variables from .env file
load_dotenv()
mcp = FastMCP("Veo MCP Server")
@mcp.tool
async def generate_video_with_image(
prompt: Annotated[
str, Field(description="Text description of the video to generate")
],
image_data: Annotated[
str, Field(description="Base64-encoded image data to use as starting frame")
],
negative_prompt: Annotated[
str | None,
Field(description="Things to avoid in the generated video"),
] = None,
) -> dict:
"""Generates a professional product marketing video from text prompt and starting image using Google's Veo API.
This function uses an image as the first frame of the generated video and automatically
enriches your prompt with professional video production quality guidelines to create
high-quality marketing assets suitable for commercial use.
AUTOMATIC ENHANCEMENTS APPLIED:
- 4K cinematic quality with professional color grading
- Smooth, stabilized camera movements
- Professional studio lighting setup
- Shallow depth of field for product focus
- Commercial-grade production quality
- Marketing-focused visual style
PROMPT WRITING TIPS:
Describe what you want to see in the video. Focus on:
- Product actions/movements (e.g., "rotating slowly", "zooming into details")
- Desired camera angles (e.g., "close-up of the product", "wide shot")
- Background/environment (e.g., "minimalist white backdrop", "lifestyle setting")
- Any specific details about the product presentation
The system will automatically enhance your prompt with professional production quality.
Args:
prompt: Description of the video to generate. Focus on the core product presentation
you want. The system will automatically add professional quality enhancements.
image_data: Base64-encoded image data to use as the starting frame
negative_prompt: Optional prompt describing what to avoid in the video
Returns:
dict: A dictionary containing:
- status: 'success' or 'error'
- message: Description of the result
- video_data: Base64-encoded video data (on success only)
"""
try:
# Initialize the Gemini client
client = genai.Client(
vertexai=True,
project=os.getenv("GOOGLE_CLOUD_PROJECT"),
location=os.getenv("GOOGLE_CLOUD_LOCATION"),
)
# Decode the image
image_bytes = base64.b64decode(image_data)
print(f"Successfully decoded image data: {len(image_bytes)} bytes")
# Create image object
image = types.Image(image_bytes=image_bytes, mime_type="image/png")
# Prepare the config
config = types.GenerateVideosConfig(
duration_seconds=8,
number_of_videos=1,
)
if negative_prompt:
config.negative_prompt = negative_prompt
# Enrich the prompt for professional marketing quality
enriched_prompt = enrich_prompt_for_marketing(prompt)
# Generate the video (async operation)
operation = client.models.generate_videos(
model="veo-3.1-generate-preview",
prompt=enriched_prompt,
image=image,
config=config,
)
# Poll until the operation is complete
poll_count = 0
while not operation.done:
poll_count += 1
print(f"Waiting for video generation to complete... (poll {poll_count})")
await asyncio.sleep(5)
operation = client.operations.get(operation)
# Download the video and convert to base64
video = operation.response.generated_videos[0]
# Get video bytes and encode to base64
video_bytes = video.video.video_bytes
video_base64 = base64.b64encode(video_bytes).decode("utf-8")
print(f"Video generated successfully: {len(video_bytes)} bytes")
return {
"status": "success",
"message": f"Video with image generated successfully after {poll_count * 5} seconds",
"complete_prompt": enriched_prompt,
"video_data": video_base64,
}
except Exception as e:
logging.error(e)
return {
"status": "error",
"message": f"Error generating video with image: {str(e)}",
}
def enrich_prompt_for_marketing(user_prompt: str) -> str:
"""Enriches user prompt with professional video production quality enhancements.
Adds cinematic quality, professional lighting, smooth camera work, and marketing-focused
elements to ensure high-quality product marketing videos.
"""
enhancement_prefix = """Create a high-quality, professional product marketing video with the following characteristics:
TECHNICAL SPECIFICATIONS:
- 4K cinematic quality with professional color grading
- Smooth, stabilized camera movements
- Professional studio lighting setup with soft, even illumination
- Shallow depth of field for product focus
- High dynamic range (HDR) for vibrant colors
VISUAL STYLE:
- Clean, minimalist aesthetic suitable for premium brand marketing
- Elegant and sophisticated presentation
- Commercial-grade production quality
- Attention to detail in product showcase
USER'S SPECIFIC REQUIREMENTS:
"""
enhancement_suffix = """
ADDITIONAL QUALITY GUIDELINES:
- Ensure smooth transitions and natural motion
- Maintain consistent lighting throughout
- Keep the product as the clear focal point
- Use professional camera techniques (slow pans, tracking shots, or dolly movements)
- Apply subtle motion blur for cinematic feel
- Ensure brand-appropriate tone and style"""
return f"{enhancement_prefix}{user_prompt}{enhancement_suffix}"
if __name__ == "__main__":
mcp.run()
Il seguente codice esegue queste operazioni:
- Crea un server FastMCP che espone uno strumento di generazione di video Veo 3.1 agli agenti ADK
- Accetta come input immagini con codifica base64, prompt di testo e prompt negativi
- Genera video di 8 secondi in modo asincrono inviando richieste all'API Veo 3.1 ed eseguendo il polling ogni 5 secondi fino al completamento
- Restituisce i dati video con codifica base64 insieme al prompt arricchito
Questo strumento MCP di Veo richiederà la stessa variabile di ambiente del nostro agente, quindi possiamo semplicemente copiare e incollare il file .env. Per farlo, esegui questo comando:
cp product_photo_editor/.env veo_mcp/
Ora possiamo verificare se il server MCP funziona correttamente eseguendo questo comando
uv run veo_mcp/main.py
e mostrerà il log della console in questo modo
╭────────────────────────────────────────────────────────────────────────────╮
│ │
│ _ __ ___ _____ __ __ _____________ ____ ____ │
│ _ __ ___ .'____/___ ______/ /_/ |/ / ____/ __ \ |___ \ / __ \ │
│ _ __ ___ / /_ / __ `/ ___/ __/ /|_/ / / / /_/ / ___/ / / / / / │
│ _ __ ___ / __/ / /_/ (__ ) /_/ / / / /___/ ____/ / __/_/ /_/ / │
│ _ __ ___ /_/ \____/____/\__/_/ /_/\____/_/ /_____(*)____/ │
│ │
│ │
│ FastMCP 2.0 │
│ │
│ │
│ 🖥️ Server name: Veo MCP Server │
│ 📦 Transport: STDIO │
│ │
│ 🏎️ FastMCP version: 2.12.5 │
│ 🤝 MCP SDK version: 1.16.0 │
│ │
│ 📚 Docs: https://gofastmcp.com │
│ 🚀 Deploy: https://fastmcp.cloud │
│ │
╰────────────────────────────────────────────────────────────────────────────╯
[10/22/25 08:28:53] INFO Starting MCP server 'Veo MCP Server' with server.py:1502
transport 'stdio'
Ora termina il processo del servizio MCP utilizzando Ctrl+C. Questo comando verrà richiamato in un secondo momento dal set di strumenti ADK MCP. Possiamo passare al passaggio successivo per consentire al nostro agente di utilizzare questi strumenti MCP
4. 🚀 Connetti il server MCP Veo all'agente ADK
Ora connettiamo il server Veo MCP in modo che possa essere utilizzato dal nostro agente. Innanzitutto, creiamo un altro script per contenere il set di strumenti, esegui il comando seguente
touch product_photo_editor/mcp_tools.py
Quindi, copia il seguente codice in product_photo_editor/mcp_tools.py
from google.adk.tools.mcp_tool.mcp_toolset import MCPToolset
from google.adk.tools.mcp_tool.mcp_session_manager import StdioConnectionParams
from mcp import StdioServerParameters
mcp_toolset = MCPToolset(
connection_params=StdioConnectionParams(
server_params=StdioServerParameters(
command="uv",
args=[
"run",
"veo_mcp/main.py",
],
),
timeout=120, # seconds
),
)
# Option to connect to remote MCP server
# from google.adk.tools.mcp_tool.mcp_session_manager import StreamableHTTPConnectionParams
# mcp_toolset = MCPToolset(
# connection_params=StreamableHTTPConnectionParams(
# url="http://localhost:8000/mcp",
# timeout=120,
# ),
# )
Il codice riportato sopra mostra come connettersi a un server MCP utilizzando ADK MCPToolset. In questo esempio ci connettiamo al server MCP utilizzando il canale di comunicazione STDIO. Nel comando specifichiamo come eseguire il server MCP e impostiamo il parametro di timeout.
5. 🚀 Modifica del parametro di chiamata dello strumento
Nella dichiarazione dello strumento del server MCP, abbiamo progettato lo strumento generate_video_with_image che specifica la stringa base64 come parametri dello strumento. Non possiamo chiedere al modello LLM di farlo per noi, quindi dobbiamo progettare una strategia specifica per gestire questo problema.
Nel lab precedente, abbiamo gestito l'immagine caricata dall'utente e la risposta dello strumento in before_model_callback da salvare come artefatto, che si riflette anche nel modello di agente preparato in precedenza. Utilizzeremo queste informazioni e adotteremo le seguenti strategie:
- Chiedi all'LLM di inviare sempre il valore artifact_id se un parametro dello strumento specifico richiede l'invio di dati di stringa Base64
- Intercetta la chiamata allo strumento in
before_tool_callbacke trasforma il parametro da artifact_id al relativo contenuto in byte caricando l'artefatto e sovrascrivi gli argomenti dello strumento
Vedi l'immagine di seguito per la visualizzazione della parte che intercetteremo
Innanzitutto, prepariamo la funzione before_tool_callback, creiamo un nuovo file product_photo_editor/tool_callbacks.py eseguendo questo comando
touch product_photo_editor/tool_callbacks.py
Quindi, copia il seguente codice nel file
# product_photo_editor/tool_callbacks.py
from google.genai.types import Part
from typing import Any
from google.adk.tools.tool_context import ToolContext
from google.adk.tools.base_tool import BaseTool
from google.adk.tools.mcp_tool.mcp_tool import McpTool
import base64
import logging
import json
from mcp.types import CallToolResult
async def before_tool_modifier(
tool: BaseTool, args: dict[str, Any], tool_context: ToolContext
):
# Identify which tool input should be modified
if isinstance(tool, McpTool) and tool.name == "generate_video_with_image":
logging.info("Modify tool args for artifact: %s", args["image_data"])
# Get the artifact filename from the tool input argument
artifact_filename = args["image_data"]
artifact = await tool_context.load_artifact(filename=artifact_filename)
file_data = artifact.inline_data.data
# Convert byte data to base64 string
base64_data = base64.b64encode(file_data).decode("utf-8")
# Then modify the tool input argument
args["image_data"] = base64_data
Il codice riportato sopra mostra i seguenti passaggi:
- Controlla se lo strumento richiamato è un oggetto McpTool e se è la chiamata allo strumento di destinazione che vogliamo modificare
- Ottieni il valore degli argomenti
image_datain cui l'argomento viene richiesto in formato base64, ma chiediamo all'LLM di restituire artifact_id - Carica l'artefatto utilizzando il servizio di artefatti su
tool_context - Sovrascrivi gli argomenti
image_datacon i dati base64
Ora dobbiamo aggiungere questo callback all'agente e modificare leggermente le istruzioni in modo che l'agente compili sempre gli argomenti dello strumento base64 con l'ID artefatto.
Apri product_photo_editor/agent.py e modifica il contenuto con il seguente codice
# product_photo_editor/agent.py
from google.adk.agents.llm_agent import Agent
from product_photo_editor.custom_tools import edit_product_asset
from product_photo_editor.mcp_tools import mcp_toolset
from product_photo_editor.model_callbacks import before_model_modifier
from product_photo_editor.tool_callbacks import before_tool_modifier
from product_photo_editor.prompt import AGENT_INSTRUCTION
root_agent = Agent(
model="gemini-2.5-flash",
name="product_photo_editor",
description="""A friendly product photo editor assistant that helps small business
owners edit and enhance their product photos. Perfect for improving photos of handmade
goods, food products, crafts, and small retail items""",
instruction=AGENT_INSTRUCTION
+ """
**IMPORTANT: Base64 Argument Rule on Tool Call**
If you found any tool call arguments that requires base64 data,
ALWAYS provide the artifact_id of the referenced file to
the tool call. NEVER ask user to provide base64 data.
Base64 data encoding process is out of your
responsibility and will be handled in another part of the system.
""",
tools=[
edit_product_asset,
mcp_toolset,
],
before_model_callback=before_model_modifier,
before_tool_callback=before_tool_modifier,
)
Ora proviamo a interagire con l'agente per testare questa modifica. Esegui questo comando per eseguire la UI di sviluppo web
uv run adk web --port 8080
Verrà generato un output simile al seguente esempio, il che significa che possiamo già accedere all'interfaccia web
INFO: Started server process [xxxx] INFO: Waiting for application startup. +-----------------------------------------------------------------------------+ | ADK Web Server started | | | | For local testing, access at http://127.0.0.1:8080. | +-----------------------------------------------------------------------------+ INFO: Application startup complete. INFO: Uvicorn running on http://127.0.0.1:8080 (Press CTRL+C to quit)
Ora, per verificarlo, puoi fare Ctrl + clic sull'URL o fare clic sul pulsante Anteprima web nella parte superiore di Cloud Shell Editor e selezionare Anteprima sulla porta 8080.
Vedrai la seguente pagina web in cui puoi selezionare gli agenti disponibili nel menu a discesa in alto a sinistra ( nel nostro caso dovrebbe essere product_photo_editor) e interagire con il bot.
Quindi, carica l'immagine seguente e chiedi all'agente di generare un clip promozionale a partire da questa.
Generate a slow zoom in and moving from left and right animation
Si verifica il seguente errore
Perché? Poiché lo strumento ha restituito i risultati direttamente sotto forma di stringa base64, verrà superato il token massimo. Ora gestiamo questo errore nella sezione successiva.
6. 🚀 Modifica della risposta dello strumento
In questa sezione, gestiremo la risposta dello strumento dalla risposta MCP. Faremo le seguenti cose:
- Memorizzare la risposta video dello strumento nel servizio di artefatti
- Restituisci invece l'identificatore dell'artefatto all'agente
Ti ricordiamo che toccheremo il seguente runtime dell'agente
Innanzitutto, implementiamo la funzione di callback, apri product_photo_editor/tool_callbacks.py e modificala per implementare after_tool_modifier
# product_photo_editor/tool_callbacks.py
from google.genai.types import Part
from typing import Any
from google.adk.tools.tool_context import ToolContext
from google.adk.tools.base_tool import BaseTool
from google.adk.tools.mcp_tool.mcp_tool import McpTool
import base64
import logging
import json
from mcp.types import CallToolResult
async def before_tool_modifier(
tool: BaseTool, args: dict[str, Any], tool_context: ToolContext
):
# Identify which tool input should be modified
if isinstance(tool, McpTool) and tool.name == "generate_video_with_image":
logging.info("Modify tool args for artifact: %s", args["image_data"])
# Get the artifact filename from the tool input argument
artifact_filename = args["image_data"]
artifact = await tool_context.load_artifact(filename=artifact_filename)
file_data = artifact.inline_data.data
# Convert byte data to base64 string
base64_data = base64.b64encode(file_data).decode("utf-8")
# Then modify the tool input argument
args["image_data"] = base64_data
async def after_tool_modifier(
tool: BaseTool,
args: dict[str, Any],
tool_context: ToolContext,
tool_response: dict | CallToolResult,
):
if isinstance(tool, McpTool) and tool.name == "generate_video_with_image":
tool_result = json.loads(tool_response.content[0].text)
# Get the expected response field which contains the video data
video_data = tool_result["video_data"]
artifact_filename = f"video_{tool_context.function_call_id}.mp4"
# Convert base64 string to byte data
video_bytes = base64.b64decode(video_data)
# Save the video as artifact
await tool_context.save_artifact(
filename=artifact_filename,
artifact=Part(inline_data={"mime_type": "video/mp4", "data": video_bytes}),
)
# Remove the video data from the tool response
tool_result.pop("video_data")
# Then modify the tool response to include the artifact filename and remove the base64 string
tool_result["video_artifact_id"] = artifact_filename
logging.info(
"Modify tool response for artifact: %s", tool_result["video_artifact_id"]
)
return tool_result
Dopodiché, dobbiamo dotare il nostro agente di questa funzione. Apri product_photo_editor/agent.py e modificalo con il seguente codice
# product_photo_editor/agent.py
from google.adk.agents.llm_agent import Agent
from product_photo_editor.custom_tools import edit_product_asset
from product_photo_editor.mcp_tools import mcp_toolset
from product_photo_editor.model_callbacks import before_model_modifier
from product_photo_editor.tool_callbacks import (
before_tool_modifier,
after_tool_modifier,
)
from product_photo_editor.prompt import AGENT_INSTRUCTION
root_agent = Agent(
model="gemini-2.5-flash",
name="product_photo_editor",
description="""A friendly product photo editor assistant that helps small business
owners edit and enhance their product photos. Perfect for improving photos of handmade
goods, food products, crafts, and small retail items""",
instruction=AGENT_INSTRUCTION
+ """
**IMPORTANT: Base64 Argument Rule on Tool Call**
If you found any tool call arguments that requires base64 data,
ALWAYS provide the artifact_id of the referenced file to
the tool call. NEVER ask user to provide base64 data.
Base64 data encoding process is out of your
responsibility and will be handled in another part of the system.
""",
tools=[
edit_product_asset,
mcp_toolset,
],
before_model_callback=before_model_modifier,
before_tool_callback=before_tool_modifier,
after_tool_callback=after_tool_modifier,
)
Fatto. Ora puoi chiedere all'agente non solo di aiutarti a modificare la foto, ma anche di generare un video. Esegui di nuovo questo comando
uv run adk web --port 8080
Poi, prova a creare un video utilizzando questa immagine.
Generate a slow zoom in and moving from left and right animation
Vedrai il video generato come nell'esempio mostrato di seguito e già salvato come artefatto
7. ⭐ Riepilogo
Ora rivediamo cosa abbiamo già fatto durante questo codelab. Ecco l'apprendimento chiave:
- Gestione dei dati multimodali (I/O dello strumento): è stata rafforzata la strategia per gestire i dati multimodali (come immagini e video) per l'input e l'output degli strumenti utilizzando il servizio Artifacts dell'ADK e callback specializzati anziché passare direttamente i dati in byte non elaborati.
- Integrazione del set di strumenti MCP: è stato sviluppato e integrato un server MCP Veo esterno utilizzando FastMCP tramite il set di strumenti MCP ADK per aggiungere funzionalità di generazione di video all'agente.
- Modifica dell'input dello strumento (before_tool_callback): è stata implementata una callback per intercettare la chiamata dello strumento generate_video_with_image, trasformando l'artifact_id del file (selezionato dall'LLM) nei dati immagine codificati in base64 richiesti per l'input del server MCP.
- Modifica dell'output dello strumento (after_tool_callback): è stata implementata una callback per intercettare la risposta video di grandi dimensioni codificata in base64 dal server MCP, salvare il video come nuovo artefatto e restituire un riferimento video_artifact_id pulito al LLM.
8. 🧹 Esegui la pulizia
Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo codelab, segui questi passaggi:
- Nella console Google Cloud, vai alla pagina Gestisci risorse.
- Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
- Nella finestra di dialogo, digita l'ID progetto, quindi fai clic su Chiudi per eliminare il progetto.