Schnellstart: Erstellen eines Aufforderungsagents

In diesem Schnellstart erstellen Sie einen Prompt-Agenten im Foundry-Agentendienst und führen eine Konversation mit ihm. Ein Eingabeaufforderungs-Agent ist ein deklarativ definierter Agent, der ein Modell aus dem Foundry-Modellkatalog, Anweisungen, Tools und Aufforderungen in natürlicher Sprache kombiniert, um das Verhalten zu fördern.

Wenn Sie nicht über ein Azure-Abonnement verfügen, erstellen Sie ein free-Konto.

Voraussetzungen

Ein Modell, das in Microsoft Foundry bereitgestellt wird. Wenn Sie kein Modell haben, führen Sie zuerst Quickstart aus: Einrichten Microsoft Foundry-Ressourcen.
Die erforderlichen Sprachlaufzeiten, globalen Tools und Visual Studio Code Erweiterungen, wie in Vorbereiten Ihrer Entwicklungsumgebung beschrieben.

Festlegen von Umgebungsvariablen

Speichern Sie Ihren Projektendpunkt als Umgebungsvariable. Legen Sie diese Werte auch für die Verwendung in Ihren Skripts fest.

Python und JavaScript

PROJECT_ENDPOINT=<endpoint copied from welcome screen>
AGENT_NAME="MyAgent"

C# und Java

ProjectEndpoint = <endpoint copied from welcome screen>
AgentName = "MyAgent"

Installieren von Paketen und Authentifizieren

Stellen Sie sicher, dass Sie die richtige Version der Pakete installieren, wie hier gezeigt.

Installieren Sie die aktuelle Version von azure-ai-projects. Diese Version verwendet die Foundry-Projekte (neue) API .
```
pip install azure-ai-projects>=2.0.0
```
Melden Sie sich mit dem BEFEHL CLI az login an, um sich zu authentifizieren, bevor Sie Ihre Python-Skripts ausführen.

Installieren von Paketen:

Fügen Sie NuGet-Pakete mithilfe der .NET CLI im integrierten Terminal hinzu: Diese Pakete verwenden die API für Foundry-Projekte (neu).

dotnet add package Azure.AI.Projects
dotnet add package Azure.AI.Projects.Agents
dotnet add package Azure.AI.Extensions.OpenAI
dotnet add package Azure.Identity

Melden Sie sich mit dem CLI-Befehl az login an, um sich zu authentifizieren, bevor Sie Ihre C#-Skripts ausführen.

Installieren Sie die aktuelle Version von @azure/ai-projects. Diese Version verwendet die API für Foundry-Projekte (neue Projekte).
```
npm install @azure/ai-projects
```
Melden Sie sich mit dem CLI-Befehl az login an, um sich zu authentifizieren, bevor Sie Ihre TypeScript-Skripts ausführen.

<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-ai-agents</artifactId>
    <version>2.0.0</version>
</dependency>

Melden Sie sich mit dem BEFEHL CLI az login an, um sich zu authentifizieren, bevor Sie Ihre Java-Skripts ausführen.

Melden Sie sich mit dem CLI-Befehl az login an, um sich zu authentifizieren, bevor Sie den nächsten Befehl ausführen.
Rufen Sie ein temporäres Zugriffstoken ab. Es läuft in 60-90 Minuten ab, Sie müssen es danach aktualisieren.
```
az account get-access-token --scope https://ai.azure.com/.default
```
Speichern Sie die Ergebnisse als Umgebungsvariable AZURE_AI_AUTH_TOKEN.

Tipp

Code verwendet Azure AI Projects 2.x und ist mit Azure AI Projects 1.x nicht kompatibel. Sehen Sie die Dokumentation zu Foundry (klassisch) für die Version 1.x der Azure AI-Projekte.

Erstellen eines Eingabeaufforderungs-Agents

Erstellen Sie einen Prompt-Agenten mit Ihrem bereitgestellten Modell. Der Agent verwendet eine PromptAgentDefinition mit Anweisungen, die das Verhalten des Agents definieren. Sie können Agents jederzeit aktualisieren oder löschen.

from azure.identity import DefaultAzureCredential
from azure.ai.projects import AIProjectClient
from azure.ai.projects.models import PromptAgentDefinition

# Format: "https://resource_name.ai.azure.com/api/projects/project_name"
PROJECT_ENDPOINT = "your_project_endpoint"
AGENT_NAME = "your_agent_name"

