Compartir a través de

Tutorial: Idea para crear prototipos: Compilación y evaluación de un agente empresarial

En este tutorial se describe la primera fase del recorrido del desarrollador de Microsoft Foundry: desde una idea inicial hasta un prototipo de trabajo. Cree un asistente para el área de trabajo moderno que combine conocimientos internos de la empresa con instrucciones técnicas externas mediante el SDK de Microsoft Foundry.

Escenario empresarial: cree un asistente de INTELIGENCIA ARTIFICIAL que ayude a los empleados mediante la combinación de:

  • Directivas de empresa (de documentos de SharePoint)
  • Guía de implementación técnica (de Microsoft Learn a través de MCP)
  • Soluciones completas (combinando ambos orígenes para la implementación empresarial)
  • Evaluación por lotes para validar el rendimiento del agente en escenarios empresariales realistas

Resultado del tutorial: Al final tiene un Asistente Moderno para el Lugar de Trabajo que puede responder a preguntas sobre políticas, técnicas y de implementación combinada; un script de evaluación por lotes repetible; y claros puntos de extensión (otras herramientas, patrones multiagente, evaluación más completa).

Hará lo siguiente:

  • Cree un asistente para un entorno de trabajo moderno mediante la integración de SharePoint y MCP.
  • Demostrar escenarios empresariales reales que combinan conocimientos internos y externos.
  • Implemente un manejo de errores sólido y una degradación elegante.
  • Cree un marco de evaluación para pruebas centradas en la empresa.
  • Prepare la base para la gobernanza y la implementación de producción.

En este ejemplo mínimo se muestran los patrones aptos para el entorno empresarial con escenarios de negocio realistas.

Importante

El código de este artículo usa paquetes que se encuentran actualmente en versión preliminar. 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.

Prerrequisitos

Paso 1: Obtener el código de ejemplo

En lugar de navegar por un árbol de repositorio grande, use uno de estos enfoques:

Opción A (clonar todo el repositorio de ejemplos)

Sugerencia

El código usa Azure AI Projects 2.x y no es compatible con Azure AI Projects 1.x. Consulte la documentación de Foundry (clásico) para obtener la versión 1.x de Azure AI Projects.

git clone --depth 1 https://github.com/microsoft-foundry/foundry-samples.git
cd foundry-samples/samples/python/enterprise-agent-tutorial/1-idea-to-prototype

Opción B (extracción dispersa solo para este tutorial - descarga reducida)

git clone --no-checkout https://github.com/microsoft-foundry/foundry-samples.git
cd foundry-samples
git sparse-checkout init --cone
git sparse-checkout set samples/python/enterprise-agent-tutorial/1-idea-to-prototype
git checkout
cd samples/python/enterprise-agent-tutorial/1-idea-to-prototype

Opción C (Descargar ARCHIVO ZIP del repositorio)

Descargue el archivo ZIP del repositorio, extráigalo en el entorno local y vaya a la carpeta del tutorial.

Importante

Para la implementación en producción, use un repositorio independiente. En este tutorial se usa el repositorio de ejemplos compartidos. La extracción dispersa minimiza el ruido local.

Descarga del código de Python ahora

Después de extraer el archivo ZIP, vaya a samples/python/enterprise-agent-tutorial/1-idea-to-prototype.

La estructura mínima solo contiene archivos esenciales:

enterprise-agent-tutorial/
└── 1-idea-to-prototype/
   ├── .env                             # Create this file (local environment variables)
   ├── .gitkeep
   ├── evaluate.py                      # Business evaluation framework
   ├── evaluation_results.json
   ├── main.py                          # Modern Workplace Assistant
   ├── questions.jsonl                  # Business test scenarios (4 questions)
   ├── requirements.txt                 # Python dependencies
   └── sharepoint-sample-data/          # Sample business documents for SharePoint
      ├── collaboration-standards.docx
      ├── data-governance-policy.docx
      ├── remote-work-policy.docx
      └── security-guidelines.docx

Paso 2: Ejecutar el ejemplo inmediatamente

Empiece por ejecutar el agente para que vea la funcionalidad de trabajo antes de profundizar en los detalles de implementación.

