Szybki przewodnik startowy Microsoft Foundry

W tym przewodniku szybkiego startu rozpoczniesz korzystanie z modeli i agentów w Foundry.

Wykonasz:

Generowanie odpowiedzi na podstawie modelu
Tworzenie agenta za pomocą zdefiniowanego monitu
Rozmowa wieloetapowa z agentem

Wymagania wstępne

Model wdrożony w rozwiązaniu Microsoft Foundry. Jeśli nie masz modelu, najpierw ukończ szybki start: konfigurowanie zasobów rozwiązania Microsoft Foundry.
Wymagane środowiska uruchomieniowe językowe, narzędzia globalne i rozszerzenia programu Visual Studio Code zgodnie z opisem w Przygotowywanie środowiska projektowego.

Ustawianie zmiennych środowiskowych i pobieranie kodu

Zapisz punkt końcowy projektu jako zmienną środowiskową. Ustaw również te wartości do użycia w skryptach.

PROJECT_ENDPOINT=<endpoint copied from welcome screen>
AGENT_NAME="MyAgent"
MODEL_DEPLOYMENT_NAME="gpt-4.1-mini"

Postępuj zgodnie z poniższymi instrukcjami lub pobierz kod:

Pobieranie kodu

Zaloguj się, używając polecenia CLI az login, aby potwierdzić swoją tożsamość przed uruchomieniem skryptów Pythona.

Postępuj zgodnie z poniższymi instrukcjami lub pobierz kod:

Pobierz kod.

Zaloguj się, używając polecenia CLI az login, aby uwierzytelnić się przed uruchomieniem następnego polecenia.
Uzyskiwanie tymczasowego tokenu dostępu. Wygaśnie on w ciągu 60–90 minut. Po tym czasie trzeba będzie odświeżyć.
```
az account get-access-token --scope https://ai.azure.com/.default
```
Zapisz wyniki jako zmienną środowiskową AZURE_AI_AUTH_TOKEN.

Instalowanie i uwierzytelnianie

Upewnij się, że zainstalujesz poprawną wersję zapoznawczą/wstępną pakietów, jak pokazano na tej stronie.

Zainstaluj te pakiety, w tym wersję zapoznawcza programu azure-ai-projects. Ta wersja używa API projektów Foundry (nowe) (wersja zapoznawcza).
```
pip install --pre "azure-ai-projects>=2.0.0b4"
pip install python-dotenv
```
Zaloguj się, używając polecenia CLI az login, aby potwierdzić swoją tożsamość przed uruchomieniem skryptów Pythona.

Instalowanie pakietów:

Dodaj pakiety NuGet za pomocą .NET CLI w zintegrowanym terminalu: te pakiety korzystają z interfejsu API projektów Foundry (nowa wersja próbna).
```
dotnet add package Azure.AI.Projects --prerelease
dotnet add package Azure.AI.Projects.OpenAI --prerelease
dotnet add package Azure.Identity
```
Zaloguj się za pomocą polecenia CLI az login, aby uwierzytelnić się przed uruchomieniem skryptów C#.

Zainstaluj te pakiety, w tym wersję zapoznawcza programu @azure/ai-projects. Ta wersja używa interfejsu API projektów Foundry (nowy) (wersja zapoznawcza).:
```
npm install @azure/ai-projects@beta @azure/identity dotenv
```
Zaloguj się, używając polecenia CLI az login, aby uwierzytelnić się przed uruchomieniem skryptów TypeScript.

Zaloguj się, używając polecenia CLI az login, aby uwierzytelnić się przed uruchomieniem następnego polecenia.
Uzyskiwanie tymczasowego tokenu dostępu. Wygaśnie on w ciągu 60–90 minut. Po tym czasie trzeba będzie odświeżyć.
```
az account get-access-token --scope https://ai.azure.com/.default
```
Zapisz wyniki jako zmienną środowiskową AZURE_AI_AUTH_TOKEN.

Wskazówka

