Quickstart: Uw eerste gehoste agent implementeren

• Azure Developer CLI (azd) 1.27.1 of hoger.

• De azd microsoft.foundry extensie. Installeer en controleer de extensie nadat azd deze is geïnstalleerd:

  azd ext install microsoft.foundry
  

• Een geverifieerde azd sessie. Meld u aan nadat u de extensie hebt geïnstalleerd:

  azd auth login
  

• Python 3.13 of hoger.

• Azure CLI geïnstalleerd en geverifieerd:

  az login
  

• De Python SDK-pakketten die in deze quickstart worden gebruikt:

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

• Een bestaand Foundry-project met een geïmplementeerd model. Met het Python SDK-pad in deze quickstart wordt een gehoste agentversie gemaakt en gerouteerd, maar er wordt geen nieuw Foundry-project gemaakt of een modelimplementatie voor u gemaakt. Als u de volledige inrichtingswerkstroom nodig hebt, gebruikt u het tabblad Azure Developer CLI in dit artikel.

• .NET 10 SDK.

• Azure CLI geïnstalleerd en geverifieerd:

  az login
  

• De .NET pakketten die in deze quickstart worden gebruikt.

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

  Note

  Api's voor broncode-implementatie zijn momenteel beschikbaar in een voorlopige versie van Azure.AI.Projects. Het stabiele 2.0.x-pakket bevat deze API's niet.

• Een bestaand Foundry-project met een geïmplementeerd model. Met het C#SDK-pad wordt een gehoste agentversie gemaakt en gerouteerd, maar er wordt geen Foundry-project of modelimplementatie gemaakt. Gebruik het tabblad Azure Developer CLI voor de volledige inrichtingswerkstroom.

• Visual Studio Code.
• Microsoft Foundry Toolkit voor Visual Studio Code.

• GitHub Copilot App.

• De Microsoft Foundry Canvas-extensie. Om het te installeren, opent u in de GitHub Copilot-app Instellingen>Plug-ins, zoekt u naar microsoft-foundry en selecteert u Installeren. Zie Wat is Microsoft Foundry Canvas voor meer informatie?

• Azure Developer CLI (azd) 1.27.1 of hoger. Het canvas gebruikt azd om de agent te testen en te implementeren.

• De azd microsoft.foundry extensie. Installeer en controleer de extensie nadat azd deze is geïnstalleerd:

  azd ext install microsoft.foundry
  

• Een codeeragenthost waarop de Microsoft Foundry Skill is geïnstalleerd.

• Azure CLI en Azure Developer CLI (azd) geïnstalleerd en geverifieerd:

  az login
  azd auth login
  

Stap 1: Voorbeeldagent initialiseren

Initialiseer een nieuwe gehoste agent met behulp van het basic Agent Framework-voorbeeld in een lege map:

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

De interactieve stroom vraagt om:

• Naam van agent: Pas de naam aan of accepteer de standaardnaam, agent-framework-agent-basic-responses
• Foundry-Project: Selecteer Een nieuwe Foundry-project maken of een bestaande Foundry-project gebruiken
• Tenant: Selecteer uw Azure-tenant
• Abonnement: selecteer uw Azure-abonnement
• Locatie: Selecteer een Azure regio
• Model: Selecteer de standaard-, gpt-5.4-mini- of een ander model dat u kunt openen
• Modelversie: Selecteer de standaardoptie
• Model-SKU: Selecteer een optie met een beschikbaar quotum dat niet Batch is, meestal Standard of GlobalStandard
• Implementatiecapaciteit: selecteer de standaardwaarde, 10
• Implementatienaam: Selecteer de standaardinstellinggpt-5.4-mini

Als u klaar bent, ziet u dat de definitie van de AI-agent is toegevoegd aan uw azd-project. Wijzig de map in de zojuist gemaakte agentmap.

cd agent-framework-agent-basic-responses

Stap 2: Azure resources inrichten

Richt de in azure.yaml gedefinieerde resources in:

azd provision

Stap 3: de agent lokaal testen

azd ai agent run

Met deze opdracht maakt u een virtuele omgeving, installeert u afhankelijkheden, start u de agent met behulp van de startupCommand gedefinieerde in azure.yamlen opent u de agentcontrole in uw browser, zodat u met de agent kunt chatten.

