Arendaja platvorm

Microsoft Foundry API

Microsoft Copilot ülevaade arendajatele, mis hõlmab API-juurdepääsu, hinnastust, SDK-tuge, lõppunkte, võimekusi ja platvormi reegleid.

Dokumentatsioon API juhend

API võti Ei ole nõutud

Peamine API Responses API

SDK tugi Ametlik OpenAI SDK tugi Pythonile ja JavaScriptile/TypeScriptile ning Microsoft Foundry SDK-d Pythonile, JavaScriptile/TypeScriptile, C#-ile ja Javale. Microsoft pakub ka Azure’i identiteediteeke ja keelepõhiseid Azure’i klientteeke.

Päringupiirangud Juurutuste kvoot määratakse piirkonna, mudeli, tellimuse ja juurutuse tüübi järgi. Piirangud hõlmavad tavaliselt minutis töödeldavate märkide arvu ja päringute arvu minutis. Vastused sisaldavad kiiruspiirangu päiseid ja juhiseid uuesti proovimiseks. Stand

Platvorm

API ülevaade

Lõppunktid (endpoints)

API ligipääs

Juuraadress (Base URL)


					https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/

Peamine API Responses API

Hinnad

API Hinnad

Hinnakujundusmudel Azure'i kasutuspõhine tarbimishinnastus, millele lisanduvad mudelipõhised tasud tokenite, meedia, pakktöötluse, juurutamise ja eraldatud läbilaskevõime eest

Hinnad sõltuvad mudelist, sisend- ja väljundtokenitest, piirkonnast, juurutuse tüübist, pakettkasutusest ning Provisioned Throughput Unitsidest. Täpsete hindade saamiseks vaadake Azure'i ajakohast hinnakalkulaatorit ja Azure OpenAI hinnalehte.

Arendaja töömugavus

SDK info

SDK Ametlik OpenAI SDK tugi Pythonile ja JavaScriptile/TypeScriptile ning Microsoft Foundry SDK-d Pythonile, JavaScriptile/TypeScriptile, C#-ile ja Javale. Microsoft pakub ka Azure’i identiteediteeke ja keelepõhiseid Azure’i klientteeke.

Kasutusmugavus Mõõdukas kuni kõrge. OpenAI-ga ühilduv Responses API on lihtsasti kasutatav, kuid Azure’i ressursid, juurutused, RBAC, kvoodid, regioonid ja võrgundus lisavad ettevõttekeskkonna konfiguratsioonile keerukust.

Dokumentatsioon Põhjalik ja mahukas dokumentatsioon, mis sisaldab ametlikke kiirjuhendeid, REST-i viiteid, SDK-de kasutusjuhiseid, kvootide dokumentatsiooni, mudelite elutsükli teavet ja privaatsusdokumentatsiooni. Azure’i võimaluste rohkus eeldab lõpp-punkti ja versioon

Viivitus Latentsus sõltub mudelist, piirkonnast, juurutuse tüübist, kvoodist, liiklusest ja teenusetasemest. Microsoft nimetab Azure OpenAI-ga ühilduvat lõpp-punkti parima latentsusega valikuks, kui eesmärk on maksimaalne ühilduvus OpenAI-ga. Global Standard ja Da

Allikad

Viited arendajale

Dokumentatsioon ↗ API juhend ↗ Liivakast ↗

Featuurid

API võimekused

✓ Voogedastus

✓ Funktsioonide kasutamine

✓ Assistants API

✓ Failide üleslaadimine

✓ Peenhäälestamine

✓ Veebiotsing

✓ Pildi sisend

✓ Struktureeritud väljund

✓ Liivakast

Lühikirjeldus

