Inicio rápido: Implementación del primer agente hospedado

• Azure CLI para desarrolladores (azd) 1.27.1 o posterior.

• extensión azd microsoft.foundry. Instale y compruebe la extensión después azd de instalarla:

  azd ext install microsoft.foundry
  

• Una sesión autenticada azd . Inicie sesión después de instalar la extensión:

  azd auth login
  

• Python 3.13 o posterior.

• CLI de Azure instalado y autenticado:

  az login
  

• Los paquetes del SDK de Python que se usan en este inicio rápido:

  pip install "azure-ai-projects>=2.3.0" azure-identity python-dotenv
  

• Un proyecto de Foundry existente con un modelo desplegado. La ruta del SDK de Python de esta guía de inicio rápido crea y redirige una versión de agente hospedada, pero no genera un nuevo proyecto de Foundry ni crea una implementación de modelo por ti. Si necesita el flujo de trabajo de aprovisionamiento completo, use la pestaña Azure CLI para desarrolladores de este artículo.

• .NET 10 SDK.

• CLI de Azure instalado y autenticado:

  az login
  

• Los paquetes de .NET usados en este inicio rápido.

  dotnet add package Azure.AI.Projects --version 2.1.0-beta.4
  dotnet add package Azure.Identity
  

  Note

  Las API de implementación de código fuente están disponibles actualmente en una versión preliminar de Azure.AI.Projects. El paquete estable 2.0.x no incluye estas API.

• Un proyecto de Foundry existente con un modelo desplegado. La ruta de acceso del SDK de C# crea y enruta una versión del agente hospedado, pero no crea un proyecto o una implementación de modelos de Foundry. Para obtener el flujo de trabajo de aprovisionamiento completo, use la pestaña Azure CLI para desarrolladores.

• Código de Visual Studio.
• Microsoft Foundry Toolkit para Visual Studio Code.

• GitHub Copilot Aplicación.

• La extensión Microsoft Foundry Canvas. Para instalarlo, en la GitHub Copilot aplicación abra Complementos de configuración>, busquemicrosoft-foundry y seleccione Instalar. Para obtener más información, consulte ¿Qué es Microsoft Foundry Canvas?

• Azure CLI para desarrolladores (azd) 1.27.1 o posterior. El lienzo utiliza azd para probar e implementar el agente.

• extensión azd microsoft.foundry. Instale y compruebe la extensión después azd de instalarla:

  azd ext install microsoft.foundry
  

• Un host de agente de programación con la Microsoft Foundry Skill instalada.

• CLI de Azure y la CLI del desarrollador de Azure (azd) instaladas y autenticadas:

  az login
  azd auth login
  

Paso 1: Inicialización del agente de ejemplo

Inicialice un nuevo agente hospedado mediante el ejemplo básico de Agent Framework en un directorio vacío:

azd ai agent init -m "https://github.com/microsoft-foundry/foundry-samples/blob/main/samples/python/hosted-agents/agent-framework/responses/01-basic/azure.yaml" --deploy-mode code

El flujo interactivo solicita lo siguiente:

• Nombre del agente: personalice el nombre o acepte el valor predeterminado, agent-framework-agent-basic-responses
• Foundry Project: Seleccione Crear un nuevo proyecto de Foundry o Usar un proyecto de Foundry existente
• Tenant: seleccione el inquilino de Azure
• Suscripción: seleccione la suscripción de Azure
• Location: seleccione una región de Azure
• Modelo: seleccione el valor predeterminado, gpt-5.4-mini u otro modelo al que puede acceder.
• Versión del modelo: seleccione la opción predeterminada .
• SKU de modelo: seleccione una opción con cuota disponible que no sea Batch, normalmente Estándar o GlobalStandard.
• Capacidad de implementación: seleccione el valor predeterminado, 10.
• Nombre de implementación: seleccione el valor predeterminado, gpt-5.4-mini

Cuando haya finalizado, verá que la definición del agente de IA se ha agregado correctamente al proyecto azd. Cambie el directorio a la carpeta del agente recién creada.

