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

Vista previa

Esta función está sujeta a las "Condiciones de la oferta previa a la DG" en la sección Condiciones Generales del Servicio de las Condiciones Específicas del Servicio. Las funciones de la fase previa a la DG están disponibles “sin modificaciones” y pueden tener asistencia limitada. Para obtener más información, consulta las descripciones de la etapa de lanzamiento.

Después de compilar y evaluar tu modelo de IA generativa, puedes usarlo para compilar un agente, como un chatbot. Las evaluaciones de Gemini Enterprise Agent Platform 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 evaluarlo:

• Desarrolla un agente: Define un agente con funciones de herramientas básicas.

• Implementar un agente: Implementa el agente en Agent Platform Runtime.

• Ejecuta la inferencia del agente: Define un conjunto de datos de evaluación y ejecuta la inferencia del agente para generar respuestas.

• Crear una ejecución de evaluación: Crea una ejecución de evaluación para realizar la evaluación.

• Visualiza los resultados de la evaluación: Consulta los resultados de la evaluación a través de la ejecución de la evaluación.

Para ver un ejemplo de cómo crear una evaluación de agente de IA generativa para un agente implementado, ejecuta el notebook "Crea e implementa un agente y ejecuta la evaluación de agente de IA generativa" en uno de los siguientes entornos:

Abrir en Colab | Abrir en Colab Enterprise | Abrir en Agent Platform Workbench | Ver en GitHub

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.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   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.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   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

Desarrollar 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 de ADK.

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

Implementar agente

Implementa tu agente en Agent Platform Runtime. 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 que se implementan en Agent Platform, consulta Administra agentes implementados.

Genera 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 seguimientos. Para obtener más información, consulta Sesión: Realiza un seguimiento de las 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 agente con métricas basadas en rúbricas adaptables 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,
   )
   

Visualiza 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 la 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 Realiza un seguimiento de un agente.

¿Qué sigue?

Prueba los siguientes notebooks de evaluación de agentes:

• Evalúa un agente de LangChain con Agent Engine

• Evalúa un agente de LangGraph con Agent Engine

• Evalúa un agente de CrewAI con Agent Engine