Compartir a través de

Ejecución de evaluaciones en la nube mediante el SDK de Microsoft Foundry

Importante

Los elementos marcados (versión preliminar) en este artículo se encuentran actualmente en versión preliminar pública. Esta versión preliminar se ofrece sin acuerdo de nivel de servicio y no se recomienda para las cargas de trabajo de producción. Es posible que algunas características no sean compatibles o que tengan sus funcionalidades limitadas. Para más información, consulte Términos de uso complementarios para las versiones preliminares de Microsoft Azure.

En este artículo, aprenderá a ejecutar evaluaciones en la nube (versión preliminar) para realizar pruebas previas a la implementación en un conjunto de datos de prueba.

Use evaluaciones en la nube para la mayoría de los escenarios, especialmente al probar a escala, integrar evaluaciones en canalizaciones de integración continua y entrega continua (CI/CD) o realizar pruebas previas a la implementación. La ejecución de evaluaciones en la nube elimina la necesidad de administrar la infraestructura de proceso local y admite flujos de trabajo de pruebas automatizadas a gran escala. También puede programar evaluaciones para que se ejecuten periódicamente o configurar la evaluación continua para evaluar automáticamente las respuestas de agente muestreadas en producción.

Los resultados de la evaluación en la nube se almacenan en el proyecto foundry. Puede revisar los resultados en el portal, recuperarlos a través del SDK o enrutarlos a Application Insights si están conectados. La evaluación en la nube admite todos los evaluadores integrados mantenidos por Microsoft y sus propios evaluadores personalizados. Los evaluadores se administran en el catálogo del evaluador con el mismo control de acceso basado en rol y ámbito del proyecto.

Sugerencia

Para ver ejemplos completos ejecutables, consulte los ejemplos de evaluación del SDK de Python en GitHub.

Al usar el SDK de Foundry, registra los resultados de la evaluación en el proyecto foundry para mejorar la observabilidad. Esta característica admite todos los evaluadores integrados seleccionados por Microsoft. y sus propios evaluadores personalizados. Los evaluadores se pueden encontrar en la biblioteca del evaluador y tener el mismo control de acceso basado en rol y ámbito del proyecto.

Funcionamiento de la evaluación en la nube

Para ejecutar una evaluación en la nube, cree una definición de evaluación con el esquema de datos y los criterios de prueba (evaluadores) y, a continuación, cree una ejecución de evaluación. La ejecución ejecuta cada evaluador en los datos y devuelve los resultados puntuados que puede sondear para su finalización.

La evaluación en la nube admite los siguientes escenarios:

Escenario Cuándo usar Tipo de origen de datos Objetivo
Evaluación del conjunto de datos Evalúe las respuestas calculadas previamente en un archivo JSONL. jsonl —
Evaluación del objetivo del modelo Proporcione consultas y genere respuestas a partir de un modelo en tiempo de ejecución para su evaluación. azure_ai_target_completions azure_ai_model
Evaluación de objetivo del agente Proporcione consultas y genere respuestas desde un agente Foundry en tiempo de ejecución para su evaluación. azure_ai_target_completions azure_ai_agent
Evaluación de la respuesta del agente Recupere y evalúe las respuestas del agente de Foundry por identificadores de respuesta. azure_ai_responses —
Evaluación del equipo rojo Realice pruebas de adversidad automatizadas en un modelo o agente. azure_ai_red_team azure_ai_model o azure_ai_agent

La mayoría de los escenarios requieren datos de entrada. Puede proporcionar datos de dos maneras:

Tipo de origen Description
file_id Haga referencia a un conjunto de datos cargado por identificador.
file_content Proporcione los datos incluidos en la solicitud.

Cada evaluación requiere un data_source_config que indique al servicio qué campos deben esperar en los datos:

  • custom — Definís un item_schema con los nombres y tipos de campo. Establezca include_sample_schema en true cuando se utilice un objetivo para que los evaluadores puedan hacer referencia a las respuestas generadas.
  • azure_ai_source : el esquema se deduce del servicio. Establezca "scenario" en "responses" para la evaluación de respuesta del agente o "red_team" para el red teaming.

Cada escenario requiere evaluadores que definan los criterios de prueba. Para obtener instrucciones sobre cómo seleccionar evaluadores, consulte Evaluadores integrados.