cd agent-framework-agent-basic-responses

Paso 2: Aprovisionar recursos de Azure

Aprovisione los recursos definidos en azure.yaml:

azd provision

Paso 3: Probar el agente localmente

azd ai agent run

Este comando crea un entorno virtual, instala dependencias, inicia el agente mediante el startupCommand definido en azure.yamly abre el inspector de agente en el explorador para que pueda chatear con el agente.

Paso 4: Implementar en Foundry Agent Service

Implemente el código fuente del agente. azd empaqueta el origen como un archivo ZIP y lo carga en Foundry. Foundry resuelve las dependencias, compila el agente hospedado de forma remota e lo implementa:

azd deploy

Una vez finalizado el comando, la salida muestra enlaces al entorno de pruebas del agente y al punto de conexión del agente:

Deploying services (azd deploy)

  Done: Deploying service basic-agent
  - Agent playground (portal): https://ai.azure.com/.../build/agents/basic-agent/build?version=1
  - Agent endpoint: https://ai-account-<name>.services.ai.azure.com/api/projects/<project>/agents/basic-agent/versions/1

Paso 5: Invocar el agente

1. Envíe el mismo mensaje al agente implementado:

   azd ai agent invoke "Write a haiku about deploying cloud applications."
   

   Debería ver una respuesta de haiku en unos segundos.

2. (Opcional) Transmita los registros de contenedor mientras interactúa con el agente:

   azd ai agent monitor --follow
   

Paso 1: Crear o elegir un proyecto de Foundry

1. Abra el portal de Foundry y cree un proyecto foundry o seleccione uno existente.

2. En el proyecto, implemente un modelo compatible con chat, como gpt-5.4-mini.

3. Copie estos valores desde el portal:

   • Punto de conexión del proyecto desde Información general.
   • Nombre de implementación en Build>Deployments.

Paso 2: Descargar el código del agente de ejemplo básico

Clona el repositorio de ejemplos de Foundry.

git clone https://github.com/microsoft-foundry/foundry-samples.git

Paso 3: Crear un entorno de Python y configurar las opciones

Cree un entorno virtual e instale los paquetes de Python necesarios para este inicio rápido.

Para macOS o Linux:

python -m venv .venv
source .venv/bin/activate
pip install "azure-ai-projects>=2.3.0" azure-identity python-dotenv

Para Windows (PowerShell):

python -m venv .venv
.\.venv\Scripts\Activate.ps1
pip install "azure-ai-projects>=2.3.0" azure-identity python-dotenv

Cree una carpeta de trabajo para el script de implementación y, a continuación, cree un .env archivo en esa carpeta:

FOUNDRY_PROJECT_ENDPOINT=<your-project-endpoint>
FOUNDRY_MODEL_NAME=<your-model-deployment-name>
FOUNDRY_HOSTED_AGENT_NAME=basic-agent
FOUNDRY_SAMPLE_PATH=<full-path-to-foundry-samples/samples/python/hosted-agents/agent-framework/responses/01-basic/src/agent-framework-agent-basic-responses>

Paso 4: Implementación del agente hospedado con Python

Cree un archivo denominado deploy_hosted_agent.py en la misma carpeta de trabajo que .env con el siguiente contenido:

import os
import tempfile
import time
import zipfile
from pathlib import Path

from azure.ai.projects import AIProjectClient
from azure.ai.projects.models import (
  AgentEndpointConfig,
  CodeConfiguration,
  CodeDependencyResolution,
  FixedRatioVersionSelectionRule,
  HostedAgentDefinition,
  ProtocolConfiguration,
  ProtocolVersionRecord,
  ResponsesProtocolConfiguration,
  VersionSelector,
)
from azure.identity import DefaultAzureCredential
from dotenv import load_dotenv

load_dotenv()

endpoint = os.environ["FOUNDRY_PROJECT_ENDPOINT"]
model_name = os.environ["FOUNDRY_MODEL_NAME"]
agent_name = os.environ.get("FOUNDRY_HOSTED_AGENT_NAME", "basic-agent")
sample_path = Path(os.environ["FOUNDRY_SAMPLE_PATH"]).resolve()