Kod używa usługi Azure AI Projects 2.x i jest niezgodny z usługą Azure AI Projects 1.x. Zapoznaj się z dokumentacją rozwiązania Foundry (klasyczną) dla wersji usługi Azure AI Projects 1.x.

Rozmowa z modelem

Interakcja z modelem to podstawowy blok konstrukcyjny aplikacji sztucznej inteligencji. Wyślij dane wejściowe i odbierz odpowiedź z modelu:

import os
from dotenv import load_dotenv
from azure.identity import DefaultAzureCredential
from azure.ai.projects import AIProjectClient

load_dotenv()

print(f"Using PROJECT_ENDPOINT: {os.environ['PROJECT_ENDPOINT']}")
print(f"Using MODEL_DEPLOYMENT_NAME: {os.environ['MODEL_DEPLOYMENT_NAME']}")

project_client = AIProjectClient(
    endpoint=os.environ["PROJECT_ENDPOINT"],
    credential=DefaultAzureCredential(),
)

openai_client = project_client.get_openai_client()

response = openai_client.responses.create(
    model=os.environ["MODEL_DEPLOYMENT_NAME"],
    input="What is the size of France in square miles?",
)
print(f"Response output: {response.output_text}")

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

#pragma warning disable OPENAI001

string projectEndpoint  = Environment.GetEnvironmentVariable("PROJECT_ENDPOINT")
    ?? throw new InvalidOperationException("Missing environment variable 'PROJECT_ENDPOINT'");
string modelDeploymentName  = Environment.GetEnvironmentVariable("MODEL_DEPLOYMENT_NAME")
    ?? throw new InvalidOperationException("Missing environment variable 'MODEL_DEPLOYMENT_NAME'");

AIProjectClient projectClient = new(new Uri(projectEndpoint ), new AzureCliCredential());

ProjectResponsesClient responseClient = projectClient.OpenAI.GetProjectResponsesClientForModel(modelDeploymentName);
ResponseResult response = await responseClient.CreateResponseAsync("What is the size of France in square miles?");

Console.WriteLine(response.GetOutputText());

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

const projectEndpoint = process.env["PROJECT_ENDPOINT"] || "<project endpoint>";
const deploymentName = process.env["MODEL_DEPLOYMENT_NAME"] || "<model deployment name>";

async function main(): Promise<void> {
    const project = new AIProjectClient(projectEndpoint, new DefaultAzureCredential());
    const openAIClient = await project.getOpenAIClient();
    const response = await openAIClient.responses.create({
        model: deploymentName,
        input: "What is the size of France in square miles?",
    });
    console.log(`Response output: ${response.output_text}`);
}

main().catch(console.error);

package com.azure.ai.agents;

import com.azure.core.util.Configuration;
import com.azure.identity.DefaultAzureCredentialBuilder;
import com.openai.models.responses.Response;
import com.openai.models.responses.ResponseCreateParams;

public class CreateResponse {
    public static void main(String[] args) {
        String endpoint = Configuration.getGlobalConfiguration().get("PROJECT_ENDPOINT");
        String model = Configuration.getGlobalConfiguration().get("MODEL_DEPLOYMENT_NAME");
        // Code sample for creating a response
        ResponsesClient responsesClient = new AgentsClientBuilder()
                .credential(new DefaultAzureCredentialBuilder().build())
                .endpoint(endpoint)
                .serviceVersion(AgentsServiceVersion.V2025_11_15_PREVIEW)
                .buildResponsesClient();

        ResponseCreateParams responseRequest = new ResponseCreateParams.Builder()
                .input("Hello, how can you help me?")
                .model(model)
                .build();

        Response response = responsesClient.getResponseService().create(responseRequest);

        System.out.println("Response ID: " + response.id());
        System.out.println("Response Model: " + response.model());
        System.out.println("Response Created At: " + response.createdAt());
        System.out.println("Response Output: " + response.output());
    }
}