Configuración del entorno y entorno virtual

  1. Instale los entornos de ejecución de lenguaje necesarios, las herramientas globales y las extensiones de VS Code, tal como se describe en Preparación del entorno de desarrollo.

  2. Compruebe que requirements.txt usa estas versiones de paquete publicadas:

    azure-ai-projects==2.0.0b3
azure-identity
python-dotenv
openai

  3. Instale las dependencias:

    python -m pip install -r requirements.txt

    Compruebe que la instalación se ha realizado correctamente. Debería ver Successfully installed azure-ai-projects-... (Python) o Restore completed (.NET) sin errores.

  4. Busque el punto de conexión del proyecto en la pantalla de bienvenida del proyecto.

    Captura de pantalla de la pantalla de bienvenida de Microsoft Foundry Models que muestra la dirección URL del punto de conexión y el botón copiar.

  5. Configurar .env.

    Establezca los valores de entorno necesarios para el idioma.

Copie .env.template en .env.

# Foundry configuration
PROJECT_ENDPOINT=https://<your-project>.aiservices.azure.com
MODEL_DEPLOYMENT_NAME=gpt-4o-mini

# The Microsoft Learn MCP Server (optional)
MCP_SERVER_URL=https://learn.microsoft.com/api/mcp

# SharePoint integration (optional - requires connection name)
SHAREPOINT_CONNECTION_NAME=<your-sharepoint-connection-name>

Confirme .env que contiene valores válidos abriendo el archivo y comprobando que PROJECT_ENDPOINT comienza con y https:// coincide con MODEL_DEPLOYMENT_NAME el nombre de un modelo implementado en el proyecto.

Sugerencia

Para obtener el identificador de inquilino, ejecute:

# Get tenant ID
az account show --query tenantId -o tsv

Para obtener el punto de conexión del proyecto, abra el proyecto en el portal de Foundry y copie el valor que se muestra allí.

Ejecutar el agente y realizar la evaluación

python main.py
python evaluate.py

Salida esperada (primera ejecución del agente)

Ejecución exitosa con SharePoint:

🤖 Creating Modern Workplace Assistant...
✅ SharePoint tool configured successfully
✅ Agent created successfully (name: Modern Workplace Assistant, version: 1)

Degradación elegante sin SharePoint:

📁 SharePoint integration skipped (SHAREPOINT_CONNECTION_NAME not set)
✅ Agent created successfully (name: Modern Workplace Assistant, version: 1)

Ahora que tiene un agente en funcionamiento, las siguientes secciones explican cómo funciona. No es necesario realizar ninguna acción al leer estas secciones; estas secciones son para obtener una explicación.

Paso 3: Configurar documentos empresariales de SharePoint de ejemplo

  1. Vaya al sitio de SharePoint (configurado en la conexión).

  2. Cree la biblioteca de documentos "Políticas de la empresa" (o use "Documentos" existentes).

  3. Cargue los cuatro documentos de Word de ejemplo proporcionados en la sharepoint-sample-data carpeta :

    • remote-work-policy.docx
    • security-guidelines.docx
    • collaboration-standards.docx
    • data-governance-policy.docx

  4. Compruebe que cuatro documentos aparecen en la biblioteca antes de continuar.

Estructura de la muestra

📁 Company Policies/
├── remote-work-policy.docx      # VPN, MFA, device requirements
├── security-guidelines.docx     # Azure security standards
├── collaboration-standards.docx # Teams, SharePoint usage
└── data-governance-policy.docx  # Data classification, retention

Descripción de la implementación del asistente

Nota:

Esta sección es solo para referencia: no se necesita ninguna acción. Explica el código que usted ya ejecutó.