def create_code_zip(source_dir: Path) -> Path:
  zip_path = Path(tempfile.gettempdir()) / f"{agent_name}.zip"
  excluded = {".git", ".venv", "__pycache__", ".env", "deploy_hosted_agent.py"}

  with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zip_file:
    for path in source_dir.rglob("*"):
      if not path.is_file():
        continue
      if any(part in excluded for part in path.parts):
        continue
      zip_file.write(path, path.relative_to(source_dir))

  return zip_path


def wait_for_active_version(project_client: AIProjectClient, version: str) -> None:
  for attempt in range(60):
    time.sleep(10)
    details = project_client.agents.get_version(
      agent_name=agent_name,
      agent_version=version,
    )
    status = details["status"]
    print(f"Provisioning status: {status} (attempt {attempt + 1}/60)")

    if status == "active":
      return

    if status == "failed":
      raise RuntimeError(f"Hosted agent provisioning failed: {dict(details)}")

  raise RuntimeError("Timed out waiting for the hosted agent version to become active.")


code_zip_path = create_code_zip(sample_path)

with (
  code_zip_path.open("rb") as code_stream,
  DefaultAzureCredential() as credential,
  AIProjectClient(endpoint=endpoint, credential=credential) as project_client,
):
  original_agent_endpoint = None
  created = None

  try:
    created = project_client.agents.create_version_from_code(
      agent_name=agent_name,
      description="Basic hosted agent deployed from local Python source.",
      definition=HostedAgentDefinition(
        cpu="0.5",
        memory="1Gi",
        code_configuration=CodeConfiguration(
          runtime="python_3_14",
          entry_point=["python", "main.py"],
          dependency_resolution=CodeDependencyResolution.REMOTE_BUILD,
        ),
        environment_variables={
          "FOUNDRY_PROJECT_ENDPOINT": endpoint,
          "FOUNDRY_MODEL_NAME": model_name,
        },
        protocol_versions=[
          ProtocolVersionRecord(protocol="responses", version="2.0.0")
        ],
      ),
      code=code_stream,
    )

    print(f"Created hosted agent version {created.version}")

    wait_for_active_version(project_client, created.version)

    original_agent_endpoint = project_client.agents.get(
      agent_name=agent_name
    ).agent_endpoint
    project_client.agents.update_details(
      agent_name=agent_name,
      agent_endpoint=AgentEndpointConfig(
        version_selector=VersionSelector(
          version_selection_rules=[
            FixedRatioVersionSelectionRule(
              agent_version=created.version,
              traffic_percentage=100,
            ),
          ]
        ),
        protocol_configuration=ProtocolConfiguration(
          responses=ResponsesProtocolConfiguration()
        ),
      ),
    )

    print(f"Agent endpoint configured for version {created.version}")

    with project_client.get_openai_client(agent_name=agent_name) as openai_client:
      response = openai_client.responses.create(
        input="Write a haiku about deploying cloud applications.",
      )

    print(f"Agent response: {response.output_text}")
  finally:
    if original_agent_endpoint is not None:
      project_client.agents.update_details(
        agent_name=agent_name,
        agent_endpoint=original_agent_endpoint,
      )
      print("Agent endpoint restored")

    if created is not None:
      project_client.agents.delete_version(
        agent_name=agent_name,
        agent_version=created.version,
        force=True,
      )
      print(f"Deleted hosted agent version {created.version}")

Ejecute el script:

python deploy_hosted_agent.py

El script comprime el origen de ejemplo, lo carga como una nueva versión del agente hospedado, espera a que se complete el aprovisionamiento, enruta temporalmente el punto de conexión del agente hospedado a esa versión, invoca al agente implementado y, a continuación, restaura la configuración del punto de conexión anterior y elimina la versión temporal.

Paso 5: Invocar el agente

Una vez completado el script, use el agente hospedado de cualquiera de estas maneras:

1. Edite deploy_hosted_agent.py y cambie el valor de input que se pasa a openai_client.responses.create(...), luego vuelva a ejecutar el script.
2. Si desea una versión enrutada persistente en lugar de una implementación de validación temporal, adapte el script para omitir los pasos de restauración y delete_version(...) después de revisar las implicaciones del enrutamiento del tráfico.
3. Si ha usado el script de ejemplo tal como está escrito, ya restaura la configuración del punto de conexión y elimina la versión del agente hospedado temporal después de la validación.
4. Si creó un grupo de recursos dedicado para este inicio rápido, puede eliminar el grupo de recursos del portal de Azure después de que ya no necesite la implementación del proyecto o el modelo.

Paso 1: Crear o elegir un proyecto de Foundry

1. Abra el portal de Foundry y cree un proyecto foundry o seleccione uno existente.

2. En el proyecto, implemente un modelo compatible con chat, como gpt-5.4-mini.

3. Copie estos valores desde el portal:

   • Punto de conexión del proyecto desde Información general.
   • Nombre de implementación en Build>Deployments.

Paso 2: Descargar el agente hello-world de C#

Clona el repositorio de ejemplos de Foundry:

git clone https://github.com/microsoft-foundry/foundry-samples.git

El origen del agente está en samples/csharp/hosted-agents/agent-framework/hello-world/src/hello-world-dotnet-agent-framework.

Paso 3: Crear un proyecto de implementación de C#

Cree una aplicación de consola e instale los paquetes necesarios:

dotnet new console --name HostedAgentDeployer
cd HostedAgentDeployer
dotnet add package Azure.AI.Projects --version 2.1.0-beta.4
dotnet add package Azure.Identity

Establezca los valores que usa la aplicación de implementación. En PowerShell, ejecute:

$env:FOUNDRY_PROJECT_ENDPOINT = "<your-project-endpoint>"
$env:FOUNDRY_MODEL_NAME = "<your-model-deployment-name>"
$env:FOUNDRY_HOSTED_AGENT_NAME = "basic-agent"
$env:FOUNDRY_SAMPLE_PATH = "<full-path-to-hello-world-dotnet-agent-framework>"

Para macOS o Linux, ejecute:

export FOUNDRY_PROJECT_ENDPOINT="<your-project-endpoint>"
export FOUNDRY_MODEL_NAME="<your-model-deployment-name>"
export FOUNDRY_HOSTED_AGENT_NAME="basic-agent"
export FOUNDRY_SAMPLE_PATH="<full-path-to-hello-world-dotnet-agent-framework>"

Paso 4: Implementación del agente hospedado con C#

Reemplace el contenido de Program.cs por el código siguiente. El SDK de .NET empaqueta y carga el directorio de origen, por lo que no necesitas crear el archivo ZIP por tu cuenta.

using Azure.AI.Extensions.OpenAI;
using Azure.AI.Projects;
using Azure.AI.Projects.Agents;
using Azure.Identity;
using OpenAI.Responses;

#pragma warning disable AAIP001, OPENAI001

var projectEndpoint = Environment.GetEnvironmentVariable("FOUNDRY_PROJECT_ENDPOINT")
  ?? throw new InvalidOperationException("FOUNDRY_PROJECT_ENDPOINT isn't set.");
var modelName = Environment.GetEnvironmentVariable("FOUNDRY_MODEL_NAME")
  ?? throw new InvalidOperationException("FOUNDRY_MODEL_NAME isn't set.");
var agentName = Environment.GetEnvironmentVariable("FOUNDRY_HOSTED_AGENT_NAME")
  ?? "basic-agent";
var samplePath = Environment.GetEnvironmentVariable("FOUNDRY_SAMPLE_PATH")
  ?? throw new InvalidOperationException("FOUNDRY_SAMPLE_PATH isn't set.");

AIProjectClient projectClient = new(
  endpoint: new Uri(projectEndpoint),
  tokenProvider: new DefaultAzureCredential());