Zastąp YOUR-FOUNDRY-RESOURCE-NAME wartościami:

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 '{
        "model": "gpt-4.1-mini",
        "input": "What is the size of France in square miles?"
}'

Po uruchomieniu kodu w konsoli zostanie wyświetlona odpowiedź wygenerowana przez model (na przykład krótki wiersz lub odpowiedź na monit). Potwierdza to, że punkt końcowy projektu, uwierzytelnianie i wdrożenie modelu działają prawidłowo.

Wskazówka

Kod używa usługi Azure AI Projects 2.x i jest niezgodny z usługą Azure AI Projects 1.x. Zapoznaj się z dokumentacją rozwiązania Foundry (klasyczną) dla wersji Azure AI Projects 1.x.

Utwórz agenta

Utwórz agenta przy użyciu wdrożonego modelu.

Agent definiuje podstawowe zachowanie. Po utworzeniu zapewnia spójne odpowiedzi w interakcjach użytkownika bez powtarzania instrukcji za każdym razem. Agentów można aktualizować lub usuwać w dowolnym momencie.

import os
from dotenv import load_dotenv
from azure.identity import DefaultAzureCredential
from azure.ai.projects import AIProjectClient
from azure.ai.projects.models import PromptAgentDefinition

load_dotenv()

project_client = AIProjectClient(
    endpoint=os.environ["PROJECT_ENDPOINT"],
    credential=DefaultAzureCredential(),
)