Prerrequisitos

  • Un proyecto Foundry.
  • Una implementación de Azure OpenAI con un modelo GPT que admita la finalización del chat (por ejemplo, gpt-5-mini).
  • Rol de usuario de Azure AI en el proyecto Foundry.
  • Opcionalmente, puede usar su propia cuenta de almacenamiento para ejecutar evaluaciones.

Nota:

Algunas características de evaluación tienen restricciones regionales. Consulte las regiones admitidas para obtener más información.

Empieza ahora

Instale el SDK y configure el cliente:

pip install "azure-ai-projects>=2.0.0b1" azure-identity openai

import os
from azure.identity import DefaultAzureCredential 
from azure.ai.projects import AIProjectClient 
from openai.types.eval_create_params import DataSourceConfigCustom
from openai.types.evals.create_eval_jsonl_run_data_source_param import (
    CreateEvalJSONLRunDataSourceParam,
    SourceFileContent,
    SourceFileContentContent,
    SourceFileID,
)

# Azure AI Project endpoint
# Example: https://<account_name>.services.ai.azure.com/api/projects/<project_name>
endpoint = os.environ["AZURE_AI_PROJECT_ENDPOINT"]

# Model deployment name (for AI-assisted evaluators)
# Example: gpt-5-mini
model_deployment_name = os.environ.get("AZURE_AI_MODEL_DEPLOYMENT_NAME", "")

# Dataset details (optional, for reusing existing datasets)
dataset_name = os.environ.get("DATASET_NAME", "")
dataset_version = os.environ.get("DATASET_VERSION", "1")

# Create the project client
project_client = AIProjectClient( 
    endpoint=endpoint, 
    credential=DefaultAzureCredential(), 
)

# Get the OpenAI client for evaluation API
client = project_client.get_openai_client()

Preparación de los datos de entrada

La mayoría de los escenarios de evaluación requieren datos de entrada. Puede proporcionar datos de dos maneras:

Cargue un archivo JSONL para crear un conjunto de datos con versiones en el proyecto foundry. Los conjuntos de datos admiten el control de versiones y la reutilización en varias ejecuciones de evaluación. Use este enfoque para pruebas de producción y flujos de trabajo de CI/CD.

Prepare un archivo JSONL con un objeto JSON por línea que contenga los campos que necesitan los evaluadores:

{"query": "What is machine learning?", "response": "Machine learning is a subset of AI.", "ground_truth": "Machine learning is a type of AI that learns from data."}
{"query": "Explain neural networks.", "response": "Neural networks are computing systems inspired by biological neural networks.", "ground_truth": "Neural networks are a set of algorithms modeled after the human brain."}

# Upload a local JSONL file. Skip this step if you already have a dataset registered.
data_id = project_client.datasets.upload_file(
    name=dataset_name,
    version=dataset_version,
    file_path="./evaluate_test_data.jsonl",
).id

Proporcionar datos en línea

Para experimentar rápidamente con conjuntos de pruebas pequeños, proporcione datos directamente en la solicitud de evaluación mediante file_content.

source = SourceFileContent(
    type="file_content",
    content=[
        SourceFileContentContent(
            item={
                "query": "How can I safely de-escalate a tense situation?",
                "ground_truth": "Encourage calm communication, seek help if needed, and avoid harm.",
            }
        ),
        SourceFileContentContent(
            item={
                "query": "What is the largest city in France?",
                "ground_truth": "Paris",
            }
        ),
    ],
)

Pase source como el campo "source" en la configuración del origen de datos al ejecutar una ejecución. Las secciones del escenario que siguen utilizan file_id de forma predeterminada.

Evaluación del conjunto de datos

Evalúe las respuestas calculadas previamente en un archivo JSONL mediante el tipo de jsonl origen de datos. Este escenario es útil cuando ya tiene salidas de modelo y desea evaluar su calidad.

Sugerencia

Antes de comenzar, complete Introducción y Preparación de los datos de entrada.

Definir el esquema de datos y los evaluadores

Especifique el esquema que coincida con los campos JSONL y seleccione los evaluadores (criterios de prueba) que se van a ejecutar. Use el data_mapping parámetro para conectar campos de los datos de entrada a los parámetros del evaluador con {{item.field}} sintaxis. data_mapping Incluya siempre los campos de entrada necesarios para cada evaluador. Los nombres de campo deben coincidir con los del archivo JSONL; por ejemplo, si los datos tienen "question" en lugar de "query", usen "{{item.question}}" en la asignación. Para conocer los parámetros necesarios por evaluador, consulte evaluadores integrados.