HostedAgentDefinition definition = new(cpu: "0.5", memory: "1Gi")
{
  Versions =
  {
    new ProtocolVersionRecord(ProjectsAgentProtocol.Responses, "2.0.0")
  },
  CodeConfiguration = new(
    runtime: "dotnet_10",
    entryPoint: ["dotnet", "hello-world.dll"],
    dependencyResolution: CodeDependencyResolution.RemoteBuild),
};
definition.EnvironmentVariables.Add(
  "FOUNDRY_PROJECT_ENDPOINT", projectEndpoint);
definition.EnvironmentVariables.Add(
  "AZURE_AI_MODEL_DEPLOYMENT_NAME", modelName);

ProjectsAgentVersion? created = null;
AgentEndpointConfiguration? originalEndpoint = null;

try
{
  created = await projectClient.AgentAdministrationClient
    .CreateAgentVersionFromCodeAsync(
      agentName: agentName,
      filePath: samplePath,
      metadata: new AgentVersionFromCodeMetadata(definition));
  Console.WriteLine($"Created hosted agent version {created.Version}");

  for (var attempt = 1; attempt <= 60; attempt++)
  {
    await Task.Delay(TimeSpan.FromSeconds(10));
    created = await projectClient.AgentAdministrationClient
      .GetAgentVersionAsync(agentName, created.Version);
    Console.WriteLine(
      $"Provisioning status: {created.Status} (attempt {attempt}/60)");

    if (created.Status == AgentVersionStatus.Active)
    {
      break;
    }
    if (created.Status == AgentVersionStatus.Failed)
    {
      throw new InvalidOperationException("Hosted agent provisioning failed.");
    }
  }

  if (created.Status != AgentVersionStatus.Active)
  {
    throw new TimeoutException(
      "Timed out waiting for the hosted agent version to become active.");
  }

  ProjectsAgentRecord agent = await projectClient.AgentAdministrationClient
    .GetAgentAsync(agentName);
  originalEndpoint = agent.AgentEndpoint;

  AgentEndpointConfiguration endpoint = new()
  {
    VersionSelector = new(
      [new FixedRatioVersionSelectionRule(created.Version, 100)]),
    ProtocolConfiguration = new()
    {
      Responses = new ResponsesProtocolConfiguration()
    }
  };
  await projectClient.AgentAdministrationClient.PatchAgentAsync(
    agentName,
    new PatchAgentOptions { AgentEndpoint = endpoint });
  Console.WriteLine($"Agent endpoint configured for version {created.Version}");

  ProjectResponsesClient responsesClient = projectClient.ProjectOpenAIClient
    .GetProjectResponsesClientForAgentEndpoint(agentName);
  ResponseResult response = await responsesClient.CreateResponseAsync(
    "Write a haiku about deploying cloud applications.");
  Console.WriteLine($"Agent response: {response.GetOutputText()}");
}
finally
{
  if (originalEndpoint is not null)
  {
    await projectClient.AgentAdministrationClient.PatchAgentAsync(
      agentName,
      new PatchAgentOptions { AgentEndpoint = originalEndpoint });
    Console.WriteLine("Agent endpoint restored");
  }

  if (created is not null)
  {
    await projectClient.AgentAdministrationClient.DeleteAgentVersionAsync(
      agentName,
      created.Version,
      force: true);
    Console.WriteLine($"Deleted hosted agent version {created.Version}");
  }
}

El código sigue los patrones de carga del código fuente y de enrutamiento de puntos de conexión del ejemplo del agente de código de SDK de Azure para .NET.

Ejecute la aplicación:

dotnet run

La aplicación carga el origen del agente de C#, espera el aprovisionamiento, enruta el punto de conexión del agente a la nueva versión, envía un mensaje, restaura la ruta anterior y elimina la versión temporal.

Paso 5: Invocar el agente

Una vez completada la aplicación, use el agente hospedado de cualquiera de estas maneras:

