Com a descontinuação das extensões da Vertex AI, os fluxos de trabalho atuais precisam ser migrados para a plataforma de agentes do Gemini Enterprise (plataforma de agentes). Este guia explica os caminhos de migração para as três categorias principais de extensão:
Extensão Intérprete de código
Migrar para:sandbox de execução de código do Agent Platform Alternativa:ferramenta CodeExecution da API Gemini
A extensão Intérprete de código precisa ser migrada para o sandbox de execução de código do Agent Platform. Esse serviço gerenciado oferece um ambiente de sandbox seguro, isolado e com estado, projetado especificamente para executar código não confiável gerado por IA. Ele é ideal para execução programática, cálculos financeiros e fluxos de trabalho de ciência de dados.
Como alternativa, se você preferir que os modelos do Gemini escrevam e executem código automaticamente durante uma passagem de geração, use a ferramenta code_execution integrada no SDK google-genai.
Exemplos de migração
Extensões da 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 de execução de código do Agent Platform
Opção 1: usar o Kit de Desenvolvimento de Agentes (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,
),
)
Opção 2: usar o SDK do cliente da 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')}")
Opção 3: definir como uma ferramenta manual dinâmica
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)]
)
Extensão da Pesquisa Google
Migrar para:Embasamento com a Pesquisa Google
Migre para o Embasamento com a Pesquisa Google. Esse recurso ancora as respostas do modelo em índices de pesquisa confiáveis e informações públicas atualizadas, gerando taxas de factualidade mais altas.
Exemplos de migração
Extensões da 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?"}
)
Embasamento com a Pesquisa Google usando o SDK da GenAI do Google :
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)
Extensões personalizadas
Migrar para:chamada de função (uso de ferramentas)
Migre as extensões personalizadas configuradas com especificações da OpenAPI para a chamada de função. A chamada de função permite definir APIs de plataformas externas nos arquivos de origem e encaminhar as abstrações de interface para modelos.
Exemplos de migração
Extensões da Vertex AI :
from vertexai.preview import extensions
extension = extensions.Extension.create(
manifest={
"name": "my_custom_api",
"apiSpec": {"openApiYaml": "..."}
}
)
Uso de ferramentas usando o SDK da GenAI do Google :
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)