Gebruik de Azure OpenAI-antwoorden-api om stateful, meerdere beurten antwoorden te genereren. Het combineert mogelijkheden van chatvoltooiingen en de Assistants-API in één uniforme ervaring. Gebruik indeling met meerdere agents om onafhankelijk werk te delegeren aan parallelle subagents, of gebruik hulpprogramma's zoeken om taakdefinities alleen te laden wanneer het model ze nodig heeft. De Response-API ondersteunt ook het computer-use-preview model dat computergebruik mogelijk maakt.
Zie de naslaginformatie voor de antwoorden-API-parameter voor volledige beschrijvingen van de aanvraag- en antwoordparameter.
Voorwaarden
- Een geïmplementeerd Azure OpenAI-model.
- Een verificatiemethode:
- API-sleutel (bijvoorbeeld
AZURE_OPENAI_API_KEY), of
- Microsoft Entra ID (aanbevolen).
- Installeer de clientbibliotheek voor uw taal:
-
Python:
pip install openai azure-identity
-
.NET:
dotnet add package OpenAI en dotnet add package Azure.Identity
-
JavaScript/TypeScript:
npm install openai @azure/identity
-
Java: voeg
com.openai:openai-java en com.azure:azure-identity toe aan uw project.
- Voor REST-voorbeelden stelt u
AZURE_OPENAI_API_KEY (API-sleutelstroom) of AZURE_OPENAI_AUTH_TOKEN (Microsoft Entra ID stroom) in.
Ondersteunde regio’s
Voordat u de voorbeelden in dit artikel uitvoert, moet u controleren of uw resourceregio ondersteuning biedt voor de response-API. De v1-API is vereist voor toegang tot de nieuwste functies. Zie de levenscyclus van de API-versie voor meer informatie. Zie de tabel met regionale beschikbaarheid voor ondersteuning per regio voor Foundry Agent Service. De Antwoorden-API is momenteel beschikbaar in de volgende regio's:
- australië-oost
- brazilsouth
- canadacentral
- canadaeast
- centralus
- eastus
- eastus2
- francecentral
- germanywestcentral
- Noord-Italië
- japaneast
- japanwest
- koreacentral
- northcentralus
- noorwegenoost
- Polencentral
- southafricanorth
- southcentralus
- southeastasia
- Zuid-India
- spaincentral
- swedencentral
- zwitserlandnoord
- switzerlandwest
- uaenorth
- uksouth
- ukwest
- westcentralus
- West-Europa
- westus
- westus2
- westus3
Ondersteunde modellen
De Antwoorden-API ondersteunt de volgende modellen:
-
gpt-6.1-terra (Versie: 2026-10-26)
-
gpt-6.1-sol (Versie: 2026-09-29)
-
gpt-6-luna (Versie: 2026-09-22)
-
gpt-6-sol (Versie: 2026-09-22)
-
gpt-6-astra (Versie: 2026-09-03)
-
gpt-5.6-sol (Versie: 2026-07-09)
-
gpt-5.6-terra (Versie: 2026-07-09)
-
gpt-5.6-luna (Versie: 2026-07-09)
-
gpt-chat-latest (Versies: 2026-10-07, 2026-08-06, 2026-06-24, 2026-05-28, 2026-05-05)
-
gpt-5.5 (Versie: 2026-04-24)
-
gpt-5.4-nano (Versie: 2026-03-17)
-
gpt-5.4-mini (Versie: 2026-03-17)
-
gpt-5.4-pro (Versie:2026-03-05)
-
gpt-5.4 (Versie:2026-03-05)
-
gpt-5.3-chat (Versie: 2026-03-03)
-
gpt-5.3-codex (Versie: 2026-02-24)
-
gpt-5.2-codex (Versie: 2026-01-14)
-
gpt-5.2 (Versie: 2025-12-11)
-
gpt-5.2-chat (Versie: 2025-12-11)
-
gpt-5.2-chat (Versie: 2026-02-10)
-
gpt-5.1-codex-max (Versie: 2025-12-04)
-
gpt-5.1 (Versie: 2025-11-13)
-
gpt-5.1-chat (Versie: 2025-11-13)
-
gpt-5.1-codex (Versie: 2025-11-13)
-
gpt-5.1-codex-mini (Versie: 2025-11-13)
-
gpt-5-pro (Versie: 2025-10-06)
-
gpt-5-codex (Versie: 2025-09-11)
-
gpt-5 (Versie: 2025-08-07)
-
gpt-5-mini (Versie: 2025-08-07)
-
gpt-5-nano (Versie: 2025-08-07)
-
gpt-5-chat (Versie: 2025-08-07)
-
gpt-5-chat (Versie: 2025-10-03)
-
gpt-5-codex (Versie: 2025-09-15)
-
gpt-4o (Versies: 2024-11-20, 2024-08-06, 2024-05-13)
-
gpt-4o-mini (Versie: 2024-07-18)
computer-use-preview
-
gpt-4.1 (Versie: 2025-04-14)
-
gpt-4.1-nano (Versie: 2025-04-14)
-
gpt-4.1-mini (Versie: 2025-04-14)
-
gpt-image-1 (Versie: 2025-04-15)
-
gpt-image-1-mini (Versie: 2025-10-06)
-
gpt-image-1.5 (Versie: 2025-12-16)
-
gpt-image-2.5-flare (Versie: 2026-09-09)
-
gpt-image-2.5-sunburst (Versie: 2026-09-09)
-
o1 (Versie: 2024-12-17)
-
o3-mini (Versie: 2025-01-31)
-
o3 (Versie: 2025-04-16)
-
o4-mini (Versie: 2025-04-16)
Niet elk model is beschikbaar in elke ondersteunde regio. Controleer de pagina modellen op beschikbaarheid van modelregio's.
Opmerking
Momenteel niet ondersteund:
- Het genereren van afbeeldingen met meerdere iteraties van bewerkingen via streaming.
Er is een bekend probleem met het volgende:
- PDF als invoerbestand wordt nu ondersteund, maar het instellen van het uploaddoel
user_data voor bestanden wordt momenteel niet ondersteund.
- Prestatieproblemen wanneer de achtergrondmodus wordt gebruikt met streaming. Microsoft werkt aan het oplossen van dit probleem.
Een tekstantwoord genereren
Genereer een eenvoudig tekstantwoord met behulp van de Antwoorden-API. Vervang YOUR-RESOURCE-NAME en MODEL_NAME door uw implementatiewaarden.
import os
from openai import OpenAI
from azure.identity import DefaultAzureCredential, get_bearer_token_provider
# API key authentication
client = OpenAI(
api_key=os.getenv("AZURE_OPENAI_API_KEY"),
base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
)
response = client.responses.create(
model="MODEL_NAME",
input="This is a test."
)
print(response.model_dump_json(indent=2))
# Microsoft Entra ID authentication (recommended)
token_provider = get_bearer_token_provider(
DefaultAzureCredential(), "https://ai.azure.com/.default"
)
client = OpenAI(
base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
api_key=token_provider(),
)
response = client.responses.create(
model="MODEL_NAME",
input="This is a test."
)
print(response.model_dump_json(indent=2))
#pragma warning disable OPENAI001
using Azure.Identity;
using OpenAI.Responses;
using System.ClientModel.Primitives;
string endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1";
// API key authentication
ResponsesClient openAIClient = new(
credential: new ApiKeyCredential(Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY")!),
options: new ResponsesClientOptions { Endpoint = new Uri(endpoint) });
// Microsoft Entra ID authentication (recommended)
BearerTokenPolicy tokenPolicy = new(
new DefaultAzureCredential(),
"https://ai.azure.com/.default");
ResponsesClient openAIClientEntra = new(
authenticationPolicy: tokenPolicy,
options: new ResponsesClientOptions { Endpoint = new Uri(endpoint) });
CreateResponseOptions options = new()
{
Model = "MODEL_NAME",
InputItems = { ResponseItem.CreateUserMessageItem("This is a test.") }
};
ResponseResult response = await openAIClient.CreateResponseAsync(options);
Console.WriteLine(response.GetOutputText());
import { OpenAI } from "openai";
import { DefaultAzureCredential, getBearerTokenProvider } from "@azure/identity";
const endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/";
// API key authentication
const openai = new OpenAI({
baseURL: endpoint,
apiKey: process.env.AZURE_OPENAI_API_KEY,
});
const response = await openai.responses.create({
model: "MODEL_NAME",
input: "This is a test."
});
console.log(response.output_text);
// Microsoft Entra ID authentication (recommended)
const tokenProvider = getBearerTokenProvider(
new DefaultAzureCredential(),
"https://ai.azure.com/.default"
);
const openaiEntra = new OpenAI({
baseURL: endpoint,
apiKey: await tokenProvider(),
});
const responseEntra = await openaiEntra.responses.create({
model: "MODEL_NAME",
input: "This is a test."
});
console.log(responseEntra.output_text);
import com.azure.identity.DefaultAzureCredentialBuilder;
import com.azure.identity.AuthenticationUtil;
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.credential.BearerTokenCredential;
import com.openai.models.responses.Response;
import com.openai.models.responses.ResponseCreateParams;
String endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1";
// API key authentication
OpenAIClient openAIClient = OpenAIOkHttpClient.builder()
.baseUrl(endpoint)
.credential(AzureApiKeyCredential.create(System.getenv("AZURE_OPENAI_API_KEY")))
.build();
// Microsoft Entra ID authentication (recommended)
OpenAIClient openAIClientEntra = OpenAIOkHttpClient.builder()
.baseUrl(endpoint)
.credential(BearerTokenCredential.create(
AuthenticationUtil.getBearerTokenSupplier(
new DefaultAzureCredentialBuilder().build(),
"https://ai.azure.com/.default")))
.build();
ResponseCreateParams params = ResponseCreateParams.builder()
.model("MODEL_NAME")
.input("This is a test.")
.build();
Response response = openAIClient.responses().create(params);
System.out.println(response.outputText());
Microsoft Entra ID
curl -X POST https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $AZURE_OPENAI_AUTH_TOKEN" \
-d '{
"model": "MODEL_NAME",
"input": "This is a test."
}'
API-sleutel
curl -X POST https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses \
-H "Content-Type: application/json" \
-H "api-key: $AZURE_OPENAI_API_KEY" \
-d '{
"model": "MODEL_NAME",
"input": "This is a test."
}'
Voorbeeld van een antwoord
{
"id": "resp_67cb32528d6881909eb2859a55e18a85",
"created_at": 1741369938.0,
"output_text": "Great! How can I help you today?",
...
}
Een antwoord ophalen
Haal een antwoord op met de bijbehorende id van een eerdere antwoord-API-aanroep.
import os
from openai import OpenAI
from azure.identity import DefaultAzureCredential, get_bearer_token_provider
# API key authentication
client = OpenAI(
api_key=os.getenv("AZURE_OPENAI_API_KEY"),
base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
)
response = client.responses.retrieve("<response_id>")
print(response.model_dump_json(indent=2))
# Microsoft Entra ID authentication
token_provider = get_bearer_token_provider(
DefaultAzureCredential(), "https://ai.azure.com/.default"
)
client = OpenAI(
base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
api_key=token_provider,
)
response = client.responses.retrieve("<response_id>")
print(response.model_dump_json(indent=2))
#pragma warning disable OPENAI001
using Azure.Identity;
using OpenAI.Responses;
string endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1";
// API key authentication
ResponsesClient openAIClient = new(
credential: new ApiKeyCredential(Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY")!),
options: new ResponsesClientOptions { Endpoint = new Uri(endpoint) });
// Microsoft Entra ID authentication
BearerTokenPolicy tokenPolicy = new(
new DefaultAzureCredential(),
"https://ai.azure.com/.default");
ResponsesClient openAIClientEntra = new(
authenticationPolicy: tokenPolicy,
options: new ResponsesClientOptions { Endpoint = new Uri(endpoint) });
string responseId = "<response_id>";
ResponseResult response = await openAIClient.GetResponseAsync(responseId);
Console.WriteLine(response.GetOutputText());
import { OpenAI } from "openai";
import { DefaultAzureCredential, getBearerTokenProvider } from "@azure/identity";
const endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/";
// API key authentication
const openai = new OpenAI({
baseURL: endpoint,
apiKey: process.env.AZURE_OPENAI_API_KEY,
});
const response = await openai.responses.retrieve("<response_id>");
console.log(response.output_text);
// Microsoft Entra ID authentication
const tokenProvider = getBearerTokenProvider(
new DefaultAzureCredential(),
"https://ai.azure.com/.default"
);
const openaiEntra = new OpenAI({
baseURL: endpoint,
apiKey: await tokenProvider(),
});
const responseEntra = await openaiEntra.responses.retrieve("<response_id>");
console.log(responseEntra.output_text);
import com.azure.identity.DefaultAzureCredentialBuilder;
import com.azure.identity.AuthenticationUtil;
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.credential.BearerTokenCredential;
String endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1";
// API key authentication
OpenAIClient openAIClient = OpenAIOkHttpClient.builder()
.baseUrl(endpoint)
.credential(AzureApiKeyCredential.create(System.getenv("AZURE_OPENAI_API_KEY")))
.build();
// Microsoft Entra ID authentication
OpenAIClient openAIClientEntra = OpenAIOkHttpClient.builder()
.baseUrl(endpoint)
.credential(BearerTokenCredential.create(
AuthenticationUtil.getBearerTokenSupplier(
new DefaultAzureCredentialBuilder().build(),
"https://ai.azure.com/.default")))
.build();
Response response = openAIClient.responses().retrieve("<response_id>");
System.out.println(response.outputText());
Microsoft Entra ID
curl -X GET https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses/<response_id> \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $AZURE_OPENAI_AUTH_TOKEN"
API-sleutel
curl -X GET https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses/<response_id> \
-H "Content-Type: application/json" \
-H "api-key: $AZURE_OPENAI_API_KEY"
Voorbeeld van een antwoord
{
"id": "resp_67cb61fa3a448190bcf2c42d96f0d1a8",
"output_text": "Hello! How can I assist you today?",
...
}
Een antwoord verwijderen
Antwoordgegevens worden standaard 30 dagen bewaard. Verwijder een opgeslagen antwoord op id.
import os
from openai import OpenAI
from azure.identity import DefaultAzureCredential, get_bearer_token_provider
# API key authentication
client = OpenAI(
api_key=os.getenv("AZURE_OPENAI_API_KEY"),
base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
)
response = client.responses.delete("<response_id>")
print(response)
# Microsoft Entra ID authentication
token_provider = get_bearer_token_provider(
DefaultAzureCredential(), "https://ai.azure.com/.default"
)
client = OpenAI(
base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
api_key=token_provider,
)
response = client.responses.delete("<response_id>")
print(response)
#pragma warning disable OPENAI001
using Azure.Identity;
using OpenAI.Responses;
string endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1";
// API key authentication
ResponsesClient openAIClient = new(
credential: new ApiKeyCredential(Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY")!),
options: new ResponsesClientOptions { Endpoint = new Uri(endpoint) });
// Microsoft Entra ID authentication
BearerTokenPolicy tokenPolicy = new(
new DefaultAzureCredential(),
"https://ai.azure.com/.default");
ResponsesClient openAIClientEntra = new(
authenticationPolicy: tokenPolicy,
options: new ResponsesClientOptions { Endpoint = new Uri(endpoint) });
string responseId = "<response_id>";
var result = await openAIClient.DeleteResponseAsync(responseId);
Console.WriteLine(result); // result.Deleted == true if successful
import { OpenAI } from "openai";
import { DefaultAzureCredential, getBearerTokenProvider } from "@azure/identity";
const endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/";
// API key authentication
const openai = new OpenAI({
baseURL: endpoint,
apiKey: process.env.AZURE_OPENAI_API_KEY,
});
const result = await openai.responses.delete("<response_id>");
console.log(result);
// Microsoft Entra ID authentication
const tokenProvider = getBearerTokenProvider(
new DefaultAzureCredential(),
"https://ai.azure.com/.default"
);
const openaiEntra = new OpenAI({
baseURL: endpoint,
apiKey: await tokenProvider(),
});
const resultEntra = await openaiEntra.responses.delete("<response_id>");
console.log(resultEntra);
import com.azure.identity.DefaultAzureCredentialBuilder;
import com.azure.identity.AuthenticationUtil;
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.credential.BearerTokenCredential;
String endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1";
// API key authentication
OpenAIClient openAIClient = OpenAIOkHttpClient.builder()
.baseUrl(endpoint)
.credential(AzureApiKeyCredential.create(System.getenv("AZURE_OPENAI_API_KEY")))
.build();
// Microsoft Entra ID authentication
OpenAIClient openAIClientEntra = OpenAIOkHttpClient.builder()
.baseUrl(endpoint)
.credential(BearerTokenCredential.create(
AuthenticationUtil.getBearerTokenSupplier(
new DefaultAzureCredentialBuilder().build(),
"https://ai.azure.com/.default")))
.build();
Response result = openAIClient.responses().delete("<response_id>");
System.out.println(result);
Microsoft Entra ID
curl -X DELETE https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses/<response_id> \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $AZURE_OPENAI_AUTH_TOKEN"
API-sleutel
curl -X DELETE https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses/<response_id> \
-H "Content-Type: application/json" \
-H "api-key: $AZURE_OPENAI_API_KEY"
Versleuteling van opgeslagen antwoordgegevens
Wanneer de Antwoorden-API berichtgeschiedenis en gerelateerde inhoud opslaat, versleutelt de service die inhoud in rust. Zie Gegevens, privacy en beveiliging voor Modellen verkocht door Azure in Microsoft Foundry voor de uitleg over opslagversleuteling. Zie Door de klant beheerde sleutelversleuteling in Microsoft Foundry voor CMK-dekking en vereisten.
Deze versleuteling is gescheiden van versleutelde redeneringsitems die worden geretourneerd naar uw toepassing wanneer u de gespreksstatus beheert met store=false.
Antwoorden aan elkaar koppelen
Keten draait door de vorige antwoord-id door te geven aan previous_response_id.
import os
from openai import OpenAI
client = OpenAI(
base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
api_key=os.getenv("AZURE_OPENAI_API_KEY")
)
first_response = client.responses.create(
model="MODEL_NAME",
input="Define catastrophic forgetting."
)
second_response = client.responses.create(
model="MODEL_NAME",
previous_response_id=first_response.id,
input="Explain it for a college freshman."
)
print(second_response.output_text)
#pragma warning disable OPENAI001
using Azure.Identity;
using OpenAI.Responses;
using System.ClientModel.Primitives;
string endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1";
// API key authentication
ResponsesClient openAIClient = new(
credential: new ApiKeyCredential(Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY")!),
options: new ResponsesClientOptions { Endpoint = new Uri(endpoint) });
// Microsoft Entra ID authentication (recommended)
BearerTokenPolicy tokenPolicy = new(
new DefaultAzureCredential(),
"https://ai.azure.com/.default");
ResponsesClient openAIClientEntra = new(
authenticationPolicy: tokenPolicy,
options: new ResponsesClientOptions { Endpoint = new Uri(endpoint) });
CreateResponseOptions firstOptions = new()
{
Model = "MODEL_NAME",
InputItems = { ResponseItem.CreateUserMessageItem("Define and explain the concept of catastrophic forgetting?") }
};
ResponseResult firstResponse = await openAIClient.CreateResponseAsync(firstOptions);
Console.WriteLine(firstResponse.GetOutputText());
CreateResponseOptions secondOptions = new()
{
Model = "MODEL_NAME",
PreviousResponseId = firstResponse.Id,
InputItems = { ResponseItem.CreateUserMessageItem("Explain this at a level that could be understood by a college freshman") }
};
ResponseResult secondResponse = await openAIClient.CreateResponseAsync(secondOptions);
Console.WriteLine(secondResponse.GetOutputText());
import { OpenAI } from "openai";
const client = new OpenAI({
baseURL: "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
apiKey: process.env.AZURE_OPENAI_API_KEY,
});
const firstResponse = await client.responses.create({
model: "MODEL_NAME",
input: "Define catastrophic forgetting."
});
const secondResponse = await client.responses.create({
model: "MODEL_NAME",
previous_response_id: firstResponse.id,
input: "Explain it for a college freshman."
});
console.log(secondResponse.output_text);
import com.azure.identity.DefaultAzureCredentialBuilder;
import com.azure.identity.AuthenticationUtil;
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.credential.BearerTokenCredential;
import com.openai.models.responses.Response;
import com.openai.models.responses.ResponseCreateParams;
String endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1";
OpenAIClient openAIClient = OpenAIOkHttpClient.builder()
.baseUrl(endpoint)
.credential(AzureApiKeyCredential.create(System.getenv("AZURE_OPENAI_API_KEY")))
.build();
Response first = openAIClient.responses().create(
ResponseCreateParams.builder()
.model("MODEL_NAME")
.input("Define and explain the concept of catastrophic forgetting?")
.build());
Response second = openAIClient.responses().create(
ResponseCreateParams.builder()
.model("MODEL_NAME")
.previousResponseId(first.id())
.input("Explain this at a level that could be understood by a college freshman.")
.build());
second.output().stream()
.flatMap(item -> item.message().stream())
.flatMap(m -> m.content().stream())
.flatMap(c -> c.outputText().stream())
.forEach(t -> System.out.println(t.text()));
# First turn
curl -X POST https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses \
-H "Content-Type: application/json" \
-H "api-key: $AZURE_OPENAI_API_KEY" \
-d '{
"model": "MODEL_NAME",
"input": "Define catastrophic forgetting."
}'
# Follow-up turn using previous_response_id from the first call
curl -X POST https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses \
-H "Content-Type: application/json" \
-H "api-key: $AZURE_OPENAI_API_KEY" \
-d '{
"model": "MODEL_NAME",
"previous_response_id": "<response_id>",
"input": "Explain it for a college freshman."
}'
Reacties handmatig koppelen
U kunt ook uitvoeritems handmatig doorsturen in de volgende aanvraag.
import os
from openai import OpenAI
client = OpenAI(
base_url = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
api_key=os.getenv("AZURE_OPENAI_API_KEY")
)
inputs = [{"type": "message", "role": "user", "content": "Define and explain the concept of catastrophic forgetting?"}]
response = client.responses.create(
model="gpt-4o", # replace with your model deployment name
input=inputs
)
inputs += response.output
inputs.append({"role": "user", "type": "message", "content": "Explain this at a level that could be understood by a college freshman"})
second_response = client.responses.create(
model="MODEL_NAME",
input=inputs
)
print(second_response.model_dump_json(indent=2))
Een antwoord comprimeren
Compactie vermindert de inputcontext, terwijl de essentiële toestand behouden blijft voor volgende interacties.
import os
from openai import OpenAI
client = OpenAI(
base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
api_key=os.getenv("AZURE_OPENAI_API_KEY")
)
compacted = client.responses.compact(
model="MODEL_NAME",
input=[
{"role": "user", "content": "Create a simple landing page for a dog cafe."},
{
"id": "msg_001",
"type": "message",
"status": "completed",
"role": "assistant",
"content": [{"type": "output_text", "text": "..."}],
},
]
)
follow_up = client.responses.create(
model="MODEL_NAME",
input=[*compacted.output, {"role": "user", "content": "Add a booking form."}]
)
print(follow_up.output_text)
Opmerking
De .NET SDK biedt nog geen sterk getypt oppervlak voor antwoordcompressie. Zie het REST-tabblad voor de indeling van de aanroep, of roep de protocolmethode direct aan met BinaryContent JSON.
import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
apiKey: process.env.AZURE_OPENAI_API_KEY,
});
const compacted = await client.responses.compact({
model: "MODEL_NAME",
input: [
{ role: "user", content: "Create a simple landing page for a dog cafe." },
{
id: "msg_001",
type: "message",
status: "completed",
role: "assistant",
content: [{ type: "output_text", text: "..." }],
},
],
});
const followUp = await client.responses.create({
model: "MODEL_NAME",
input: [...compacted.output, { role: "user", content: "Add a booking form." }],
});
console.log(followUp.output_text);
import com.azure.identity.DefaultAzureCredentialBuilder;
import com.azure.identity.AuthenticationUtil;
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.credential.BearerTokenCredential;
import com.openai.models.responses.CompactedResponse;
import com.openai.models.responses.Response;
import com.openai.models.responses.ResponseCompactParams;
import com.openai.models.responses.ResponseCreateParams;
String endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1";
OpenAIClient openAIClient = OpenAIOkHttpClient.builder()
.baseUrl(endpoint)
.credential(AzureApiKeyCredential.create(System.getenv("AZURE_OPENAI_API_KEY")))
.build();
Response initial = openAIClient.responses().create(
ResponseCreateParams.builder()
.model("MODEL_NAME")
.input("Create a simple landing page for a dog cafe.")
.build());
CompactedResponse compacted = openAIClient.responses().compact(
ResponseCompactParams.builder()
.model("MODEL_NAME")
.previousResponseId(initial.id())
.build());
Response followUp = openAIClient.responses().create(
ResponseCreateParams.builder()
.model("MODEL_NAME")
.previousResponseId(compacted.id())
.input("Add a booking form.")
.build());
System.out.println(followUp.outputText());
curl -X POST https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses/compact \
-H "Content-Type: application/json" \
-H "api-key: $AZURE_OPENAI_API_KEY" \
-d '{
"model": "MODEL_NAME",
"input": [
{"role": "user", "content": "Create a simple landing page for a dog cafe."},
{
"id": "msg_001",
"type": "message",
"status": "completed",
"role": "assistant",
"content": [{"type": "output_text", "text": "..."}]
}
]
}'
Comprimeren met behulp van geretourneerde items
U kunt alle items comprimeren die zijn geretourneerd uit eerdere aanvragen, zoals redenering, bericht, functieoproep, enzovoort.
curl -X POST https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses/compact \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $AZURE_OPENAI_AUTH_TOKEN" \
-d '{
"model": "MODEL_NAME",
"input": [
{
"role" : "user",
"content": "Create a simple landing page for a dog petting café."
},
{
"id": "msg_001",
"type": "message",
"status": "completed",
"content": [
{
"type": "output_text",
"annotations": [],
"logprobs": [],
"text": "Below is a single file, ready-to-use landing page for a dog petting café:..."
}
],
"role": "assistant"
}
]
}'
# Use the compacted output as input for the next turn.
next_response = client.responses.create(
model="MODEL_NAME",
input=[*compacted.output, {"role": "user", "content": "Add opening hours."}],
)
print(next_response.output_text)
Comprimeren met behulp van vorige antwoord-id
U kunt ook comprimeren met behulp van een vorige antwoord-id.
initial_response = client.responses.create(
model="MODEL_NAME",
input="What is the size of France?"
)
compacted_response = client.responses.compact(
model="MODEL_NAME",
previous_response_id=initial_response.id
)
follow_up_response = client.responses.create(
model="MODEL_NAME",
input=[
*compacted_response.output,
{"role": "user", "content": "What is the capital?"}
]
)
print(follow_up_response.output_text)
Compressie aan serverzijde
U kunt server-side compactie ook direct in Responses (POST /responses of client.responses.create) gebruiken door context_management in te stellen met een compact_threshold.
- Wanneer het aantal uitvoertoken de geconfigureerde drempelwaarde overschrijdt, wordt de api voor antwoorden automatisch gecomprimeerd.
- In deze modus hoeft u niet afzonderlijk aan te roepen
/responses/compact .
- Het antwoord bevat een versleuteld compressie-item.
- Compressie aan de serverzijde werkt wanneer u store=false instelt bij aanvragen voor het genereren van antwoorden.
Het compactie-item draagt de essentiële voorafgaande status en redenering over naar de volgende beurt met minder tokens. Het is ondoorzichtig en is niet bedoeld om leesbaar te zijn voor mensen.
Als u staatloze invoermatrixketens gebruikt, voegt u uitvoeritems zoals gebruikelijk toe. Als u gebruikmaakt van previous_response_id, geeft u bij elke beurt alleen het nieuwe gebruikersbericht door. In beide patronen bevat het compressie-item de context die nodig is voor het volgende venster.
Tip
Nadat u uitvoeritems hebt toegevoegd aan de vorige invoeritems, kunt u items verwijderen die vóór het meest recente compressie-item zijn geleverd om aanvragen kleiner te houden en de latentie van de lange staart te verminderen. Het meest recente compactie-item bevat de benodigde context om het gesprek voort te zetten. Als u kettingen gebruikt previous_response_id , moet u niet handmatig snoeien.
Stroom
- Bel
responses zoals gebruikelijk. Voeg context_management samen met compact_threshold toe om compressie aan de serverzijde in te schakelen.
- Als de uitvoer de drempelwaarde overschrijdt, activeert de service compactie, stuurt een compactie-item in de uitvoerstroom en verwijdert de context voordat inferentie wordt voortgezet.
- Ga door met het gesprek met behulp van een van deze patronen:
- Staatloze invoermatrixkoppeling: uitvoeritems, inclusief compressie-items, toevoegen aan de volgende invoermatrix.
-
previous_response_id koppelen: geef alleen het nieuwe gebruikersbericht op elke keer door en draag de meest recente antwoord-id door.
Voorbeeld
conversation = [
{
"type": "message",
"role": "user",
"content": "Let's begin a long coding task.",
}
]
while keep_going:
response = client.responses.create(
model="MODEL_NAME",
input=conversation,
store=False,
context_management=[{"type": "compaction", "compact_threshold": 200000}],
)
conversation.append(
{
"type": "message",
"role": "user",
"content": get_next_user_input(),
}
)
Streamen
Stream het antwoord terwijl het wordt gegenereerd door stream=true in te stellen. De service verzendt incrementele gebeurtenissen die u kunt gebruiken om uitvoertoken per token weer te geven.
import os
from openai import OpenAI
client = OpenAI(
base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
api_key=os.getenv("AZURE_OPENAI_API_KEY")
)
stream = client.responses.create(
model="MODEL_NAME",
input="Summarize Azure OpenAI Responses API in one sentence.",
stream=True,
)
for event in stream:
if event.type == "response.output_text.delta":
print(event.delta, end="")
#pragma warning disable OPENAI001
using Azure.Identity;
using OpenAI.Responses;
using System.ClientModel.Primitives;
string endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1";
// API key authentication
ResponsesClient openAIClient = new(
credential: new ApiKeyCredential(Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY")!),
options: new ResponsesClientOptions { Endpoint = new Uri(endpoint) });
// Microsoft Entra ID authentication (recommended)
BearerTokenPolicy tokenPolicy = new(
new DefaultAzureCredential(),
"https://ai.azure.com/.default");
ResponsesClient openAIClientEntra = new(
authenticationPolicy: tokenPolicy,
options: new ResponsesClientOptions { Endpoint = new Uri(endpoint) });
CreateResponseOptions options = new()
{
Model = "MODEL_NAME",
InputItems = { ResponseItem.CreateUserMessageItem("Summarize Azure OpenAI Responses API in one sentence.") },
StreamingEnabled = true
};
await foreach (StreamingResponseUpdate update in openAIClient.CreateResponseStreamingAsync(options))
{
if (update is StreamingResponseOutputTextDeltaUpdate textDelta)
{
Console.Write(textDelta.Delta);
}
else if (update is StreamingResponseCompletedUpdate completed)
{
Console.WriteLine();
Console.WriteLine($"[done] response id: {completed.Response.Id}");
}
}
import { OpenAI } from "openai";
const client = new OpenAI({
baseURL: "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
apiKey: process.env.AZURE_OPENAI_API_KEY,
});
const stream = await client.responses.create({
model: "MODEL_NAME",
input: "Summarize Azure OpenAI Responses API in one sentence.",
stream: true,
});
for await (const event of stream) {
if (event.type === "response.output_text.delta") {
process.stdout.write(event.delta);
}
}
import com.azure.identity.DefaultAzureCredentialBuilder;
import com.azure.identity.AuthenticationUtil;
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.core.http.StreamResponse;
import com.openai.credential.BearerTokenCredential;
import com.openai.models.responses.ResponseCreateParams;
import com.openai.models.responses.ResponseStreamEvent;
String endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1";
OpenAIClient openAIClient = OpenAIOkHttpClient.builder()
.baseUrl(endpoint)
.credential(AzureApiKeyCredential.create(System.getenv("AZURE_OPENAI_API_KEY")))
.build();
ResponseCreateParams params = ResponseCreateParams.builder()
.model("MODEL_NAME")
.input("This is a test")
.build();
try (StreamResponse<ResponseStreamEvent> stream = openAIClient.responses().createStreaming(params)) {
stream.stream()
.flatMap(event -> event.outputTextDelta().stream())
.forEach(delta -> System.out.print(delta.delta()));
}
curl -N -X POST https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses \
-H "Content-Type: application/json" \
-H "api-key: $AZURE_OPENAI_API_KEY" \
-d '{
"model": "MODEL_NAME",
"input": "Summarize Azure OpenAI Responses API in one sentence.",
"stream": true
}'
Als er tijdens het streamen een fout optreedt, probeert het systeem intern opnieuw om de fout op te lossen. Als de aanvraag nog steeds mislukt, treedt er een onherstelbare fout op. In deze gevallen is de HTTP-antwoordcode 200 (geslaagd), maar de fout gebeurtenis in de stream bevat details over de midstream-fouten.
De server retourneert de volgende fouttypen:
| Fouttype |
Kan worden vertaald als |
server_error |
Retourcode 500 |
too_many_requests |
Retourcode 429 |
forbidden |
Retourcode 403 |
user_error |
Retourcode 400 |
Voorbeeld van een foutgebeurtenis:
{
"type": "error",
"error": {
"type": "too_many_requests",
"code": "no_capacity",
"headers": {
"skip-error-remapping": "true"
},
"message": "The system is currently experiencing high demand and cannot process your request. Your request exceeds the maximum usage size allowed during peak load. For improved capacity reliability, consider switching to Provisioned Throughput.",
"param": null
}
}
Toepassingen moeten deze fouten detecteren en streaming probleemloos stoppen of opnieuw starten. Er worden geen kosten in rekening gebracht voor tokens die worden gegenereerd tijdens mislukte streamingantwoorden.
Gestructureerde uitvoer
Gebruik gestructureerde uitvoer om een antwoord te maken volgens een JSON-schema. Definieer in een antwoord-API-aanvraag het schema in text.format. Chat Completions gebruikt in plaats daarvan response_format. Zie Gestructureerde uitvoer voor voorbeelden van SDK en REST, ondersteunde schemabeperkingen en beperkingen.
Functie aanroepen
De Response-API biedt ondersteuning voor functie-aanroepen.
import os
import json
from openai import OpenAI
client = OpenAI(
base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
api_key=os.getenv("AZURE_OPENAI_API_KEY")
)
response = client.responses.create(
model="MODEL_NAME",
tools=[
{
"type": "function",
"name": "get_weather",
"description": "Get weather for a location",
"parameters": {
"type": "object",
"properties": {"location": {"type": "string"}},
"required": ["location"],
},
}
],
input="What is the weather in San Francisco?",
)
tool_outputs = []
for item in response.output:
if item.type == "function_call" and item.name == "get_weather":
args = json.loads(item.arguments)
weather = {"location": args["location"], "temperature": "70 F"}
tool_outputs.append(
{
"type": "function_call_output",
"call_id": item.call_id,
"output": json.dumps(weather),
}
)
final_response = client.responses.create(
model="MODEL_NAME",
previous_response_id=response.id,
input=tool_outputs,
)
print(final_response.output_text)
#pragma warning disable OPENAI001
using System.Text.Json;
using Azure.Identity;
using OpenAI.Responses;
using System.ClientModel.Primitives;
string endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1";
// API key authentication
ResponsesClient openAIClient = new(
credential: new ApiKeyCredential(Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY")!),
options: new ResponsesClientOptions { Endpoint = new Uri(endpoint) });
// Microsoft Entra ID authentication (recommended)
BearerTokenPolicy tokenPolicy = new(
new DefaultAzureCredential(),
"https://ai.azure.com/.default");
ResponsesClient openAIClientEntra = new(
authenticationPolicy: tokenPolicy,
options: new ResponsesClientOptions { Endpoint = new Uri(endpoint) });
FunctionTool getWeatherTool = ResponseTool.CreateFunctionTool(
functionName: "get_weather",
functionParameters: BinaryData.FromBytes("""
{
"type": "object",
"properties": {
"location": { "type": "string", "description": "The city, e.g. Boston, MA" }
},
"required": ["location"]
}
"""u8.ToArray()),
strictModeEnabled: false,
functionDescription: "Get the current weather for a location.");
CreateResponseOptions options = new()
{
Model = "MODEL_NAME",
InputItems = { ResponseItem.CreateUserMessageItem("What is the weather in San Francisco?") },
Tools = { getWeatherTool }
};
ResponseResult response = await openAIClient.CreateResponseAsync(options);
foreach (ResponseItem item in response.OutputItems)
{
if (item is FunctionCallResponseItem call && call.FunctionName == "get_weather")
{
using JsonDocument args = JsonDocument.Parse(call.FunctionArguments);
string location = args.RootElement.GetProperty("location").GetString();
string toolOutput = $"{{ \"location\": \"{location}\", \"temperature\": \"70 F\" }}";
CreateResponseOptions followUp = new()
{
Model = "MODEL_NAME",
PreviousResponseId = response.Id,
InputItems = { ResponseItem.CreateFunctionCallOutputItem(call.CallId, toolOutput) },
Tools = { getWeatherTool }
};
ResponseResult finalResponse = await openAIClient.CreateResponseAsync(followUp);
Console.WriteLine(finalResponse.GetOutputText());
}
}
import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
apiKey: process.env.AZURE_OPENAI_API_KEY,
});
const response = await client.responses.create({
model: "MODEL_NAME",
tools: [
{
type: "function",
name: "get_weather",
description: "Get weather for a location",
parameters: {
type: "object",
properties: { location: { type: "string" } },
required: ["location"],
},
},
],
input: "What is the weather in San Francisco?",
});
const toolOutputs = [];
for (const item of response.output ?? []) {
if (item.type === "function_call" && item.name === "get_weather") {
const args = JSON.parse(item.arguments);
toolOutputs.push({
type: "function_call_output",
call_id: item.call_id,
output: JSON.stringify({ location: args.location, temperature: "70 F" }),
});
}
}
const finalResponse = await client.responses.create({
model: "MODEL_NAME",
previous_response_id: response.id,
input: toolOutputs,
});
console.log(finalResponse.output_text);
import com.azure.identity.DefaultAzureCredentialBuilder;
import com.azure.identity.AuthenticationUtil;
import com.fasterxml.jackson.annotation.JsonPropertyDescription;
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.credential.BearerTokenCredential;
import com.openai.models.responses.Response;
import com.openai.models.responses.ResponseCreateParams;
import com.openai.models.responses.ResponseFunctionToolCall;
import com.openai.models.responses.ResponseInputItem;
import java.util.ArrayList;
import java.util.List;
String endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1";
OpenAIClient openAIClient = OpenAIOkHttpClient.builder()
.baseUrl(endpoint)
.credential(AzureApiKeyCredential.create(System.getenv("AZURE_OPENAI_API_KEY")))
.build();
// Strongly-typed function parameter class.
class GetWeather {
@JsonPropertyDescription("City and country, for example, Paris, France")
public String location;
}
Response response = openAIClient.responses().create(
ResponseCreateParams.builder()
.model("MODEL_NAME")
.input("What is the weather like in Paris today?")
.addTool(GetWeather.class)
.build());
List<ResponseInputItem> followUp = new ArrayList<>();
response.output().forEach(item -> {
if (item.isFunctionCall()) {
ResponseFunctionToolCall call = item.asFunctionCall();
// Execute the tool with call.arguments() and capture the result.
String result = "{\"temperature\":\"22 C\",\"conditions\":\"Sunny\"}";
followUp.add(ResponseInputItem.ofFunctionCallOutput(
ResponseInputItem.FunctionCallOutput.builder()
.callId(call.callId())
.output(result)
.build()));
}
});
Response finalResponse = openAIClient.responses().create(
ResponseCreateParams.builder()
.model("MODEL_NAME")
.previousResponseId(response.id())
.inputOfResponse(followUp)
.addTool(GetWeather.class)
.build());
System.out.println(finalResponse.outputText());
curl -X POST https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses \
-H "Content-Type: application/json" \
-H "api-key: $AZURE_OPENAI_API_KEY" \
-d '{
"model": "MODEL_NAME",
"tools": [
{
"type": "function",
"name": "get_weather",
"description": "Get weather for a location",
"parameters": {
"type": "object",
"properties": {"location": {"type": "string"}},
"required": ["location"]
}
}
],
"input": "What is the weather in San Francisco?"
}'
Veiligheidsmaatregelen en inhoudsfilters afhandelen
Pas vangrails (inhoudsfilters) toe op deploymentsniveau. Elke geconfigureerde beveiligingsmaatregel evalueert de ondersteunde inhoud en interventiepunten: filters voor kernschade evalueren invoer en uitvoer, detectie van aanvallen via gebruikersprompts evalueert gebruikersinvoer en documentaanvaldetectie evalueert documentinhoud wanneer ingeschakeld. Stel guardrails afzonderlijk in. Zie Kaders en controles configureren voor meer informatie. In deze sectie wordt uitgelegd hoe u guardrailresultaten kunt detecteren en afhandelen wanneer u de Responses API aanroept.
De Responses API presenteert guardrailresultaten op een andere manier dan chatcompletions. In plaats van de velden prompt_filter_results en content_filter_results die chataanvullingen teruggeven, bevat het responsobject een content_filters-array op het hoogste niveau. Elke vermelding beschrijft één filterresultaat.
| Veld |
Beschrijving |
blocked |
Of de inhoud is geblokkeerd. |
source_type |
Of het resultaat van toepassing is op de prompt (invoer) of de completion (uitvoer). |
content_filter_results |
De categorieresultaten, zoals hate, sexual, violence en self_harm met ernstniveaus, en optionele categorieën zoals jailbreak, indirect_attack, protected_material_text en protected_material_code. |
content_filter_offsets |
De tekenoffsets waarop het resultaat van toepassing is. |
Opmerking
De content_filters matrix is een Microsoft Foundry-extensie die geen deel uitmaakt van het openAI-basisantwoordschema, zodat de SDK's geen getypte eigenschap beschikbaar maken. Lees het veld als onbewerkt of extra veld, zoals wordt weergegeven in de volgende voorbeelden.
Wanneer kaders uw invoer blokkeren, retourneert de API een HTTP 400-fout met de code content_filter. Onderschep deze fout om geblokkeerde prompts netjes af te handelen.
import os
from openai import OpenAI, BadRequestError
client = OpenAI(
api_key=os.getenv("AZURE_OPENAI_API_KEY"),
base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
)
# A blocked prompt raises BadRequestError with the code "content_filter"
try:
response = client.responses.create(
model="MODEL_NAME",
input="This is a test."
)
print(response.output_text)
except BadRequestError as error:
if error.code == "content_filter":
print("The prompt was blocked by a guardrail.")
else:
raise
#pragma warning disable OPENAI001
using OpenAI.Responses;
using System.ClientModel;
using System.ClientModel.Primitives;
string endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1";
ResponsesClient openAIClient = new(
credential: new ApiKeyCredential(Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY")!),
options: new ResponsesClientOptions { Endpoint = new Uri(endpoint) });
CreateResponseOptions options = new()
{
Model = "MODEL_NAME",
InputItems = { ResponseItem.CreateUserMessageItem("This is a test.") }
};
// A blocked prompt throws ClientResultException with HTTP 400
try
{
ResponseResult response = await openAIClient.CreateResponseAsync(options);
Console.WriteLine(response.GetOutputText());
}
catch (ClientResultException error) when (error.Status == 400)
{
Console.WriteLine("The prompt was blocked by a guardrail.");
}
import { OpenAI, APIError } from "openai";
const openai = new OpenAI({
baseURL: "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
apiKey: process.env.AZURE_OPENAI_API_KEY,
});
// A blocked prompt throws APIError with the code "content_filter"
try {
const response = await openai.responses.create({
model: "MODEL_NAME",
input: "This is a test."
});
console.log(response.output_text);
} catch (error) {
if (error instanceof APIError && error.code === "content_filter") {
console.log("The prompt was blocked by a guardrail.");
} else {
throw error;
}
}
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.credential.AzureApiKeyCredential;
import com.openai.errors.BadRequestException;
import com.openai.models.responses.Response;
import com.openai.models.responses.ResponseCreateParams;
OpenAIClient openAIClient = OpenAIOkHttpClient.builder()
.baseUrl("https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1")
.credential(AzureApiKeyCredential.create(System.getenv("AZURE_OPENAI_API_KEY")))
.build();
ResponseCreateParams params = ResponseCreateParams.builder()
.model("MODEL_NAME")
.input("This is a test.")
.build();
// A blocked prompt throws BadRequestException (HTTP 400)
try {
Response response = openAIClient.responses().create(params);
System.out.println(response.outputText());
} catch (BadRequestException error) {
System.out.println("The prompt was blocked by a guardrail.");
}
curl -X POST https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses \
-H "Content-Type: application/json" \
-H "api-key: $AZURE_OPENAI_API_KEY" \
-d '{
"model": "MODEL_NAME",
"input": "This is a test."
}'
Wanneer kaders de invoer blokkeren, retourneert de API HTTP 400 met de code content_filter:
{
"error": {
"code": "content_filter",
"message": "The response was filtered due to the prompt triggering content management policy."
}
}
Annotaties van beveiligingsrails lezen
Wanneer een verzoek slaagt, lees dan de array content_filters in de respons om de guardrailresultaten voor de invoer en uitvoer te inspecteren.
In de annotatiemodus kunnen geconfigureerde controls ernstniveaus of detectieresultaten rapporteren zonder deze af te dwingen. De bijbehorende blocked- en filtered-waarden blijven false. Annotatiemodus voor de vier categorieën voor kernschade vereist goedkeuring voor gewijzigde Guardrails.
import os
from openai import OpenAI
client = OpenAI(
api_key=os.getenv("AZURE_OPENAI_API_KEY"),
base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
)
response = client.responses.create(
model="MODEL_NAME",
input="This is a test."
)
# content_filters is an Azure extension, so read it from model_extra
content_filters = response.model_extra.get("content_filters", [])
for result in content_filters:
print(f"Source: {result['source_type']}, Blocked: {result['blocked']}")
#pragma warning disable OPENAI001
using OpenAI.Responses;
using System.ClientModel;
using System.ClientModel.Primitives;
using System.Text.Json;
string endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1";
ResponsesClient openAIClient = new(
credential: new ApiKeyCredential(Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY")!),
options: new ResponsesClientOptions { Endpoint = new Uri(endpoint) });
CreateResponseOptions options = new()
{
Model = "MODEL_NAME",
InputItems = { ResponseItem.CreateUserMessageItem("This is a test.") }
};
// content_filters has no typed property, so parse it from the raw response
ClientResult<ResponseResult> result = await openAIClient.CreateResponseAsync(options);
using JsonDocument doc = JsonDocument.Parse(result.GetRawResponse().Content);
if (doc.RootElement.TryGetProperty("content_filters", out JsonElement filters))
{
foreach (JsonElement filter in filters.EnumerateArray())
{
string source = filter.GetProperty("source_type").GetString()!;
bool blocked = filter.GetProperty("blocked").GetBoolean();
Console.WriteLine($"Source: {source}, Blocked: {blocked}");
}
}
import { OpenAI } from "openai";
const openai = new OpenAI({
baseURL: "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
apiKey: process.env.AZURE_OPENAI_API_KEY,
});
const response = await openai.responses.create({
model: "MODEL_NAME",
input: "This is a test."
});
// content_filters is an Azure extension not in the typed response
const contentFilters = response.content_filters ?? [];
for (const result of contentFilters) {
console.log(`Source: ${result.source_type}, Blocked: ${result.blocked}`);
}
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.credential.AzureApiKeyCredential;
import com.openai.core.JsonValue;
import com.openai.models.responses.Response;
import com.openai.models.responses.ResponseCreateParams;
OpenAIClient openAIClient = OpenAIOkHttpClient.builder()
.baseUrl("https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1")
.credential(AzureApiKeyCredential.create(System.getenv("AZURE_OPENAI_API_KEY")))
.build();
ResponseCreateParams params = ResponseCreateParams.builder()
.model("MODEL_NAME")
.input("This is a test.")
.build();
Response response = openAIClient.responses().create(params);
// content_filters has no typed accessor, so read it from additional properties
JsonValue contentFilters = response._additionalProperties().get("content_filters");
System.out.println(contentFilters);
curl -X POST https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses \
-H "Content-Type: application/json" \
-H "api-key: $AZURE_OPENAI_API_KEY" \
-d '{
"model": "MODEL_NAME",
"input": "This is a test."
}'
De content_filters matrix wordt weergegeven op het antwoordobject:
{
"id": "resp_<id>",
"content_filters": [
{
"source_type": "prompt",
"blocked": false,
"content_filter_results": {
"hate": { "filtered": false, "severity": "safe" },
"self_harm": { "filtered": false, "severity": "safe" },
"sexual": { "filtered": false, "severity": "safe" },
"violence": { "filtered": false, "severity": "safe" }
}
}
]
}
Zie Overzicht van guardrails en Werken met annotaties voor meer informatie over guardrailcategorieën en ernstniveaus.
Code-interpreter
Met het hulpprogramma Code Interpreter kunnen modellen Python code schrijven en uitvoeren in een beveiligde, sandbox-omgeving. Het ondersteunt een reeks geavanceerde taken, waaronder:
- Bestanden verwerken met verschillende gegevensindelingen en structuren
- Bestanden genereren die gegevens en visualisaties bevatten (bijvoorbeeld grafieken)
- Iteratief code schrijven en uitvoeren om problemen op te lossen: modellen kunnen fouten opsporen en code opnieuw proberen totdat het lukt
- Visuele redenering in ondersteunde modellen verbeteren (bijvoorbeeld o3, o4-mini) door afbeeldingstransformaties in te schakelen, zoals bijsnijden, zoomen en draaien
- Dit hulpprogramma is vooral handig voor scenario's met betrekking tot gegevensanalyse, wiskundige berekening en het genereren van code.
curl -X POST https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses \
-H "Content-Type: application/json" \
-H "api-key: $AZURE_OPENAI_API_KEY" \
-d '{
"model": "MODEL_NAME",
"tools": [
{ "type": "code_interpreter", "container": {"type": "auto"} }
],
"instructions": "You are a personal math tutor. When asked a math question, write and run code using the python tool to answer the question.",
"input": "I need to solve the equation 3x + 11 = 14. Can you help me?"
}'
import os
from openai import OpenAI
client = OpenAI(
base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
api_key=os.getenv("AZURE_OPENAI_API_KEY")
)
response = client.responses.create(
model="MODEL_NAME",
tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
instructions="You are a math tutor. Write and run Python code to solve math problems.",
input="Solve 3x + 11 = 14."
)
print(response.output_text)
#pragma warning disable OPENAI001
using Azure.Identity;
using OpenAI.Containers;
using OpenAI.Responses;
using System.ClientModel.Primitives;
string endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1";
// API key authentication
ResponsesClient openAIClient = new(
credential: new ApiKeyCredential(Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY")!),
options: new ResponsesClientOptions { Endpoint = new Uri(endpoint) });
// Microsoft Entra ID authentication (recommended)
BearerTokenPolicy tokenPolicy = new(
new DefaultAzureCredential(),
"https://ai.azure.com/.default");
ResponsesClient openAIClientEntra = new(
authenticationPolicy: tokenPolicy,
options: new ResponsesClientOptions { Endpoint = new Uri(endpoint) });
CodeInterpreterToolContainer container = new(
CodeInterpreterToolContainerConfiguration.CreateAutomaticContainerConfiguration());
CodeInterpreterTool codeInterpreterTool = new(container);
CreateResponseOptions options = new()
{
Model = "MODEL_NAME",
InputItems =
{
ResponseItem.CreateUserMessageItem("Solve 3x + 11 = 14.")
},
Tools = { codeInterpreterTool }
};
ResponseResult response = await openAIClient.CreateResponseAsync(options);
Console.WriteLine(response.GetOutputText());
import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
apiKey: process.env.AZURE_OPENAI_API_KEY,
});
const response = await client.responses.create({
model: "MODEL_NAME",
tools: [{ type: "code_interpreter", container: { type: "auto" } }],
instructions: "You are a math tutor. Write and run Python code to solve math problems.",
input: "Solve 3x + 11 = 14.",
});
console.log(response.output_text);
import com.azure.identity.DefaultAzureCredentialBuilder;
import com.azure.identity.AuthenticationUtil;
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.credential.BearerTokenCredential;
import com.openai.models.responses.Response;
import com.openai.models.responses.ResponseCreateParams;
import com.openai.models.responses.Tool;
String endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1";
OpenAIClient openAIClient = OpenAIOkHttpClient.builder()
.baseUrl(endpoint)
.credential(AzureApiKeyCredential.create(System.getenv("AZURE_OPENAI_API_KEY")))
.build();
Tool codeInterpreter = Tool.ofCodeInterpreter(
Tool.CodeInterpreter.builder()
.container(Tool.CodeInterpreter.Container.ofCodeInterpreterToolAuto(
Tool.CodeInterpreter.Container.CodeInterpreterToolAuto.builder().build()))
.build());
Response response = openAIClient.responses().create(
ResponseCreateParams.builder()
.model("MODEL_NAME")
.input("Solve 3x + 11 = 14.")
.addTool(codeInterpreter)
.build());
System.out.println(response.outputText());
curl -X POST https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses \
-H "Content-Type: application/json" \
-H "api-key: $AZURE_OPENAI_API_KEY" \
-d '{
"model": "MODEL_NAME",
"tools": [{"type": "code_interpreter", "container": {"type": "auto"}}],
"instructions": "You are a math tutor. Write and run Python code to solve math problems.",
"input": "Solve 3x + 11 = 14."
}'
Containers
Belangrijk
Code-interpreter heeft extra kosten naast de token-gebaseerde kosten voor Azure OpenAI-gebruik. Als de Response-API code-interpreter tegelijkertijd aanroept in twee verschillende threads, worden er twee Code Interpreter-sessies gemaakt. Voor elke sessie worden kosten per minuut in rekening gebracht, met een minimale kosten van vijf minuten. Een sessie blijft actief zolang u de container benadert binnen de inactiviteitstime-out van 20 minuten.
Het hulpprogramma Code Interpreter vereist een container: een volledig in de sandbox geplaatste virtuele machine waar het model Python code kan uitvoeren. Containers kunnen geüploade bestanden of bestanden bevatten die tijdens de uitvoering zijn gegenereerd.
Als u een container wilt maken, geeft u "container": { "type": "auto", "file_ids": ["file-1", "file-2"] } op in de configuratie van het hulpprogramma bij het maken van een nieuw antwoordobject. Hiermee wordt automatisch een nieuwe container gemaakt of wordt een actieve container opnieuw gebruikt op basis van een eerdere code_interpreter_call in de context van het model. De code_interpreter_call in de uitvoer van de API zal de container_id bevatten die is gegenereerd. Deze container verloopt als deze gedurende 20 minuten niet wordt gebruikt.
De volgende bestandslimieten zijn van toepassing:
- Een aanvraag kan maximaal 50 bestands-id's bevatten.
- Een container kan in totaal maximaal 1000 bestanden bevatten, inclusief invoerbestanden en bestanden die zijn gegenereerd door code-interpreter.
Bij het uitvoeren van code-interpreter kan het model zijn eigen bestanden maken. Als u bijvoorbeeld vraagt om een plot te maken of een CSV te maken, worden deze afbeeldingen rechtstreeks in uw container gemaakt. Deze bestanden worden in de aantekeningen van het volgende bericht weergegeven.
Bestanden in de modelinvoer worden automatisch geüpload naar de container. U hoeft deze niet expliciet te uploaden naar de container.
Ondersteunde bestanden
| Bestandsindeling |
MIME-type |
.c |
tekst/x-c |
.cs |
text/x-csharp |
.cpp |
text/x-c++ |
.csv |
text/csv |
.doc |
application/msword |
.docx |
application/vnd.openxmlformats-officedocument.wordprocessingml.document |
.html |
text/html |
.java |
text/x-java |
.json |
application/json |
.md |
text/markdown |
.pdf |
application/pdf |
.php |
text/x-php |
.pptx |
application/vnd.openxmlformats-officedocument.presentationml.presentation |
.py |
text/x-python |
.py |
text/x-script.python |
.rb |
text/x-ruby |
.tex |
tekst/x-tex |
.txt |
platte tekst |
.css |
text/css |
.js |
text/JavaScript |
.sh |
application/x-sh |
.ts |
toepassing/TypeScript |
.csv |
application/csv |
.jpeg |
afbeelding/jpeg |
.jpg |
afbeelding/jpeg |
.gif |
image/gif |
.pkl |
application/octet-stream |
.png |
image/png |
.tar |
application/x-tar |
.xlsx |
application/vnd.openxmlformats-officedocument.spreadsheetml.sheet |
.xml |
application/xml of "text/xml" |
.zip |
toepassing/zip |
Haal de invoeritems op die naar een antwoord zijn verzonden. Dit is handig voor het inspecteren van de volledige gesprekscontext, inclusief alle items die door het model worden toegevoegd (bijvoorbeeld functie-aanroepen of compressie-items).
import os
from openai import OpenAI
client = OpenAI(
base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
api_key=os.getenv("AZURE_OPENAI_API_KEY")
)
items = client.responses.input_items.list("<response_id>")
print(items.model_dump_json(indent=2))
Opmerking
De .NET SDK maakt dit eindpunt alleen beschikbaar als protocolmethode. Zie het REST-tabblad voor de aanroepindeling, of gebruik de protocolmethode rechtstreeks.
import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
apiKey: process.env.AZURE_OPENAI_API_KEY,
});
const items = await client.responses.inputItems.list("<response_id>");
console.log(JSON.stringify(items, null, 2));
import com.azure.identity.DefaultAzureCredentialBuilder;
import com.azure.identity.AuthenticationUtil;
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.credential.BearerTokenCredential;
import com.openai.models.responses.inputitems.ResponseInputItemListPage;
import com.openai.models.responses.inputitems.ResponseInputItemListParams;
String endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1";
OpenAIClient openAIClient = OpenAIOkHttpClient.builder()
.baseUrl(endpoint)
.credential(AzureApiKeyCredential.create(System.getenv("AZURE_OPENAI_API_KEY")))
.build();
ResponseInputItemListPage page = openAIClient.responses().inputItems().list(
ResponseInputItemListParams.builder()
.responseId("<response_id>")
.build());
page.autoPager().stream().forEach(item -> System.out.println(item));
curl -X GET https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses/<response_id>/input_items \
-H "Content-Type: application/json" \
-H "api-key: $AZURE_OPENAI_API_KEY"
Voorbeeld van een antwoord
{
"object": "list",
"data": [
{
"id": "msg_...",
"type": "message",
"role": "user",
"content": [{"type": "input_text", "text": "This is a test."}]
}
]
}
Vision-modellen kunnen afbeeldingen naast tekst interpreteren. Ze kunnen objecten, vormen, kleuren en patronen herkennen en tekst lezen in een afbeelding, afhankelijk van de beperkingen die verderop in dit artikel worden vermeld.
U kunt een afbeelding als invoer opgeven voor een aanvraag op een van de volgende manieren:
- Een volledig gekwalificeerde URL naar een afbeeldingsbestand
- Een met Base64 gecodeerde gegevens-URI
- Een bestands-id die is gemaakt met de Files-API
Afbeeldings-URL
Verwijs naar een image die wordt gehost op een openbare URL. Het model haalt de afbeelding op en bevat deze als onderdeel van de invoerinhoud.
import os
from openai import OpenAI
client = OpenAI(
base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
api_key=os.getenv("AZURE_OPENAI_API_KEY")
)
response = client.responses.create(
model="MODEL_NAME",
input=[
{
"role": "user",
"content": [
{"type": "input_text", "text": "What is in this image?"},
{"type": "input_image", "image_url": "<image_url>"}
]
}
]
)
print(response.output_text)
#pragma warning disable OPENAI001
using Azure.Identity;
using OpenAI.Responses;
using System.ClientModel.Primitives;
string endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1";
// API key authentication
ResponsesClient openAIClient = new(
credential: new ApiKeyCredential(Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY")!),
options: new ResponsesClientOptions { Endpoint = new Uri(endpoint) });
// Microsoft Entra ID authentication (recommended)
BearerTokenPolicy tokenPolicy = new(
new DefaultAzureCredential(),
"https://ai.azure.com/.default");
ResponsesClient openAIClientEntra = new(
authenticationPolicy: tokenPolicy,
options: new ResponsesClientOptions { Endpoint = new Uri(endpoint) });
CreateResponseOptions options = new()
{
Model = "MODEL_NAME",
InputItems =
{
ResponseItem.CreateUserMessageItem(
[
ResponseContentPart.CreateInputTextPart("What is in this image?"),
ResponseContentPart.CreateInputImagePart(new Uri("<image_url>"))
])
}
};
ResponseResult response = await openAIClient.CreateResponseAsync(options);
Console.WriteLine(response.GetOutputText());
import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
apiKey: process.env.AZURE_OPENAI_API_KEY,
});
const response = await client.responses.create({
model: "MODEL_NAME",
input: [
{
role: "user",
content: [
{ type: "input_text", text: "What is in this image?" },
{ type: "input_image", image_url: "<image_url>" }
],
},
],
});
console.log(response.output_text);
import com.azure.identity.DefaultAzureCredentialBuilder;
import com.azure.identity.AuthenticationUtil;
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.credential.BearerTokenCredential;
import com.openai.models.responses.Response;
import com.openai.models.responses.ResponseCreateParams;
import com.openai.models.responses.ResponseInputImage;
import com.openai.models.responses.ResponseInputItem;
import java.util.List;
String endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1";
OpenAIClient openAIClient = OpenAIOkHttpClient.builder()
.baseUrl(endpoint)
.credential(AzureApiKeyCredential.create(System.getenv("AZURE_OPENAI_API_KEY")))
.build();
ResponseInputImage image = ResponseInputImage.builder()
.detail(ResponseInputImage.Detail.AUTO)
.imageUrl("<image_url>")
.build();
ResponseInputItem userMsg = ResponseInputItem.ofMessage(
ResponseInputItem.Message.builder()
.role(ResponseInputItem.Message.Role.USER)
.addInputTextContent("What is in this image?")
.addContent(image)
.build());
Response response = openAIClient.responses().create(
ResponseCreateParams.builder()
.model("MODEL_NAME")
.inputOfResponse(List.of(userMsg))
.build());
System.out.println(response.outputText());
curl -X POST https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses \
-H "Content-Type: application/json" \
-H "api-key: $AZURE_OPENAI_API_KEY" \
-d '{
"model": "MODEL_NAME",
"input": [
{
"role": "user",
"content": [
{"type": "input_text", "text": "What is in this image?"},
{"type": "input_image", "image_url": "<image_url>"}
]
}
]
}'
Base64-gecodeerde afbeelding
Verstuur een afbeelding inline door de bytes ervan te coderen als een base64-data-URI. Gebruik dit patroon wanneer de afbeelding niet op een openbare URL wordt gehost of wanneer u een extra netwerkaanvraag wilt vermijden.
import base64
import os
from openai import OpenAI
client = OpenAI(
base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
api_key=os.getenv("AZURE_OPENAI_API_KEY")
)
with open("path_to_your_image.jpg", "rb") as image_file:
base64_image = base64.b64encode(image_file.read()).decode("utf-8")
response = client.responses.create(
model="MODEL_NAME",
input=[
{
"role": "user",
"content": [
{"type": "input_text", "text": "What is in this image?"},
{"type": "input_image", "image_url": f"data:image/jpeg;base64,{base64_image}"}
]
}
]
)
print(response.output_text)
#pragma warning disable OPENAI001
using System.IO;
using System.Threading.Tasks;
using Azure.Identity;
using OpenAI.Responses;
using System.ClientModel.Primitives;
string endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1";
// API key authentication
ResponsesClient openAIClient = new(
credential: new ApiKeyCredential(Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY")!),
options: new ResponsesClientOptions { Endpoint = new Uri(endpoint) });
// Microsoft Entra ID authentication (recommended)
BearerTokenPolicy tokenPolicy = new(
new DefaultAzureCredential(),
"https://ai.azure.com/.default");
ResponsesClient openAIClientEntra = new(
authenticationPolicy: tokenPolicy,
options: new ResponsesClientOptions { Endpoint = new Uri(endpoint) });
byte[] imageBytes = await File.ReadAllBytesAsync("path_to_your_image.jpg");
BinaryData imageData = BinaryData.FromBytes(imageBytes);
CreateResponseOptions options = new()
{
Model = "MODEL_NAME",
InputItems =
{
ResponseItem.CreateUserMessageItem(
[
ResponseContentPart.CreateInputTextPart("What is in this image?"),
ResponseContentPart.CreateInputImagePart(imageData, "image/jpeg")
])
}
};
ResponseResult response = await openAIClient.CreateResponseAsync(options);
Console.WriteLine(response.GetOutputText());
import { readFileSync } from "node:fs";
import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
apiKey: process.env.AZURE_OPENAI_API_KEY,
});
const base64Image = readFileSync("path_to_your_image.jpg").toString("base64");
const response = await client.responses.create({
model: "MODEL_NAME",
input: [
{
role: "user",
content: [
{ type: "input_text", text: "What is in this image?" },
{ type: "input_image", image_url: `data:image/jpeg;base64,${base64Image}` }
],
},
],
});
console.log(response.output_text);
import com.azure.identity.DefaultAzureCredentialBuilder;
import com.azure.identity.AuthenticationUtil;
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.credential.BearerTokenCredential;
import com.openai.models.responses.Response;
import com.openai.models.responses.ResponseCreateParams;
import com.openai.models.responses.ResponseInputImage;
import com.openai.models.responses.ResponseInputItem;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Base64;
import java.util.List;
String endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1";
OpenAIClient openAIClient = OpenAIOkHttpClient.builder()
.baseUrl(endpoint)
.credential(AzureApiKeyCredential.create(System.getenv("AZURE_OPENAI_API_KEY")))
.build();
byte[] bytes = Files.readAllBytes(Paths.get("cat.jpg"));
String dataUrl = "data:image/jpeg;base64," + Base64.getEncoder().encodeToString(bytes);
ResponseInputImage image = ResponseInputImage.builder()
.detail(ResponseInputImage.Detail.AUTO)
.imageUrl(dataUrl)
.build();
ResponseInputItem userMsg = ResponseInputItem.ofMessage(
ResponseInputItem.Message.builder()
.role(ResponseInputItem.Message.Role.USER)
.addInputTextContent("What is in this image?")
.addContent(image)
.build());
Response response = openAIClient.responses().create(
ResponseCreateParams.builder()
.model("MODEL_NAME")
.inputOfResponse(List.of(userMsg))
.build());
System.out.println(response.outputText());
curl -X POST https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses \
-H "Content-Type: application/json" \
-H "api-key: $AZURE_OPENAI_API_KEY" \
-d '{
"model": "MODEL_NAME",
"input": [
{
"role": "user",
"content": [
{"type": "input_text", "text": "What is in this image?"},
{"type": "input_image", "image_url": "data:image/jpeg;base64,<BASE64_IMAGE>"}
]
}
]
}'
Bestands-ID
Upload een afbeelding met de Files-API met behulp van purpose="assistants"en verwijs vervolgens naar de geretourneerde bestands-id in uw aanvraag. Deze aanpak is handig wanneer u dezelfde afbeelding voor meerdere verzoeken wilt hergebruiken zonder de bytes opnieuw te hoeven verzenden.
import os
from openai import OpenAI
client = OpenAI(
base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
api_key=os.getenv("AZURE_OPENAI_API_KEY")
)
def create_file(file_path):
with open(file_path, "rb") as file_content:
result = client.files.create(
file=file_content,
purpose="assistants",
)
return result.id
file_id = create_file("path_to_your_image.jpg")
response = client.responses.create(
model="MODEL_NAME",
input=[
{
"role": "user",
"content": [
{"type": "input_text", "text": "What is in this image?"},
{"type": "input_image", "file_id": file_id},
],
}
],
)
print(response.output_text)
#pragma warning disable OPENAI001
using System.IO;
using System.Threading.Tasks;
using Azure.Identity;
using OpenAI;
using OpenAI.Files;
using OpenAI.Responses;
using System.ClientModel;
using System.ClientModel.Primitives;
string endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1";
// API key authentication
ResponsesClient openAIClient = new(
credential: new ApiKeyCredential(Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY")!),
options: new ResponsesClientOptions { Endpoint = new Uri(endpoint) });
OpenAIFileClient fileClient = new(
credential: new ApiKeyCredential(Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY")!),
options: new OpenAIClientOptions { Endpoint = new Uri(endpoint) });
// Microsoft Entra ID authentication (recommended)
BearerTokenPolicy tokenPolicy = new(
new DefaultAzureCredential(),
"https://ai.azure.com/.default");
ResponsesClient openAIClientEntra = new(
authenticationPolicy: tokenPolicy,
options: new ResponsesClientOptions { Endpoint = new Uri(endpoint) });
byte[] imageBytes = await File.ReadAllBytesAsync("path_to_your_image.jpg");
OpenAIFile uploadedFile = await fileClient.UploadFileAsync(
BinaryData.FromBytes(imageBytes),
"path_to_your_image.jpg",
FileUploadPurpose.Assistants);
CreateResponseOptions options = new()
{
Model = "MODEL_NAME",
InputItems =
{
ResponseItem.CreateUserMessageItem(
[
ResponseContentPart.CreateInputTextPart("What is in this image?"),
ResponseContentPart.CreateInputImagePart(uploadedFile.Id)
])
}
};
ResponseResult response = await openAIClient.CreateResponseAsync(options);
Console.WriteLine(response.GetOutputText());
import fs from "node:fs";
import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
apiKey: process.env.AZURE_OPENAI_API_KEY,
});
const file = await client.files.create({
file: fs.createReadStream("path_to_your_image.jpg"),
purpose: "assistants",
});
const response = await client.responses.create({
model: "MODEL_NAME",
input: [
{
role: "user",
content: [
{ type: "input_text", text: "What is in this image?" },
{ type: "input_image", file_id: file.id },
],
},
],
});
console.log(response.output_text);
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.credential.AzureApiKeyCredential;
import com.openai.models.files.FileCreateParams;
import com.openai.models.files.FileObject;
import com.openai.models.files.FilePurpose;
import com.openai.models.responses.Response;
import com.openai.models.responses.ResponseCreateParams;
import com.openai.models.responses.ResponseInputImage;
import com.openai.models.responses.ResponseInputItem;
import java.nio.file.Paths;
import java.util.List;
String endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1";
OpenAIClient openAIClient = OpenAIOkHttpClient.builder()
.baseUrl(endpoint)
.credential(AzureApiKeyCredential.create(System.getenv("AZURE_OPENAI_API_KEY")))
.build();
FileObject uploaded = openAIClient.files().create(
FileCreateParams.builder()
.file(Paths.get("path_to_your_image.jpg"))
.purpose(FilePurpose.ASSISTANTS)
.build());
ResponseInputImage image = ResponseInputImage.builder()
.detail(ResponseInputImage.Detail.AUTO)
.fileId(uploaded.id())
.build();
ResponseInputItem userMsg = ResponseInputItem.ofMessage(
ResponseInputItem.Message.builder()
.role(ResponseInputItem.Message.Role.USER)
.addInputTextContent("What is in this image?")
.addContent(image)
.build());
Response response = openAIClient.responses().create(
ResponseCreateParams.builder()
.model("MODEL_NAME")
.inputOfResponse(List.of(userMsg))
.build());
System.out.println(response.outputText());
# Upload the image
curl -X POST https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/files \
-H "api-key: $AZURE_OPENAI_API_KEY" \
-F purpose="assistants" \
-F file="@path_to_your_image.jpg"
# Use the returned file ID with Responses
curl -X POST https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses \
-H "Content-Type: application/json" \
-H "api-key: $AZURE_OPENAI_API_KEY" \
-d '{
"model": "MODEL_NAME",
"input": [
{
"role": "user",
"content": [
{"type": "input_text", "text": "What is in this image?"},
{"type": "input_image", "file_id": "<file_id>"}
]
}
]
}'
De volgende tabel bevat de ondersteunde bestandstypen voor afbeeldingsinvoer.
| Bestandstype |
MIME-type |
| PNG |
image/png |
| JPEG |
image/jpeg |
| WebP |
image/webp |
| Niet-geanimeerde GIF |
image/gif |
In één aanvraag kunt u maximaal 50 afbeeldingen opnemen. Elk afzonderlijk afbeeldingsbestand moet kleiner zijn dan 512 MB en de gecombineerde grootte van de prompt, inclusief alle afbeeldingen in de aanvraag, moet ook kleiner zijn dan 512 MB.
Afbeeldingen moeten voldoen aan deze aanvullende vereisten:
- De afbeelding moet relevant zijn voor de prompt; het model is niet ontworpen voor niet-gerelateerde visuele inhoud.
- Afbeeldingen mogen geen schadelijke of gevoelige inhoud bevatten die in strijd is met het inhoudsbeleid.
- Afbeeldingsbestanden kunnen niet beschadigd of onleesbaar zijn. Als het model een afbeelding niet kan verwerken, mislukt de aanvraag.
Een afbeeldingsdetailniveau kiezen
Gebruik de detail eigenschap in een input_image inhoudsonderdeel om te bepalen hoe het model de afbeelding verwerkt. Minder detail gebruikt minder tokens en is sneller, terwijl meer detail meer tokens gebruikt, maar het model in staat stelt fijnere kenmerken vast te leggen.
{
"type": "input_image",
"image_url": "<image_url>",
"detail": "high"
}
In de volgende tabel wordt elk detailniveau beschreven.
| Detailniveau |
Beschrijving |
low |
Het model gebruikt een versie van de afbeelding met een lagere resolutie. Deze optie maakt gebruik van de minste tokens en produceert het snelste antwoord, maar het model mist mogelijk gedetailleerde details. |
high |
Het model maakt gebruik van een versie van de afbeelding met een hogere resolutie. Met deze optie worden gedetailleerdere details vastgelegd, maar worden meer tokens gebruikt en duurt het langer om te reageren. |
auto |
De standaardwaarde. Het model selecteert het juiste detailniveau op basis van de afbeelding en de prompt. |
Modellen met beeldverwerking hebben de volgende beperkingen:
-
Medische afbeeldingen: Het model is niet geschikt voor het interpreteren van gespecialiseerde medische afbeeldingen zoals CT-scans en mag niet worden gebruikt voor medisch advies.
-
Niet-Engelse tekst: Het model presteert mogelijk niet optimaal bij het verwerken van afbeeldingen die tekst bevatten in niet-Latijnse alfabetten, zoals Japans of Koreaans.
-
Kleine tekst: Vergroot tekst in een afbeelding om de leesbaarheid te verbeteren, maar vermijd het bijsnijden van belangrijke details.
-
Rotatie: Het model kan gedraaide of ondersteboven staande tekst en afbeeldingen mogelijk verkeerd interpreteren.
-
Visuele elementen: Het model kan moeite hebben met grafieken of tekst waarbij kleuren of stijlen, zoals effen, stippellijnen of stippellijnen, variëren.
-
Ruimtelijke redenering: Het model heeft moeite met taken waarvoor nauwkeurige ruimtelijke lokalisatie is vereist, zoals het identificeren van schaakposities.
-
Nauwkeurigheid: Het model kan in sommige gevallen onjuiste beschrijvingen of bijschriften genereren.
-
Afbeeldingsvorm: Het model heeft problemen met panoramische en fisheye-afbeeldingen.
-
Metagegevens en het formaat wijzigen: het model verwerkt geen oorspronkelijke bestandsnamen of metagegevens en afbeeldingen worden vóór analyse gewijzigd, wat van invloed is op de oorspronkelijke afmetingen.
-
Tellen: Het model kan geschatte aantallen geven voor objecten in afbeeldingen.
-
CAPTCHAs: Om veiligheidsredenen is een systeem aanwezig om het indienen van CAPTCHA's te blokkeren.
Modellen met vision-mogelijkheden ondersteunen PDF-invoer. U kunt een PDF-bestand op een van de volgende manieren opgeven:
- Base64-gecodeerde gegevens
- Een bestands-id die is gemaakt met de Files-API
- Een URL van een extern bestand (
file_url)
Om modellen te helpen PDF-inhoud te interpreteren, bevat de context van het model zowel de geëxtraheerde tekst als een afbeelding van elke pagina. Deze functie is handig wanneer belangrijke informatie wordt overgebracht via diagrammen of niet-tekstuele inhoud.
Opmerking
- Alle geëxtraheerde tekst en afbeeldingen worden in de context van het model geplaatst. Zorg ervoor dat u de gevolgen van het gebruik van prijzen en tokens begrijpt voor het gebruik van PDF-bestanden als invoer.
- In één API-aanvraag kunt u meer dan één bestand opnemen, maar elk bestand moet kleiner zijn dan 50 MB. De gecombineerde limiet voor alle bestanden in de aanvraag is 50 MB.
- Alleen modellen die zowel tekst- als afbeeldingsinvoer ondersteunen, kunnen PDF-bestanden als invoer accepteren.
- Een
purpose van user_data wordt momenteel niet ondersteund. Als tijdelijke oplossing moet u het doel instellen op assistants.
PDF converteren naar Base64 en analyseren
Verzend een PDF inline door de bytes te coderen naar een base64-data-URI. Het model ontvangt zowel de geëxtraheerde tekst als een gerenderde afbeelding van elke pagina.
import base64
import os
from openai import OpenAI
client = OpenAI(
base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
api_key=os.getenv("AZURE_OPENAI_API_KEY")
)
with open("PDF-FILE-NAME.pdf", "rb") as f:
base64_string = base64.b64encode(f.read()).decode("utf-8")
response = client.responses.create(
model="MODEL_NAME",
input=[
{
"role": "user",
"content": [
{
"type": "input_file",
"filename": "PDF-FILE-NAME.pdf",
"file_data": f"data:application/pdf;base64,{base64_string}",
},
{"type": "input_text", "text": "Summarize this PDF."},
],
},
]
)
print(response.output_text)
#pragma warning disable OPENAI001
using System.IO;
using System.Threading.Tasks;
using Azure.Identity;
using OpenAI.Responses;
using System.ClientModel.Primitives;
string endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1";
// API key authentication
ResponsesClient openAIClient = new(
credential: new ApiKeyCredential(Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY")!),
options: new ResponsesClientOptions { Endpoint = new Uri(endpoint) });
// Microsoft Entra ID authentication (recommended)
BearerTokenPolicy tokenPolicy = new(
new DefaultAzureCredential(),
"https://ai.azure.com/.default");
ResponsesClient openAIClientEntra = new(
authenticationPolicy: tokenPolicy,
options: new ResponsesClientOptions { Endpoint = new Uri(endpoint) });
byte[] pdfBytes = await File.ReadAllBytesAsync("PDF-FILE-NAME.pdf");
BinaryData pdfData = BinaryData.FromBytes(pdfBytes);
CreateResponseOptions options = new()
{
Model = "MODEL_NAME",
InputItems =
{
ResponseItem.CreateUserMessageItem(
[
ResponseContentPart.CreateInputFilePart(pdfData, "application/pdf", "PDF-FILE-NAME.pdf"),
ResponseContentPart.CreateInputTextPart("Summarize this PDF.")
])
}
};
ResponseResult response = await openAIClient.CreateResponseAsync(options);
Console.WriteLine(response.GetOutputText());
import { readFileSync } from "node:fs";
import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
apiKey: process.env.AZURE_OPENAI_API_KEY,
});
const base64Pdf = readFileSync("PDF-FILE-NAME.pdf").toString("base64");
const response = await client.responses.create({
model: "MODEL_NAME",
input: [
{
role: "user",
content: [
{
type: "input_file",
filename: "PDF-FILE-NAME.pdf",
file_data: `data:application/pdf;base64,${base64Pdf}`,
},
{ type: "input_text", text: "Summarize this PDF." },
],
},
],
});
console.log(response.output_text);
import com.azure.identity.DefaultAzureCredentialBuilder;
import com.azure.identity.AuthenticationUtil;
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.credential.BearerTokenCredential;
import com.openai.models.responses.Response;
import com.openai.models.responses.ResponseCreateParams;
import com.openai.models.responses.ResponseInputFile;
import com.openai.models.responses.ResponseInputItem;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Base64;
import java.util.List;
String endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1";
OpenAIClient openAIClient = OpenAIOkHttpClient.builder()
.baseUrl(endpoint)
.credential(AzureApiKeyCredential.create(System.getenv("AZURE_OPENAI_API_KEY")))
.build();
byte[] pdfBytes = Files.readAllBytes(Paths.get("document.pdf"));
String dataUrl = "data:application/pdf;base64," + Base64.getEncoder().encodeToString(pdfBytes);
ResponseInputFile file = ResponseInputFile.builder()
.filename("document.pdf")
.fileData(dataUrl)
.build();
ResponseInputItem userMsg = ResponseInputItem.ofMessage(
ResponseInputItem.Message.builder()
.role(ResponseInputItem.Message.Role.USER)
.addInputTextContent("Summarize this PDF.")
.addContent(file)
.build());
Response response = openAIClient.responses().create(
ResponseCreateParams.builder()
.model("MODEL_NAME")
.inputOfResponse(List.of(userMsg))
.build());
System.out.println(response.outputText());
curl -X POST https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses \
-H "Content-Type: application/json" \
-H "api-key: $AZURE_OPENAI_API_KEY" \
-d '{
"model": "MODEL_NAME",
"input": [
{
"role": "user",
"content": [
{"type": "input_file", "filename": "PDF-FILE-NAME.pdf", "file_data": "data:application/pdf;base64,<BASE64_PDF>"},
{"type": "input_text", "text": "Summarize this PDF."}
]
}
]
}'
PDF uploaden en analyseren
Upload het PDF-bestand met purpose="assistants". Een purpose van user_data wordt momenteel niet ondersteund.
import os
from openai import OpenAI
client = OpenAI(
base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
api_key=os.getenv("AZURE_OPENAI_API_KEY")
)
file = client.files.create(
file=open("nucleus_sampling.pdf", "rb"),
purpose="assistants"
)
response = client.responses.create(
model="MODEL_NAME",
input=[
{
"role": "user",
"content": [
{"type": "input_file", "file_id": file.id},
{"type": "input_text", "text": "Summarize this PDF."},
],
},
]
)
print(response.output_text)
#pragma warning disable OPENAI001
using System.IO;
using System.Threading.Tasks;
using Azure.Identity;
using OpenAI;
using OpenAI.Files;
using OpenAI.Responses;
using System.ClientModel;
using System.ClientModel.Primitives;
string endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1";
// API key authentication
ResponsesClient openAIClient = new(
credential: new ApiKeyCredential(Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY")!),
options: new ResponsesClientOptions { Endpoint = new Uri(endpoint) });
OpenAIFileClient fileClient = new(
credential: new ApiKeyCredential(Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY")!),
options: new OpenAIClientOptions { Endpoint = new Uri(endpoint) });
// Microsoft Entra ID authentication (recommended)
BearerTokenPolicy tokenPolicy = new(
new DefaultAzureCredential(),
"https://ai.azure.com/.default");
ResponsesClient openAIClientEntra = new(
authenticationPolicy: tokenPolicy,
options: new ResponsesClientOptions { Endpoint = new Uri(endpoint) });
byte[] pdfBytes = await File.ReadAllBytesAsync("nucleus_sampling.pdf");
OpenAIFile uploadedFile = await fileClient.UploadFileAsync(
BinaryData.FromBytes(pdfBytes),
"nucleus_sampling.pdf",
FileUploadPurpose.Assistants);
CreateResponseOptions options = new()
{
Model = "MODEL_NAME",
InputItems =
{
ResponseItem.CreateUserMessageItem(
[
ResponseContentPart.CreateInputFilePart(uploadedFile.Id),
ResponseContentPart.CreateInputTextPart("Summarize this PDF.")
])
}
};
ResponseResult response = await openAIClient.CreateResponseAsync(options);
Console.WriteLine(response.GetOutputText());
import fs from "node:fs";
import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
apiKey: process.env.AZURE_OPENAI_API_KEY,
});
const file = await client.files.create({
file: fs.createReadStream("nucleus_sampling.pdf"),
purpose: "assistants",
});
const response = await client.responses.create({
model: "MODEL_NAME",
input: [
{
role: "user",
content: [
{ type: "input_file", file_id: file.id },
{ type: "input_text", text: "Summarize this PDF." },
],
},
],
});
console.log(response.output_text);
import com.azure.identity.DefaultAzureCredentialBuilder;
import com.azure.identity.AuthenticationUtil;
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.credential.BearerTokenCredential;
import com.openai.models.files.FileCreateParams;
import com.openai.models.files.FileObject;
import com.openai.models.files.FilePurpose;
import com.openai.models.responses.Response;
import com.openai.models.responses.ResponseCreateParams;
import com.openai.models.responses.ResponseInputFile;
import com.openai.models.responses.ResponseInputItem;
import java.nio.file.Paths;
import java.util.List;
String endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1";
OpenAIClient openAIClient = OpenAIOkHttpClient.builder()
.baseUrl(endpoint)
.credential(AzureApiKeyCredential.create(System.getenv("AZURE_OPENAI_API_KEY")))
.build();
FileObject uploaded = openAIClient.files().create(
FileCreateParams.builder()
.file(Paths.get("document.pdf"))
.purpose(FilePurpose.ASSISTANTS)
.build());
ResponseInputFile file = ResponseInputFile.builder()
.fileId(uploaded.id())
.build();
ResponseInputItem userMsg = ResponseInputItem.ofMessage(
ResponseInputItem.Message.builder()
.role(ResponseInputItem.Message.Role.USER)
.addInputTextContent("Summarize this PDF.")
.addContent(file)
.build());
Response response = openAIClient.responses().create(
ResponseCreateParams.builder()
.model("MODEL_NAME")
.inputOfResponse(List.of(userMsg))
.build());
System.out.println(response.outputText());
# Upload the PDF
curl -X POST https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/files \
-H "api-key: $AZURE_OPENAI_API_KEY" \
-F purpose="assistants" \
-F file="@your_file.pdf"
# Use the returned file ID with Responses
curl -X POST https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses \
-H "Content-Type: application/json" \
-H "api-key: $AZURE_OPENAI_API_KEY" \
-d '{
"model": "MODEL_NAME",
"input": [
{
"role": "user",
"content": [
{"type": "input_file", "file_id": "<file_id>"},
{"type": "input_text", "text": "Summarize this PDF."}
]
}
]
}'
Een PDF analyseren op basis van een URL van een extern bestand
Verwijs naar een PDF die wordt gehost op een openbaar toegankelijke URL met behulp van de file_url eigenschap van een input_file inhoudsitem. U hoeft het bestand niet eerst te downloaden, coderen of uploaden.
import os
from openai import OpenAI
client = OpenAI(
base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
api_key=os.getenv("AZURE_OPENAI_API_KEY")
)
response = client.responses.create(
model="MODEL_NAME",
input=[
{
"role": "user",
"content": [
{
"type": "input_text",
"text": "Analyze the letter and provide a summary of the key points.",
},
{
"type": "input_file",
"file_url": "https://www.berkshirehathaway.com/letters/2024ltr.pdf",
},
],
},
]
)
print(response.output_text)
#pragma warning disable OPENAI001
using Azure.Identity;
using OpenAI.Responses;
using System.ClientModel.Primitives;
string endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1";
// API key authentication
ResponsesClient openAIClient = new(
credential: new ApiKeyCredential(Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY")!),
options: new ResponsesClientOptions { Endpoint = new Uri(endpoint) });
// Microsoft Entra ID authentication (recommended)
BearerTokenPolicy tokenPolicy = new(
new DefaultAzureCredential(),
"https://ai.azure.com/.default");
ResponsesClient openAIClientEntra = new(
authenticationPolicy: tokenPolicy,
options: new ResponsesClientOptions { Endpoint = new Uri(endpoint) });
CreateResponseOptions options = new()
{
Model = "MODEL_NAME",
InputItems =
{
ResponseItem.CreateUserMessageItem(
[
ResponseContentPart.CreateInputTextPart("Analyze the letter and provide a summary of the key points."),
ResponseContentPart.CreateInputFilePart(new Uri("https://www.berkshirehathaway.com/letters/2024ltr.pdf"))
])
}
};
ResponseResult response = await openAIClient.CreateResponseAsync(options);
Console.WriteLine(response.GetOutputText());
import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
apiKey: process.env.AZURE_OPENAI_API_KEY,
});
const response = await client.responses.create({
model: "MODEL_NAME",
input: [
{
role: "user",
content: [
{
type: "input_text",
text: "Analyze the letter and provide a summary of the key points.",
},
{
type: "input_file",
file_url: "https://www.berkshirehathaway.com/letters/2024ltr.pdf",
},
],
},
],
});
console.log(response.output_text);
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.responses.Response;
import com.openai.models.responses.ResponseCreateParams;
import com.openai.models.responses.ResponseInputFile;
import com.openai.models.responses.ResponseInputItem;
import java.util.List;
String endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1";
OpenAIClient openAIClient = OpenAIOkHttpClient.builder()
.baseUrl(endpoint)
.credential(AzureApiKeyCredential.create(System.getenv("AZURE_OPENAI_API_KEY")))
.build();
ResponseInputFile file = ResponseInputFile.builder()
.fileUrl("https://www.berkshirehathaway.com/letters/2024ltr.pdf")
.build();
ResponseInputItem userMsg = ResponseInputItem.ofMessage(
ResponseInputItem.Message.builder()
.role(ResponseInputItem.Message.Role.USER)
.addInputTextContent("Analyze the letter and provide a summary of the key points.")
.addContent(file)
.build());
Response response = openAIClient.responses().create(
ResponseCreateParams.builder()
.model("MODEL_NAME")
.inputOfResponse(List.of(userMsg))
.build());
System.out.println(response.outputText());
curl -X POST https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses \
-H "Content-Type: application/json" \
-H "api-key: $AZURE_OPENAI_API_KEY" \
-d '{
"model": "MODEL_NAME",
"input": [
{
"role": "user",
"content": [
{
"type": "input_text",
"text": "Analyze the letter and provide a summary of the key points."
},
{
"type": "input_file",
"file_url": "https://www.berkshirehathaway.com/letters/2024ltr.pdf"
}
]
}
]
}'
Externe MCP-servers gebruiken
U kunt de mogelijkheden van uw model uitbreiden door het te verbinden met hulpprogramma's die worden gehost op MCP-servers (Remote Model Context Protocol). Deze servers worden onderhouden door ontwikkelaars en organisaties en maken hulpprogramma's beschikbaar die toegankelijk zijn voor MCP-compatibele clients, zoals de Antwoorden-API.
Model Context Protocol (MCP) is een open standaard die definieert hoe toepassingen hulpprogramma's en contextuele gegevens bieden aan grote taalmodellen (LLM's). Het maakt consistente, schaalbare integratie van externe hulpprogramma's mogelijk in modelwerkstromen.
In het volgende voorbeeld ziet u hoe u een externe MCP-server gebruikt om informatie op te vragen over een Azure REST API-opslagplaats. Het model haalt repository-inhoud in realtime op en redeneert erover.
import os
from openai import OpenAI
client = OpenAI(
base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
api_key=os.getenv("AZURE_OPENAI_API_KEY")
)
response = client.responses.create(
model="MODEL_NAME",
tools=[
{
"type": "mcp",
"server_label": "github",
"server_url": "https://contoso.com/Azure/azure-rest-api-specs",
"require_approval": "never"
}
],
input="What transport protocols are supported in the 2025-03-26 version of the MCP spec?"
)
print(response.output_text)
#pragma warning disable OPENAI001
using Azure.Identity;
using OpenAI.Responses;
using System.ClientModel.Primitives;
string endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1";
// API key authentication
ResponsesClient openAIClient = new(
credential: new ApiKeyCredential(Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY")!),
options: new ResponsesClientOptions { Endpoint = new Uri(endpoint) });
// Microsoft Entra ID authentication (recommended)
BearerTokenPolicy tokenPolicy = new(
new DefaultAzureCredential(),
"https://ai.azure.com/.default");
ResponsesClient openAIClientEntra = new(
authenticationPolicy: tokenPolicy,
options: new ResponsesClientOptions { Endpoint = new Uri(endpoint) });
CreateResponseOptions options = new()
{
Model = "MODEL_NAME",
InputItems = { ResponseItem.CreateUserMessageItem("What transport protocols are supported in the 2025-03-26 version of the MCP spec?") },
Tools =
{
new McpTool(serverLabel: "github", serverUri: new Uri("https://contoso.com/Azure/azure-rest-api-specs"))
{
ToolCallApprovalPolicy = GlobalMcpToolCallApprovalPolicy.NeverRequireApproval
}
}
};
ResponseResult response = await openAIClient.CreateResponseAsync(options);
Console.WriteLine(response.GetOutputText());
import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
apiKey: process.env.AZURE_OPENAI_API_KEY,
});
const response = await client.responses.create({
model: "MODEL_NAME",
tools: [
{
type: "mcp",
server_label: "github",
server_url: "https://contoso.com/Azure/azure-rest-api-specs",
require_approval: "never",
},
],
input: "What is this repo in 100 words?",
});
console.log(response.output_text);
import com.azure.identity.DefaultAzureCredentialBuilder;
import com.azure.identity.AuthenticationUtil;
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.credential.BearerTokenCredential;
import com.openai.models.responses.Response;
import com.openai.models.responses.ResponseCreateParams;
import com.openai.models.responses.Tool;
String endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1";
OpenAIClient openAIClient = OpenAIOkHttpClient.builder()
.baseUrl(endpoint)
.credential(AzureApiKeyCredential.create(System.getenv("AZURE_OPENAI_API_KEY")))
.build();
Tool mcpTool = Tool.ofMcp(
Tool.Mcp.builder()
.serverLabel("github")
.serverUrl("https://contoso.com/Azure/azure-rest-api-specs")
.requireApproval(Tool.Mcp.RequireApproval.ofMcpToolApprovalSetting(
Tool.Mcp.RequireApproval.McpToolApprovalSetting.NEVER))
.build());
Response response = openAIClient.responses().create(
ResponseCreateParams.builder()
.model("MODEL_NAME")
.input("What is this repo in 100 words?")
.addTool(mcpTool)
.build());
System.out.println(response.outputText());
curl -X POST https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses \
-H "Content-Type: application/json" \
-H "api-key: $AZURE_OPENAI_API_KEY" \
-d '{
"model": "MODEL_NAME",
"tools": [
{
"type": "mcp",
"server_label": "github",
"server_url": "https://contoso.com/Azure/azure-rest-api-specs",
"require_approval": "never"
}
],
"input": "What is this repo in 100 words?"
}'
Het MCP-hulpprogramma werkt alleen in de Antwoorden-API en is beschikbaar voor alle nieuwere modellen (gpt-4o, gpt-4.1 en onze redeneringsmodellen). Wanneer u het MCP-hulpprogramma gebruikt, betaalt u alleen voor tokens die worden gebruikt bij het importeren van hulpprogrammadefinities of het maken van hulpprogramma-aanroepen. Er zijn geen extra kosten verbonden.
Goedkeuringen
De Antwoorden-API vereist standaard expliciete goedkeuring voordat gegevens worden gedeeld met een externe MCP-server. Deze goedkeuringsstap zorgt voor transparantie en geeft u controle over welke informatie extern wordt verzonden.
We raden u aan alle gegevens te controleren die worden gedeeld met externe MCP-servers en deze eventueel te registreren voor controledoeleinden.
Wanneer een goedkeuring is vereist, retourneert het model een mcp_approval_request item in de antwoorduitvoer. Dit object bevat de details van de aanvraag die in behandeling is en stelt u in staat om de gegevens te inspecteren of te wijzigen voordat u doorgaat.
{
"id": "mcpr_682bd9cd428c8198b170dc6b549d66fc016e86a03f4cc828",
"type": "mcp_approval_request",
"arguments": {},
"name": "fetch_azure_rest_api_docs",
"server_label": "github"
}
Als u wilt doorgaan met de externe MCP-aanroep, moet u reageren op de goedkeuringsaanvraag door een nieuw antwoordobject te maken dat een mcp_approval_response item bevat. Dit object bevestigt uw intentie zodat het model de opgegeven gegevens naar de externe MCP-server kan verzenden.
import os
from openai import OpenAI
client = OpenAI(
base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
api_key=os.getenv("AZURE_OPENAI_API_KEY")
)
response = client.responses.create(
model="MODEL_NAME",
tools=[
{
"type": "mcp",
"server_label": "github",
"server_url": "https://contoso.com/Azure/azure-rest-api-specs",
"require_approval": "never"
}
],
previous_response_id="<previous_response_id>",
input=[
{
"type": "mcp_approval_response",
"approve": True,
"approval_request_id": "<approval_request_id>"
}
]
)
print(response.output_text)
#pragma warning disable OPENAI001
using Azure.Identity;
using OpenAI.Responses;
using System.ClientModel.Primitives;
string endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1";
// API key authentication
ResponsesClient openAIClient = new(
credential: new ApiKeyCredential(Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY")!),
options: new ResponsesClientOptions { Endpoint = new Uri(endpoint) });
// Microsoft Entra ID authentication (recommended)
BearerTokenPolicy tokenPolicy = new(
new DefaultAzureCredential(),
"https://ai.azure.com/.default");
ResponsesClient openAIClientEntra = new(
authenticationPolicy: tokenPolicy,
options: new ResponsesClientOptions { Endpoint = new Uri(endpoint) });
McpTool mcpTool = new(serverLabel: "github", serverUri: new Uri("https://contoso.com/Azure/azure-rest-api-specs"));
ResponseResult priorResponse = await openAIClient.GetResponseAsync("<previous_response_id>");
foreach (ResponseItem item in priorResponse.OutputItems)
{
if (item is McpToolCallApprovalRequestItem approvalRequest)
{
CreateResponseOptions followUp = new()
{
Model = "MODEL_NAME",
PreviousResponseId = priorResponse.Id,
InputItems = { new McpToolCallApprovalResponseItem(approvalRequest.Id, approved: true) },
Tools = { mcpTool }
};
ResponseResult finalResponse = await openAIClient.CreateResponseAsync(followUp);
Console.WriteLine(finalResponse.GetOutputText());
}
}
import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
apiKey: process.env.AZURE_OPENAI_API_KEY,
});
const response = await client.responses.create({
model: "MODEL_NAME",
tools: [
{
type: "mcp",
server_label: "github",
server_url: "https://contoso.com/Azure/azure-rest-api-specs",
require_approval: "never",
},
],
previous_response_id: "<previous_response_id>",
input: [
{
type: "mcp_approval_response",
approve: true,
approval_request_id: "<approval_request_id>",
},
],
});
console.log(response.output_text);
import com.azure.identity.DefaultAzureCredentialBuilder;
import com.azure.identity.AuthenticationUtil;
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.credential.BearerTokenCredential;
import com.openai.models.responses.Response;
import com.openai.models.responses.ResponseCreateParams;
import com.openai.models.responses.ResponseInputItem;
import java.util.List;
String endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1";
OpenAIClient openAIClient = OpenAIOkHttpClient.builder()
.baseUrl(endpoint)
.credential(AzureApiKeyCredential.create(System.getenv("AZURE_OPENAI_API_KEY")))
.build();
Response response = openAIClient.responses().create(
ResponseCreateParams.builder()
.model("MODEL_NAME")
.previousResponseId("<previous_response_id>")
.inputOfResponse(List.of(
ResponseInputItem.ofMcpApprovalResponse(
ResponseInputItem.McpApprovalResponse.builder()
.approvalRequestId("<approval_request_id>")
.approve(true)
.build())))
.build());
System.out.println(response.outputText());
curl -X POST https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses \
-H "Content-Type: application/json" \
-H "api-key: $AZURE_OPENAI_API_KEY" \
-d '{
"model": "MODEL_NAME",
"tools": [
{
"type": "mcp",
"server_label": "github",
"server_url": "https://contoso.com/Azure/azure-rest-api-specs",
"require_approval": "never"
}
],
"previous_response_id": "<previous_response_id>",
"input": [
{
"type": "mcp_approval_response",
"approve": true,
"approval_request_id": "<approval_request_id>"
}
]
}'
Verificatie
Belangrijk
- Voor de MCP-client in de antwoorden-API is TLS 1.2 of hoger vereist.
- Wederzijdse TLS (mTLS) wordt momenteel niet ondersteund.
-
Azure servicetags worden momenteel niet ondersteund voor MCP-clientverkeer.
In tegenstelling tot de GitHub MCP-server vereisen de meeste externe MCP-servers verificatie. Het MCP-hulpprogramma in de antwoorden-API ondersteunt aangepaste headers, zodat u veilig verbinding kunt maken met deze servers met behulp van het verificatieschema dat ze nodig hebben.
U kunt headers opgeven, zoals API-sleutels, OAuth-toegangstokens of andere referenties, rechtstreeks in uw aanvraag. De meest gebruikte header is de Authorization header.
import os
from openai import OpenAI
client = OpenAI(
base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
api_key=os.getenv("AZURE_OPENAI_API_KEY")
)
response = client.responses.create(
model="MODEL_NAME",
input="What is this repo in 100 words?",
tools=[
{
"type": "mcp",
"server_label": "github",
"server_url": "https://contoso.com/Azure/azure-rest-api-specs",
"headers": {"Authorization": "Bearer $YOUR_MCP_TOKEN"}
}
]
)
print(response.output_text)
#pragma warning disable OPENAI001
using Azure.Identity;
using OpenAI.Responses;
using System.ClientModel.Primitives;
string endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1";
// API key authentication
ResponsesClient openAIClient = new(
credential: new ApiKeyCredential(Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY")!),
options: new ResponsesClientOptions { Endpoint = new Uri(endpoint) });
// Microsoft Entra ID authentication (recommended)
BearerTokenPolicy tokenPolicy = new(
new DefaultAzureCredential(),
"https://ai.azure.com/.default");
ResponsesClient openAIClientEntra = new(
authenticationPolicy: tokenPolicy,
options: new ResponsesClientOptions { Endpoint = new Uri(endpoint) });
CreateResponseOptions options = new()
{
Model = "MODEL_NAME",
InputItems = { ResponseItem.CreateUserMessageItem("What is this repo in 100 words?") },
Tools =
{
new McpTool(serverLabel: "github", serverUri: new Uri("https://contoso.com/Azure/azure-rest-api-specs"))
{
AuthorizationToken = Environment.GetEnvironmentVariable("YOUR_MCP_TOKEN"),
ToolCallApprovalPolicy = GlobalMcpToolCallApprovalPolicy.NeverRequireApproval
}
}
};
ResponseResult response = await openAIClient.CreateResponseAsync(options);
Console.WriteLine(response.GetOutputText());
import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
apiKey: process.env.AZURE_OPENAI_API_KEY,
});
const response = await client.responses.create({
model: "MODEL_NAME",
input: "What is this repo in 100 words?",
tools: [
{
type: "mcp",
server_label: "github",
server_url: "https://contoso.com/Azure/azure-rest-api-specs",
headers: { Authorization: "Bearer $YOUR_MCP_TOKEN" },
},
],
});
console.log(response.output_text);
import com.azure.identity.DefaultAzureCredentialBuilder;
import com.azure.identity.AuthenticationUtil;
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.core.JsonValue;
import com.openai.credential.BearerTokenCredential;
import com.openai.models.responses.Response;
import com.openai.models.responses.ResponseCreateParams;
import com.openai.models.responses.Tool;
String endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1";
OpenAIClient openAIClient = OpenAIOkHttpClient.builder()
.baseUrl(endpoint)
.credential(AzureApiKeyCredential.create(System.getenv("AZURE_OPENAI_API_KEY")))
.build();
Tool mcpTool = Tool.ofMcp(
Tool.Mcp.builder()
.serverLabel("github")
.serverUrl("https://contoso.com/Azure/azure-rest-api-specs")
.headers(Tool.Mcp.Headers.builder()
.putAdditionalProperty("Authorization", JsonValue.from("Bearer $YOUR_MCP_TOKEN"))
.build())
.requireApproval(Tool.Mcp.RequireApproval.ofMcpToolApprovalSetting(
Tool.Mcp.RequireApproval.McpToolApprovalSetting.NEVER))
.build());
Response response = openAIClient.responses().create(
ResponseCreateParams.builder()
.model("MODEL_NAME")
.input("What is this repo in 100 words?")
.addTool(mcpTool)
.build());
System.out.println(response.outputText());
curl -X POST https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses \
-H "Content-Type: application/json" \
-H "api-key: $AZURE_OPENAI_API_KEY" \
-d '{
"model": "MODEL_NAME",
"input": "What is this repo in 100 words?",
"tools": [
{
"type": "mcp",
"server_label": "github",
"server_url": "https://contoso.com/Azure/azure-rest-api-specs",
"headers": {"Authorization": "Bearer $YOUR_MCP_TOKEN"}
}
]
}'
Achtergrondtaken
Met de achtergrondmodus kunt u langlopende taken asynchroon uitvoeren met redeneringsmodellen zoals o3 en o1-pro. Het is handig voor complexe taken die enkele minuten kunnen duren (bijvoorbeeld Codex- of Deep Research-agents). Wanneer een verzoek met "background": true wordt verzonden, wordt de taak asynchroon verwerkt en vraagt u de status ervan op.
Een achtergrondtaak starten
Stel background=true in voor het verzoek, zodat de taak in de wachtrij wordt geplaatst. De service wordt onmiddellijk geretourneerd met een antwoord-id en een queued status. Gebruik deze id om de taak te peilen, te streamen of te annuleren.
import os
from openai import OpenAI
client = OpenAI(
base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
api_key=os.getenv("AZURE_OPENAI_API_KEY")
)
response = client.responses.create(
model="MODEL_NAME",
input="Write me a very long story.",
background=True
)
print(response.status)
#pragma warning disable OPENAI001
using Azure.Identity;
using OpenAI.Responses;
using System.ClientModel.Primitives;
string endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1";
// API key authentication
ResponsesClient openAIClient = new(
credential: new ApiKeyCredential(Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY")!),
options: new ResponsesClientOptions { Endpoint = new Uri(endpoint) });
// Microsoft Entra ID authentication (recommended)
BearerTokenPolicy tokenPolicy = new(
new DefaultAzureCredential(),
"https://ai.azure.com/.default");
ResponsesClient openAIClientEntra = new(
authenticationPolicy: tokenPolicy,
options: new ResponsesClientOptions { Endpoint = new Uri(endpoint) });
CreateResponseOptions options = new()
{
Model = "MODEL_NAME",
InputItems = { ResponseItem.CreateUserMessageItem("Write me a very long story.") },
BackgroundModeEnabled = true
};
ResponseResult queued = await openAIClient.CreateResponseAsync(options);
Console.WriteLine($"Response id: {queued.Id}");
Console.WriteLine($"Status: {queued.Status}");
import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
apiKey: process.env.AZURE_OPENAI_API_KEY,
});
const response = await client.responses.create({
model: "MODEL_NAME",
input: "Write me a very long story.",
background: true,
});
console.log(response.status);
import com.azure.identity.DefaultAzureCredentialBuilder;
import com.azure.identity.AuthenticationUtil;
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.credential.BearerTokenCredential;
import com.openai.models.responses.Response;
import com.openai.models.responses.ResponseCreateParams;
String endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1";
OpenAIClient openAIClient = OpenAIOkHttpClient.builder()
.baseUrl(endpoint)
.credential(AzureApiKeyCredential.create(System.getenv("AZURE_OPENAI_API_KEY")))
.build();
Response response = openAIClient.responses().create(
ResponseCreateParams.builder()
.model("MODEL_NAME")
.input("Write a 1000-word essay on the history of computing.")
.background(true)
.build());
System.out.println(response.status());
curl -X POST https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses \
-H "Content-Type: application/json" \
-H "api-key: $AZURE_OPENAI_API_KEY" \
-d '{
"model": "MODEL_NAME",
"input": "Write me a very long story.",
"background": true
}'
Peiling voor voltooiing
Blijf polling uitvoeren zolang de status queued of in_progress is. Zodra het antwoord de terminalstatus heeft bereikt, is het beschikbaar voor het ophalen.
from time import sleep
while response.status in {"queued", "in_progress"}:
print(f"Current status: {response.status}")
sleep(2)
response = client.responses.retrieve(response.id)
print(f"Final status: {response.status}\nOutput:\n{response.output_text}")
#pragma warning disable OPENAI001
using System.Threading.Tasks;
using Azure.Identity;
using OpenAI.Responses;
using System.ClientModel.Primitives;
string endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1";
// API key authentication
ResponsesClient openAIClient = new(
credential: new ApiKeyCredential(Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY")!),
options: new ResponsesClientOptions { Endpoint = new Uri(endpoint) });
// Microsoft Entra ID authentication (recommended)
BearerTokenPolicy tokenPolicy = new(
new DefaultAzureCredential(),
"https://ai.azure.com/.default");
ResponsesClient openAIClientEntra = new(
authenticationPolicy: tokenPolicy,
options: new ResponsesClientOptions { Endpoint = new Uri(endpoint) });
ResponseResult current = await openAIClient.GetResponseAsync("<response_id>");
while (current.Status == ResponseStatus.Queued || current.Status == ResponseStatus.InProgress)
{
Console.WriteLine($"Current status: {current.Status}");
await Task.Delay(TimeSpan.FromSeconds(2));
current = await openAIClient.GetResponseAsync(current.Id);
}
Console.WriteLine($"Final status: {current.Status}");
if (current.Status == ResponseStatus.Completed)
{
Console.WriteLine(current.GetOutputText());
}
let current = response;
while (current.status === "queued" || current.status === "in_progress") {
console.log(`Current status: ${current.status}`);
await new Promise((r) => setTimeout(r, 2000));
current = await client.responses.retrieve(current.id);
}
console.log(`Final status: ${current.status}\nOutput:\n${current.output_text}`);
import com.azure.identity.DefaultAzureCredentialBuilder;
import com.azure.identity.AuthenticationUtil;
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.credential.BearerTokenCredential;
import com.openai.models.responses.Response;
String endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1";
OpenAIClient openAIClient = OpenAIOkHttpClient.builder()
.baseUrl(endpoint)
.credential(AzureApiKeyCredential.create(System.getenv("AZURE_OPENAI_API_KEY")))
.build();
Response current = openAIClient.responses().retrieve("<response_id>");
while (current.status().filter(s ->
s.equals(Response.Status.QUEUED) || s.equals(Response.Status.IN_PROGRESS)).isPresent()) {
System.out.println("Current status: " + current.status());
Thread.sleep(2000);
current = openAIClient.responses().retrieve(current.id());
}
System.out.println("Final status: " + current.status());
System.out.println("Output:\n" + current.outputText());
curl -X GET https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses/<response_id> \
-H "Content-Type: application/json" \
-H "api-key: $AZURE_OPENAI_API_KEY"
Een achtergrondtaak annuleren
Annuleer een lopende achtergrondtaak via het cancel-eindpunt. Annuleren is idempotent. Volgende aanroepen retourneren het uiteindelijke antwoordobject.
response = client.responses.cancel("<response_id>")
print(response.status)
#pragma warning disable OPENAI001
using Azure.Identity;
using OpenAI.Responses;
using System.ClientModel.Primitives;
string endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1";
// API key authentication
ResponsesClient openAIClient = new(
credential: new ApiKeyCredential(Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY")!),
options: new ResponsesClientOptions { Endpoint = new Uri(endpoint) });
// Microsoft Entra ID authentication (recommended)
BearerTokenPolicy tokenPolicy = new(
new DefaultAzureCredential(),
"https://ai.azure.com/.default");
ResponsesClient openAIClientEntra = new(
authenticationPolicy: tokenPolicy,
options: new ResponsesClientOptions { Endpoint = new Uri(endpoint) });
ResponseResult cancelled = await openAIClient.CancelResponseAsync("<response_id>");
Console.WriteLine($"Status: {cancelled.Status}");
const cancelled = await client.responses.cancel("<response_id>");
console.log(cancelled.status);
import com.azure.identity.DefaultAzureCredentialBuilder;
import com.azure.identity.AuthenticationUtil;
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.credential.BearerTokenCredential;
import com.openai.models.responses.Response;
String endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1";
OpenAIClient openAIClient = OpenAIOkHttpClient.builder()
.baseUrl(endpoint)
.credential(AzureApiKeyCredential.create(System.getenv("AZURE_OPENAI_API_KEY")))
.build();
Response cancelled = openAIClient.responses().cancel("<response_id>");
System.out.println(cancelled.status());
curl -X POST https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses/<response_id>/cancel \
-H "Content-Type: application/json" \
-H "api-key: $AZURE_OPENAI_API_KEY"
Als u een achtergrondantwoord wilt streamen, stelt u zowel background als stream in op true. Met dit patroon kunt u streaming hervatten als de verbinding afneemt. Houd uw positie bij met de sequence_number uit elke gebeurtenis.
stream = client.responses.create(
model="MODEL_NAME",
input="Write me a very long story.",
background=True,
stream=True,
)
cursor = None
for event in stream:
print(event)
cursor = event["sequence_number"]
#pragma warning disable OPENAI001
using Azure.Identity;
using OpenAI.Responses;
using System.ClientModel.Primitives;
string endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1";
// API key authentication
ResponsesClient openAIClient = new(
credential: new ApiKeyCredential(Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY")!),
options: new ResponsesClientOptions { Endpoint = new Uri(endpoint) });
// Microsoft Entra ID authentication (recommended)
BearerTokenPolicy tokenPolicy = new(
new DefaultAzureCredential(),
"https://ai.azure.com/.default");
ResponsesClient openAIClientEntra = new(
authenticationPolicy: tokenPolicy,
options: new ResponsesClientOptions { Endpoint = new Uri(endpoint) });
CreateResponseOptions createOptions = new()
{
Model = "MODEL_NAME",
InputItems = { ResponseItem.CreateUserMessageItem("Write me a very long story.") },
BackgroundModeEnabled = true,
StreamingEnabled = true
};
string queuedResponseId = null;
int lastSequenceNumber = 0;
await foreach (StreamingResponseUpdate update in openAIClient.CreateResponseStreamingAsync(createOptions))
{
if (update is StreamingResponseQueuedUpdate queuedUpdate)
{
queuedResponseId = queuedUpdate.Response.Id;
lastSequenceNumber = queuedUpdate.SequenceNumber;
Console.WriteLine($"Queued response: {queuedResponseId}, sequence {lastSequenceNumber}");
break;
}
}
// Resume streaming from where we disconnected.
GetResponseOptions resumeOptions = new(queuedResponseId)
{
StartingAfter = lastSequenceNumber,
StreamingEnabled = true
};
await foreach (StreamingResponseUpdate update in openAIClient.GetResponseStreamingAsync(resumeOptions))
{
Console.WriteLine(update.GetType().Name);
if (update is StreamingResponseCompletedUpdate completed)
{
Console.WriteLine($"[done] final id: {completed.Response.Id}");
}
}
const stream = await client.responses.create({
model: "MODEL_NAME",
input: "Write me a very long story.",
background: true,
stream: true,
});
let cursor = null;
for await (const event of stream) {
console.log(event);
cursor = event.sequence_number;
}
import com.azure.identity.DefaultAzureCredentialBuilder;
import com.azure.identity.AuthenticationUtil;
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.core.http.StreamResponse;
import com.openai.credential.BearerTokenCredential;
import com.openai.models.responses.ResponseRetrieveParams;
import com.openai.models.responses.ResponseStreamEvent;
String endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1";
OpenAIClient openAIClient = OpenAIOkHttpClient.builder()
.baseUrl(endpoint)
.credential(AzureApiKeyCredential.create(System.getenv("AZURE_OPENAI_API_KEY")))
.build();
long cursor = 0L;
try (StreamResponse<ResponseStreamEvent> stream = openAIClient.responses().retrieveStreaming(
"<response_id>",
ResponseRetrieveParams.builder().startingAfter(cursor).build())) {
stream.stream().forEach(event -> System.out.println(event));
}
curl -N -X POST https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses \
-H "Content-Type: application/json" \
-H "api-key: $AZURE_OPENAI_API_KEY" \
-d '{
"model": "MODEL_NAME",
"input": "Write me a very long story.",
"background": true,
"stream": true
}'
Achtergrondantwoorden hebben momenteel een hogere tijd-tot-eerste-token latentie dan synchrone antwoorden. Er worden verbeteringen doorgevoerd om deze kloof te verminderen.
Beperkingen
- Voor de achtergrondmodus is vereist
store=true. Staatloze aanvragen worden niet ondersteund.
- U kunt streaming alleen hervatten als het oorspronkelijke verzoek
stream=true bevat.
- Als u een synchrone reactie wilt annuleren, beëindigt u de verbinding rechtstreeks.
Streaming hervatten vanaf een specifiek punt
Als een streamingverbinding wegvalt, kunt u vanaf een bekende gebeurtenis hervatten door stream=true samen met starting_after=<sequence_number> mee te geven met het GET-antwoord. De service speelt gebeurtenissen die na dat sequentienummer zijn gegenereerd opnieuw af.
curl -N -X GET "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses/<response_id>?stream=true&starting_after=42" \
-H "Content-Type: application/json" \
-H "api-key: $AZURE_OPENAI_API_KEY"
Versleutelde reasoning
Wanneer u een redeneringsmodel gebruikt met de Responses API in de stateless-modus (store=false), levert uw toepassing de context voor elke volgende aanvraag. Eerdere berichten bieden gespreksgeschiedenis, maar bevatten geen interne redenering van het model. Met een versleuteld redeneringsitem kunt u compatibele redeneringscontext naar een latere aanvraag overbrengen zonder deze redenering als leesbare tekst aan uw toepassing bloot te leggen.
Waarom versleutelde redenering gebruiken?
Gebruik versleutelde redenering wanneer uw toepassing de gespreksstatus beheert en een multi-turn-redeneringsworkflow moet voortzetten. Een gebruiker kan bijvoorbeeld een vervolgvraag stellen, of het model kan een hulpprogramma aanroepen en vervolgens doorgaan na ontvangst van het resultaat.
Het doorgeven van eerdere berichten alleen geeft niet de redeneringscontext van het model uit de vorige beurt door. Een versleuteld redeneringsitem neemt die context mee, terwijl de inhoud onleesbaar blijft voor uw applicatie.
Het gebruik ervan
- Stel
store=falsein. Als u expliciet versleutelde redenering wilt aanvragen, voegt u deze toe reasoning.encrypted_content aan de include parameter, zoals wordt weergegeven in de volgende voorbeelden.
- Bewaar alle geretourneerde uitvoeritems in de oorspronkelijke volgorde, inclusief redeneringsitems met een
encrypted_content eigenschap.
- Neem in het volgende gesprek deze items samen met de andere relevante gespreksitems op in
input en blijf store=false instellen. Gebruik dit niet previous_response_id voor een niet-opgeslagen respons.
Staatloze antwoorden retourneren standaard versleutelde inhoud; de include parameter blijft ondersteund voor compatibiliteit. Het opnieuw afspelen van een item maakt compatibel redeneren mogelijk, maar welke redenering het model gebruikt, is afhankelijk van de ondersteunde modus voor redeneercontext. Zie Redenering behouden tussen aanroepen voor meer informatie.
In de staatloze modus wordt het versleutelde redeneringsitem geretourneerd naar uw applicatie. Uw toepassing is verantwoordelijk voor het veilig bewaren en doorgeven ervan bij een volgende aanvraag. Kies een opslaglocatie aan de toepassingszijde die voldoet aan uw vereisten voor beveiliging en levenscyclus.
In de volgende codevoorbeelden wordt verificatie met API-sleutels gebruikt. De Python voorbeelden gebruiken de OpenAI-clientbibliotheek. In de andere voorbeelden wordt het Responses REST-endpoint rechtstreeks aangeroepen en de volledige uitvoeritems als JSON behouden.
Installeer de afhankelijkheden voor uw taal:
-
Python: installeer de client met
pip install --upgrade openai.
-
C#: Gebruik een consoletoepassing met .NET 8 of hoger. Er zijn geen extra pakketten vereist.
-
JavaScript: gebruik Node.js 18 of hoger en sla elk voorbeeld op als een
.mjs bestand. Er zijn geen extra pakketten vereist.
-
Java: gebruik JDK 17 of hoger en voeg de Maven-afhankelijkheid
com.fasterxml.jackson.core:jackson-databind:2.22.4toe. Sla elk voorbeeldbestand op met de bestandsnaam die wordt weergegeven in het bijbehorende tabblad.
-
REST: Voer de PowerShell-voorbeelden uit met PowerShell 7 of hoger.
Stel deze omgevingsvariabelen in voor elke taal:
-
AZURE_OPENAI_ENDPOINT: uw resource-eindpunt, zoals https://YOUR-RESOURCE-NAME.openai.azure.com.
-
AZURE_OPENAI_API_KEY: uw API-sleutel.
-
AZURE_OPENAI_DEPLOYMENT: De naam van een ondersteunde deployment van een redeneermodel.
Beide voorbeelden controleren op een versleuteld redeneringsitem en genereren een fout als er geen wordt geretourneerd. Gebruik een deployment- en redeneringsconfiguratie die redeneringsitems produceert voor de voorbeeldaanvragen.
Een stateless gesprek voortzetten
In dit voorbeeld worden de geretourneerde items in een door de toepassing beheerde lijst bewaard en doorgegeven aan een opvolgingsaanvraag.
import os
from openai import BadRequestError, OpenAI
client = OpenAI(
api_key=os.environ["AZURE_OPENAI_API_KEY"],
base_url=f"{os.environ['AZURE_OPENAI_ENDPOINT'].rstrip('/')}/openai/v1/",
)
deployment = os.environ["AZURE_OPENAI_DEPLOYMENT"]
# Application-managed state. This example keeps it in memory.
conversation = [
{"role": "user", "content": "Explain the trade-offs of this design."}
]
def add_response_items(response):
items = [item.model_dump(exclude_none=True) for item in response.output]
if not any(
item.get("type") == "reasoning" and item.get("encrypted_content")
for item in items
):
raise RuntimeError(
"No encrypted reasoning item was returned. Check the deployment "
"and the request's include parameter."
)
# Preserve the returned items, including encrypted reasoning.
conversation.extend(items)
try:
first = client.responses.create(
model=deployment,
input=conversation,
store=False,
include=["reasoning.encrypted_content"],
)
add_response_items(first)
print("First answer:", first.output_text)
conversation.append({
"role": "user",
"content": "Which trade-off matters most for reliability?",
})
second = client.responses.create(
model=deployment,
input=conversation,
store=False,
include=["reasoning.encrypted_content"],
)
add_response_items(second)
print("Follow-up answer:", second.output_text)
except BadRequestError as exc:
# Inspect the service error before deciding whether to restart.
print(f"Request rejected: {exc}")
raise
using System;
using System.Linq;
using System.Net.Http;
using System.Text;
using System.Text.Json.Nodes;
using System.Threading.Tasks;
string endpoint = RequiredEnvironment("AZURE_OPENAI_ENDPOINT").TrimEnd('/');
string deployment = RequiredEnvironment("AZURE_OPENAI_DEPLOYMENT");
using HttpClient openAIClient = new();
openAIClient.DefaultRequestHeaders.Add(
"api-key", RequiredEnvironment("AZURE_OPENAI_API_KEY"));
// Application-managed state. Preserve each complete output item.
JsonArray conversation = new()
{
new JsonObject
{
["role"] = "user",
["content"] = "Explain the trade-offs of this design."
}
};
JsonObject first = await CreateResponseAsync();
AddResponseItems(first);
Console.WriteLine($"First answer: {GetOutputText(first)}");
conversation.Add(new JsonObject
{
["role"] = "user",
["content"] = "Which trade-off matters most for reliability?"
});
JsonObject second = await CreateResponseAsync();
AddResponseItems(second);
Console.WriteLine($"Follow-up answer: {GetOutputText(second)}");
async Task<JsonObject> CreateResponseAsync()
{
JsonObject request = new()
{
["model"] = deployment,
["input"] = conversation.DeepClone(),
["store"] = false,
["include"] = new JsonArray("reasoning.encrypted_content")
};
using StringContent content = new(
request.ToJsonString(), Encoding.UTF8, "application/json");
using HttpResponseMessage response = await openAIClient.PostAsync(
$"{endpoint}/openai/v1/responses", content);
string body = await response.Content.ReadAsStringAsync();
if (!response.IsSuccessStatusCode)
{
throw new HttpRequestException(
$"Request rejected ({(int)response.StatusCode}): {body}");
}
return JsonNode.Parse(body)?.AsObject()
?? throw new InvalidOperationException("No response body was returned.");
}
void AddResponseItems(JsonObject response)
{
JsonArray items = response["output"]?.AsArray()
?? throw new InvalidOperationException("No output items were returned.");
if (!items.OfType<JsonObject>().Any(item =>
item["type"]?.GetValue<string>() == "reasoning" &&
!string.IsNullOrEmpty(item["encrypted_content"]?.GetValue<string>())))
{
throw new InvalidOperationException(
"No encrypted reasoning item was returned.");
}
foreach (JsonNode? item in items)
{
conversation.Add(item?.DeepClone()
?? throw new InvalidOperationException("An output item was null."));
}
}
static string GetOutputText(JsonObject response) => string.Concat(
response["output"]!.AsArray().OfType<JsonObject>()
.Where(item => item["type"]?.GetValue<string>() == "message")
.SelectMany(item => item["content"]!.AsArray().OfType<JsonObject>())
.Where(part => part["type"]?.GetValue<string>() == "output_text")
.Select(part => part["text"]!.GetValue<string>()));
static string RequiredEnvironment(string name)
{
string? value = Environment.GetEnvironmentVariable(name);
return !string.IsNullOrEmpty(value) ? value
: throw new InvalidOperationException($"Set {name} before running.");
}
const requiredEnvironment = (name) => {
const value = process.env[name];
if (!value) throw new Error(`Set ${name} before running.`);
return value;
};
const endpoint = requiredEnvironment("AZURE_OPENAI_ENDPOINT").replace(/\/+$/, "");
const deployment = requiredEnvironment("AZURE_OPENAI_DEPLOYMENT");
const apiKey = requiredEnvironment("AZURE_OPENAI_API_KEY");
// Application-managed state. Preserve each complete output item.
const conversation = [
{ role: "user", content: "Explain the trade-offs of this design." },
];
async function createResponse() {
const response = await fetch(`${endpoint}/openai/v1/responses`, {
method: "POST",
headers: { "Content-Type": "application/json", "api-key": apiKey },
body: JSON.stringify({
model: deployment,
input: conversation,
store: false,
include: ["reasoning.encrypted_content"],
}),
});
if (!response.ok) {
throw new Error(
`Request rejected (${response.status}): ${await response.text()}`,
);
}
return response.json();
}
function addResponseItems(response) {
if (!Array.isArray(response.output)) {
throw new Error("No output items were returned.");
}
if (!response.output.some(
(item) => item.type === "reasoning" && item.encrypted_content,
)) {
throw new Error("No encrypted reasoning item was returned.");
}
conversation.push(...response.output);
}
function getOutputText(response) {
return response.output
.filter((item) => item.type === "message")
.flatMap((item) => item.content)
.filter((part) => part.type === "output_text")
.map((part) => part.text)
.join("");
}
const first = await createResponse();
addResponseItems(first);
console.log("First answer:", getOutputText(first));
conversation.push({
role: "user",
content: "Which trade-off matters most for reliability?",
});
const second = await createResponse();
addResponseItems(second);
console.log("Follow-up answer:", getOutputText(second));
Sla dit voorbeeld op als StatelessConversation.java.
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.ObjectNode;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
public class StatelessConversation {
private static final ObjectMapper JSON = new ObjectMapper();
public static void main(String[] args) throws Exception {
String endpoint = requiredEnvironment("AZURE_OPENAI_ENDPOINT")
.replaceAll("/+$", "");
String deployment = requiredEnvironment("AZURE_OPENAI_DEPLOYMENT");
String apiKey = requiredEnvironment("AZURE_OPENAI_API_KEY");
HttpClient openAIClient = HttpClient.newHttpClient();
// Application-managed state. Preserve each complete output item.
ArrayNode conversation = JSON.createArrayNode();
conversation.add(JSON.createObjectNode()
.put("role", "user")
.put("content", "Explain the trade-offs of this design."));
JsonNode first = createResponse(
openAIClient, endpoint, apiKey, deployment, conversation);
addResponseItems(conversation, first);
System.out.println("First answer: " + getOutputText(first));
conversation.add(JSON.createObjectNode()
.put("role", "user")
.put("content", "Which trade-off matters most for reliability?"));
JsonNode second = createResponse(
openAIClient, endpoint, apiKey, deployment, conversation);
addResponseItems(conversation, second);
System.out.println("Follow-up answer: " + getOutputText(second));
}
private static JsonNode createResponse(
HttpClient openAIClient, String endpoint, String apiKey,
String deployment, ArrayNode conversation) throws Exception {
ObjectNode payload = JSON.createObjectNode();
payload.put("model", deployment);
payload.set("input", conversation);
payload.put("store", false);
payload.set("include", JSON.createArrayNode()
.add("reasoning.encrypted_content"));
HttpRequest request = HttpRequest.newBuilder(
URI.create(endpoint + "/openai/v1/responses"))
.header("Content-Type", "application/json")
.header("api-key", apiKey)
.POST(HttpRequest.BodyPublishers.ofString(
JSON.writeValueAsString(payload)))
.build();
HttpResponse<String> response = openAIClient.send(
request, HttpResponse.BodyHandlers.ofString());
if (response.statusCode() < 200 || response.statusCode() >= 300) {
throw new IllegalStateException(
"Request rejected (" + response.statusCode() + "): "
+ response.body());
}
return JSON.readTree(response.body());
}
private static void addResponseItems(
ArrayNode conversation, JsonNode response) {
JsonNode items = response.get("output");
if (items == null || !items.isArray()) {
throw new IllegalStateException("No output items were returned.");
}
boolean hasEncryptedReasoning = false;
for (JsonNode item : items) {
JsonNode encrypted = item.get("encrypted_content");
if ("reasoning".equals(item.path("type").asText())
&& encrypted != null && encrypted.isTextual()
&& !encrypted.asText().isEmpty()) {
hasEncryptedReasoning = true;
}
}
if (!hasEncryptedReasoning) {
throw new IllegalStateException(
"No encrypted reasoning item was returned.");
}
for (JsonNode item : items) {
conversation.add(item);
}
}
private static String getOutputText(JsonNode response) {
StringBuilder text = new StringBuilder();
for (JsonNode item : response.get("output")) {
if ("message".equals(item.path("type").asText())) {
for (JsonNode part : item.get("content")) {
if ("output_text".equals(part.path("type").asText())) {
text.append(part.get("text").asText());
}
}
}
}
return text.toString();
}
private static String requiredEnvironment(String name) {
String value = System.getenv(name);
if (value == null || value.isEmpty()) {
throw new IllegalStateException("Set " + name + " before running.");
}
return value;
}
}
Met dit PowerShell-voorbeeld worden JSON-aanvragen rechtstreeks naar het REST-eindpunt verzonden.
$ErrorActionPreference = "Stop"
foreach ($name in "AZURE_OPENAI_ENDPOINT", "AZURE_OPENAI_API_KEY",
"AZURE_OPENAI_DEPLOYMENT") {
if (-not [Environment]::GetEnvironmentVariable($name)) {
throw "Set $name before running."
}
}
$endpoint = $env:AZURE_OPENAI_ENDPOINT.TrimEnd("/")
$deployment = $env:AZURE_OPENAI_DEPLOYMENT
$headers = @{ "api-key" = $env:AZURE_OPENAI_API_KEY }
# Application-managed state. Preserve each complete output item.
$conversation = [System.Collections.Generic.List[object]]::new()
$conversation.Add(@{
role = "user"
content = "Explain the trade-offs of this design."
})
function New-Response {
$body = @{
model = $deployment
input = $conversation.ToArray()
store = $false
include = @("reasoning.encrypted_content")
} | ConvertTo-Json -Depth 100
Invoke-RestMethod -Method Post -Uri "$endpoint/openai/v1/responses" `
-Headers $headers -ContentType "application/json" -Body $body
}
function Add-ResponseItems($response) {
$items = @($response.output)
if (-not ($items | Where-Object {
$_.type -eq "reasoning" -and $_.encrypted_content
})) {
throw "No encrypted reasoning item was returned."
}
foreach ($item in $items) {
$conversation.Add($item)
}
}
function Get-OutputText($response) {
$parts = foreach ($item in $response.output) {
if ($item.type -eq "message") {
foreach ($part in $item.content) {
if ($part.type -eq "output_text") { $part.text }
}
}
}
$parts -join ""
}
$first = New-Response
Add-ResponseItems $first
Write-Output "First answer: $(Get-OutputText $first)"
$conversation.Add(@{
role = "user"
content = "Which trade-off matters most for reliability?"
})
$second = New-Response
Add-ResponseItems $second
Write-Output "Follow-up answer: $(Get-OutputText $second)"
In het voorbeeld worden het eerste antwoord en het vervolgantwoord afgedrukt. Alle uitvoeritems, inclusief versleutelde redenering, blijven behouden in plaats van alleen het leesbare antwoord.
De conversation lijst is waar de toepassing van dit voorbeeld de items bewaart. Het wordt in het geheugen bewaard en overleeft een herstart van een proces niet. Een toepassing die later moet worden hervat, moet een eigen opslag kiezen en beveiligen.
In dit voorbeeld blijven de redenerings- en functieaanroepitems behouden, wordt een voorbeeldfunctie uitgevoerd en wordt het resultaat teruggestuurd met behulp van de overeenkomende call_id.
import json
import os
from openai import BadRequestError, OpenAI
client = OpenAI(
api_key=os.environ["AZURE_OPENAI_API_KEY"],
base_url=f"{os.environ['AZURE_OPENAI_ENDPOINT'].rstrip('/')}/openai/v1/",
)
deployment = os.environ["AZURE_OPENAI_DEPLOYMENT"]
tools = [{
"type": "function",
"name": "get_order_status",
"description": "Look up the status of an example order.",
"parameters": {
"type": "object",
"properties": {
"order_id": {"type": "string"}
},
"required": ["order_id"],
"additionalProperties": False,
},
}]
def get_order_status(order_id):
# Replace this example with your own trusted data source.
if order_id == "A123":
return {"order_id": order_id, "status": "Shipped"}
return {"order_id": order_id, "status": "Not found"}
conversation = [{
"role": "user",
"content": "What is the status of order A123?",
}]
def create_response():
return client.responses.create(
model=deployment,
input=conversation,
tools=tools,
store=False,
include=["reasoning.encrypted_content"],
)
try:
# Bound the number of tool rounds.
for _ in range(3):
response = create_response()
items = [item.model_dump(exclude_none=True) for item in response.output]
if not any(
item.get("type") == "reasoning" and item.get("encrypted_content")
for item in items
):
raise RuntimeError("No encrypted reasoning item was returned.")
# Preserve returned items in order, including reasoning and tool calls.
conversation.extend(items)
calls = [
item for item in response.output
if item.type == "function_call"
]
if not calls:
print(response.output_text)
break
for call in calls:
if call.name != "get_order_status":
raise ValueError(f"Unexpected tool: {call.name}")
arguments = json.loads(call.arguments)
result = get_order_status(arguments["order_id"])
conversation.append({
"type": "function_call_output",
"call_id": call.call_id,
"output": json.dumps(result),
})
else:
raise RuntimeError("The tool-call limit was reached.")
except BadRequestError as exc:
print(f"Request rejected: {exc}")
raise
using System;
using System.Linq;
using System.Net.Http;
using System.Text;
using System.Text.Json.Nodes;
using System.Threading.Tasks;
string endpoint = RequiredEnvironment("AZURE_OPENAI_ENDPOINT").TrimEnd('/');
string deployment = RequiredEnvironment("AZURE_OPENAI_DEPLOYMENT");
using HttpClient openAIClient = new();
openAIClient.DefaultRequestHeaders.Add(
"api-key", RequiredEnvironment("AZURE_OPENAI_API_KEY"));
JsonArray tools = JsonNode.Parse("""
[
{
"type": "function",
"name": "get_order_status",
"description": "Look up the status of an example order.",
"parameters": {
"type": "object",
"properties": { "order_id": { "type": "string" } },
"required": ["order_id"],
"additionalProperties": false
}
}
]
""")!.AsArray();
JsonArray conversation = new()
{
new JsonObject
{
["role"] = "user",
["content"] = "What is the status of order A123?"
}
};
// Preserve reasoning and tool calls before appending each tool result.
for (int round = 0; round < 3; round++)
{
JsonObject response = await CreateResponseAsync();
JsonArray items = response["output"]?.AsArray()
?? throw new InvalidOperationException("No output items were returned.");
if (!items.OfType<JsonObject>().Any(item =>
item["type"]?.GetValue<string>() == "reasoning" &&
!string.IsNullOrEmpty(item["encrypted_content"]?.GetValue<string>())))
{
throw new InvalidOperationException(
"No encrypted reasoning item was returned.");
}
foreach (JsonNode? item in items)
{
conversation.Add(item?.DeepClone()
?? throw new InvalidOperationException("An output item was null."));
}
JsonObject[] calls = items.OfType<JsonObject>()
.Where(item => item["type"]?.GetValue<string>() == "function_call")
.ToArray();
if (calls.Length == 0)
{
Console.WriteLine(GetOutputText(response));
return;
}
foreach (JsonObject call in calls)
{
if (call["name"]?.GetValue<string>() != "get_order_status")
{
throw new InvalidOperationException($"Unexpected tool: {call["name"]}");
}
JsonObject arguments = JsonNode.Parse(
call["arguments"]!.GetValue<string>())?.AsObject()
?? throw new InvalidOperationException("Invalid tool arguments.");
if (arguments["order_id"] is not JsonValue orderIdNode ||
!orderIdNode.TryGetValue<string>(out string? orderId) ||
orderId is null)
{
throw new InvalidOperationException("Missing or invalid order_id.");
}
// Replace this example data with your own trusted data source.
JsonObject result = new()
{
["order_id"] = orderId,
["status"] = orderId == "A123" ? "Shipped" : "Not found"
};
conversation.Add(new JsonObject
{
["type"] = "function_call_output",
["call_id"] = call["call_id"]!.GetValue<string>(),
["output"] = result.ToJsonString()
});
}
}
throw new InvalidOperationException("The tool-call limit was reached.");
async Task<JsonObject> CreateResponseAsync()
{
JsonObject request = new()
{
["model"] = deployment,
["input"] = conversation.DeepClone(),
["tools"] = tools.DeepClone(),
["store"] = false,
["include"] = new JsonArray("reasoning.encrypted_content")
};
using StringContent content = new(
request.ToJsonString(), Encoding.UTF8, "application/json");
using HttpResponseMessage response = await openAIClient.PostAsync(
$"{endpoint}/openai/v1/responses", content);
string body = await response.Content.ReadAsStringAsync();
if (!response.IsSuccessStatusCode)
{
throw new HttpRequestException(
$"Request rejected ({(int)response.StatusCode}): {body}");
}
return JsonNode.Parse(body)?.AsObject()
?? throw new InvalidOperationException("No response body was returned.");
}
static string GetOutputText(JsonObject response) => string.Concat(
response["output"]!.AsArray().OfType<JsonObject>()
.Where(item => item["type"]?.GetValue<string>() == "message")
.SelectMany(item => item["content"]!.AsArray().OfType<JsonObject>())
.Where(part => part["type"]?.GetValue<string>() == "output_text")
.Select(part => part["text"]!.GetValue<string>()));
static string RequiredEnvironment(string name)
{
string? value = Environment.GetEnvironmentVariable(name);
return !string.IsNullOrEmpty(value) ? value
: throw new InvalidOperationException($"Set {name} before running.");
}
const requiredEnvironment = (name) => {
const value = process.env[name];
if (!value) throw new Error(`Set ${name} before running.`);
return value;
};
const endpoint = requiredEnvironment("AZURE_OPENAI_ENDPOINT").replace(/\/+$/, "");
const deployment = requiredEnvironment("AZURE_OPENAI_DEPLOYMENT");
const apiKey = requiredEnvironment("AZURE_OPENAI_API_KEY");
const tools = [{
type: "function",
name: "get_order_status",
description: "Look up the status of an example order.",
parameters: {
type: "object",
properties: { order_id: { type: "string" } },
required: ["order_id"],
additionalProperties: false,
},
}];
const conversation = [{
role: "user",
content: "What is the status of order A123?",
}];
async function createResponse() {
const response = await fetch(`${endpoint}/openai/v1/responses`, {
method: "POST",
headers: { "Content-Type": "application/json", "api-key": apiKey },
body: JSON.stringify({
model: deployment,
input: conversation,
tools,
store: false,
include: ["reasoning.encrypted_content"],
}),
});
if (!response.ok) {
throw new Error(
`Request rejected (${response.status}): ${await response.text()}`,
);
}
return response.json();
}
function getOutputText(response) {
return response.output
.filter((item) => item.type === "message")
.flatMap((item) => item.content)
.filter((part) => part.type === "output_text")
.map((part) => part.text)
.join("");
}
// Preserve reasoning and tool calls before appending each tool result.
let completed = false;
for (let round = 0; round < 3; round++) {
const response = await createResponse();
if (!Array.isArray(response.output)) {
throw new Error("No output items were returned.");
}
if (!response.output.some(
(item) => item.type === "reasoning" && item.encrypted_content,
)) {
throw new Error("No encrypted reasoning item was returned.");
}
conversation.push(...response.output);
const calls = response.output.filter((item) => item.type === "function_call");
if (calls.length === 0) {
console.log(getOutputText(response));
completed = true;
break;
}
for (const call of calls) {
if (call.name !== "get_order_status") {
throw new Error(`Unexpected tool: ${call.name}`);
}
const argumentsObject = JSON.parse(call.arguments);
if (typeof argumentsObject.order_id !== "string") {
throw new Error("Missing or invalid order_id.");
}
// Replace this example data with your own trusted data source.
const result = {
order_id: argumentsObject.order_id,
status: argumentsObject.order_id === "A123" ? "Shipped" : "Not found",
};
conversation.push({
type: "function_call_output",
call_id: call.call_id,
output: JSON.stringify(result),
});
}
}
if (!completed) throw new Error("The tool-call limit was reached.");
Sla dit voorbeeld op als StatelessToolCalling.java.
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.ObjectNode;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.ArrayList;
import java.util.List;
public class StatelessToolCalling {
private static final ObjectMapper JSON = new ObjectMapper();
public static void main(String[] args) throws Exception {
String endpoint = requiredEnvironment("AZURE_OPENAI_ENDPOINT")
.replaceAll("/+$", "");
String deployment = requiredEnvironment("AZURE_OPENAI_DEPLOYMENT");
String apiKey = requiredEnvironment("AZURE_OPENAI_API_KEY");
HttpClient openAIClient = HttpClient.newHttpClient();
JsonNode tools = JSON.readTree("""
[{
"type": "function",
"name": "get_order_status",
"description": "Look up the status of an example order.",
"parameters": {
"type": "object",
"properties": { "order_id": { "type": "string" } },
"required": ["order_id"],
"additionalProperties": false
}
}]
""");
ArrayNode conversation = JSON.createArrayNode();
conversation.add(JSON.createObjectNode()
.put("role", "user")
.put("content", "What is the status of order A123?"));
// Preserve reasoning and tool calls before appending each tool result.
for (int round = 0; round < 3; round++) {
JsonNode response = createResponse(openAIClient, endpoint, apiKey,
deployment, conversation, tools);
JsonNode items = response.get("output");
if (items == null || !items.isArray()) {
throw new IllegalStateException("No output items were returned.");
}
boolean hasEncryptedReasoning = false;
List<JsonNode> calls = new ArrayList<>();
for (JsonNode item : items) {
JsonNode encrypted = item.get("encrypted_content");
if ("reasoning".equals(item.path("type").asText())
&& encrypted != null && encrypted.isTextual()
&& !encrypted.asText().isEmpty()) {
hasEncryptedReasoning = true;
}
if ("function_call".equals(item.path("type").asText())) {
calls.add(item);
}
}
if (!hasEncryptedReasoning) {
throw new IllegalStateException(
"No encrypted reasoning item was returned.");
}
for (JsonNode item : items) {
conversation.add(item);
}
if (calls.isEmpty()) {
System.out.println(getOutputText(response));
return;
}
for (JsonNode call : calls) {
if (!"get_order_status".equals(call.path("name").asText())) {
throw new IllegalArgumentException(
"Unexpected tool: " + call.path("name").asText());
}
JsonNode arguments = JSON.readTree(
call.get("arguments").asText());
JsonNode orderIdNode = arguments.get("order_id");
if (orderIdNode == null || !orderIdNode.isTextual()) {
throw new IllegalArgumentException(
"Missing or invalid order_id.");
}
String orderId = orderIdNode.asText();
// Replace this example data with your trusted data source.
ObjectNode result = JSON.createObjectNode()
.put("order_id", orderId)
.put("status", "A123".equals(orderId)
? "Shipped" : "Not found");
conversation.add(JSON.createObjectNode()
.put("type", "function_call_output")
.put("call_id", call.get("call_id").asText())
.put("output", JSON.writeValueAsString(result)));
}
}
throw new IllegalStateException("The tool-call limit was reached.");
}
private static JsonNode createResponse(
HttpClient openAIClient, String endpoint, String apiKey,
String deployment, ArrayNode conversation,
JsonNode tools) throws Exception {
ObjectNode payload = JSON.createObjectNode();
payload.put("model", deployment);
payload.set("input", conversation);
payload.set("tools", tools);
payload.put("store", false);
payload.set("include", JSON.createArrayNode()
.add("reasoning.encrypted_content"));
HttpRequest request = HttpRequest.newBuilder(
URI.create(endpoint + "/openai/v1/responses"))
.header("Content-Type", "application/json")
.header("api-key", apiKey)
.POST(HttpRequest.BodyPublishers.ofString(
JSON.writeValueAsString(payload)))
.build();
HttpResponse<String> response = openAIClient.send(
request, HttpResponse.BodyHandlers.ofString());
if (response.statusCode() < 200 || response.statusCode() >= 300) {
throw new IllegalStateException(
"Request rejected (" + response.statusCode() + "): "
+ response.body());
}
return JSON.readTree(response.body());
}
private static String getOutputText(JsonNode response) {
StringBuilder text = new StringBuilder();
for (JsonNode item : response.get("output")) {
if ("message".equals(item.path("type").asText())) {
for (JsonNode part : item.get("content")) {
if ("output_text".equals(part.path("type").asText())) {
text.append(part.get("text").asText());
}
}
}
}
return text.toString();
}
private static String requiredEnvironment(String name) {
String value = System.getenv(name);
if (value == null || value.isEmpty()) {
throw new IllegalStateException("Set " + name + " before running.");
}
return value;
}
}
Met dit PowerShell-voorbeeld worden JSON-aanvragen rechtstreeks naar het REST-eindpunt verzonden.
$ErrorActionPreference = "Stop"
foreach ($name in "AZURE_OPENAI_ENDPOINT", "AZURE_OPENAI_API_KEY",
"AZURE_OPENAI_DEPLOYMENT") {
if (-not [Environment]::GetEnvironmentVariable($name)) {
throw "Set $name before running."
}
}
$endpoint = $env:AZURE_OPENAI_ENDPOINT.TrimEnd("/")
$deployment = $env:AZURE_OPENAI_DEPLOYMENT
$headers = @{ "api-key" = $env:AZURE_OPENAI_API_KEY }
$tools = @(@{
type = "function"
name = "get_order_status"
description = "Look up the status of an example order."
parameters = @{
type = "object"
properties = @{ order_id = @{ type = "string" } }
required = @("order_id")
additionalProperties = $false
}
})
$conversation = [System.Collections.Generic.List[object]]::new()
$conversation.Add(@{
role = "user"
content = "What is the status of order A123?"
})
function New-Response {
$body = @{
model = $deployment
input = $conversation.ToArray()
tools = $tools
store = $false
include = @("reasoning.encrypted_content")
} | ConvertTo-Json -Depth 100
Invoke-RestMethod -Method Post -Uri "$endpoint/openai/v1/responses" `
-Headers $headers -ContentType "application/json" -Body $body
}
function Get-OutputText($response) {
$parts = foreach ($item in $response.output) {
if ($item.type -eq "message") {
foreach ($part in $item.content) {
if ($part.type -eq "output_text") { $part.text }
}
}
}
$parts -join ""
}
# Preserve reasoning and tool calls before appending each tool result.
$completed = $false
for ($round = 0; $round -lt 3; $round++) {
$response = New-Response
$items = @($response.output)
if (-not ($items | Where-Object {
$_.type -eq "reasoning" -and $_.encrypted_content
})) {
throw "No encrypted reasoning item was returned."
}
foreach ($item in $items) {
$conversation.Add($item)
}
$calls = @($items | Where-Object { $_.type -eq "function_call" })
if ($calls.Count -eq 0) {
Write-Output (Get-OutputText $response)
$completed = $true
break
}
foreach ($call in $calls) {
if ($call.name -cne "get_order_status") {
throw "Unexpected tool: $($call.name)"
}
$arguments = $call.arguments | ConvertFrom-Json
if ($arguments.order_id -isnot [string]) {
throw "Missing or invalid order_id."
}
# Replace this example data with your own trusted data source.
$status = if ($arguments.order_id -ceq "A123") {
"Shipped"
} else {
"Not found"
}
$result = @{
order_id = $arguments.order_id
status = $status
} | ConvertTo-Json -Compress
$conversation.Add(@{
type = "function_call_output"
call_id = $call.call_id
output = $result
})
}
}
if (-not $completed) { throw "The tool-call limit was reached." }
Het voorbeeld drukt het laatste antwoord van het model af nadat het de status van de voorbeeldorder heeft verwerkt. De functie maakt gebruik van voorbeeldgegevens, geen live bestelsysteem. De lus beperkt het aantal antwoordaanvragen tot drie en genereert een fout als het model doorgaat met het aanvragen van hulpprogramma's.
Versleutelde redeneringsitems intact houden; probeer hun versleutelde inhoud niet te lezen of te wijzigen. Zie Function calling voor functiedefinities en indelingen voor hulpprogrammaresultaten.
Overwegingen voor routering
Als u door Azure API Management routeert, valideert u versleutelde reasoning replay voor uw geconfigureerde back-ends voordat u erop vertrouwt. Als de service invalid_encrypted_content retourneert, inspecteert u de fout en de resourceroutering voordat u beslist of het gesprek opnieuw moet worden gestart.
Overwegingen voor gegevensbescherming
Versleutelde reasoning-items bevatten afgeschermde redeneercontext tussen aanvragen. Ze beschrijven niet hoe de service opgeslagen gegevens versleutelt, welke sleutels opgeslagen prompts of gespreksstatus beschermen, of waar uw toepassing geretourneerde items moet opslaan.
Het instellen van store=false is geen algemene garantie voor nulretentie voor elk serviceproces. Zie Gegevens, privacy en beveiliging voor Azure OpenAI voor informatie over opslag en misbruikcontrole aan de servicezijde.
Afbeeldingen genereren
De Antwoorden-API maakt het genereren van afbeeldingen mogelijk als onderdeel van gesprekken en werkstromen met meerdere paden. Het ondersteunt invoer en uitvoer van afbeeldingen binnen context en bevat ingebouwde hulpprogramma's voor het genereren en bewerken van afbeeldingen.
Vergeleken met de zelfstandige image-API biedt de Response-API twee voordelen:
-
Streaming: Deeluitvoer van afbeeldingen weergeven tijdens het genereren om de ervaren latentie te verbeteren.
-
Flexibele invoer: Accepteer afbeeldingsbestand-id's als invoer naast onbewerkte afbeeldingsbytes.
Opmerking
Het hulpprogramma voor het genereren van afbeeldingen in de Antwoorden-API wordt ondersteund door gpt-image-1-seriemodellen en u kunt het aanroepen vanuit een set compatibele chat- en redeneringsmodellen. Raadpleeg verderop in dit artikel de sectie Ondersteunde modellen voor de huidige lijst met ondersteunde orkestratiemodellen.
Het hulpprogramma voor het genereren van afbeeldingen biedt momenteel geen ondersteuning voor de streamingmodus. Als u gedeeltelijke afbeeldingen wilt streamen, roept u de API voor het genereren van afbeeldingen rechtstreeks aan buiten de Responses API.
Gebruik de Responses API om conversationele beeldervaringen te bouwen met GPT Image-modellen.
import base64
import os
from openai import OpenAI
from azure.identity import DefaultAzureCredential, get_bearer_token_provider
token_provider = get_bearer_token_provider(
DefaultAzureCredential(), "https://ai.azure.com/.default"
)
client = OpenAI(
base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
api_key=token_provider,
default_headers={
"x-ms-oai-image-generation-deployment": os.getenv("IMAGE_MODEL_NAME"),
"api_version": "preview",
},
)
response = client.responses.create(
model="MODEL_NAME",
input="Generate an image of a gray tabby cat hugging an otter with an orange scarf.",
tools=[{"type": "image_generation"}],
)
image_data = [
output.result
for output in response.output
if output.type == "image_generation_call"
]
if image_data:
with open("otter.png", "wb") as f:
f.write(base64.b64decode(image_data[0]))
#pragma warning disable OPENAI001
using System.IO;
using System.Threading.Tasks;
using Azure.Identity;
using OpenAI.Responses;
using System.ClientModel.Primitives;
string endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1";
// API key authentication
ResponsesClient openAIClient = new(
credential: new ApiKeyCredential(Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY")!),
options: new ResponsesClientOptions { Endpoint = new Uri(endpoint) });
// Microsoft Entra ID authentication (recommended)
BearerTokenPolicy tokenPolicy = new(
new DefaultAzureCredential(),
"https://ai.azure.com/.default");
ResponsesClient openAIClientEntra = new(
authenticationPolicy: tokenPolicy,
options: new ResponsesClientOptions { Endpoint = new Uri(endpoint) });
ImageGenerationTool imageTool = ResponseTool.CreateImageGenerationTool(model: "gpt-image-1");
CreateResponseOptions options = new()
{
Model = "MODEL_NAME",
InputItems =
{
ResponseItem.CreateUserMessageItem("Generate an image of an otter swimming in a pond.")
},
Tools = { imageTool }
};
ResponseResult response = await openAIClient.CreateResponseAsync(options);
foreach (ResponseItem item in response.OutputItems)
{
if (item is ImageGenerationCallResponseItem imageCall && imageCall.ImageResultBytes is not null)
{
await File.WriteAllBytesAsync("otter.png", imageCall.ImageResultBytes.ToArray());
Console.WriteLine($"Saved image. Revised prompt: {imageCall.RevisedPrompt}");
}
}
import fs from "fs";
import OpenAI from "openai";
import { DefaultAzureCredential, getBearerTokenProvider } from "@azure/identity";
const tokenProvider = getBearerTokenProvider(
new DefaultAzureCredential(),
"https://ai.azure.com/.default"
);
const client = new OpenAI({
baseURL: "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
apiKey: await tokenProvider(),
defaultHeaders: {
"x-ms-oai-image-generation-deployment": process.env.IMAGE_MODEL_NAME,
api_version: "preview",
},
});
const response = await client.responses.create({
model: "MODEL_NAME",
input: "Generate an image of a gray tabby cat hugging an otter with an orange scarf.",
tools: [{ type: "image_generation" }],
});
const imageBase64 = response.output
.filter((o) => o.type === "image_generation_call")
.map((o) => o.result)[0];
if (imageBase64) {
fs.writeFileSync("otter.png", Buffer.from(imageBase64, "base64"));
}
import com.azure.identity.DefaultAzureCredentialBuilder;
import com.azure.identity.AuthenticationUtil;
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.credential.BearerTokenCredential;
import com.openai.models.responses.Response;
import com.openai.models.responses.ResponseCreateParams;
import com.openai.models.responses.ResponseOutputItem;
import com.openai.models.responses.Tool;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Base64;
String endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1";
OpenAIClient openAIClient = OpenAIOkHttpClient.builder()
.baseUrl(endpoint)
.credential(AzureApiKeyCredential.create(System.getenv("AZURE_OPENAI_API_KEY")))
.build();
Tool imageGen = Tool.ofImageGeneration(Tool.ImageGeneration.builder().build());
Response response = openAIClient.responses().create(
ResponseCreateParams.builder()
.model("MODEL_NAME")
.input("Generate an image of a gray tabby cat hugging an otter with an orange scarf.")
.addTool(imageGen)
.build());
response.output().stream()
.filter(ResponseOutputItem::isImageGenerationCall)
.map(ResponseOutputItem::asImageGenerationCall)
.findFirst()
.flatMap(call -> call.result())
.ifPresent(b64 -> {
try {
Files.write(Paths.get("otter.png"), Base64.getDecoder().decode(b64));
} catch (IOException e) {
throw new RuntimeException(e);
}
});
curl -X POST https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/responses \
-H "Content-Type: application/json" \
-H "api-key: $AZURE_OPENAI_API_KEY" \
-H "x-ms-oai-image-generation-deployment: $IMAGE_MODEL_NAME" \
-d '{
"model": "MODEL_NAME",
"input": "Generate an image of a gray tabby cat hugging an otter with an orange scarf.",
"tools": [{ "type": "image_generation" }]
}'
Redeneringsmodellen
Zie de handleiding met redeneringsmodellen voor voorbeelden van het gebruik van redeneringsmodellen met de api voor antwoorden.
Computergebruik
Computergebruik met Playwright is verplaatst naar de speciale handleiding voor computergebruik.
Probleemoplossing
Waarom is mijn API-sessie beëindigd als voorzorgsmaatregel?
Bij het gebruik van Astra-modellen, om ervoor te zorgen dat agents uw instructies correct interpreteren en volgen, hebben we een systeem dat sessies stopt in de Response-API als de agent detecteert dat de agent uw instructies mogelijk niet correct heeft geïnterpreteerd in gevallen zoals het overdragen van gevoelige gegevens, het openen van gevoelige gegevens of het aanbrengen van destructieve wijzigingen. Als uw sessie is beëindigd, betekent dit niet noodzakelijkerwijs dat de agent een fout heeft gemaakt, alleen dat het de moeite waard is om de acties van de agent te controleren om ervoor te zorgen dat de agent uw instructies correct heeft geïnterpreteerd en gevolgd.
Welke API-aanvragen worden bewaakt door dit systeem?
Hetzelfde systeem dat hierboven wordt beschreven, bewaakt asynchroon aanvragen naar Astra in de Response-API. De API voor chatvoltooiingen wordt niet gescand door dit specifieke bewakingssysteem. We raden u aan de Response-API te gebruiken voor de grootste mate van prestaties en veiligheid voor agentische gebruiksvoorbeelden.
Hoe kan ik detecteren dat een gesprek is beëindigd in de API door dit systeem?
Wanneer het veiligheidssysteem vaststelt dat een agent instructies mogelijk in aanzienlijke mate verkeerd heeft geïnterpreteerd, retourneert de API de veiligheidsannotatiecode misalignment-enforcement. In dit geval kan de opgegeven sessie niet worden hervat.
Wat moet mijn toepassing doen als een dergelijk geval wordt gedetecteerd?
U kunt overwegen om een systeem in te stellen om iemand in staat te stellen de acties te controleren die de agent heeft uitgevoerd in dergelijke gesprekken, bijvoorbeeld door een gebruikersinterface aan de eindgebruiker te geven die moet worden gecontroleerd. Zodra een gesprek om deze reden in de API is gestopt, kan het niet meer worden hervat.
Veelvoorkomende API-fouten oplossen
Gebruik de volgende richtlijnen om veelvoorkomende API-fouten op te lossen:
-
401/403: Als u Microsoft Entra ID gebruikt, controleert u of het token is afgestemd op
https://ai.azure.com/.default. Als u een API-sleutel gebruikt, controleert u of u de juiste sleutel voor de resource gebruikt.
-
404: Bevestig
model dat deze overeenkomt met uw implementatienaam.
Verwante inhoud