1. En Program.cs, cambie el prompt pasado a CreateResponseAsync y luego vuelva a ejecutar dotnet run.
2. Para mantener la versión enrutada, quite la restauración del punto de conexión y DeleteAgentVersionAsync las llamadas después de revisar el impacto en el enrutamiento del tráfico.
3. Si utilizó la aplicación de C# tal como está escrita, restaura la configuración del extremo y elimina la versión temporal del agente alojado después de la validación.
4. Si creó un grupo de recursos dedicado para este inicio rápido, elimine el grupo de recursos del portal de Azure cuando ya no necesite la implementación del proyecto o del modelo.

Paso 1: Crear un proyecto Foundry

1. Abra la paleta de comandos (Ctrl+Mayús+P) y seleccione Foundry Toolkit: Crear Project.
2. Seleccione la suscripción de Azure.
3. Cree un nuevo grupo de recursos o seleccione uno existente.
4. Escriba un nombre para el proyecto Foundry.

Paso 2: Implementación de un modelo

1. Abra la paleta de comandos y seleccione Foundry Toolkit: Abrir catálogo de modelos.
2. gpt-4.1 Busque y seleccione Implementar.
3. En la página implementación del modelo, seleccione Deploy to Microsoft Foundry.

Paso 3: Creación de un proyecto de agente hospedado

1. Abra la paleta de comandos y seleccione Foundry Toolkit: Crear nuevo agente hospedado.
2. Seleccione Python como lenguaje.
3. En Marco, seleccione Marco de agente.
4. Seleccione La API de respuestas como tipo de protocolo.
5. Seleccione Básico como código de ejemplo.
6. Haga clic en el botón Siguiente.
7. Elija una carpeta para los archivos del proyecto y escriba un nombre para el agente.
8. En Configuración del entorno, elija Configurar con Microsoft Foundry. El contenido se rellena automáticamente con el proyecto y el modelo que creó en los pasos 1 y 2.
9. Seleccione el botón Crear.

Se abre una nueva ventana de VS Code con el proyecto como área de trabajo activa.

Paso 4: Instalación de dependencias

Cree un entorno virtual e instale los requisitos.

Para macOS o Linux:

python -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt

Para Windows (PowerShell):

python -m venv .venv
.\.venv\Scripts\Activate.ps1
pip install -r requirements.txt

Paso 5: Probar el agente localmente

Presione F5 para iniciar el servidor HTTP local con la depuración habilitada. Foundry Toolkit Agent Inspector se abre para pruebas interactivas y puede establecer puntos de interrupción en el código.

Para ejecutar el servidor sin depuración:

python main.py

El agente escucha en http://localhost:8088/. Enviar un mensaje de prueba con curl (o cualquier cliente HTTP):

curl -sS -H "Content-Type: application/json" -X POST http://localhost:8088/responses \
    -d '{"input": "Write a haiku about deploying cloud applications.", "stream": false}'

Paso 6: Implementación en Foundry Agent Service

1. Abra la paleta de comandos y seleccione Foundry Toolkit: Deploy Hosted Agent (Implementar agente hospedado). Se abre una vista web de implementación.
2. En Deployment Method (Método de implementación), seleccione Code (Código).
3. Seleccione Remoto como modo de paquete.
4. El nombre del agente se rellena automáticamente.
5. Haga clic en el botón Siguiente.
6. La página Revisar e implementar se rellena automáticamente.
7. Seleccione el botón Implementar .

Cuando finalice la implementación, el agente aparece en Agentes hospedados en el explorador de Foundry Toolkit.

Paso 7: Invocar el agente

1. En el explorador de Foundry Toolkit, expanda Agentes hospedados y seleccione el agente. La página de detalles muestra el estado en Detalles de implementación.
2. Seleccione la pestaña Parque infantil y envíe un mensaje de prueba como Write a haiku about deploying cloud applications..

El Microsoft Foundry Canvas le guía a través de la compilación e implementación de un agente hospedado desde un panel lateral de la aplicación GitHub Copilot. A medida que realiza selecciones en el lienzo, este pasa cada paso a Copilot con el contexto relevante de su proyecto de Foundry.

Paso 1: Abrir el lienzo

1. En la aplicación GitHub Copilot, pida a Copilot que cree un agente alojado en Foundry. Por ejemplo:

   Create a Foundry hosted agent using Microsoft Foundry Canvas
   