Stap 4: Implementeren in Foundry Agent Service

Implementeer de broncode van de agent. azd verpakt de bron als een ZIP-bestand en uploadt het naar Foundry. Foundry lost afhankelijkheden op, bouwt de gehoste agent op afstand en implementeert deze:

azd deploy

Wanneer de opdracht is voltooid, ziet u in de uitvoer koppelingen naar de agentspeelplaats en het agenteindpunt:

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

Stap 5: Uw agent aanroepen

1. Dezelfde prompt verzenden naar de geïmplementeerde agent:

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

   U zou binnen een paar seconden een haiku-antwoord moeten zien.

2. (Optioneel) Stream containerlogboeken terwijl u communiceert met de agent:

   azd ai agent monitor --follow
   

Stap 1: Een Foundry-project maken of kiezen

1. Open de Foundry-portal en maak een Foundry-project of selecteer een bestaand project.

2. Implementeer in het project een model dat geschikt is voor chats, zoals gpt-5.4-mini.

3. Kopieer deze waarden vanuit de portal:

   • Projecteindpunt vanuit Overzicht.
   • Implementatienaam van Build>Implementaties.

Stap 2: De code van de Basic-voorbeeldagent downloaden

Kloon de Foundry-voorbeeldenrepository.

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

Stap 3: Een Python-omgeving maken en instellingen configureren

Maak een virtuele omgeving en installeer de Python pakketten die vereist zijn voor deze quickstart.

Voor macOS of Linux:

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

Voor Windows (PowerShell):

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

Maak een werkmap voor het implementatiescript en maak vervolgens een .env bestand in die map:

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>

Stap 4: De gehoste agent implementeren met Python

Maak een bestand met de naam deploy_hosted_agent.py in dezelfde werkmap als .env met de volgende inhoud:

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

Voer het script uit:

python deploy_hosted_agent.py

Het script zipt de voorbeeldbron, uploadt het als een nieuwe gehoste agentversie, wacht tot het inrichten is voltooid, stuurt het gehoste agenteindpunt tijdelijk naar die versie, roept de geïmplementeerde agent aan en herstelt vervolgens de vorige eindpuntconfiguratie en verwijdert de tijdelijke versie.

Stap 5: Uw agent aanroepen

Nadat het script is voltooid, gebruikt u de gehoste agent op een van de volgende manieren:

1. Bewerk deploy_hosted_agent.py en wijzig de input waarde die is doorgegeven aan openai_client.responses.create(...)en voer het script opnieuw uit.
2. Als u een permanente gerouteerde versie wilt in plaats van een tijdelijke validatie-implementatie, past u het script aan om het herstel en delete_version(...) de stappen over te slaan nadat u de gevolgen voor verkeersroutering hebt bekeken.
3. Als u het voorbeeldscript hebt gebruikt zoals geschreven, wordt de eindpuntconfiguratie al hersteld en wordt de tijdelijke gehoste agentversie na validatie verwijderd.
4. Als u voor deze quickstart een toegewezen resourcegroep hebt gemaakt, kunt u de resourcegroep verwijderen uit de Azure-portal nadat u het project of de modelimplementatie niet meer nodig hebt.

Stap 1: Een Foundry-project maken of kiezen

1. Open de Foundry-portal en maak een Foundry-project of selecteer een bestaand project.

2. Implementeer in het project een model dat geschikt is voor chats, zoals gpt-5.4-mini.

3. Kopieer deze waarden vanuit de portal:

   • Projecteindpunt vanuit Overzicht.
   • Implementatienaam van Build>Implementaties.

Stap 2: de C# hello-world-agent downloaden

Kloon de voorbeeldenrepository van Foundry:

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

De bron van de agent bevindt zich in samples/csharp/hosted-agents/agent-framework/hello-world/src/hello-world-dotnet-agent-framework.

Stap 3: Een C#-implementatieproject maken

Maak een consoletoepassing en installeer de vereiste pakketten:

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

Stel de waarden in die door de implementatietoepassing worden gebruikt. Voer in PowerShell het volgende uit:

$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>"

Voer voor macOS of Linux het volgende uit:

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

Stap 4: De gehoste agent implementeren met C#