# Create project client to call Foundry API
project = AIProjectClient(
    endpoint=PROJECT_ENDPOINT,
    credential=DefaultAzureCredential(),
)

# Create an agent with a model and instructions
agent = project.agents.create_version(
    agent_name=AGENT_NAME,
    definition=PromptAgentDefinition(
        model="gpt-5-mini",  # supports all Foundry direct models"
        instructions="You are a helpful assistant that answers general questions",
    ),
)
print(f"Agent created (id: {agent.id}, name: {agent.name}, version: {agent.version})")

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

// Format: "https://resource_name.ai.azure.com/api/projects/project_name"
var ProjectEndpoint = "your_project_endpoint";
var AgentName = "your_agent_name";

// Create project client to call Foundry API
AIProjectClient projectClient = new(
    endpoint: new Uri(ProjectEndpoint),
    tokenProvider: new DefaultAzureCredential());

// Create an agent with a model and instructions
ProjectsAgentDefinition agentDefinition = new DeclarativeAgentDefinition("gpt-5-mini") // supports all Foundry direct models
{
    Instructions = "You are a helpful assistant that answers general questions",
};

ProjectsAgentVersion agent = projectClient.AgentAdministrationClient.CreateAgentVersion(
    AgentName,
    options: new(agentDefinition));
Console.WriteLine($"Agent created (id: {agent.Id}, name: {agent.Name}, version: {agent.Version})");

import { DefaultAzureCredential } from "@azure/identity";
import { AIProjectClient } from "@azure/ai-projects";

// Format: "https://resource_name.ai.azure.com/api/projects/project_name"
const PROJECT_ENDPOINT = "your_project_endpoint";
const AGENT_NAME = "your_agent_name";

async function main(): Promise<void> {
    // Create project client to call Foundry API
    const project = new AIProjectClient(PROJECT_ENDPOINT, new DefaultAzureCredential());

    // Create an agent with a model and instructions
    const agent = await project.agents.createVersion(AGENT_NAME, {
        kind: "prompt",
        model: "gpt-5-mini", //supports all Foundry direct models
        instructions: "You are a helpful assistant that answers general questions",
    });
    console.log(`Agent created (id: ${agent.id}, name: ${agent.name}, version: ${agent.version})`);
}

main().catch(console.error);

package com.azure.ai.agents;

import com.azure.ai.agents.models.AgentVersionDetails;
import com.azure.ai.agents.models.PromptAgentDefinition;
import com.azure.identity.DefaultAzureCredentialBuilder;

public class CreateAgent {
    public static void main(String[] args) {
        // Format: "https://resource_name.ai.azure.com/api/projects/project_name"
        String ProjectEndpoint = "your_project_endpoint";
        String AgentName = "your_agent_name";

        // Create agents client to call Foundry API
        AgentsClient agentsClient = new AgentsClientBuilder()
                .credential(new DefaultAzureCredentialBuilder().build())
                .endpoint(ProjectEndpoint)
                .buildAgentsClient();

        // Create an agent with a model and instructions
        PromptAgentDefinition request = new PromptAgentDefinition("gpt-5-mini") // supports all Foundry direct models
                .setInstructions("You are a helpful assistant that answers general questions");
        AgentVersionDetails agent = agentsClient.createAgentVersion(AgentName, request);

        System.out.println("Agent ID: " + agent.getId());
        System.out.println("Agent Name: " + agent.getName());
        System.out.println("Agent Version: " + agent.getVersion());
    }
}

Ersetzen Sie YOUR-FOUNDRY-RESOURCE-NAME mit Ihren Werten.

curl -X POST https://YOUR-FOUNDRY-RESOURCE-NAME.services.ai.azure.com/api/projects/YOUR-PROJECT-NAME/agents?api-version=v1 \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $AZURE_AI_AUTH_TOKEN" \
  -d '{
    "name": "MyAgent",
    "definition": {
      "kind": "prompt",
      "model": "gpt-4.1-mini",
      "instructions": "You are a helpful assistant that answers general questions"
    }
  }'

Die Ausgabe bestätigt, dass ein Agent erstellt wurde. Der Agentname und die ID werden in der Konsole ausgegeben.

Chatten mit dem Agent

Verwenden Sie den von Ihnen erstellten Agent, um zu interagieren, indem Sie eine Frage und eine zugehörige Nachverfolgung stellen. Die Kommunikation verfolgt den Verlauf dieser Interaktionen.