2. El lienzo se abre en el panel derecho. Si no se abre automáticamente, ábralo desde el panel derecho.

El panel le guía a través de tres fases, que corresponden a los siguientes pasos:

• Cree un agente hospedado. Elija su proyecto de Foundry e indique a Copilot lo que desea crear. Puede empezar desde un aviso preescrito para acelerar las cosas.
• Compile el agente hospedado. Elija el modelo, los conjuntos de herramientas, las habilidades y las salvaguardas para su agente a partir de los recursos de su proyecto de Foundry.
• Implementar y probar. Pruebe el agente localmente y, cuando esté satisfecho, impleméntelo en Foundry Agent Service.

Paso 2: Conecte un proyecto de Foundry

1. Abra el menú del proyecto de lienzo e inicie sesión en Azure si se le solicita.
2. Seleccione una suscripción.
3. Seleccione un proyecto de Foundry. El lienzo mantiene esta selección al volver a abrirla.

Paso 3: Generar el esqueleto del agente

Elija cómo empezar:

• Seleccione Inspírame para crear la estructura base de un agente alojado a partir de una idea generada.
• Seleccione el mensaje de ejemplo Hola mundo para empezar desde un agente básico.

Copilot genera el esqueleto del código del agente en su espacio de trabajo según su elección.

Paso 4: Configurar el agente

En esta fase, conecta el agente a los recursos de tu proyecto de Foundry. Cada selección envía un mensaje para Copilot, que actualiza el código del agente y la configuración automáticamente:

1. Seleccione un modelo implementado para impulsar el razonamiento del agente.
2. Conecte Foundry Toolboxes y sus herramientas para proporcionar las funcionalidades del agente, como llamar a las API o ejecutar código.
3. Conecta habilidades que encapsulan lógica reutilizable para que el agente pueda usarla.
4. Asigne salvaguardas para aplicar controles de seguridad y de contenido.

Paso 5: Probar el agente localmente

1. Seleccione Inspeccionar localmente. El lienzo ejecuta azd ai agent run en el terminal integrado de Copilot, espera al agente en el puerto 8088 e integra el Inspector de agentes.

2. Envíe un mensaje de prueba, como:

   Write a haiku about deploying cloud applications.
   

3. Si el inspector indica un error, copie el mensaje de error en el área de instrucciones del lienzo y pídale a Copilot que corrija el problema.

Paso 6: Implementación en Foundry Agent Service

1. Seleccione Implementar en Foundry. El lienzo utiliza azd y Copilot para implementar su agente hospedado.
2. Cuando finalice la implementación, use los vínculos de la salida para abrir el área de juegos del agente en el portal de Foundry.

Paso 1: Abre un área de trabajo con Foundry Skill

Abra una carpeta vacía en el host del agente de codificación, como GitHub Copilot en Visual Studio Code, Copilot CLI o Claude Code. Asegúrate de que la habilidad microsoft-foundry esté disponible antes de pedirle al agente de programación que cree recursos de Azure.

Si la habilidad no está disponible, consulte Uso de la habilidad de Microsoft Foundry en agentes de programación.

Paso 2: Pide a la skill que cree el agente hospedado

Pide a tu agente de programación que use la habilidad para el flujo de trabajo completo del agente alojado:

Use the Microsoft Foundry Skill hosted-agent quick-start workflow to create my
first hosted agent end to end. Verify my environment first, and stop if I need
to sign in myself. Use Python 3.13, Agent Framework, the Responses API, the
Basic sample, and code deployment. Create a new Foundry project unless I provide
an existing project. Use the model deployment from the Basic sample unless I
provide an existing deployment. Test the agent locally, deploy it to Foundry
Agent Service, and invoke it with: "Write a haiku about deploying cloud
applications."

El agente de codificación debe inspeccionar las herramientas de Foundry disponibles cuando haya herramientas de MCP disponibles, cargar el flujo de trabajo de inicio rápido del agente alojado y solicitar los valores que falten o usar valores predeterminados, como la suscripción, la región, el nombre del proyecto y si se debe usar un proyecto de Foundry existente.

