Evalúa agentes de IA generativa con el cliente de IA generativa en el SDK de Agent Platform

Después de compilar y evaluar tu modelo de IA generativa, puedes usarlo para compilar un agente, como un chatbot. Las evaluaciones de IA generativa te permiten medir la capacidad de tu agente para completar tareas y objetivos en tu caso de uso.

En esta página, se muestra cómo crear e implementar un agente básico y usar las evaluaciones de IA generativa para evaluar el agente:

Antes de comenzar

  1. Accede a tu cuenta de Google Cloud . Si eres nuevo en Google Cloud, crea una cuenta para evaluar el rendimiento de nuestros productos en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.

    In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

    Verify that billing is enabled for your Google Cloud project.

    In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

    Verify that billing is enabled for your Google Cloud project.

  2. Instala el SDK de Agent Platform para Python:

    %pip install google-cloud-aiplatform[adk,agent_engines]
%pip install --upgrade --force-reinstall -q google-cloud-aiplatform[evaluation]

  3. Configura tus credenciales. Si ejecutas este instructivo en Colaboratory, ejecuta lo siguiente:

    from google.colab import auth
auth.authenticate_user()

    Para otros entornos, consulta Autentícate en Agent Platform.

  4. Inicializa el cliente de IA generativa en el SDK de Agent Platform:

    import vertexai
from vertexai import Client
from google.genai import types as genai_types

GCS_DEST = "gs://BUCKET_NAME/output-path"
vertexai.init(
    project=PROJECT_ID,
    location=LOCATION,
)

client = Client(
    project=PROJECT_ID,
    location=LOCATION,
    http_options=genai_types.HttpOptions(api_version="v1beta1"),
  )

    Reemplaza lo siguiente:

    • BUCKET_NAME: Es el nombre del bucket de Cloud Storage. Consulta Crea un bucket para obtener más información sobre cómo crear buckets.

    • PROJECT_ID: ID del proyecto

    • LOCATION: Es la región que seleccionaste.

Desarrolla un agente

Desarrolla un agente del Kit de desarrollo de agentes (ADK) definiendo el modelo, la instrucción y el conjunto de herramientas. Para obtener más información sobre cómo desarrollar un agente, consulta Cómo desarrollar un agente del Kit de desarrollo de agentes.

from google.adk import Agent

# Define Agent Tools
def search_products(query: str):
    """Searches for products based on a query."""
    # Mock response for demonstration
    if "headphones" in query.lower():
        return {"products": [{"name": "Wireless Headphones", "id": "B08H8H8H8H"}]}
    else:
        return {"products": []}

def get_product_details(product_id: str):
    """Gets the details for a given product ID."""
    if product_id == "B08H8H8H8H":
        return {"details": "Noise-cancelling, 20-hour battery life."}
    else:
        return {"error": "Product not found."}

def add_to_cart(product_id: str, quantity: int):
    """Adds a specified quantity of a product to the cart."""
    return {"status": f"Added {quantity} of {product_id} to cart."}

# Define Agent
my_agent = Agent(
    model="gemini-2.5-flash",
    name='ecommerce_agent',
    instruction='You are an ecommerce expert',
    tools=[search_products, get_product_details, add_to_cart],
)

Implementa el agente

Implementa tu agente en el entorno de ejecución de Agent Platform. Este proceso puede tardar hasta 10 minutos. Recupera el nombre del recurso del agente implementado.

def deploy_adk_agent(root_agent):
  """Deploy agent to agent engine.
  Args:
    root_agent: The ADK agent to deploy.
  """
  app = vertexai.agent_engines.AdkApp(
      agent=root_agent,
  )
  remote_app = client.agent_engines.create(
      agent=app,
      config = {
          "staging_bucket": gs://BUCKET_NAME,
          "requirements": ['google-cloud-aiplatform[adk,agent_engines]'],
          "env_vars": {"GOOGLE_CLOUD_AGENT_ENGINE_ENABLE_TELEMETRY": "true"}
      }
  )
  return remote_app

agent_engine = deploy_adk_agent(my_agent)
agent_engine_resource_name = agent_engine.api_resource.name

Para obtener la lista de agentes implementados en Agent Platform, consulta Administra agentes implementados.

Generar respuestas

  1. Genera respuestas del modelo para tu conjunto de datos con run_inference():

    Prepara tu conjunto de datos como un DataFrame de Pandas. Las instrucciones deben ser específicas para tu agente. Las entradas de sesión son obligatorias para los registros. Para obtener más información, consulta Sesión: Seguimiento de conversaciones individuales.

    import pandas as pd
from vertexai import types

session_inputs = types.evals.SessionInput(
    user_id="user_123",
    state={},
)
agent_prompts = [
    "Search for 'noise-cancelling headphones'.",
    "Show me the details for product 'B08H8H8H8H'.",
    "Add one pair of 'B08H8H8H8H' to my shopping cart.",
    "Find 'wireless earbuds' and then add the first result to my cart.",
    "I need a new laptop for work, can you find one with at least 16GB of RAM?",
]
agent_dataset = pd.DataFrame({
    "prompt": agent_prompts,
    "session_inputs": [session_inputs] * len(agent_prompts),
})

  2. Genera respuestas del modelo con run_inference():

    agent_dataset_with_inference = client.evals.run_inference(
    agent=agent_engine_resource_name,
    src=agent_dataset,
)

  3. Visualiza los resultados de la inferencia llamando a .show() en el objeto EvaluationDataset para inspeccionar los resultados del modelo junto con tus instrucciones y referencias originales:

    agent_dataset_with_inference.show()

Ejecuta la evaluación del agente

Ejecuta create_evaluation_run() para evaluar las respuestas del agente.

  1. Recupera el agent_info con la función auxiliar integrada:

    agent_info = types.evals.AgentInfo.load_from_agent(
    my_agent,
    agent_engine_resource_name
)

  2. Evalúa las respuestas del modelo con métricas adaptables basadas en rúbricas específicas del agente (FINAL_RESPONSE_QUALITY, TOOL_USE_QUALITY y HALLUCINATION):

    evaluation_run = client.evals.create_evaluation_run(
    dataset=agent_dataset_with_inference,
    agent_info=agent_info,
    metrics=[
        types.RubricMetric.FINAL_RESPONSE_QUALITY,
        types.RubricMetric.TOOL_USE_QUALITY,
        types.RubricMetric.HALLUCINATION,
        types.RubricMetric.SAFETY,
    ],
    dest=GCS_DEST,
)

Cómo ver los resultados de la evaluación del agente

Puedes ver los resultados de la evaluación con el SDK de Agent Platform.

Recupera la ejecución de evaluación y visualiza los resultados de la evaluación llamando a .show() para mostrar las métricas de resumen y los resultados detallados:

evaluation_run = client.evals.get_evaluation_run(
    name=evaluation_run.name,
    include_evaluation_items=True
)

evaluation_run.show()

Los resultados detallados también incluyen seguimientos que muestran las interacciones del agente. Para obtener más información sobre los seguimientos, consulta Cómo hacer un seguimiento de un agente.

¿Qué sigue?

Prueba los siguientes notebooks de evaluación de agentes: