Mit der Einstellung von Vertex AI-Erweiterungen müssen vorhandene Arbeitsabläufe zur Gemini Enterprise Agent Platform (Agent Platform) migriert werden. In diesem Leitfaden werden die Migrationspfade für die drei wichtigsten Erweiterungskategorien erläutert:
Code-Interpreter-Erweiterung
Migrieren zu:Agent Platform Code Execution Sandbox Alternative:Gemini API-Tool CodeExecution
Die Code-Interpreter-Erweiterung sollte zur Agent Platform Code Execution Sandbox migriert werden. Dieser verwaltete Dienst bietet eine sichere, isolierte und zustandsbehaftete Sandbox-Umgebung, die speziell für die Ausführung von nicht vertrauenswürdigem, KI-generiertem Code entwickelt wurde. Er eignet sich ideal für die programmatische Ausführung, Finanzberechnungen und Data-Science-Arbeitsabläufe.
Alternativ können Sie das integrierte Tool code_execution im google-genai-SDK verwenden, wenn Sie möchten, dass die Gemini-Modelle Code automatisch schreiben und nativ während eines Generierungsvorgangs ausführen.
Beispiele für die Migration
Vertex AI-Erweiterungen :
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))"}
)
Agent Platform Code Execution Sandbox :
Option 1: Mit dem 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,
),
)
Option 2: Mit dem GenAI Client SDK
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')}")
Option 3: Als dynamisches manuelles Tool definieren
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)]
)
Google Suche-Erweiterung
Migrieren zu:Fundierung mit der Google Suche
Migrieren Sie zu Fundierung mit der Google Suche. Mit dieser Funktion werden Modellantworten in vertrauenswürdigen Suchindizes und aktuellen öffentlichen Informationen verankert, was zu höheren Faktizitätsraten führt.
Beispiele für die Migration
Vertex AI-Erweiterungen :
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?"}
)
Fundierung mit der Google Suche mit dem Google GenAI SDK :
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)
Benutzerdefinierte Erweiterungen
Migrieren zu:Funktionsaufrufe (Toolnutzung)
Migrieren Sie benutzerdefinierte Erweiterungen, die Sie mit OpenAPI-Spezifikationen konfiguriert haben, zu Funktionsaufrufe. Mit Funktionsaufrufen können Sie externe Plattform-APIs in Ihren Quelldateien definieren und deren Schnittstellenabstraktionen an Modelle weiterleiten.
Beispiele für die Migration
Vertex AI-Erweiterungen :
from vertexai.preview import extensions
extension = extensions.Extension.create(
manifest={
"name": "my_custom_api",
"apiSpec": {"openApiYaml": "..."}
}
)
Toolnutzung mit dem Google GenAI SDK :
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)