data_source_config = DataSourceConfigCustom(
    type="custom",
    item_schema={
        "type": "object",
        "properties": {
            "query": {"type": "string"},
            "response": {"type": "string"},
            "ground_truth": {"type": "string"},
        },
        "required": ["query", "response", "ground_truth"],
    },
)

testing_criteria = [
    {
        "type": "azure_ai_evaluator",
        "name": "coherence",
        "evaluator_name": "builtin.coherence",
        "initialization_parameters": {
            "deployment_name": model_deployment_name
        },
        "data_mapping": {
            "query": "{{item.query}}",
            "response": "{{item.response}}",
        },
    },
    {
        "type": "azure_ai_evaluator",
        "name": "violence",
        "evaluator_name": "builtin.violence",
        "initialization_parameters": {
            "deployment_name": model_deployment_name
        },
        "data_mapping": {
            "query": "{{item.query}}",
            "response": "{{item.response}}",
        },
    },
    {
        "type": "azure_ai_evaluator",
        "name": "f1",
        "evaluator_name": "builtin.f1_score",
        "data_mapping": {
            "response": "{{item.response}}",
            "ground_truth": "{{item.ground_truth}}",
        },
    },
]

Creación de evaluación y ejecución

Cree la evaluación y, a continuación, inicie una ejecución en el conjunto de datos cargado. La ejecución ejecuta cada evaluador en cada fila del conjunto de datos.

# Create the evaluation
eval_object = client.evals.create(
    name="dataset-evaluation",
    data_source_config=data_source_config,
    testing_criteria=testing_criteria,
)

# Create a run using the uploaded dataset
eval_run = client.evals.runs.create(
    eval_id=eval_object.id,
    name="dataset-run",
    data_source=CreateEvalJSONLRunDataSourceParam(
        type="jsonl",
        source=SourceFileID(
            type="file_id",
            id=data_id,
        ),
    ),
)

Para obtener un ejemplo completo de ejecución, consulte sample_evaluations_builtin_with_dataset_id.py en GitHub. Para sondear la finalización e interpretar los resultados, consulte Obtener los resultados.

Evaluación del objetivo del modelo

Envíe consultas a un modelo implementado en tiempo de ejecución y evalúe las respuestas mediante el tipo de azure_ai_target_completions origen de datos con un azure_ai_model destino. Los datos de entrada contienen consultas; el modelo genera respuestas que se evalúan a continuación.

Sugerencia

Antes de comenzar, complete Introducción y Preparación de los datos de entrada.

Definir la plantilla de mensaje y el destino

La input_messages plantilla controla cómo se envían las consultas al modelo. Use {{item.query}} para hacer referencia a campos de los datos de entrada. Especifique el modelo para evaluar y los parámetros de muestreo opcionales:

input_messages = {
    "type": "template",
    "template": [
        {
            "type": "message",
            "role": "user",
            "content": {
                "type": "input_text",
                "text": "{{item.query}}"
            }
        }
    ]
}

target = {
    "type": "azure_ai_model",
    "model": "gpt-5-mini",
    "sampling_params": {
        "top_p": 1.0,
        "max_completion_tokens": 2048,
    },
}

Configurar evaluadores y mapeos de datos

Cuando el modelo genera respuestas en tiempo de ejecución, use {{sample.output_text}} en data_mapping para hacer referencia a la salida del modelo. Use {{item.field}} para hacer referencia a campos de los datos de entrada.

data_source_config = DataSourceConfigCustom(
    type="custom",
    item_schema={
        "type": "object",
        "properties": {
            "query": {"type": "string"},
        },
        "required": ["query"],
    },
    include_sample_schema=True,
)

testing_criteria = [
    {
        "type": "azure_ai_evaluator",
        "name": "coherence",
        "evaluator_name": "builtin.coherence",
        "initialization_parameters": {
            "deployment_name": model_deployment_name,
        },
        "data_mapping": {
            "query": "{{item.query}}",
            "response": "{{sample.output_text}}",
        },
    },
    {
        "type": "azure_ai_evaluator",
        "name": "violence",
        "evaluator_name": "builtin.violence",
        "data_mapping": {
            "query": "{{item.query}}",
            "response": "{{sample.output_text}}",
        },
    },
]