En esta sección se explica el código principal en main.py (Python) o ModernWorkplaceAssistant/Program.cs (C#). Ya ejecutó el agente. Después de leerlo, puede:

  • Agregue nuevas herramientas de datos internas y externas.
  • Amplíe las instrucciones dinámicas.
  • Introduce la orquestación multiagente.
  • Mejorar la observabilidad y el diagnóstico.

El código se divide en las secciones principales siguientes, ordenadas como aparecen en el código de ejemplo completo:

  1. Configuración de importaciones y autenticación
  2. Configuración de la autenticación en Azure
  3. Configurar la herramienta de SharePoint
  4. Configuración de la herramienta MCP
  5. Creación del agente y conexión de las herramientas
  6. Conversación con el agente

Importante

El código de este artículo usa paquetes que se encuentran actualmente en versión preliminar. 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.

Importación y configuración de autenticación

El código usa varias bibliotecas cliente del SDK de Microsoft Foundry para crear un agente empresarial sólido.

import os
import time
from azure.ai.projects import AIProjectClient
from azure.ai.projects.models import (
    PromptAgentDefinition,
    SharepointPreviewTool,
    SharepointGroundingToolParameters,
    ToolProjectConnection,
    MCPTool,
)
from azure.identity import DefaultAzureCredential
from dotenv import load_dotenv
from openai.types.responses.response_input_param import (
    McpApprovalResponse,
)

Configuración de la autenticación en Azure

Antes de crear el agente, configure la autenticación en Foundry.

with (
    DefaultAzureCredential() as credential,
    AIProjectClient(endpoint=endpoint, credential=credential) as project_client,
    project_client.get_openai_client() as openai_client,
):
    print(f"✅ Connected to Foundry: {endpoint}")

Crear la herramienta de SharePoint para el agente

El agente usa SharePoint y puede acceder a la directiva de la empresa y a los documentos de procedimientos almacenados allí. Configure la conexión a SharePoint en el código.

sharepoint_connection_id = os.environ.get("SHAREPOINT_CONNECTION_ID")
sharepoint_tool = None

if sharepoint_connection_id:
    print("📁 Configuring SharePoint integration...")
    print(f"   Connection ID: {sharepoint_connection_id}")

    try:
        sharepoint_tool = SharepointPreviewTool(
            sharepoint_grounding_preview=SharepointGroundingToolParameters(
                project_connections=[
                    ToolProjectConnection(
                        project_connection_id=sharepoint_connection_id
                    )
                ]
            )
        )
        print("✅ SharePoint tool configured successfully")
    except Exception as e:
        print(f"⚠️  SharePoint tool unavailable: {e}")
        print("   Agent will operate without SharePoint access")
        sharepoint_tool = None
else:
    print("📁 SharePoint integration skipped (SHAREPOINT_CONNECTION_ID not set)")

Creación de la herramienta MCP para el agente

mcp_server_url = os.environ.get("MCP_SERVER_URL")
mcp_tool = None

if mcp_server_url:
    print("📚 Configuring Microsoft Learn MCP integration...")
    print(f"   Server URL: {mcp_server_url}")

    try:
        mcp_tool = MCPTool(
            server_url=mcp_server_url,
            server_label="Microsoft_Learn_Documentation",
            require_approval="always",
        )
        print("✅ MCP tool configured successfully")
    except Exception as e:
        print(f"⚠️  MCP tool unavailable: {e}")
        print("   Agent will operate without Microsoft Learn access")
        mcp_tool = None
else:
    print("📚 MCP integration skipped (MCP_SERVER_URL not set)")

Creación del agente y conexión de las herramientas

Cree el agente y conecte las herramientas de SharePoint y MCP.

print(f"🛠️  Creating agent with model: {os.environ['MODEL_DEPLOYMENT_NAME']}")

tools = []
if sharepoint_tool:
    tools.append(sharepoint_tool)
    print("   ✓ SharePoint tool added")
if mcp_tool:
    tools.append(mcp_tool)
    print("   ✓ MCP tool added")

print(f"   Total tools: {len(tools)}")

agent = project_client.agents.create_version(
    agent_name="Modern Workplace Assistant",
    definition=PromptAgentDefinition(
        model=os.environ["MODEL_DEPLOYMENT_NAME"],
        instructions=instructions,
        tools=tools if tools else None,
    ),
)

print(f"✅ Agent created successfully (name: {agent.name}, version: {agent.version})")
return agent

Conversación con el agente

Por último, implemente un bucle interactivo para conversar con el agente.

print("🤖 AGENT RESPONSE:")
response, status = create_agent_response(agent, scenario["question"], openai_client)

Salida esperada del código de ejemplo del agente

Al ejecutar el agente, verá una salida similar al ejemplo siguiente. La salida muestra una configuración correcta de herramientas y respuestas del agente a escenarios empresariales:

✅ Connected to Foundry
🚀 Foundry - Modern Workplace Assistant
Tutorial 1: Building Enterprise Agents with Microsoft Foundry SDK
======================================================================
🤖 Creating Modern Workplace Assistant...
📁 Configuring SharePoint integration...
   Connection ID: /subscriptions/.../connections/ContosoCorpPoliciesProcedures
✅ SharePoint tool configured successfully
📚 Configuring Microsoft Learn MCP integration...
   Server URL: https://learn.microsoft.com/api/mcp
✅ MCP tool configured successfully
🛠️  Creating agent with model: gpt-4o-mini
   ✓ SharePoint tool added
   ✓ MCP tool added
   Total tools: 2
✅ Agent created successfully (name: Modern Workplace Assistant, version: 1)

======================================================================
🏢 MODERN WORKPLACE ASSISTANT - BUSINESS SCENARIO DEMONSTRATION
======================================================================
This demonstration shows how AI agents solve real business problems
using the Microsoft Foundry SDK.
======================================================================

📊 SCENARIO 1/3: 📋 Company Policy Question (SharePoint Only)
--------------------------------------------------
❓ QUESTION: What is Contosoʹs remote work policy?
🎯 BUSINESS CONTEXT: Employee needs to understand company-specific remote work requirements
🎓 LEARNING POINT: SharePoint tool retrieves internal company policies
--------------------------------------------------
🤖 AGENT RESPONSE:
✅ SUCCESS: Contosoʹs remote work policy, effective January 2024, outlines the following key points:

### Overview
Contoso Corp supports flexible work arrangements, including remote work, to enhance employee productivity and work-life balance.

### Eligibility
- **Full-time Employees**: Must have completed a 90...
   📏 Full response: 1530 characters
📈 STATUS: completed
--------------------------------------------------

📊 SCENARIO 2/3: 📚 Technical Documentation Question (MCP Only)
--------------------------------------------------
❓ QUESTION: According to Microsoft Learn, what is the correct way to implement Azure AD Conditional Access policies? Please include reference links to the official documentation.
🎯 BUSINESS CONTEXT: IT administrator needs authoritative Microsoft technical guidance
🎓 LEARNING POINT: MCP tool accesses Microsoft Learn for official documentation with links
--------------------------------------------------
🤖 AGENT RESPONSE:
✅ SUCCESS: To implement Azure AD Conditional Access policies correctly, follow these key steps outlined in the Microsoft Learn documentation:

### 1. Understanding Conditional Access
Conditional Access policies act as "if-then" statements that enforce organizational access controls based on various signals. Th...
   📏 Full response: 2459 characters
📈 STATUS: completed
--------------------------------------------------

📊 SCENARIO 3/3: 🔄 Combined Implementation Question (SharePoint + MCP)
--------------------------------------------------
❓ QUESTION: Based on our companyʹs remote work security policy, how should I configure my Azure environment to comply? Please include links to Microsoft documentation showing how to implement each requirement.
🎯 BUSINESS CONTEXT: Need to map company policy to technical implementation with official guidance
🎓 LEARNING POINT: Both tools work together: SharePoint for policy + MCP for implementation docs
--------------------------------------------------
🤖 AGENT RESPONSE:
✅ SUCCESS: To configure your Azure environment in compliance with Contoso Corpʹs remote work security policy, you need to focus on several key areas, including enabling Multi-Factor Authentication (MFA), utilizing Azure Security Center, and implementing proper access management. Below are specific steps and li...
   📏 Full response: 3436 characters
📈 STATUS: completed
--------------------------------------------------

✅ DEMONSTRATION COMPLETED!
🎓 Key Learning Outcomes:
   • Microsoft Foundry SDK usage for enterprise AI
   • Conversation management via the Responses API
   • Real business value through AI assistance
   • Foundation for governance and monitoring (Tutorials 2-3)

🎯 Try interactive mode? (y/n): n

🎉 Sample completed successfully!
📚 This foundation supports Tutorial 2 (Governance) and Tutorial 3 (Production)
🔗 Next: Add evaluation metrics, monitoring, and production deployment

Paso 4: Evaluación del asistente mediante la evaluación en la nube

El marco de evaluación prueba escenarios empresariales realistas mediante la funcionalidad de evaluación en la nube del SDK de Microsoft Foundry. En lugar de un enfoque local personalizado, este patrón usa los evaluadores integrados (builtin.violence, builtin.fluency, builtin.task_adherence) y la openai_client.evals API para ejecutar evaluaciones escalables repetibles en la nube.

En este marco de evaluación se muestra lo siguiente:

  • Dirección del agente: la evaluación ejecuta las consultas directamente en el agente usando azure_ai_target_completions.
  • Evaluadores integrados: Seguridad (detección de violencia), calidad (fluidez) y métricas de cumplimiento de tareas.
  • Ejecución basada en la nube: elimina los requisitos de proceso local y admite la integración de CI/CD.
  • Resultados estructurados: etiquetas, puntuaciones y razonamiento de paso/error para cada caso de prueba.

El código se divide en las secciones principales siguientes:

  1. Configure la evaluación.
  2. Ejecute la evaluación en la nube.
  3. Recuperar los resultados de la evaluación.

Sugerencia

Para obtener instrucciones detalladas sobre las evaluaciones en la nube, consulte Ejecución de evaluaciones en la nube. Para encontrar una lista completa de evaluadores integrados disponibles en Foundry, consulte Observabilidad en IA generativa.

Nota:

El SDK de C# usa métodos de protocolo con BinaryData y BinaryContent en lugar de objetos tipados. Este enfoque requiere métodos auxiliares para analizar las respuestas JSON. Consulte el ejemplo del SDK de evaluaciones de C# para obtener el patrón completo.

Configuración de la evaluación

En primer lugar, cree un objeto de evaluación que defina el esquema de datos y los criterios de prueba. La evaluación usa evaluadores integrados para la detección de violencia, la fluidez y el cumplimiento de tareas.

En Python, use directamente el cliente openAI. En C#, consiga un EvaluationClient del cliente del proyecto:

load_dotenv()
endpoint = os.environ["PROJECT_ENDPOINT"]
model_deployment_name = os.environ.get("MODEL_DEPLOYMENT_NAME", "gpt-4o-mini")

with (
    DefaultAzureCredential() as credential,
    AIProjectClient(endpoint=endpoint, credential=credential) as project_client,
    project_client.get_openai_client() as openai_client,
):
    # Create or retrieve the agent to evaluate
    agent = project_client.agents.create_version(
        agent_name="Modern Workplace Assistant",
        definition=PromptAgentDefinition(
            model=model_deployment_name,
            instructions="You are a helpful Modern Workplace Assistant that answers questions about company policies and technical guidance.",
        ),
    )
    print(f"Agent created (id: {agent.id}, name: {agent.name}, version: {agent.version})")

    # Define the data schema for evaluation
    data_source_config = DataSourceConfigCustom(
        type="custom",
        item_schema={
            "type": "object",
            "properties": {"query": {"type": "string"}},
            "required": ["query"]
        },
        include_sample_schema=True,
    )

    # Define testing criteria with built-in evaluators
    testing_criteria = [
        {
            "type": "azure_ai_evaluator",
            "name": "violence_detection",
            "evaluator_name": "builtin.violence",
            "data_mapping": {"query": "{{item.query}}", "response": "{{sample.output_text}}"},
        },
        {
            "type": "azure_ai_evaluator",
            "name": "fluency",
            "evaluator_name": "builtin.fluency",
            "initialization_parameters": {"deployment_name": f"{model_deployment_name}"},
            "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": f"{model_deployment_name}"},
            "data_mapping": {"query": "{{item.query}}", "response": "{{sample.output_items}}"},
        },
    ]

    # Create the evaluation object
    eval_object = openai_client.evals.create(
        name="Agent Evaluation",
        data_source_config=data_source_config,
        testing_criteria=testing_criteria,
    )
    print(f"Evaluation created (id: {eval_object.id}, name: {eval_object.name})")