Microsoft Foundry on pigem arendajaplatvorm kui üksainus lõpp-punkt. Azure OpenAI-ga ühilduvat lõpp-punkti soovitatakse maksimaalse OpenAI-ühilduvuse, manuste, pildiloome, vestluse lõpuleviimise ja väikseima latentsuse saavutamiseks. Foundry projekti lõpp-punkti soovitatakse Foundry-spetsiifiliste võimaluste jaoks, nagu agendid, hindamised, projektiressursid, failiotsing, kooditõlk, veebiotsing, mälu, MCP, SharePoint, WorkIQ ja Fabric IQ. Responses API toetab teksti-, pildi- ja failisisendit, voogedastust, mitme vooruga vestlusi, struktureeritud väljundit, tööriistade ja funktsioonide kutsumist, taustatoiminguid, arutlusmudeleid, vastuste hankimist ja kustutamist. Foundry Agent Service pakub püsivaid agendivõimalusi, samas kui Responses API agendimustrid võivad olla ka ajutised. Saadavus sõltub mudelist, piirkonnast, juurutustüübist, API versioonist, eelvaateolekust, kvoodist ja juurdepääsuõigustest. Chat Completions on ühilduvate töökoormuste puhul endiselt toetatud, kuid uute rakenduste puhul, mis vajavad ühtset olekuhaldust, tööriistu, struktureeritud väljundit või agenditöövooge, tuleks üldjuhul esmalt hinnata Responses API-t. Praeguses dokumentatsioonis kasutatakse aegunud functions- ja function_call-parameetrite asemel tools-parameetrit.

Näited

API Näited

set -euo pipefail

: "${AZURE_OPENAI_ENDPOINT:?Set AZURE_OPENAI_ENDPOINT, for example https://YOUR-RESOURCE-NAME.openai.azure.com}"
: "${AZURE_OPENAI_API_KEY:?Set AZURE_OPENAI_API_KEY}"
: "${AZURE_OPENAI_MODEL:?Set AZURE_OPENAI_MODEL to your deployed model identifier}"

response=$(curl --fail-with-body -sS -X POST "${AZURE_OPENAI_ENDPOINT%/}/openai/v1/responses" \
  -H "Content-Type: application/json" \
  -H "api-key: ${AZURE_OPENAI_API_KEY}" \
  -d @- <<JSON
{
  "model": "${AZURE_OPENAI_MODEL}",
  "instructions": "You are a concise technical assistant.",
  "input": [
    {
      "role": "user",
      "content": [
        {"type": "input_text", "text": "Explain why API rate limits matter in one paragraph."}
      ]
    }
  ]
}
JSON
)

printf '%s\n' "$response" | python -c 'import json,sys; print(json.load(sys.stdin).get("output_text", ""))'

# Streaming example:
# curl -N --fail-with-body -sS -X POST "${AZURE_OPENAI_ENDPOINT%/}/openai/v1/responses" \
#   -H "Content-Type: application/json" \
#   -H "api-key: ${AZURE_OPENAI_API_KEY}" \
#   -d "{\"model\":\"${AZURE_OPENAI_MODEL}\",\"input\":\"Write a short explanation of server-sent events.\",\"stream\":true}"

# Install: pip install openai
import json
import os
from openai import OpenAI, APIError, RateLimitError

endpoint = os.environ["AZURE_OPENAI_ENDPOINT"].rstrip("/")
model = os.environ["AZURE_OPENAI_MODEL"]

client = OpenAI(
    api_key=os.environ["AZURE_OPENAI_API_KEY"],
    base_url=f"{endpoint}/openai/v1/",
)

try:
    response = client.responses.create(
        model=model,
        instructions="You are a helpful technical assistant.",
        input="Explain the difference between RPM and TPM in two sentences.",
    )
    print(response.output_text)

    follow_up = client.responses.create(
        model=model,
        previous_response_id=response.id,
        input="Now give one practical mitigation for each limit.",
    )
    print(follow_up.output_text)

    structured = client.responses.create(
        model=model,
        input="Extract a person and an organization from: Ada works at Example Corp.",
        text={
            "format": {
                "type": "json_schema",
                "name": "entity_extraction",
                "schema": {
                    "type": "object",
                    "properties": {
                        "person": {"type": "string"},
                        "organization": {"type": "string"},
                    },
                    "required": ["person", "organization"],
                    "additionalProperties": False,
                },
                "strict": True,
            }
        },
    )
    print(json.loads(structured.output_text))

    print("Streaming:")
    stream = client.responses.create(
        model=model,
        input="Give three short API reliability tips.",
        stream=True,
    )
    for event in stream:
        if getattr(event, "type", "") == "response.output_text.delta":
            print(event.delta, end="", flush=True)
    print()