Creación de evaluación y ejecución

eval_object = client.evals.create(
    name="Model Target Evaluation",
    data_source_config=data_source_config,
    testing_criteria=testing_criteria,
)

data_source = {
    "type": "azure_ai_target_completions",
    "source": {
        "type": "file_id",
        "id": data_id,
    },
    "input_messages": input_messages,
    "target": target,
}

eval_run = client.evals.runs.create(
    eval_id=eval_object.id,
    name="model-target-evaluation",
    data_source=data_source,
)

Para obtener un ejemplo completo de ejecución, consulte sample_model_evaluation.py en GitHub. Para sondear la finalización e interpretar los resultados, consulte Obtener los resultados.

Sugerencia

Para agregar otra ejecución de evaluación, puede usar el mismo código.

Evaluación de objetivos del agente

Envíe consultas a un agente de Foundry en tiempo de ejecución y evalúe las respuestas usando el tipo de origen de datos azure_ai_target_completions con el destino azure_ai_agent.

Sugerencia

Antes de comenzar, complete Introducción y Preparación de los datos de entrada.

Definir la plantilla de mensaje y el destino

La input_messages plantilla controla cómo se envían las consultas al agente. Use {{item.query}} para hacer referencia a campos de los datos de entrada. Especifique el agente por nombre para evaluarlo:

input_messages = {
    "type": "template",
    "template": [
        {
            "type": "message",
            "role": "developer",
            "content": {
                "type": "input_text",
                "text": "You are a helpful assistant. Answer clearly and safely."
            }
        },
        {
            "type": "message",
            "role": "user",
            "content": {
                "type": "input_text",
                "text": "{{item.query}}"
            }
        }
    ]
}

target = {
    "type": "azure_ai_agent",
    "name": "my-agent",
    "version": "1"  # Optional. Uses latest version if omitted.
}

Configurar evaluadores y mapeos de datos

Cuando el agente genera respuestas en tiempo de ejecución, use {{sample.*}} variables en data_mapping para hacer referencia a la salida del agente:

Variable Description Usado para
{{sample.output_text}} Respuesta de texto sin formato del agente. Evaluadores que esperan una respuesta de cadena (por ejemplo, coherence, violence).
{{sample.output_items}} Salida JSON estructurada del agente, incluidas las llamadas a herramientas. Evaluadores que necesitan contexto de interacción completo (por ejemplo, task_adherence).
{{item.field}} Campo de los datos de entrada. Campos de entrada como query o ground_truth.

Sugerencia

El query campo puede contener JSON estructurado, incluidos los mensajes del sistema y el historial de conversaciones. Algunos evaluadores de agentes, como task_adherence, usan este contexto para obtener una puntuación más precisa. Para más información sobre el formato de consulta, consulte evaluadores de agentes.

data_source_config = DataSourceConfigCustom(
    type="custom",
    item_schema={
        "type": "object",
        "properties": {
            "query": {"type": "string"},
        },
        "required": ["query"],
    },
    include_sample_schema=True,
)

testing_criteria = [
    {
        "type": "azure_ai_evaluator",
        "name": "coherence",
        "evaluator_name": "builtin.coherence",
        "initialization_parameters": {
            "deployment_name": model_deployment_name,
        },
        "data_mapping": {
            "query": "{{item.query}}",
            "response": "{{sample.output_text}}",
        },
    },
    {
        "type": "azure_ai_evaluator",
        "name": "violence",
        "evaluator_name": "builtin.violence",
        "data_mapping": {
            "query": "{{item.query}}",
            "response": "{{sample.output_text}}",
        },
    },
    {
        "type": "azure_ai_evaluator",
        "name": "task_adherence",
        "evaluator_name": "builtin.task_adherence",
        "initialization_parameters": {
            "deployment_name": model_deployment_name,
        },
        "data_mapping": {
            "query": "{{item.query}}",
            "response": "{{sample.output_items}}",
        },
    },
]

Creación de evaluación y ejecución

eval_object = client.evals.create(
    name="Agent Target Evaluation",
    data_source_config=data_source_config,
    testing_criteria=testing_criteria,
)

data_source = {
    "type": "azure_ai_target_completions",
    "source": {
        "type": "file_id",
        "id": data_id,
    },
    "input_messages": input_messages,
    "target": target,
}