La testing_criteria matriz especifica qué evaluadores se van a ejecutar:

  • builtin.violence: detecta contenido violento o perjudicial en las respuestas.
  • builtin.fluency: evalúa la calidad y la legibilidad de la respuesta (requiere una implementación de modelos).
  • builtin.task_adherence: evalúa si el agente ha seguido las instrucciones correctamente.

Ejecución de la evaluación en la nube

Cree una ejecución de evaluación dirigida a su agente. El azure_ai_target_completions origen de datos envía consultas al agente y captura las respuestas para su evaluación:

# Define the data source for the evaluation run
data_source = {
    "type": "azure_ai_target_completions",
    "source": {
        "type": "file_content",
        "content": [
            {"item": {"query": "What is Contoso's remote work policy?"}},
            {"item": {"query": "What are the security requirements for remote employees?"}},
            {"item": {"query": "According to Microsoft Learn, how do I configure Azure AD Conditional Access?"}},
            {"item": {"query": "Based on our company policy, how should I configure Azure security to comply?"}},
        ],
    },
    "input_messages": {
        "type": "template",
        "template": [
            {"type": "message", "role": "user", "content": {"type": "input_text", "text": "{{item.query}}"}}
        ],
    },
    "target": {
        "type": "azure_ai_agent",
        "name": agent.name,
        "version": agent.version,
    },
}