Vervang de inhoud van Program.cs door de volgende code. De .NET SDK verpakt en uploadt de bronmap, zodat u het ZIP-archief niet zelf hoeft aan te maken.

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

De code volgt de patronen voor bronupload en eindpuntroutering uit het Azure SDK voor .NET-code-agentvoorbeeld.

Voer de toepassing uit:

dotnet run

De toepassing uploadt de C#-agentbron, wacht op inrichting, stuurt het agenteindpunt naar de nieuwe versie, verzendt een prompt, herstelt de vorige route en verwijdert de tijdelijke versie.

Stap 5: Uw agent aanroepen

Nadat de toepassing is voltooid, gebruikt u de gehoste agent op een van de volgende manieren:

1. Wijzig in Program.cs de prompt die aan CreateResponseAsync wordt doorgegeven, en voer dotnet run vervolgens opnieuw uit.
2. Als u de gerouteerde versie wilt behouden, verwijdert u het endpointherstel en de DeleteAgentVersionAsync-aanroepen nadat u de impact op de verkeersroutering hebt beoordeeld.
3. Als u de C#-toepassing hebt gebruikt zoals geschreven, wordt de eindpuntconfiguratie hersteld en wordt de tijdelijke gehoste agentversie na validatie verwijderd.
4. Als u voor deze quickstart een toegewezen resourcegroep hebt gemaakt, verwijdert u de resourcegroep uit de Azure-portal wanneer u het project of model niet meer nodig hebt.

Stap 1: Een Foundry-project maken

1. Open het opdrachtpalet (Ctrl+Shift+P) en selecteer Foundry Toolkit: Create Project.
2. Selecteer uw Azure-abonnement.
3. Maak een nieuwe resourcegroep of selecteer een bestaande resourcegroep.
4. Voer een naam in voor het Foundry-project.

Stap 2: Een model implementeren

1. Open het opdrachtpalet en selecteer Foundry Toolkit: Open Model Catalog.
2. Zoek naar gpt-4.1 en selecteer Deploy.
3. Selecteer op de pagina voor modelimplementatie Implementeren in Microsoft Foundry.

Stap 3: Een gehost agentproject maken

1. Open het opdrachtenpalet en selecteer Foundry Toolkit: Nieuwe gehoste agent maken.
2. Selecteer Python als taal.
3. Selecteer Agent Framework voor Framework.
4. Selecteer de Response-API als protocoltype.
5. Selecteer Basic als voorbeeldcode.
6. Selecteer de Volgende knop.
7. Kies een map voor de projectbestanden en voer een naam in voor de agent.
8. Kies Instellen met Microsoft Foundry voor omgevingsinstellingen. De inhoud wordt automatisch gevuld met het project en model dat u in stap 1 en 2 hebt gemaakt.
9. Selecteer de knop Create.

Er wordt een nieuw VS Code-venster geopend met het project als de actieve werkruimte.

Stap 4: Afhankelijkheden installeren

Maak een virtuele omgeving en installeer de vereisten.

Voor macOS of Linux:

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

Voor Windows (PowerShell):

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

Stap 5: de agent lokaal testen

Druk op F5 om de lokale HTTP-server te starten waarvoor foutopsporing is ingeschakeld. De Foundry Toolkit Agent Inspector wordt geopend voor interactief testen en u kunt onderbrekingspunten instellen in uw code.

De server uitvoeren zonder foutopsporing:

python main.py

De agent luistert.http://localhost:8088/ Een testprompt verzenden met curl (of een HTTP-client):

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

Stap 6: Implementeren in Foundry Agent Service

1. Open het opdrachtenpalet en selecteer Foundry Toolkit: Hosted Agent implementeren. Er wordt een implementatiewebweergave geopend.
2. Voor de implementatiemethode selecteert u Code.
3. Selecteer Remote als pakketmodus.
4. De agentnaam wordt automatisch ingevuld.
5. Selecteer de Volgende knop.
6. De pagina Controleren en implementeren wordt automatisch ingevuld.
7. Selecteer de knop Implementeren .

Wanneer de implementatie is voltooid, wordt de agent weergegeven onder Gehoste agents in de Foundry Toolkit Explorer.

Stap 7: Uw agent aanroepen

