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:

  • Políticas de la compañía (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 de Lugar de Trabajo Moderno con 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 obtener más información, vea Supplemental Terms of Use for Microsoft Azure Previews.

Prerrequisitos

  • Una suscripción Azure. Si no tiene ninguna, cree una gratis.

  • CLI de Azure 2.67.0 o posterior, autenticado con az login (compruebe con az version)

  • Un proyecto Foundry con un modelo implementado (por ejemplo, ). Si no tiene uno: cree un proyecto y, a continuación, implemente un modelo (consulte Información general del modelo: Catálogo de modelos).

  • Python 3.10 o posterior

  • .NET SDK 8.0 o posterior (para el ejemplo de C#)

  • Conexión de SharePoint configurada en tu proyecto (SharePoint documentación de la herramienta)

    Nota:

    Para configurar el proyecto foundry para la conectividad de SharePoint, consulte la documentación de la herramienta SharePoint.

  • (Opcional) Git instalado para clonar el repositorio de ejemplo

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 la versión de Azure AI Projects 1.x.

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.

Descargar el código de Python ahora

Después de extraer el archivo ZIP, vaya a .

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 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 .

    Establezca los valores de entorno necesarios para el idioma.

Copie en .

# 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 que contiene valores válidos abriendo el archivo y comprobando que comienza con y coincide con 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: Configuración de documentos empresariales de ejemplo de SharePoint

  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 ejemplo Word proporcionados en la carpeta sharepoint-sample-data:

    • 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 de 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. Configurar la autenticación en Azure
  3. Configurar la herramienta 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 obtener más información, vea Supplemental Terms of Use for Microsoft Azure Previews.

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

Creación de la herramienta SharePoint para el agente

El agente usa SharePoint y puede acceder a los documentos de procedimientos y directivas de la empresa almacenados allí. Configura la conexión a SharePoint en tu 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 (, , ) y la 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 .
  • 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 ejemplo de C# usa un enfoque de evaluación por lotes local con en lugar de la API de /> en la nube C# Evaluations SDK para ver los patrones de evaluación en la nube en C#.

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 de OpenAI. En C#, consiga un 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 matriz especifica qué evaluadores se van a ejecutar:

  • : detecta contenido violento o perjudicial en las respuestas.
  • : evalúa la calidad y la legibilidad de la respuesta (requiere una implementación de modelos).
  • : 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 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 configuración:

  • type: 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

Sondee la ejecución de la evaluación hasta que finalice y, después, recupere 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 "suspenso"
  • 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 "suspenso" binario según el umbral
Puntuación Puntuación numérica (la escala depende del tipo de evaluador)
Umbral Valor de corte que determina el aprobado/suspenso
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 de la canalización de CI/CD. Consulte Cómo ejecutar una evaluación en Azure DevOps y Evalúe continuamente los agentes de IA para obtener patrones de integración.

Solución de problemas

Síntoma Causa Resolución
error de autenticación La sesión de CLI de Azure ha expirado o no se ha iniciado sesión. Ejecuta y vuelve a intentar
Model deployment not found El nombre del modelo en no coincide con una implementación en el proyecto Abra el proyecto en el portal de Foundry, compruebe Implementaciones y actualice en .
SharePoint tool configured, pero el agente no encuentra 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 coincide con la conexión del proyecto.
Error de conexión o tiempo de espera de la herramienta MCP El servidor MCP de Microsoft Learn no es accesible Compruebe que está configurado en 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 al menos Read acceso a la biblioteca de documentos de SharePoint

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

  • Agregue más orígenes de datos (Búsqueda de Azure AI, other sources).
  • Implemente métodos de evaluación avanzados (evaluación asistida por IA).
  • Cree herramientas personalizadas para operaciones específicas de la empresa.
  • Agregar memoria de conversación y personalización.

Fase 2: Prototipo a producción

  • Implemente la evaluación de seguridad con pruebas de equipo rojo (red teaming).
  • Cree conjuntos de datos de evaluación completos con métricas de calidad.
  • Aplicar directivas de gobernanza en toda la organización y comparación de modelos.
  • Configurar la monitorización de flotas, la integración de CI/CD y los puntos de conexión implementación de 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. Delete 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. Eliminar documentos de ejemplo de SharePoint: Si has subido los archivos de ejemplo .docx a un sitio de SharePoint de producción, elimínalos 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

  • Introducción al servicio Foundry Agent
  • documentación de la herramienta SharePoint
  • Integración de herramientas de MCP
  • Patrones de varios agentes
  • Last updated on