# Create and submit the evaluation run
agent_eval_run: Union[RunCreateResponse, RunRetrieveResponse] = openai_client.evals.runs.create(
    eval_id=eval_object.id,
    name=f"Evaluation Run for Agent {agent.name}",
    data_source=data_source,
)
print(f"Evaluation run created (id: {agent_eval_run.id})")

La data_source configuración:

  • type: azure_ai_target_completions enruta las consultas a través del agente.
  • source: contenido insertado con consultas de prueba (también puede usar un identificador de archivo de conjunto de datos)
  • input_messages: plantilla que da formato a cada consulta para el agente
  • target: especifica el nombre y la versión del agente que se van a evaluar.

Recuperación de los resultados de la evaluación

Monitorice la ejecución de evaluación hasta que se complete y luego obtenga los elementos de salida detallados.

# Poll until the evaluation run completes
while agent_eval_run.status not in ["completed", "failed"]:
    agent_eval_run = openai_client.evals.runs.retrieve(
        run_id=agent_eval_run.id,
        eval_id=eval_object.id
    )
    print(f"Waiting for eval run to complete... current status: {agent_eval_run.status}")
    time.sleep(5)

if agent_eval_run.status == "completed":
    print("\n✓ Evaluation run completed successfully!")
    print(f"Result Counts: {agent_eval_run.result_counts}")

    # Retrieve detailed output items
    output_items = list(
        openai_client.evals.runs.output_items.list(
            run_id=agent_eval_run.id,
            eval_id=eval_object.id
        )
    )
    print(f"\nOUTPUT ITEMS (Total: {len(output_items)})")
    print(f"{'-'*60}")
    pprint(output_items)
    print(f"{'-'*60}")
    print(f"Eval Run Report URL: {agent_eval_run.report_url}")