1. Vouw in de Foundry Toolkit Explorer gehoste agents uit en selecteer uw agent. Op de detailpagina ziet u de status onder Implementatiedetails.
2. Selecteer het tabblad Speeltuin en verzend een testprompt, zoals Write a haiku about deploying cloud applications..

De Microsoft Foundry Canvas begeleidt u bij het bouwen en implementeren van een gehoste agent vanuit een zijpaneel in de GitHub Copilot App. Wanneer u keuzes maakt in het canvas, wordt elke stap doorgegeven aan Copilot met de relevante context van uw Foundry-project.

Stap 1: Het canvas openen

1. Vraag in de GitHub Copilot-app Copilot om een gehoste Foundry-agent te maken. Voorbeeld:

   Create a Foundry hosted agent using Microsoft Foundry Canvas
   

2. Het canvas opent in het rechterpaneel. Als het niet automatisch wordt geopend, opent u deze vanuit het rechterdeelvenster.

Het canvas begeleidt u door drie fasen, die zijn toegewezen aan de volgende stappen:

• Maak een gehoste agent. Kies uw Foundry-project en vertel Copilot wat u wilt bouwen. U kunt beginnen met een vooraf geschreven prompt om dingen sneller te maken.
• Maak de gehoste agent. Kies het model, werksets, vaardigheden en kaders voor uw agent uit de resources in uw Foundry-project.
• Implementeren en testen. Test de agent lokaal en implementeer deze naar Foundry Agent Service wanneer u tevreden bent.

Stap 2: Een Foundry-project verbinden

1. Open het canvasprojectmenu en meld u aan bij Azure als u hierom wordt gevraagd.
2. Selecteer een abonnement.
3. Selecteer een Foundry-project. Op het canvas blijft deze selectie staan wanneer u deze opnieuw opent.

Stap 3: De agent scaffolden

Kies hoe u wilt beginnen:

• Selecteer Inspire me om een gehoste agent op te richten op basis van een gegenereerd idee.
• Selecteer de hello world-voorbeeldprompt om te beginnen met een basisagent.

Copilot genereert de code voor de agent in uw werkruimte op basis van uw keuze.

Stap 4: De agent configureren

In deze fase verbindt u de agent met de resources in uw Foundry-project. Elke selectie verzendt een prompt naar Copilot, waarmee de agentcode en configuratie voor u worden bijgewerkt:

1. Selecteer een uitgerold model om het redeneervermogen van de agent aan te sturen.
2. Verbind Foundry Toolboxes en de bijbehorende hulpprogramma’s om de agent mogelijkheden te geven, zoals het aanroepen van API’s of het uitvoeren van code.
3. Koppel vaardigheden die herbruikbare logica verpakken die door de agent kan worden gebruikt.
4. Wijs vangrails toe om veiligheids- en inhoudscontroles toe te passen.

Stap 5: de agent lokaal testen

1. Selecteer Lokaal inspecteren. Het canvas draait azd ai agent run in de in Copilot geïntegreerde terminal, wacht op de agent op poort 8088 en integreert Agent Inspector.

2. Een testprompt verzenden, zoals:

   Write a haiku about deploying cloud applications.
   

3. Als de inspector een fout meldt, kopieert u het foutbericht naar het gebied met de canvasprompt en vraagt u Copilot om het probleem op te lossen.

Stap 6: Implementeren in Foundry Agent Service

1. Selecteer Implementeren in Foundry. Het canvas gebruikt azd en Copilot om uw gehoste agent te implementeren.
2. Wanneer de implementatie is voltooid, gebruikt u de koppelingen in de uitvoer om de agentspeelplaats te openen in de Foundry-portal.

Stap 1: Een werkruimte openen met de Foundry Skill

Open een lege map in de host van uw coderingsagent, zoals GitHub Copilot in Visual Studio Code, Copilot CLI of Claude Code. Controleer of de microsoft-foundry vaardigheid beschikbaar is voordat u de coderingsagent vraagt om Azure resources te maken.

Als de vaardigheid niet beschikbaar is, volg De Microsoft Foundry Skill gebruiken in codeeragents.

Stap 2: Vraag de vaardigheid om de gehoste agent te maken

Vraag uw coderingsagent om de vaardigheid te gebruiken voor de volledige werkstroom voor gehoste agents:

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