except RateLimitError as exc:
    print(f"Rate limited; retry with backoff: {exc}")
except APIError as exc:
    print(f"Microsoft Foundry API error: {exc}")

// Install: npm install openai
import OpenAI from "openai";

const endpoint = process.env.AZURE_OPENAI_ENDPOINT?.replace(/\/$/, "");
const model = process.env.AZURE_OPENAI_MODEL;

if (!endpoint || !model || !process.env.AZURE_OPENAI_API_KEY) {
  throw new Error("Set AZURE_OPENAI_ENDPOINT, AZURE_OPENAI_MODEL, and AZURE_OPENAI_API_KEY");
}

const client = new OpenAI({
  apiKey: process.env.AZURE_OPENAI_API_KEY,
  baseURL: `${endpoint}/openai/v1/`,
  maxRetries: 3,
});

try {
  const response = await client.responses.create({
    model,
    instructions: "You are a helpful technical assistant.",
    input: "Explain what an API gateway does in two sentences.",
  });
  console.log(response.output_text);

  const structured = await client.responses.create({
    model,
    input: "Extract a product and a category from: Azure is a cloud platform.",
    text: {
      format: {
        type: "json_schema",
        name: "product_extraction",
        schema: {
          type: "object",
          properties: {
            product: { type: "string" },
            category: { type: "string" },
          },
          required: ["product", "category"],
          additionalProperties: false,
        },
        strict: true,
      },
    },
  });
  console.log(JSON.parse(structured.output_text));

  console.log("Streaming:");
  const stream = await client.responses.create({
    model,
    input: "List three API observability practices.",
    stream: true,
  });
  for await (const event of stream) {
    if (event.type === "response.output_text.delta") {
      process.stdout.write(event.delta);
    }
  }
  process.stdout.write("\n");
} catch (error) {
  if (error?.status === 429) {
    console.error("Rate limited; retry after backoff.");
  } else {
    console.error("Microsoft Foundry API request failed:", error);
  }
  process.exitCode = 1;
}

<?php
// Requires PHP 8+ with the cURL extension.

$endpoint = rtrim(getenv('AZURE_OPENAI_ENDPOINT') ?: '', '/');
$apiKey = getenv('AZURE_OPENAI_API_KEY') ?: '';
$model = getenv('AZURE_OPENAI_MODEL') ?: '';

if ($endpoint === '' || $apiKey === '' || $model === '') {
    fwrite(STDERR, "Set AZURE_OPENAI_ENDPOINT, AZURE_OPENAI_API_KEY, and AZURE_OPENAI_MODEL\n");
    exit(1);
}

$url = $endpoint . '/openai/v1/responses';
$payload = [
    'model' => $model,
    'instructions' => 'You are a helpful technical assistant.',
    'input' => 'Explain what an API rate limit is in two sentences.',
];

$ch = curl_init($url);
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Content-Type: application/json',
        'api-key: ' . $apiKey,
    ],
    CURLOPT_POSTFIELDS => json_encode($payload, JSON_THROW_ON_ERROR),
    CURLOPT_TIMEOUT => 120,
]);

$raw = curl_exec($ch);
if ($raw === false) {
    $message = curl_error($ch);
    curl_close($ch);
    throw new RuntimeException('cURL error: ' . $message);
}

$status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);
$data = json_decode($raw, true, 512, JSON_THROW_ON_ERROR);

if ($status < 200 || $status >= 300) {
    $message = $data['error']['message'] ?? $raw;
    throw new RuntimeException("Microsoft Foundry API HTTP $status: $message");
}

echo ($data['output_text'] ?? '') . PHP_EOL;

// For a structured JSON response, add a text.format JSON Schema object to $payload.
// For streaming, add 'stream' => true and process the returned server-sent events.
?>

Põhimõtted

Andmete kasutus