from azure.identity import DefaultAzureCredential
from azure.ai.projects import AIProjectClient

# Format: "https://resource_name.ai.azure.com/api/projects/project_name"
PROJECT_ENDPOINT = "your_project_endpoint"
AGENT_NAME = "your_agent_name"

# Create project and openai clients to call Foundry API
project = AIProjectClient(
    endpoint=PROJECT_ENDPOINT,
    credential=DefaultAzureCredential(),
)
openai = project.get_openai_client()

# Create a conversation for multi-turn chat
conversation = openai.conversations.create()

# Chat with the agent to answer questions
response = openai.responses.create(
    conversation=conversation.id,
    extra_body={"agent_reference": {"name": AGENT_NAME, "type": "agent_reference"}},
    input="What is the size of France in square miles?",
)
print(response.output_text)

# Ask a follow-up question in the same conversation
response = openai.responses.create(
    conversation=conversation.id,
    extra_body={"agent_reference": {"name": AGENT_NAME, "type": "agent_reference"}},
    input="And what is the capital city?",
)
print(response.output_text)

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

#pragma warning disable OPENAI001

// Format: "https://resource_name.ai.azure.com/api/projects/project_name"
var ProjectEndpoint = "your_project_endpoint";
var AgentName = "your_agent_name";

// Create project client to call Foundry API
AIProjectClient projectClient = new(
    endpoint: new Uri(ProjectEndpoint),
    tokenProvider: new DefaultAzureCredential());

// Create a conversation for multi-turn chat
ProjectConversation conversation = projectClient.ProjectOpenAIClient.GetProjectConversationsClient().CreateProjectConversation();

// Chat with the agent to answer questions
ProjectResponsesClient responsesClient = projectClient.ProjectOpenAIClient.GetProjectResponsesClientForAgent(
    defaultAgent: AgentName,
    defaultConversationId: conversation.Id);
ResponseResult response = responsesClient.CreateResponse("What is the size of France in square miles?");
Console.WriteLine(response.GetOutputText());

// Ask a follow-up question in the same conversation
response = responsesClient.CreateResponse("And what is the capital city?");
Console.WriteLine(response.GetOutputText());

import { DefaultAzureCredential } from "@azure/identity";
import { AIProjectClient } from "@azure/ai-projects";

// Format: "https://resource_name.ai.azure.com/api/projects/project_name"
const PROJECT_ENDPOINT = "your_project_endpoint";
const AGENT_NAME = "your_agent_name";

async function main(): Promise<void> {
    // Create project and openai clients to call Foundry API
    const project = new AIProjectClient(PROJECT_ENDPOINT, new DefaultAzureCredential());
    const openai = project.getOpenAIClient();

    // Create a conversation for multi-turn chat
    const conversation = await openai.conversations.create();

    // Chat with the agent to answer questions
    const response = await openai.responses.create(
        {
            conversation: conversation.id,
            input: "What is the size of France in square miles?",
        },
        {
            body: { agent_reference: { name: AGENT_NAME, type: "agent_reference" } },
        },
    );
    console.log(response.output_text);

    // Ask a follow-up question in the same conversation
    const response2 = await openai.responses.create(
        {
            conversation: conversation.id,
            input: "And what is the capital city?",
        },
        {
            body: { agent_reference: { name: AGENT_NAME, type: "agent_reference" } },
        },
    );
    console.log(response2.output_text);
}

main().catch(console.error);

package com.azure.ai.agents;

import com.azure.ai.agents.models.AgentDetails;
import com.azure.ai.agents.models.AgentReference;
import com.azure.ai.agents.models.AzureCreateResponseOptions;
import com.azure.ai.agents.models.AgentVersionDetails;
import com.azure.ai.agents.models.PromptAgentDefinition;
import com.azure.identity.AuthenticationUtil;
import com.azure.identity.DefaultAzureCredentialBuilder;
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.credential.BearerTokenCredential;
import com.openai.models.conversations.Conversation;
import com.openai.models.conversations.items.ItemCreateParams;
import com.openai.models.responses.EasyInputMessage;
import com.openai.models.responses.Response;
import com.openai.models.responses.ResponseCreateParams;
import com.openai.services.blocking.ConversationService;