agent = project_client.agents.create_version(
    agent_name=os.environ["AGENT_NAME"],
    definition=PromptAgentDefinition(
        model=os.environ["MODEL_DEPLOYMENT_NAME"],
        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.AI.Projects;
using Azure.AI.Projects.OpenAI;
using Azure.Identity;

string projectEndpoint = Environment.GetEnvironmentVariable("PROJECT_ENDPOINT")
    ?? throw new InvalidOperationException("Missing environment variable 'PROJECT_ENDPOINT'");
string modelDeploymentName = Environment.GetEnvironmentVariable("MODEL_DEPLOYMENT_NAME")
    ?? throw new InvalidOperationException("Missing environment variable 'MODEL_DEPLOYMENT_NAME'");
string agentName = Environment.GetEnvironmentVariable("AGENT_NAME")
    ?? throw new InvalidOperationException("Missing environment variable 'AGENT_NAME'");

AIProjectClient projectClient = new(new Uri(projectEndpoint), new AzureCliCredential());

AgentDefinition agentDefinition = new PromptAgentDefinition(modelDeploymentName)
{
    Instructions = "You are a helpful assistant that answers general questions",
};

AgentVersion newAgentVersion = projectClient.Agents.CreateAgentVersion(
    agentName,
    options: new(agentDefinition));

List<AgentVersion> agentVersions = projectClient.Agents.GetAgentVersions(agentName);
foreach (AgentVersion agentVersion in agentVersions)
{
    Console.WriteLine($"Agent: {agentVersion.Id}, Name: {agentVersion.Name}, Version: {agentVersion.Version}");
}

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

const projectEndpoint = process.env["PROJECT_ENDPOINT"] || "<project endpoint>";
const deploymentName = process.env["MODEL_DEPLOYMENT_NAME"] || "<model deployment name>";

async function main(): Promise<void> {
    const project = new AIProjectClient(projectEndpoint, new DefaultAzureCredential());
    const agent = await project.agents.createVersion("my-agent-basic", {
        kind: "prompt",
        model: deploymentName,
        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.core.util.Configuration;
import com.azure.identity.DefaultAzureCredentialBuilder;

public class CreateAgent {
    public static void main(String[] args) {
        String endpoint = Configuration.getGlobalConfiguration().get("PROJECT_ENDPOINT");
        String model = Configuration.getGlobalConfiguration().get("MODEL_DEPLOYMENT_NAME");
        // Code sample for creating an agent
        AgentsClient agentsClient = new AgentsClientBuilder()
                .credential(new DefaultAzureCredentialBuilder().build())
                .endpoint(endpoint)
                .buildAgentsClient();

        PromptAgentDefinition request = new PromptAgentDefinition(model);
        AgentVersionDetails agent = agentsClient.createAgentVersion("MyAgent", request);

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

Zastąp YOUR-FOUNDRY-RESOURCE-NAME wartościami:

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

Dane wyjściowe potwierdzają, że agent został utworzony. W przypadku kart zestawu SDK zobaczysz nazwę agenta i identyfikator wydrukowany w konsoli.

Wskazówka

Kod używa usługi Azure AI Projects 2.x i jest niezgodny z usługą Azure AI Projects 1.x. Zapoznaj się z dokumentacją Foundry (klasyczną) dla wersji Azure AI Projects 1.x.

Rozmowa z agentem

Użyj wcześniej utworzonego agenta o nazwie "MyAgent", aby nawiązać interakcję, zadając pytanie i powiązaną odpowiedź. Konwersacja zachowuje historię podczas tych interakcji.

import os
from dotenv import load_dotenv
from azure.identity import DefaultAzureCredential
from azure.ai.projects import AIProjectClient

load_dotenv()

project_client = AIProjectClient(
    endpoint=os.environ["PROJECT_ENDPOINT"],
    credential=DefaultAzureCredential(),
)

agent_name = os.environ["AGENT_NAME"]
openai_client = project_client.get_openai_client()

# Optional Step: Create a conversation to use with the agent
conversation = openai_client.conversations.create()
print(f"Created conversation (id: {conversation.id})")

# Chat with the agent to answer questions
response = openai_client.responses.create(
    conversation=conversation.id, #Optional conversation context for multi-turn
    extra_body={"agent_reference": {"name": agent_name, "type": "agent_reference"}},
    input="What is the size of France in square miles?",
)
print(f"Response output: {response.output_text}")

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

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

#pragma warning disable OPENAI001

string projectEndpoint = Environment.GetEnvironmentVariable("PROJECT_ENDPOINT")
    ?? throw new InvalidOperationException("Missing environment variable 'PROJECT_ENDPOINT'");
string modelDeploymentName = Environment.GetEnvironmentVariable("MODEL_DEPLOYMENT_NAME")
    ?? throw new InvalidOperationException("Missing environment variable 'MODEL_DEPLOYMENT_NAME'");
string agentName = Environment.GetEnvironmentVariable("AGENT_NAME")
    ?? throw new InvalidOperationException("Missing environment variable 'AGENT_NAME'");

AIProjectClient projectClient = new(new Uri(projectEndpoint), new AzureCliCredential());

// Optional Step: Create a conversation to use with the agent
ProjectConversation conversation = projectClient.OpenAI.Conversations.CreateProjectConversation();

ProjectResponsesClient responsesClient = projectClient.OpenAI.GetProjectResponsesClientForAgent(
    defaultAgent: agentName,
    defaultConversationId: conversation.Id);

// Chat with the agent to answer questions
ResponseResult response = responsesClient.CreateResponse("What is the size of France in square miles?");
Console.WriteLine(response.GetOutputText());

// Optional Step: 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";
import "dotenv/config";

const projectEndpoint = process.env["PROJECT_ENDPOINT"] || "<project endpoint>";
const deploymentName = process.env["MODEL_DEPLOYMENT_NAME"] || "<model deployment name>";

async function main(): Promise<void> {
    const project = new AIProjectClient(projectEndpoint, new DefaultAzureCredential());
    const openAIClient = await project.getOpenAIClient();
    
    // Create agent
    console.log("Creating agent...");
    const agent = await project.agents.createVersion("my-agent-basic", {
        kind: "prompt",
        model: deploymentName,
        instructions: "You are a helpful assistant that answers general questions",
    });
    console.log(`Agent created (id: ${agent.id}, name: ${agent.name}, version: ${agent.version})`);
    
    // Create conversation with initial user message
    // You can save the conversation ID to database to retrieve later
    console.log("\nCreating conversation with initial user message...");
    const conversation = await openAIClient.conversations.create({
        items: [
            { type: "message", role: "user", content: "What is the size of France in square miles?" },
        ],
    });
    console.log(`Created conversation with initial user message (id: ${conversation.id})`);

    // Generate response using the agent
    console.log("\nGenerating response...");
    const response = await openAIClient.responses.create(
        {
            conversation: conversation.id,
        },
        {
            body: { agent: { name: agent.name, type: "agent_reference" } },
        },
    );
    console.log(`Response output: ${response.output_text}`);

     // Clean up
    console.log("\nCleaning up resources...");
    await openAIClient.conversations.delete(conversation.id);
    console.log("Conversation deleted");

    await project.agents.deleteVersion(agent.name, agent.version);
    console.log("Agent deleted");
}

main().catch(console.error);

package com.azure.ai.agents;

import com.azure.ai.agents.models.AgentReference;
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.azure.AzureOpenAIServiceVersion;
import com.openai.azure.AzureUrlPathMode;
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;

public class ChatWithAgent {
    public static void main(String[] args) {
        String endpoint = Configuration.getGlobalConfiguration().get("AZURE_AGENTS_ENDPOINT");
        String agentName = "MyAgent";
        
        AgentsClient agentsClient = new AgentsClientBuilder()
                .credential(new DefaultAzureCredentialBuilder().build())
                .endpoint(endpoint)
                .buildAgentsClient();

        AgentDetails agent = agentsClient.getAgent(agentName);

        Conversation conversation = conversationsClient.getConversationService().create();
        conversationsClient.getConversationService().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.createWithAgentConversation(agentReference, conversation.id());

        OpenAIClient client = OpenAIOkHttpClient.builder()
            .baseUrl(endpoint.endsWith("/") ? endpoint + "openai" : endpoint + "/openai")
            .azureUrlPathMode(AzureUrlPathMode.UNIFIED)
            .credential(BearerTokenCredential.create(AuthenticationUtil.getBearerTokenSupplier(
                    new DefaultAzureCredentialBuilder().build(), "https://ai.azure.com/.default")))
            .azureServiceVersion(AzureOpenAIServiceVersion.fromString("2025-11-15-preview"))
            .build();

        ResponseCreateParams responseRequest = new ResponseCreateParams.Builder()
            .input("Hello, how can you help me?")
            .model(model)
            .build();

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

Zastąp YOUR-FOUNDRY-RESOURCE-NAME wartościami:

# 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?"}]
  }'

Zobaczysz odpowiedzi agenta na obie komendy. Odpowiedź kolejna pokazuje, że agent utrzymuje historię rozmowy w kolejnych wymianach zdań.

Wskazówka

Kod używa usługi Azure AI Projects 2.x i jest niezgodny z usługą Azure AI Projects 1.x. Zapoznaj się z dokumentacją rozwiązania Foundry (klasyczną) w odniesieniu do wersji 1.x Azure AI Projects.

Uprzątnij zasoby

Jeśli nie potrzebujesz już żadnych utworzonych zasobów, usuń grupę zasobów skojarzona z projektem.

W witrynie Azure Portal wybierz grupę zasobów, a następnie wybierz pozycję Usuń. Upewnij się, że chcesz usunąć grupę zasobów.

Następny krok

Od pomysłu do prototypu - Tworzenie i ocenianie agenta firmowego

Sprzężenie zwrotne

Czy ta strona była pomocna?

Last updated on 2026-02-28

Udostępnij przez

Szybki przewodnik startowy Microsoft Foundry

Wymagania wstępne

Ustawianie zmiennych środowiskowych i pobieranie kodu

Instalowanie i uwierzytelnianie

Rozmowa z modelem

Utwórz agenta

Rozmowa z agentem

Uprzątnij zasoby

Następny krok

Sprzężenie zwrotne

Dodatkowe źródła