Microsoft kinnitab, et Azure’i kaudu müüdavatele mudelitele saadetud viipasid ja mudelite genereeritud vastuseid ei kasutata baasmudelite treenimiseks, ümbertreenimiseks ega täiustamiseks. Peenhäälestuse andmeid ei kasutata generatiivse tehisintellekti alusmudelite treenimiseks ilma kliendi loata või vastava juhiseta. Eraldi Microsofti toodetele või valikulistele andmejagamisprogrammidele võivad kehtida teistsugused tingimused, mistõttu peaksid kliendid tutvuma oma ressursile kohaldatava täpse teenuse ja lepinguga.

Andmete säilitamine

Mudeli inferentsi kirjeldatakse olekuta toimivana, kuid olekuga platvormifunktsioonid võivad salvestada andmeid kliendi Azure'i rentnikus. Salvestatud andmed võivad hõlmata Responses API vastuseid, vestlusi, Assistants- või Agent Service'i lõimi, üles laaditud faile, vektorp hoidlaid, pakkandmeid ja peenhäälestuse artefakte. Responses API dokumentatsiooni kohaselt säilitatakse salvestatud vastuseandmeid vaikimisi 30 päeva ning neid saab vastuse ID alusel kustutada. Microsofti sõnul on salvestatud funktsiooniandmed puhkeolekus krüpteeritud ja klient saab need kustutada, kuid sellele kehtivad funktsioonipõhised, eelversiooni-, piirkondlikud ja andmete nullsäilitamise tingimused.

Päringupiirangud

Juurutuste kvoot määratakse piirkonna, mudeli, tellimuse ja juurutuse tüübi järgi. Piirangud hõlmavad tavaliselt minutis töödeldavate märkide arvu ja päringute arvu minutis. Vastused sisaldavad kiiruspiirangu päiseid ja juhiseid uuesti proovimiseks. Stand

Arendaja juhend

Microsoft Foundry API: algaja juhend Azure OpenAI ja agentide kasutamiseks

Microsoft Foundry on Microsofti arendajaplatvorm tehisintellektirakenduste ja -agentide loomiseks. See ühendab Azure OpenAI-ga ühilduva Responses API Foundry projektide API-de, agenditeenuste, tööriistade, faili- ja pildisisendite, struktureeritud väljundite, hindamiste, peenhäälestuse ning Azure’i turvakontrollidega. Arendajad saavad OpenAI-ga ühilduvate rakenduste ja väiksema latentsusega juurdepääsu jaoks kasutada Azure OpenAI lõpp-punkti või agentide, hindamiste ja muude Foundry spetsiifiliste ressursside jaoks Foundry projektide lõpp-punkte.

Microsoft Foundry pakub arendajatele hallatavat Azure’i platvormi, mille abil lisada rakendustele mudelipõhiseid teksti-, pildi-, faili-, tööriista- ja agendivõimalusi. Uute projektide jaoks on soovitatav generatiivne liides Responses API. Seda saab kasutada Azure OpenAI-ga ühilduva lõpp-punkti kaudu, kasutades OpenAI SDK-d, või Foundry projekti lõpp-punkti ja Foundry SDK-d, kui vajate projektiressursse, püsivaid agente, hindamisi või platvormi tööriistu. Selles juhendis käsitletakse juurdepääsu, autentimist, esimesi päringuid, hinnastamist, võimalusi, SDK-sid, tootmiskeskkonna piiranguid ning peamisi põhjuseid, miks platvormi valida või selle kasutamisest loobuda.

Microsoft Foundry pakub Azure'is hostitud mudelite API-sid, Responses API-t, projektipõhiseid lõpp-punkte, püsivaid agente, tööriistu, failide ja piltide sisendit, struktureeritud JSON-väljundit, peenhäälestust, ettevõtte autentimist, kvoodikontrolle ning Azure'i privaatsus- ja haldusfunktsioone.

Mis on Microsoft Foundry API ja millal seda kasutada

Microsoft Foundry on arendajatele mõeldud platvorm Azure'is tehisintellektirakenduste ja agentide loomiseks, juurutamiseks, hindamiseks, haldamiseks ja käitamiseks. See koondab Azure'is saadaolevad mudelid, Azure OpenAI-ga ühilduvad API-d, Foundry projektide ressursid, Foundry Agent Service'i, tööriistad, hindamisfunktsioonid, peenhäälestuse, sisuturbe ning Azure'i identiteedi- ja turvakontrollid.