public class ChatWithAgent {
    public static void main(String[] args) {
        // Format: "https://resource_name.ai.azure.com/api/projects/project_name"
        String ProjectEndpoint = "your_project_endpoint";
        String AgentName = "your_agent_name";
        
        AgentsClientBuilder builder = new AgentsClientBuilder()
                .credential(new DefaultAzureCredentialBuilder().build())
                .endpoint(ProjectEndpoint);

        AgentsClient agentsClient = builder.buildAgentsClient();
        ResponsesClient responsesClient = builder.buildResponsesClient();
        ConversationService conversationService
            = builder.buildOpenAIClient().conversations();

        AgentDetails agent = agentsClient.getAgent(AgentName);

        Conversation conversation = conversationService.create();
        conversationService.items().create(
            ItemCreateParams.builder()
                .conversationId(conversation.id())
                .addItem(EasyInputMessage.builder()
                    .role(EasyInputMessage.Role.SYSTEM)
                    .content("You are a helpful assistant that speaks like a pirate.")
                    .build()
                ).addItem(EasyInputMessage.builder()
                    .role(EasyInputMessage.Role.USER)
                    .content("Hello, agent!")
                    .build()
            ).build()
        );

        AgentReference agentReference = new AgentReference(agent.getName()).setVersion(agent.getVersion());
        Response response = responsesClient.createAzureResponse(
            new AzureCreateResponseOptions().setAgentReference(agentReference),
            ResponseCreateParams.builder().conversation(conversation.id()));

        OpenAIClient client = OpenAIOkHttpClient.builder()
            .baseUrl(ProjectEndpoint.endsWith("/") ? ProjectEndpoint + "openai/v1" : ProjectEndpoint + "/openai/v1")
            .credential(BearerTokenCredential.create(AuthenticationUtil.getBearerTokenSupplier(
                    new DefaultAzureCredentialBuilder().build(), "https://ai.azure.com/.default")))
            .build();

        ResponseCreateParams responseRequest = new ResponseCreateParams.Builder()
            .input("Hello, how can you help me?")
            .model("gpt-5-mini") //supports all Foundry direct models
            .build();

        Response result = client.responses().create(responseRequest);
    }
}

Ersetzen Sie YOUR-FOUNDRY-RESOURCE-NAME mit Ihren Werten.

# Generate a response using the agent

curl -X POST https://YOUR-FOUNDRY-RESOURCE-NAME.services.ai.azure.com/api/projects/YOUR-PROJECT-NAME/openai/v1/responses \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $AZURE_AI_AUTH_TOKEN" \
  -d '{
    "agent_reference": {"type": "agent_reference", "name": "<AGENT_NAME>"},
    "input": [{"role": "user", "content": "What is the size of France in square miles?"}]
  }'

# Optional Step: Create a conversation to use with the agent
curl -X POST https://YOUR-FOUNDRY-RESOURCE-NAME.services.ai.azure.com/api/projects/YOUR-PROJECT-NAME/openai/v1/conversations \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $AZURE_AI_AUTH_TOKEN" \
  -d '{
    "items": [
      {
        "type": "message",
        "role": "user",
        "content": [
          {
            "type": "input_text",
            "text": "What is the size of France in square miles?"
          }
        ]
      }
    ]
  }'

# Lets say Conversation ID created is conv_123456789. Use this in the next step

#Optional Step: Ask a follow-up question in the same conversation
curl -X POST https://YOUR-FOUNDRY-RESOURCE-NAME.services.ai.azure.com/api/projects/YOUR-PROJECT-NAME/openai/v1/responses \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $AZURE_AI_AUTH_TOKEN" \
  -d '{
    "agent_reference": {"type": "agent_reference", "name": "<AGENT_NAME>", "version": "1"},
    "conversation": "<CONVERSATION_ID>",
    "input": [{"role": "user", "content": "And what is the capital?"}]
  }'

Sie sehen die Antworten des Agents auf beide Eingabeaufforderungen. Die Antwort zur Nachverfolgung zeigt, dass der Agent den Gesprächsverlauf kontinuierlich verfolgt.

Bereinigen von Ressourcen

Wenn Sie keine der von Ihnen erstellten Ressourcen mehr benötigen, löschen Sie die dem Projekt zugeordnete Ressourcengruppe.

Wählen Sie im portal Azure die Ressourcengruppe aus, und wählen Sie dann Delete aus. Vergewissern Sie sich, dass Sie die Ressourcengruppe löschen möchten.

Feedback

War diese Seite hilfreich?

Last updated on 2026-04-30