Paso 3: Revisar y aprobar el plan

1. Revise el plan, los archivos, los comandos, los recursos Azure y las asignaciones de roles que propone el agente de codificación.
2. Para seguir esta guía de inicio rápido, seleccione Python 3.13, Agent Framework, Responses API, el código de ejemplo Básico y la implementación Code.
3. Apruebe la creación de recursos que soportan costos solo después de comprobar la suscripción, la región, el grupo de recursos, la implementación del modelo y la cuota.
4. Si el agente de codificación le pide que se autentique, ejecútelo az login y azd auth login luego pida al agente de codificación que continúe.

Paso 4: Deja que la skill genere el esqueleto y pruebe el agente

Deje que el agente de codificación cree el proyecto del agente hospedado, aprovisione recursos cuando elija un nuevo proyecto foundry, escriba valores de entorno local, prepare el entorno local y ejecute una prueba de humo local. Para los agentes de Python, el flujo de trabajo de habilidades usa azd ai agent run para instalar dependencias durante la primera ejecución local.

El flujo de trabajo también debe agregar el archivo de instrucciones del proyecto requerido por el host del agente de codificación y comprobar la integridad de la configuración del proyecto generada antes de la prueba local.

Si tu host de agentes de programación no puede mantener un servidor local en ejecución para la prueba de humo, utiliza la pestaña Azure Developer CLI de este artículo para obtener los comandos de prueba locales. Solo podrás continuar con la implementación una vez que hayas decidido validar el agente de forma remota.

Paso 5: Implementación e invocación del agente hospedado

Una vez que la prueba de humo local se realice correctamente, pida al agente de codificación que finalice la implementación y la validación remota:

Continue with the Microsoft Foundry Skill workflow. Deploy the hosted agent to
Foundry Agent Service, show the deployment status and playground link, and invoke
it remotely with: "Write a haiku about deploying cloud applications." If the
skill workflow requires evaluation suite generation before the final summary,
submit the generation job and show me the follow-up eval command.

Cuando se complete el flujo de trabajo, el agente de código deberá mostrar el nombre del agente alojado, la versión, el estado de implementación, el punto de conexión, el enlace al entorno de pruebas, los recursos creados, la respuesta a la instrucción de prueba y cualquier comando de seguimiento para la evaluación.

azd down

Cuando el entorno creó el proyecto, azd enumera los recursos, solicita confirmación y los elimina en unos 2 a 5 minutos.

1. Abra el portal de Azure y vaya al grupo de recursos que contiene el agente.
2. Seleccione Eliminar grupo de recursos, escriba el nombre del grupo de recursos para confirmar y seleccione Eliminar.

El lienzo crea un espacio de trabajo respaldado por azd, por lo que debe limpiarlo con azd down desde la carpeta del espacio de trabajo.

azd down

Cuando el entorno creó el proyecto, azd enumera los recursos, solicita confirmación y los elimina en unos 2 a 5 minutos.

La habilidad de Microsoft Foundry no elimina los recursos por sí sola. Puede ayudar al agente de codificación a identificar los recursos que creó este inicio rápido y elegir el método de limpieza correcto. Usted o el agente de codificación siguen ejecutando el comando de limpieza después de revisarlo y aprobarlo.

1. En la carpeta del proyecto del agente hospedado, pida a su agente de programación que revise las tareas de limpieza:

   Use the Microsoft Foundry Skill to identify the Azure resources created for
   this quickstart. Confirm whether azd down is the right cleanup method for
   this project, and show me the resources before any deletion command runs.
   

2. Si el proyecto del agente hospedado se creó con azd y el grupo de recursos solo contiene recursos de inicio rápido, ejecute:

   azd down
   

3. Apruebe la eliminación solo después de comprobar el grupo de recursos y los recursos que muestra el comando.

Si el agente de codificación no puede ejecutar comandos de limpieza, use la pestaña Azure CLI para desarrolladores de este artículo o elimine el grupo de recursos del portal de Azure.