Uute rakenduste peamine generatiivne liides on Responses API. See võtab vastu teksti-, pildi- ja toetatud failisisendeid ning võib tagastada genereeritud teksti, struktureeritud JSON-i, tööriistakutseid ja voogesitatavaid sündmusi. See toetab ka mitmevoorulist suhtlust, taustatoiminguid, arutlusmudeleid, vastuste hankimist ja jätkamist funktsiooniga previous_response_id.

Platvormiga töötamiseks on kaks olulist võimalust:

Vali see lahendus	Kõige sobivam
Azure OpenAI-ga ühilduv lõpp-punkt	Rakendustele, mille puhul on oluline ühilduvus OpenAI klientide, embeddingu-te, pildigeneratsiooni, vestluse lõpetamise funktsioonide ja latentsusega.
Foundry projekti lõpp-punkt	Rakendustele, mis vajavad Foundry-spetsiifilisi agente, hindamisi, projektiressursse, failotsingut, kooditõlgendit, veebiotsingut, mälu, MCP-d, SharePointi, WorkIQ-d või Fabric IQ-d.

Platvorm on suunatud rakenduste arendajatele, taustsüsteemide inseneridele, andme- ja automatiseerimismeeskondadele ning organisatsioonidele, kes vajavad Azure'i haldust, piirkondlikku juurutamist, identiteediintegratsiooni, kvootide haldamist ja ettevõtte tasemel kontrolle. See sobib vähem olukorras, kus soovite lihtsat tarbijatele mõeldud vestlusroboti tellimust, üht kindlat kõikjal ühtmoodi käituvat mudelit või teenust, mille puhul puudub Azure'i ressursside ja juurutuste haldus.

Juurdepääsu ja autentimisandmete hankimine

Alustuseks looge Azure'is Microsoft Foundry või Azure OpenAI ressurss ja juurutage toetatud mudel. Täpne mudeli identifikaator sõltub juurutusest ja Azure'i keskkonnast, seega ärge eeldage, et avalik mudelinimi teie ressursis kehtib. Salvestage juurutatud mudeli identifikaator, lõpp-punkt ja autentimisandmed keskkonnamuutujatena, mitte otse lähtekoodi.

Microsoft toetab Azure OpenAI-ga ühilduvate API-de puhul kahte peamist autentimisviisi:

Microsoft Entra ID: Tavaliselt parem valik tootmiskeskkonna jaoks, sest see töötab Azure'i rollipõhise juurdepääsukontrolliga ega nõua pikaajaliste API-võtmete jagamist.
API-võti: Lihtne võimalus arenduseks ja toetatud juurutuste puhul. Saatke see api-key HTTP-päises ning kaitske seda nagu iga teist salajast autentimisandmet.

Autentimisnõuded ja õigused võivad Azure OpenAI-ga ühilduvate ressursside ning Foundry projektide lõpp-punktide vahel erineda. Tootmiskeskkonnas kasutage võimaluse korral hallatavat identiteeti või muud Entra-põhist lahendust, piirake õigusi Azure RBAC-i abil ning hoidke autentimisandmeid serveris, mitte brauseri- või mobiilirakenduse koodis.

Lõpp-punkti ja mudeli valimine

Valige lõpp-punkt vajalike rakendusefunktsioonide põhjal, mitte ärge käsitlege Microsoft Foundryt üheainsa API URL-ina. Azure OpenAI-ga ühilduva baas-URL-i muster on järgmine:

https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/

Foundry projekti lõpp-punkti muster on järgmine:

https://RESOURCE-NAME.services.ai.azure.com/api/projects/PROJECT-NAME

Tavapärase rakenduse puhul, mis saadab viipasid, võtab vastu vastuseid, kasutab voogesitust või vajab OpenAI-ga ühilduvat kliendikäitumist, alustage Azure OpenAI-ga ühilduvast Responses API-st. Projektipõhiste agentide, hindamiste, platvormi tööriistade või püsivate agendiresursside jaoks kasutage Foundry projekti lõpp-punkti ja sobivat Foundry SDK-d.