agent_eval_run = client.evals.runs.create(
    eval_id=eval_object.id,
    name="agent-target-evaluation",
    data_source=data_source,
)

Para obtener un ejemplo completo de ejecución, consulte sample_agent_evaluation.py en GitHub. Para sondear la finalización e interpretar los resultados, consulte Obtener los resultados.

Evaluación de la respuesta del agente

Recupere y evalúe las respuestas del agente Foundry por medio de los identificadores de respuesta utilizando el tipo de origen de datos azure_ai_responses. Use este escenario para evaluar interacciones específicas del agente después de que se produzcan.

Sugerencia

Antes de comenzar, complete Introducción.

Un identificador de respuesta es un identificador único devuelto cada vez que un agente Foundry genera una respuesta. Puede recopilar identificadores de respuesta de las interacciones del agente mediante la API de respuestas o los registros de seguimiento de la aplicación. Proporcione los IDs en línea como contenido de archivo, o súbalos como un conjunto de datos (consulte Preparación de los datos de entrada).

Recopilar identificadores de respuesta

Cada llamada a la API de respuestas devuelve un objeto de respuesta con un campo único id . Recopile estos identificadores de las interacciones de la aplicación o indíquelos directamente:

# Generate response IDs by calling a model through the Responses API
response = client.responses.create(
    model=model_deployment_name,
    input="What is machine learning?",
)
print(response.id)  # Example: resp_abc123

También puede recopilar identificadores de respuesta de las interacciones del agente en los registros de trazabilidad o en la canalización de monitoreo de la aplicación. Cada identificador de respuesta identifica de forma única una respuesta almacenada que el servicio de evaluación puede recuperar.

Creación de evaluación y ejecución

data_source_config = {"type": "azure_ai_source", "scenario": "responses"}

testing_criteria = [
    {
        "type": "azure_ai_evaluator",
        "name": "coherence",
        "evaluator_name": "builtin.coherence",
        "initialization_parameters": {
            "deployment_name": model_deployment_name,
        },
    },
    {
        "type": "azure_ai_evaluator",
        "name": "violence",
        "evaluator_name": "builtin.violence",
    },
]

eval_object = client.evals.create(
    name="Agent Response Evaluation",
    data_source_config=data_source_config,
    testing_criteria=testing_criteria,
)

data_source = {
    "type": "azure_ai_responses",
    "item_generation_params": {
        "type": "response_retrieval",
        "data_mapping": {"response_id": "{{item.resp_id}}"},
        "source": {
            "type": "file_content",
            "content": [
                {"item": {"resp_id": "resp_abc123"}},
                {"item": {"resp_id": "resp_def456"}},
            ]
        },
    },
}

eval_run = client.evals.runs.create(
    eval_id=eval_object.id,
    name="agent-response-evaluation",
    data_source=data_source,
)

Para obtener un ejemplo completo de ejecución, consulte sample_agent_response_evaluation.py en GitHub. Para sondear la finalización e interpretar los resultados, consulte Obtener los resultados.

Obtención de resultados

Una vez completada una ejecución de evaluación, recupere los resultados puntuados y repase los resultados en el portal o mediante programación.

Consultar los resultados

Las ejecuciones de evaluación son asincrónicas. Sondee el estado de ejecución hasta que finalice y recupere los resultados:

import time
from pprint import pprint

while True:
    run = client.evals.runs.retrieve(
        run_id=eval_run.id, eval_id=eval_object.id
    )
    if run.status in ("completed", "failed"):
        break
    time.sleep(5)
    print("Waiting for eval run to complete...")

# Retrieve results
output_items = list(
    client.evals.runs.output_items.list(
        run_id=run.id, eval_id=eval_object.id
    )
)
pprint(output_items)
print(f"Report URL: {run.report_url}")

Interpretación de los resultados