De coderingsagent moet de beschikbare Foundry-hulpprogramma's inspecteren wanneer MCP-hulpprogramma's beschikbaar zijn, de snelstartwerkstroom van de gehoste agent laden en vragen of er standaard ontbrekende waarden ontbreken, zoals het abonnement, de regio, de projectnaam en of u een bestaand Foundry-project wilt gebruiken.

Stap 3: Het plan beoordelen en goedkeuren

1. Controleer het plan, de bestanden, opdrachten, Azure resources en roltoewijzingen die de coderingsagent voorstelt.
2. Als u deze quickstart wilt vergelijken, kiest u Python 3.13, Agent Framework, Response-API, Basisvoorbeeldcode en Code-implementatie.
3. Keur het maken van resources die kosten met zich meebrengen pas goed nadat u het abonnement, de regio, de resourcegroep, de modelimplementatie en het quotum hebt gecontroleerd.
4. Als de codeeragent u vraagt om u te authenticeren, voer dan zelf az login en azd auth login uit en vraag vervolgens de codeeragent om door te gaan.

Stap 4: Laat de vaardigheid de agent opzetten en testen

Laat de codeeragent het gehoste-agentproject maken, resources provisioneren wanneer u een nieuw Foundry-project kiest, waarden voor de lokale omgeving wegschrijven, de lokale omgeving voorbereiden en een lokale smoketest uitvoeren. Voor Python-agents gebruikt de skillworkflow azd ai agent run om afhankelijkheden te installeren bij de eerste lokale uitvoering.

De werkstroom moet ook het projectrichtlijnenbestand toevoegen dat is vereist door de host van de coderingsagent en de gegenereerde projectconfiguratie controleren vóór de lokale test.

Als de host van uw codeeragent geen lokale server actief kan houden voor de smoketest, gebruik dan het tabblad Azure Developer CLI in dit artikel voor de opdrachten voor lokaal testen. U kunt de implementatie alleen blijven uitvoeren nadat u hebt besloten om de agent op afstand te valideren.

Stap 5: De gehoste agent implementeren en aanroepen

Nadat de lokale betrouwbaarheidstest is geslaagd, vraagt u uw coderingsagent om de implementatie en externe validatie te voltooien:

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.

Wanneer de werkstroom is voltooid, moet de coderingsagent de naam van de gehoste agent, versie, implementatiestatus, eindpunt, speeltuinkoppeling, gemaakte resources, het antwoord op de testprompt en een evaluatieopvolgopdracht weergeven.

azd down

Wanneer de omgeving het project heeft gemaakt, azd worden de resources weergegeven, wordt u gevraagd om bevestiging en worden ze binnen ongeveer 2-5 minuten verwijderd.

1. Open de Azure-portal en ga naar de resourcegroep die uw agent bevat.
2. Selecteer Resourcegroep verwijderen, typ de naam van de resourcegroep die u wilt bevestigen en selecteer Verwijderen.

Het canvas maakt een werkruimte op basis van azd aan, zodat u deze met azd down vanuit de werkruimtemap opschoont.

azd down

Nadat de omgeving het project heeft aangemaakt, azd wordt een overzicht van de resources getoond, wordt om bevestiging gevraagd en worden deze binnen ongeveer 2-5 minuten verwijderd.

De Microsoft Foundry Skill verwijdert geen resources zelf. Het kan uw codeeragent helpen de resources te identificeren die met deze quickstart zijn gemaakt en de juiste opschoonmethode te kiezen. U of uw coderingsagent voert nog steeds de opschoonopdracht uit nadat u deze hebt bekeken en goedgekeurd.

1. Vraag in de projectmap van de gehoste agent uw codeeragent om de opschoning te controleren:

   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. Als het gehoste agentproject is gemaakt met azd en de resourcegroep alleen quickstart-resources bevat, voert u het volgende uit:

   azd down
   

3. Keur verwijdering pas goed nadat u de resourcegroep en resources hebt gecontroleerd die door de opdracht worden vermeld.

Als uw coderingsagent geen opschoonopdrachten kan uitvoeren, gebruikt u het tabblad Azure Developer CLI in dit artikel of verwijdert u de resourcegroep uit de Azure-portal.