Päringu väli model peab sisaldama täpselt teie ressursis konfigureeritud mudeli või juurutuse identifikaatorit. Saadavus sõltub mudelist, piirkonnast, juurutuse tüübist, API versioonist, eelvaatest, kvoodist ja juurdepääsuõigustest. Kontrollige neid tingimusi enne, kui rajate lahenduse konkreetsele võimekusele, näiteks pildisisendile, arutlusele, peenhäälestusele või tööriistale.

Esimese päringu tegemine

Järgmine näide kasutab praegust OpenAI Pythoni SDK-d koos Azure OpenAI-ga ühilduva Responses API-ga. See saadab lihtsa tekstisisendi ja kuvab tagastatud teksti.

pip install openai

import os
from openai import OpenAI

endpoint = os.environ["AZURE_OPENAI_ENDPOINT"].rstrip("/")
model = os.environ["AZURE_OPENAI_MODEL"]

client = OpenAI(
    api_key=os.environ["AZURE_OPENAI_API_KEY"],
    base_url=f"{endpoint}/openai/v1/",
)

response = client.responses.create(
    model=model,
    instructions="You are a concise technical assistant.",
    input="Explain what an API rate limit is in two sentences.",
)

print(response.output_text)

Samaväärne HTTP-toiming on POST päring aadressile /responses. Päring sisaldab juurutatud mudeli identifikaatorit ning kas stringina esitatud sisendit või struktureeritud loendit sisendsõnumitest ja sisuüksustest.

Vastuse mõistmine

Responses API tulemus võib sisaldada rohkem kui üht väljundüksust. SDK mugavusatribuut output_text on kasulik siis, kui vajate ainult genereeritud teksti. Tööriistu, struktureeritud tulemusi, arutlust või muid väljunditüüpe toetavad rakendused peaksid vastuseüksusi uurima ning töötlema asjakohaseid sündmuse- või väljunditüüpe selgesõnaliselt.

Responses API-t saab kasutada mitmevooruliseks suhtluseks. Üks lihtne võimalus on saata varasema vastuse ID järgmise päringuga:

follow_up = client.responses.create(
    model=model,
    previous_response_id=response.id,
    input="Now give one practical mitigation for this limit.",
)

print(follow_up.output_text)

Olekupõhisel käitumisel on andmete säilitamisega seotud tagajärjed. Mudeli järelduste tegemist kirjeldatakse olekuta protsessina, kuid salvestatud vastused, vestlused, lõimed, failid, vektorpoodid, pakettandmed ja agendiresursid võivad kasutatavast funktsioonist ja konfiguratsioonist olenevalt säilida.

Kuidas Microsoft Foundry API hinnastamine toimib

Microsoft Foundry ja Azure OpenAI kasutavad Azure'i tarbimispõhist hinnastamist, mitte üht universaalset igakuist API-paketti. Kulud sõltuvad mudelist, sisend- ja väljundtokenitest, pildi- või helikasutusest, pakettöötlusest, juurutuse tüübist, piirkonnast ja teenusetasemest. Täpsed hinnad tuleks üle vaadata Azure'i ajakohasest hinnakalkulaatorist ja Azure OpenAI hinnastamise dokumentatsioonist.

Standard- ja Global Standardi juurutused kasutavad kvoodi- ja jagatud mahu kontrolle. Provisioned Throughput Units pakuvad spetsiaalset mahtu ning on mõeldud töökoormustele, mis vajavad prognoositavamat läbilaskevõimet ja latentsust. See võib kulumudelit oluliselt muuta, seega võrrelge enne juurutuse tüübi valimist eeldatavat päringumahtu ja latentsusnõudeid.

API kasutust võivad mõjutada ka piirkondlik kvoot, tokenid minutis, päringud minutis, mudelivalik, korduspäringud ja iga päringuga saadetava sisendkonteksti maht. Jälgige tokenikasutust ning ebaõnnestunud või korratud päringuid, mitte ärge hinnake kulu ainult API-kutsete arvu põhjal.

API kaudu saadaolevad võimalused

Voogesitatavad vastused