Para obtener un único ejemplo de datos, todos los evaluadores generan el esquema siguiente:

  • Etiqueta: una etiqueta binaria "pass" o "fail", similar a la salida de una prueba unitaria. Use este resultado para facilitar las comparaciones entre evaluadores.
  • Puntuación: una puntuación de la escala natural de cada evaluador. Algunos evaluadores usan una referencia específica, la puntuación en una escala de 5 puntos (evaluadores de calidad) o una escala de 7 puntos (evaluadores de seguridad de contenido). Otros, como evaluadores de similitud textual, usan puntuaciones F1, que son números flotantes entre 0 y 1. Cualquier "puntuación" no binaria se binariza como "pasar" o "fallar" en el campo "etiqueta" en función del "umbral".
  • Umbral: las puntuaciones no binarias se binarizan para "pasar" o "fallar" en función de un umbral predeterminado, que el usuario puede anular en la interfaz del SDK.
  • Motivo: Con el fin de mejorar la inteligibilidad, todos los evaluadores del juez de LLM también generan un campo de justificación para explicar por qué se da una puntuación determinada.
  • Detalles: (opcional) Para algunos evaluadores, como tool_call_accuracy, puede haber un campo o marcas de "detalles" que contengan información adicional para ayudar a los usuarios a depurar sus aplicaciones.

Salida de ejemplo (elemento único)

{
  "type": "azure_ai_evaluator",
  "name": "Coherence",
  "metric": "coherence",
  "score": 4.0,
  "label": "pass",
  "reason": "The response is well-structured and logically organized, presenting information in a clear and coherent manner.",
  "threshold": 3,
  "passed": true
}

Ejemplo de resultados (conjunto)

Para obtener resultados agregados en varios ejemplos de datos (un conjunto de datos), la tasa media de los ejemplos con un "aprobado" forma la tasa de aprobación de ese conjunto de datos.

{
  "eval_id": "eval_abc123",
  "run_id": "run_xyz789",
  "status": "completed",
  "result_counts": {
    "passed": 85,
    "failed": 15,
    "total": 100
  },
  "per_testing_criteria_results": [
    {
      "name": "coherence",
      "passed": 92,
      "failed": 8,
      "pass_rate": 0.92
    },
    {
      "name": "relevance", 
      "passed": 78,
      "failed": 22,
      "pass_rate": 0.78
    }
  ]
}

Solución de problemas

Trabajo en ejecución durante mucho tiempo

El trabajo de evaluación puede permanecer en el estado En ejecución durante un período prolongado. Esto suele ocurrir cuando la implementación del modelo de Azure OpenAI no tiene suficiente capacidad, lo que hace que el servicio vuelva a intentar las solicitudes.

Resolución:

  1. Cancele el trabajo de evaluación actual mediante client.evals.runs.cancel(run_id, eval_id=eval_id).
  2. Aumente la capacidad del modelo en Azure Portal.
  3. Vuelva a ejecutar la evaluación.

Errores de autenticación

Si recibe un error 401 Unauthorized o 403 Forbidden, verifique que:

  • Tu DefaultAzureCredential está configurado correctamente (ejecuta az login si estás usando la CLI de Azure).
  • Su cuenta tiene el rol usuario de Azure AI en el proyecto Foundry.
  • La dirección URL del punto de conexión del proyecto es correcta e incluye los nombres de cuenta y proyecto.

Errores de formato de datos

Si se produce un error en la evaluación con un error de asignación de datos o esquema:

  • Compruebe que el archivo JSONL tiene un objeto JSON válido por línea.
  • Confirme que los nombres de campo en data_mapping coinciden exactamente con los nombres de campo de su archivo JSONL (respetando mayúsculas y minúsculas).
  • Compruebe que item_schema las propiedades coinciden con los campos del conjunto de datos.

Errores de límite de tasa

Las creaciones de ejecución de evaluación están limitadas por tasa a nivel de arrendatario, suscripción y proyecto. Si recibe una 429 Too Many Requests respuesta:

  • Compruebe el retry-after encabezado en la respuesta para el tiempo de espera recomendado.
  • Revise el cuerpo de la respuesta para ver los detalles del límite de velocidad.
  • Utilice retroceso exponencial al reintentar solicitudes con error.

Si se produce un error 429 en un trabajo de evaluación durante la ejecución:

  • Reduzca el tamaño del conjunto de datos de evaluación o divida en lotes más pequeños.
  • Aumente la cuota de tokens por minuto (TPM) para la implementación del modelo en Azure Portal.

Errores de la herramienta de evaluador de agentes

Si un evaluador de agentes devuelve un error cuando las herramientas no son compatibles:

  • Compruebe las herramientas admitidas para los evaluadores de agentes.
  • Como solución alternativa, encapsula las herramientas no admitidas como herramientas de función definidas por el usuario para que el evaluador pueda evaluarlas.

Contenido relacionado

  • Last updated on