Con il ritiro delle estensioni di Vertex AI, i workflow esistenti devono essere migrati a Gemini Enterprise Agent Platform (Agent Platform). Questa guida illustra i percorsi di migrazione per le tre categorie di estensioni principali:
Estensione Interprete codice
Esegui la migrazione a: sandbox di esecuzione del codice di Agent Platform Alternativa: strumento CodeExecution dell'API Gemini
L'estensione Interprete codice deve essere migrata alla sandbox di esecuzione del codice di Agent Platform. Questo servizio gestito fornisce un ambiente sandbox sicuro, isolato e con stato, progettato specificamente per eseguire codice non attendibile generato dall'AI. È ideale per l'esecuzione programmatica, i calcoli finanziari e i workflow di data science.
In alternativa, se preferisci che i modelli Gemini scrivano ed eseguano automaticamente il codice in modo nativo durante un passaggio di generazione, puoi utilizzare lo strumento code_execution integrato nell'SDK google-genai.
Esempi di migrazione
Estensioni di Vertex AI:
from vertexai.preview import extensions
extension = extensions.Extension.from_hub("code_interpreter")
response = extension.execute(
operation_id="generate_and_execute_code",
operation_params={"code": "import math\nprint(math.sqrt(15376))"}
)
Sandbox di esecuzione del codice di Agent Platform:
Opzione 1: utilizzo dell'Agent Development Kit (ADK)
from google.adk.code_executors.agent_engine_sandbox_code_executor import (
AgentEngineSandboxCodeExecutor,
)
from vertexai.preview.reasoning_engines import Agent
root_agent = Agent(
model="gemini-2.0-flash-001",
name="agent_engine_code_execution_agent",
instruction=base_system_instruction()
+ """
You need to assist the user with their queries by looking at the data and the
context in the conversation. Your final answer should summarize the code and
code execution relevant to the user query.
Include all pieces of data required to answer the question, such as a table
from code execution results. If the query can be answered directly without
writing code, generate the textual response directly. Take care not to manually
run commands like `pip install`. When plotting trends, sort data by the x-axis.
""",
code_executor=AgentEngineSandboxCodeExecutor(
sandbox_resource_name=None,
agent_engine_resource_name=None,
),
)
Opzione 2: utilizzo dell'SDK client GenAI
from google import genai
# Initialize Gemini model
model = genai.Client().models
# Ask Gemini to generate code for a calculation
prompt = """
Write Python code to calculate the mean and standard deviation of these numbers:
[23, 45, 67, 89, 12, 34, 56]
Return only the Python code, no explanations.
"""
response = model.generate_content(
model="gemini-2.5-flash",
contents=prompt
)
generated_code = response.text.replace("```python", "").replace("```", "").strip()
# Execute the generated code in Agent Engine Sandbox using new pattern
exec_response = client.agent_engines.sandboxes.execute_code(
name=sandbox_resource_name,
input_data={"code": generated_code},
)
# Parse response with new file handling logic
for output in exec_response.outputs:
if output.mime_type == "application/json" and output.metadata is None:
result = json.loads(output.data.decode("utf-8"))
if result.get("msg_out"):
print(result.get("msg_out"))
if result.get("msg_err"):
print(f"Error occurred: {result.get('msg_err')}")
Opzione 3: definizione come strumento manuale dinamico
import json
import re
from google.genai.types import FunctionDeclaration, Tool
def execute_python_code(code: str) -> str:
"""Execute Python code in a secure sandbox.
Args:
code: Python code to execute
Returns:
The output from code execution
"""
# Extract code block if wrapped in markdown
code_match = re.search(r"```python\n(.*?)\n```", code, re.DOTALL)
code_to_execute = code_match.group(1) if code_match else code
# Execute in sandbox
response = client.agent_engines.sandboxes.execute_code(
name=sandbox_resource_name, input_data={"code": code_to_execute}
)
# Parse response using new pattern
for output in response.outputs:
if output.mime_type == "application/json" and output.metadata is None:
result = json.loads(output.data.decode("utf-8"))
if result.get("msg_err"):
return f"Error: {result.get('msg_err')}"
return result.get("msg_out", "Code executed successfully")
return "Code executed (no output)"
# Create a tool from the function
code_tool = Tool(
function_declarations=[FunctionDeclaration.from_func(execute_python_code)]
)
Estensione Ricerca Google
Esegui la migrazione a: grounding con la Ricerca Google
Esegui la migrazione al grounding con la Ricerca Google. Questa funzionalità ancora le risposte del modello in indici di ricerca attendibili e informazioni pubbliche aggiornate, con conseguenti tassi di factualità più elevati.
Esempi di migrazione
Estensioni di Vertex AI:
from vertexai.preview import extensions
extension = extensions.Extension.from_hub("google_search")
response = extension.execute(
operation_id="search",
operation_params={"query": "What is the next total solar eclipse in the US?"}
)
Grounding con la Ricerca Google utilizzando l'SDK Google GenAI:
from google import genai
from google.genai.types import GenerateContentConfig, GoogleSearch, Tool
client = genai.Client()
response = client.models.generate_content(
model="gemini-3.1-flash",
contents="When is the next total solar eclipse in the United States?",
config=GenerateContentConfig(
tools=[Tool(google_search=GoogleSearch())],
temperature=0.0,
),
)
print(response.text)
Estensioni personalizzate
Esegui la migrazione a: chiamata di funzione (utilizzo dello strumento)
Esegui la migrazione delle estensioni personalizzate configurate con le specifiche OpenAPI alla chiamata di funzione. La chiamata di funzione consente di definire le API della piattaforma esterna all'interno dei file di origine e di inoltrare le relative astrazioni dell'interfaccia ai modelli.
Esempi di migrazione
Estensioni di Vertex AI:
from vertexai.preview import extensions
extension = extensions.Extension.create(
manifest={
"name": "my_custom_api",
"apiSpec": {"openApiYaml": "..."}
}
)
Utilizzo dello strumento utilizzando l'SDK Google GenAI:
from google import genai
from google.genai.types import GenerateContentConfig
def get_order_status(order_id: str) -> str:
"""Returns the current status of a customer order.
Args:
order_id: The unique identifier of the order.
"""
statuses = {"123": "Shipped", "456": "Processing"}
return statuses.get(order_id, "Order not found")
client = genai.Client()
response = client.models.generate_content(
model="gemini-3.0-pro",
contents="Can you check the status of my order 123?",
config=GenerateContentConfig(
tools=[get_order_status],
),
)
print(response.text)