Seadke stream: true, et saada vastuse genereerimise ajal serveri saadetud sündmusi. Voogesitus võimaldab liidesel kuvada osalist teksti, selle asemel et oodata täielikku tulemust. Teie klient peab sündmuste voogu töötlema ning käsitlema katkestusi, vigu ja lõpetamata väljundit.

stream = client.responses.create(
    model=model,
    input="Give three short API reliability tips.",
    stream=True,
)

for event in stream:
    if getattr(event, "type", "") == "response.output_text.delta":
        print(event.delta, end="", flush=True)

print()

Tööriistad ja funktsioonikutsed

Tööriistakutsed võimaldavad mudelil paluda toimingut, mida teie rakendus teostab, näiteks kontoandmete otsimist või siseveergu päringu tegemist. Teie kood vastutab endiselt argumentide valideerimise, toimingu autoriseerimise, selle täitmise ja tulemuse tagastamise eest. Kasutage praegust tools-konventsiooni; vanemad functions- ja function_call-parameetrimustrid ei tohiks olla uute integratsioonide aluseks.

Foundry projektipõhised töövood võivad toetatud juhtudel avada ka platvormi tööriistu, näiteks veebiotsingu, failotsingu, kooditõlgendi, mälu, MCP, SharePointi, WorkIQ ja Fabric IQ. Tööriistade saadavus sõltub lõpp-punktist, mudelist, piirkonnast, õigustest ja teenuse hetkeseisust.

Faili- ja pildisisend

Nägemisvõimega mudelid võivad vastu võtta toetatud pildisisu, sealhulgas pildi URL-e või muid lubatud pildisisendeid. Faile saab üles laadida Files API kaudu ning neile saab viidata toetatud mudeli- või tööriistapõhistes töövoogudes. Failiotsing ja kooditõlgend on eriti seotud Foundry projektide ja agentide kasutusjuhtudega.

Ärge eeldage, et iga juurutatud mudel aktsepteerib kõiki meediumitüüpe. Kinnitage valitud mudeli ja juurutuse tugi ning uurige enne tundliku teabe saatmist, kuidas üleslaaditud faile säilitatakse, neile juurde pääsetakse ja need kustutatakse.

Struktureeritud väljundid

Struktureeritud väljundid kasutavad JSON Schema't, mis esitatakse võtme text.format all. Range valideerimise lubamisel saab rakendus taotleda prognoositava struktuuriga JSON-i, selle asemel et proovida JSON-i tavalisest proosast eraldada.

structured = client.responses.create(
    model=model,
    input="Extract a person and an organization from: Ada works at Example Corp.",
    text={
        "format": {
            "type": "json_schema",
            "name": "entity_extraction",
            "schema": {
                "type": "object",
                "properties": {
                    "person": {"type": "string"},
                    "organization": {"type": "string"}
                },
                "required": ["person", "organization"],
                "additionalProperties": False
            },
            "strict": True
        }
    }
)

print(structured.output_text)

Agendid ja peenhäälestus

Foundry toetab ajutisi agendimustreid Responses API kaudu ning püsivaid agendifunktsioone Foundry Agent Service'i kaudu. Projektitaseme agendifunktsioonid võivad ühendada mudelid tööriistade, failide, hindamiste ja muude hallatavate ressurssidega. Peenhäälestus on toetatud mudelite ja meetodite puhul saadaval, kuid sellele kehtivad mudelist, piirkonnast, kvoodist ja juurdepääsuõigustest tulenevad piirangud.

SDK-d, mänguväljak ja arendajatööriistad

Azure OpenAI-ga ühilduva Responses API jaoks pakub Microsoft ajakohaseid näiteid ametliku OpenAI SDK kasutamiseks Pythonis ning JavaScriptis või TypeScriptis. Pythoni pakett on openai ning JavaScripti või TypeScripti pakett on samuti openai. Projektitaseme Foundry API-de jaoks pakub Microsoft Foundry SDK-sid, sealhulgas stabiilset Pythoni paketti azure-ai-projects, samuti Foundry pakette JavaScripti või TypeScripti, C#-i ja Java jaoks.

Microsoft Foundry portaal aadressil ai.azure.com pakub mudelikataloogi sirvimist, juurutusi, agentide ja hindamiste töövooge, mänguväljakul testimist, konfigureerimist ja seiret. Azure'i portaal on endiselt oluline ressursside loomise, kvootide, identiteedi, võrgunduse, juurutuste haldamise ja arvelduse jaoks.

