Migrer de Vertex AI Extensions vers Agent Platform

Avec l'abandon de Vertex AI Extensions, les workflows existants doivent être migrés vers Gemini Enterprise Agent Platform (Agent Platform). Ce guide explique les chemins de migration pour les trois catégories d'extensions principales :

Extension de l'interpréteur de code

Migrer vers : bac à sable d'exécution de code Agent Platform Alternative : outil CodeExecution de l'API Gemini

L'extension de l'interpréteur de code doit être migrée vers le bac à sable d'exécution de code Agent Platform. Ce service géré fournit un environnement de bac à sable sécurisé, isolé et avec état, spécialement conçu pour exécuter du code non approuvé généré par l'IA. Il est idéal pour l'exécution programmatique, les calculs financiers et les workflows de science des données.

Vous pouvez également utiliser l'outil intégré code_execution dans le SDK google-genai si vous préférez laisser les modèles Gemini écrire et exécuter automatiquement du code de manière native lors d'une passe de génération.

Exemples de migration

Vertex AI Extensions :

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))"}
)

Bac à sable d'exécution de code Agent Platform :

Option 1 : Utiliser 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 : Utiliser le 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')}")

Option 3 : Définir comme outil manuel dynamique

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)]
)

Extension de la recherche Google

Migrer vers : ancrage avec la recherche Google

Migrez vers l'ancrage avec la recherche Google. Cette fonctionnalité ancre les réponses du modèle dans des index de recherche fiables et des informations publiques à jour, ce qui permet d'obtenir des taux de factualité plus élevés.

Exemples de migration

Vertex AI Extensions :

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?"}
)

Ancrage avec la recherche Google à l'aide du 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)

Extensions personnalisées

Migrer vers : appel de fonction (utilisation d'outil)

Migrez les extensions personnalisées que vous avez configurées avec des spécifications OpenAPI vers l'appel de fonction. L'appel de fonction vous permet de définir des API de plate-forme externes dans vos fichiers sources et de transmettre leurs abstractions d'interface aux modèles.

Exemples de migration

Vertex AI Extensions :

from vertexai.preview import extensions

extension = extensions.Extension.create(
    manifest={
        "name": "my_custom_api",
        "apiSpec": {"openApiYaml": "..."}
    }
)

Utilisation d'outil à l'aide du 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)