else:
    print("\n✗ Evaluation run failed.")

# Cleanup
openai_client.evals.delete(eval_id=eval_object.id)
print("Evaluation deleted")

project_client.agents.delete(agent_name=agent.name)
print("Agent deleted")

Cada elemento de salida incluye:

  • Etiqueta: resultado binario "aprobado" o "reprobado"
  • Puntuación: puntuación numérica en la escala del evaluador
  • Motivo: Explicación de por qué se asignó la puntuación (para evaluadores basados en LLM)

Salida esperada de la evaluación en la nube (evaluate.py)

Al ejecutar el script de evaluación, verá un resultado similar al ejemplo siguiente. La salida muestra la creación de objetos de evaluación, el envío de ejecución y la recuperación de resultados:

python evaluate.py
Agent created (name: Modern_Workplace_Assistant, version: 1)
Evaluation created (id: eval_xyz789, name: Agent Evaluation)
Evaluation run created (id: run_def456)
Waiting for eval run to complete... current status: running
Waiting for eval run to complete... current status: running

✓ Evaluation run completed successfully!
Result Counts: {'passed': 2, 'failed': 0, 'errored': 0}

OUTPUT ITEMS (Total: 2)
------------------------------------------------------------
[OutputItem(id='item_1', 
            sample={'query': 'What is the largest city in France?', 
                    'output_text': 'The largest city in France is Paris...'},
            results=[{'name': 'violence_detection', 'passed': True, 'score': 0},
                     {'name': 'fluency', 'passed': True, 'score': 4, 
                      'reason': 'Response is clear and well-structured'},
                     {'name': 'task_adherence', 'passed': True, 'score': 5}]),
 OutputItem(id='item_2', ...)]