Kasutage valitud lõpp-punktiga sobivat SDK-d. Vältige vanemate Azure SDK põlvkondade näidete kombineerimist praeguse OpenAI-ga ühilduva Responses API süntaksiga.

Olulised piirangud ja tootmiskeskkonna kaalutlused

Kvoot määratakse piirkonna, mudeli, tellimuse ja juurutuse tüübi põhjal. Levinud piirangud hõlmavad tokeneid minutis ja päringuid minutis. Vastused võivad sisaldada päiseid, näiteks x-ratelimit-limit-requests, x-ratelimit-remaining-requests, x-ratelimit-limit-tokens ja retry-after-ms.

Tootmiskliendid peaksid:

Rakendama ajutiste tõrgete ja HTTP 429 vastuste korral eksponentsiaalset tagasipöördumist.
Järgima korduspäringu päiseid, mitte tegema kohe tihedas tsüklis uusi päringuid.
Vältima äkilisi liikluspuhanguid ning jälgima järelejäänud päringu- ja tokenimahtu.
Jälgima latentsust, tokenikasutust, tõrkeid, sisufiltri tulemusi ja tööriistavigu.
Kasutama Provisioned Throughputi, kui ühtlane maht ja latentsus on olulisemad kui jagatud mahu paindlikkus.
Kontrollima enne juurutamist mudeli piirkondlikku saadavust ja API versiooni elutsükli teavet.
Enne salvestatud vastuste, lõimede, failide, vektoripoodide või agentide lubamist üle vaatama säilitamise ja geograafilise töötlemise nõuded.

Microsofti sõnul ei kasutata Azure'i kaudu müüdavatele mudelitele saadetud viipasid ja lõpetusi baasmudelite treenimiseks, ümbertreenimiseks ega täiustamiseks. See ei tähenda, et kõik funktsioonid oleksid salvestusvabad: olekupõhised funktsioonid võivad kliendiandmeid Azure'i rentnikus salvestada. Responses API dokumentatsioon kirjeldab, et salvestatud vastuseandmeid säilitatakse vaikimisi 30 päeva, kuid funktsioonipõhised, eelvaate-, piirkondlikud ja null-andmesäilitusega lahendused võivad sellest erineda.

Millal on Microsoft Foundry hea või halb valik

Microsoft Foundry sobib hästi siis, kui teie rakendus töötab juba Azure'is või vajab Azure RBAC-i, Entra ID-d, piirkondlikku juurutamist, ettevõtte võrgundust, kvoodikontrolle, mudelihaldust, hindamisi ja hallatavaid agendifunktsioone. Azure OpenAI-ga ühilduv lõpp-punkt võimaldab taaskasutada OpenAI-le suunatud kliendikoodi, säilitades samal ajal Azure'i juurutus- ja haldusvõimalused.

See võib olla halb valik juhul, kui teie projekt vajab minimaalset seadistust ilma pilveressursside halduseta, kindlat ja üle maailma ühtset mudelikataloogi või hinnastust, mida saab hõlpsasti väljendada ühe tellimustasuna. Platvormil on palju lõpp-punkti, juurutuse, piirkonna, kvoodi, identiteedi ja eelvaate olekuga seotud valikuid. Võimalused võivad mudelite ja keskkondade vahel märkimisväärselt erineda, mistõttu edukas prototüüp ei taga automaatselt sama käitumist tootmiskeskkonnas.

Uue rakenduse puhul on mõistlik alustada toetatud mudeli juurutamisest, kasutada Azure OpenAI-ga ühilduvat Responses API-t, autentida võimaluse korral Entra ID abil ning lisada voogesitus, struktureeritud väljundid, failid või tööriistad alles pärast seda, kui olete valitud mudeli ja juurutuse toe kinnitanud. Liikuge Foundry projekti lõpp-punktide ja Agent Service'i juurde siis, kui rakendus vajab püsivaid agente, hindamisi või Foundry-spetsiifilisi projektiressursse.

Allikad 11