------------------------------------------------------------
Eval Run Report URL: https://ai.azure.com/...
Evaluation deleted
Agent deleted

Descripción de los resultados de la evaluación

Las evaluaciones en la nube proporcionan resultados estructurados que puede ver en el portal de Foundry o recuperar mediante programación. Cada elemento de salida incluye:

Campo Description
Etiqueta "Aprobado" o "no aprobado" binario basado en el umbral
Puntuación Puntuación numérica (la escala depende del tipo de evaluador)
Umbral Valor de límite que determina el paso o error
Reason Explicación generada por LLM para la puntuación (cuando procede)

Escalas de puntuación según el tipo de evaluador:

  • Evaluadores de calidad (fluidez y coherencia): escala de 1 a 5
  • Evaluadores de seguridad (violencia, auto-daño): escala de gravedad de 0 a 7 (menor es más seguro)
  • Evaluadores de tareas (task_adherence): escala de 1 a 5

También puede ver los resultados detallados en el portal de Foundry seleccionando Evaluación en el proyecto y seleccionando la ejecución de evaluación. El portal proporciona visualizaciones, filtrado y opciones de exportación.

Sugerencia

En escenarios de producción, considere la posibilidad de ejecutar evaluaciones como parte del pipeline de CI/CD. Consulte Ejecución de una evaluación en Azure DevOps y Evaluación continua de los agentes de inteligencia artificial para los patrones de integración.

Solución de problemas

Síntoma Causa Resolución
DefaultAzureCredential error de autenticación La sesión de la CLI de Azure ha expirado o no ha iniciado sesión Ejecuta az login y vuelve a intentar
Model deployment not found El nombre del modelo en .env no coincide con una implementación en el proyecto Abra el proyecto en el portal de Foundry, compruebe Implementaciones y actualice MODEL_DEPLOYMENT_NAME en . .env
SharePoint tool configured pero el agente no puede encontrar documentos Los documentos que no se cargan o el nombre de conexión son incorrectos Compruebe que los documentos aparecen en la biblioteca de SharePoint y que SHAREPOINT_CONNECTION_NAME coinciden con la conexión en el proyecto
Error de conexión o tiempo de espera de la herramienta MCP El servidor MCP de Microsoft Learn no es accesible Compruebe que MCP_SERVER_URL está configurado en https://learn.microsoft.com/api/mcp y que su red permite tráfico HTTPS saliente.
403 Forbidden en SharePoint Permisos insuficientes en el sitio de SharePoint Confirme que la identidad de inicio de sesión tiene acceso de lectura a la biblioteca de documentos de SharePoint al menos.

Resumen

Ahora tiene:

  • Un prototipo de agente único en funcionamiento basado en conocimientos internos y externos.
  • Un script de evaluación repetible que muestra patrones de validación empresarial.
  • Una ruta de actualización clara: más herramientas, orquestación multiagente, evaluación más completa, implementación.

Estos patrones reducen la fricción entre prototipos y producción: puede agregar orígenes de datos, aplicar la gobernanza e integrar la supervisión sin volver a escribir la lógica principal.

Pasos siguientes

En este tutorial se muestra la fase 1 del recorrido del desarrollador, desde la idea hasta el prototipo. Este ejemplo mínimo proporciona la base para el desarrollo de inteligencia artificial empresarial. Para continuar su viaje, explore las siguientes fases:

Mejoras adicionales sugeridas

Fase 2: Prototipo a producción

Fase 3: Producción a la adopción

Limpieza de recursos

Cuando ya no los necesite, elimine los recursos que creó en este tutorial:

  1. Eliminar el agente: el agente se elimina automáticamente al final de main.py (Python) o Program.cs (C#). Si interrumpió la ejecución, elimínela manualmente desde la página Agentes del portal de Foundry.
  2. Eliminar la ejecución de evaluación: en el portal de Foundry, vaya a Evaluación, seleccione la ejecución de evaluación y elimínela.
  3. Quitar documentos de ejemplo de SharePoint: si cargó los archivos de ejemplo .docx en un sitio de SharePoint de producción, quítelos de la biblioteca de documentos.
  4. (Opcional) Elimine el proyecto Foundry: si creó un proyecto solo para este tutorial, elimínelo del portal de Foundry para quitar todos los recursos asociados.

Contenido relacionado

  • Last updated on