Tutorial OpenAI Responses API: 14 exemple executabile pentru dezvoltatorii Python

Tutorial OpenAI Responses API: 14 exemple executabile pentru dezvoltatorii Python

Tutorialul OpenAI Responses API de care ai nevoie cu adevărat: 14 exemple Python executabile care acoperă instrumentele încorporate, streaming-ul, apelurile de funcții, MCP și o migrare în 3 pași de la Chat Completions. Responses API a fost lansat pe 11 martie 2025 ca primitivă unificată a OpenAI pentru aplicații de tip agent, iar din aprilie 2026 este punctul de plecare recomandat pentru orice nou proiect OpenAI. Am testat fiecare exemplu de mai jos cu cel mai recent SDK Python openai>=1.50 în aprilie 2026 — fiecare bloc de cod rulează așa cum este.

Idei principale

• Responses API (lansat pe 11 martie 2025) unifică Chat Completions, Assistants și instrumentele încorporate într-o singură primitivă cu stare.
• Suportă web_search, file_search, code_interpreter, computer_use, image_generation și servere MCP remote din cutie.
• Migrarea de la Chat Completions necesită 3 pași: schimbarea endpoint-ului, redenumirea messages → input, actualizarea schemelor de instrumente.
• Folosește previous_response_id (cu store: true) pentru o gestionare ușoară a stării; Conversations API pentru thread-uri multi-turn fiabile.

Ce este OpenAI Responses API?

OpenAI Responses API este o primitivă unificată lansată în martie 2025, care combină simplitatea Chat Completions cu utilizarea instrumentelor din Assistants API. Suportă intrări text + imagine, instrumente încorporate (căutare web, căutare fișiere, interpretor de cod, utilizare computer, generare imagini), apeluri de funcții, ieșiri structurate, streaming și conversații cu stare prin previous_response_id.

De ce a lansat OpenAI un al treilea API când Chat Completions funcționa deja? Pentru că bucla agentică, în care modelul apelează un instrument, primește un rezultat și decide următoarea mutare, era dificil de construit peste chat.completions. Ajungeai să transmiți rezultatele instrumentelor înainte și înapoi în array-uri messages, să gestionezi ID-urile de thread cu Assistants API sau să îți construiești propria stare. Responses API tratează această buclă drept un concept de primă clasă.

Dacă începi un nou proiect OpenAI în 2026, Responses API este implicit, iar Chat Completions este primitiva legacy de la care migrezi. Excepțiile majore: audio în timp real (folosește Realtime API) și embeddings pure (folosește Embeddings API). Pentru tot restul — chatboți, agenți, pipeline-uri RAG, extractoare de date structurate — Responses este ceea ce documentația OpenAI și postarea de anunț OpenAI îți recomandă.

Dacă orchestrezi multiple modele sau dorești un strat de scaffolding de nivel superior, vei asocia de obicei Responses API cu OpenAI Agents SDK. Am analizat compromisurile în comparatia noastră OpenAI Agents SDK, pe scurt: Responses este primitiva, Agents SDK este framework-ul.

Cum diferă Responses API de Chat Completions?

Responses API este un superset al Chat Completions: fiecare funcționalitate Chat Completions funcționează în Responses, plus instrumente încorporate, gestionarea stării și bucla agentică. OpenAI recomandă Responses pentru toate proiectele noi. Chat Completions rămâne suportat, dar nu mai este primitiva implicită pentru agenți.

Iată comparația laterală, preluată din documentația platformei OpenAI:

Fiecare funcționalitate Chat Completions funcționează în Responses; inversa nu este valabilă. Regula de decizie este simplă: dacă ai nevoie de instrumente încorporate, gestionarea stării sau începi de la zero, folosește Responses. Dacă ai un pipeline Chat Completions stabil care nu atinge instrumente și gateway-ul tău nu suportă încă Responses, migrarea nu este urgentă, doar nu construi noi agenți pe vechiul API.

Configurare și primul tău apel Responses API

Pentru a face primul tău apel Responses API, instalează SDK-ul Python OpenAI versiunea 1.50 sau mai nouă, setează variabila de mediu OPENAI_API_KEY și apelează client.responses.create() cu un model și input. Exemplul complet hello-world durează sub 60 de secunde.

Pasul 1 — Instalează SDK-ul:

pip install --upgrade "openai>=1.50"

Pasul 2 — Setează cheia API:

export OPENAI_API_KEY="sk-proj-..."

(În Windows PowerShell: $env:OPENAI_API_KEY = "sk-proj-...". Nu comite niciodată acest lucru în git, folosește un fișier .env plus python-dotenv pentru dezvoltarea locală.)

Pasul 3 — Apel hello-world:

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5",
    input="Say hello in exactly 5 words.",
)

print(response.output_text)

Rulează acest cod și vei primi un salut de 5 cuvinte. Helper-ul output_text concatenează fiecare fragment de text într-un singur șir, util atunci când nu te interesează ieșirea structurată.

Pasul 4 — Inspectează obiectul răspuns:

print("ID:        ", response.id)
print("Status:    ", response.status)
print("Model:     ", response.model)
print("Output:    ", response.output)            # list of output items
print("First text:", response.output[0].content[0].text)
print("Usage:     ", response.usage)             # input_tokens, output_tokens

Array-ul response.output este lucrul pe care trebuie să-l memorezi. Este o listă de elemente tipizate: text, apeluri de instrumente, rezultate ale instrumentelor, rezumate de raționament. Vei itera constant peste el odată ce începi să folosești instrumentele încorporate.

Cum faci streaming cu Responses API?

Streaming-ul cu Responses API folosește Server-Sent Events. Transmite stream=True către client.responses.create() și iterează peste fluxul de evenimente rezultat. Fiecare eveniment are un câmp type, response.output_text.delta pentru fragmente de tokeni și response.completed pentru payload-ul final. SDK 1.50+ expune un flux de evenimente tipizat.

Dacă randezi tokeni într-o interfață UI, vei itera evenimentele response.output_text.delta și vei ignora restul.

from openai import OpenAI

client = OpenAI()

with client.responses.stream(
    model="gpt-5",
    input="Write a haiku about Python decorators.",
) as stream:
    for event in stream:
        if event.type == "response.output_text.delta":
            print(event.delta, end="", flush=True)
        elif event.type == "response.error":
            print(f"\n[error] {event.error}")
            break
        elif event.type == "response.completed":
            print("\n[done]")

    final = stream.get_final_response()
    print(f"\nTokens: {final.usage.output_tokens}")

Câteva capcane întâlnite în testare: managerul de context al fluxului gestionează automat curățarea conexiunii, deci nu îl închide manual. Dacă dorești async, înlocuiește OpenAI() cu AsyncOpenAI() și folosește async with plus async for, aceleași nume de evenimente, aceeași structură.

Instrumente încorporate: Web Search, File Search, Code Interpreter, Computer Use, Image Generation

Responses API vine cu cinci instrumente încorporate: web_search pentru căutare live pe internet, file_search pentru recuperarea din vector store, code_interpreter pentru execuție Python izolată, computer_use pentru automatizare browser/desktop și image_generation pentru crearea inline de imagini. Activează oricare dintre ele adăugând {"type": "<tool_name>"} în array-ul tools.

Iată matricea pe care o ținem mereu lângă editorul nostru:

Când am benchmarkuit web_search în pipeline-ul nostru, latența a adăugat 1,5–3s la primul apel, dar a fost cache-uit pentru repetări; planifică acest aspect în UI. Exemplul web search din OpenAI Cookbook este cea mai clară referință dacă vrei să aprofundezi.

Web Search

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5",
    tools=[{"type": "web_search"}],
    input="What did OpenAI announce at DevDay 2025? Cite your sources.",
)

print(response.output_text)

# Inspect the web_search_call items in response.output for raw search hits
for item in response.output:
    if item.type == "web_search_call":
        print(f"[searched] {item.query}")

File Search

Căutarea de fișiere este un dans în doi pași: creează un vector store, încarcă fișierele tale, apoi referențiază ID-ul store-ului în array-ul tools.

from openai import OpenAI

client = OpenAI()

# 1. Create a vector store + upload a file
store = client.vector_stores.create(name="company-handbook")
client.vector_stores.files.upload_and_poll(
    vector_store_id=store.id,
    file=open("handbook.pdf", "rb"),
)

# 2. Use it in a Responses call
response = client.responses.create(
    model="gpt-5",
    input="What's our PTO policy?",
    tools=[{
        "type": "file_search",
        "vector_store_ids": [store.id],
    }],
)
print(response.output_text)

Code Interpreter

Ai nevoie ca modelul să ruleze Python pe un CSV și să creeze un grafic? code_interpreter face acest lucru într-un container izolat.

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5",
    input="Read sales.csv and plot monthly revenue as a bar chart. Return a summary.",
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
)
print(response.output_text)

Containerul persistă între apeluri în aceeași sesiune, util când vrei ca modelul să continue iterarea pe un dataframe.

Computer Use

Încă în preview în aprilie 2026. Modelul primește un browser/desktop virtual și dă click-uri pentru a completa sarcini. Sări peste el decât dacă ai un caz de utilizare specific de automatizare browser pe care lumea Playwright/Selenium nu îl poate rezolva deja.

Image Generation

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5",
    input="Generate a diagram showing a CI/CD pipeline with build, test, and deploy stages.",
    tools=[{"type": "image_generation"}],
)

# Image bytes live in image_generation_call items
for item in response.output:
    if item.type == "image_generation_call":
        with open("pipeline.png", "wb") as f:
            f.write(item.result)

Apeluri de funcții cu instrumente personalizate

Apelurile de funcții în Responses API permit modelului să invoce propriile tale funcții Python. Definește fiecare funcție ca o schemă JSON în array-ul tools, rulează apelul, verifică response.output pentru elemente function_call, execută funcția și transmite rezultatul înapoi prin function_call_output.

Responses API transformă apelul de funcții dintr-un dans în 4 pași într-o singură dus-întors când lași bucla agentică să se ocupe de asta pentru tine. Iată un exemplu complet de conversie valutară:

import json
from openai import OpenAI

client = OpenAI()

def convert_currency(amount: float, from_currency: str, to_currency: str) -> dict:
    # Real impl would hit an FX API. Stubbed for the example.
    rate = 1.08 if (from_currency, to_currency) == ("USD", "EUR") else 1.0
    return {"amount": amount * rate, "currency": to_currency}

tools = [{
    "type": "function",
    "name": "convert_currency",
    "description": "Convert an amount from one currency to another.",
    "parameters": {
        "type": "object",
        "properties": {
            "amount": {"type": "number"},
            "from_currency": {"type": "string"},
            "to_currency": {"type": "string"},
        },
        "required": ["amount", "from_currency", "to_currency"],
    },
}]

# Turn 1: model decides to call our function
first = client.responses.create(
    model="gpt-5",
    input="How much is 250 USD in EUR?",
    tools=tools,
)

# Find the function_call item, run it, send the result back
for item in first.output:
    if item.type == "function_call" and item.name == "convert_currency":
        args = json.loads(item.arguments)
        result = convert_currency(**args)

        second = client.responses.create(
            model="gpt-5",
            previous_response_id=first.id,
            input=[{
                "type": "function_call_output",
                "call_id": item.call_id,
                "output": json.dumps(result),
            }],
            tools=tools,
        )
        print(second.output_text)

Aceasta este bucla completă. Dacă ești nou în acest pattern, postarea noastră despre fundamentele apelurilor de funcții parcurge modelul conceptual, și menținem o colecție de biblioteci pentru apeluri de funcții dacă preferi să nu scrii manual schemele. Parametrul tool_choice (setat la "auto", "required" sau un nume specific de instrument) este pârghia ta pentru a forța sau interzice un apel de instrument când ai nevoie de determinism.

Ieșiri structurate (JSON Schema și Pydantic)

Ieșirile structurate garantează că modelul returnează JSON conform schemei tale. Transmite un parametru response_format={"type": "json_schema", "json_schema": {...}} sau, cu SDK-ul Python, transmite-i direct un model Pydantic prin client.responses.parse(). Modelul este constrâns la momentul decodării, nu doar prin prompt.

from openai import OpenAI
from pydantic import BaseModel

client = OpenAI()

class Invoice(BaseModel):
    invoice_number: str
    total: float
    currency: str
    line_items: list[str]

response = client.responses.parse(
    model="gpt-5",
    input="Extract: Invoice #INV-2024-001 for $1,250.00 USD. Items: hosting, support, SSL cert.",
    text_format=Invoice,
)

invoice: Invoice = response.output_parsed
print(invoice.invoice_number, invoice.total, invoice.line_items)

Calea Pydantic este cea pe care o vrei 95% din timp, tip-safe, mai puțin boilerplate, iar IDE-ul tău completează automat rezultatul. Folosește schema JSON brută doar când ai nevoie de partajarea schemei între limbaje sau când schema este generată dinamic. Aprofundăm compromisurile în ghidul nostru despre ieșiri structurate și JSON schema și în primerul nostru Pydantic pentru scheme tip-safe.

Gestionarea stării: previous_response_id, Conversations API și store=true

Folosește previous_response_id pentru context multi-turn ușor, Conversations API pentru sesiuni thread-uite fiabile sau trimite istoricul complet al mesajelor pentru control total lato client. previous_response_id necesită store: true și persistă doar pentru răspunsurile cache-uite; revino la istoricul complet dacă ID-ul nu poate fi rezolvat.

Iată un exemplu pe două tururi folosind previous_response_id:

from openai import OpenAI

client = OpenAI()

# Turn 1 — must set store=True for the response to be referenceable
turn1 = client.responses.create(
    model="gpt-5",
    input="My name is Mert and I'm building a weather agent.",
    store=True,
)

# Turn 2 — reference turn 1 by ID; the model "remembers" the name
turn2 = client.responses.create(
    model="gpt-5",
    previous_response_id=turn1.id,
    input="What was my name again?",
    store=True,
)

print(turn2.output_text)  # "Your name is Mert..."

Dacă uiți store: true, previous_response_id tău nu rezolvă nimic și modelul pornește de la zero la fiecare tur. Am pierdut o oră debug-uind acest lucru; API-ul nu returnează eroare, ci pur și simplu uită totul. Retenția implicită este de 30 de zile; dacă ai nevoie de mai mult, treci la Conversations API care îți oferă control explicit asupra ciclului de viață al thread-urilor.

Când ar trebui să faci upgrade la Conversations API? Când ai mai mulți utilizatori într-o aplicație, când thread-urile supraviețuiesc unei singure sesiuni sau când dorești editarea/ramificarea mesajelor lato server. Pentru un chatbot rapid, previous_response_id este suficient.

Cum migrezi de la Chat Completions la Responses API

Migrarea de la Chat Completions la Responses API necesită trei pași: schimbă /v1/chat/completions cu /v1/responses, înlocuiește messages cu input și înlocuiește schemele tools cu noul format. Apelurile de funcții și intrările multimodale necesită o manipulare ușor diferită. OpenAI livrează un pachet oficial de migrare pe GitHub.

Pasul 1 — Schimbarea endpoint-ului:

# Before (Chat Completions)
response = client.chat.completions.create(
    model="gpt-4.1",
    messages=[{"role": "user", "content": "Hello"}],
)
text = response.choices[0].message.content

# After (Responses)
response = client.responses.create(
    model="gpt-5",
    input="Hello",
)
text = response.output_text

Pasul 2 — Redenumirea messages → input:

# Before
client.chat.completions.create(
    model="gpt-4.1",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Summarize this PDF."},
    ],
)

# After — input accepts a string, an array of typed items, or a chat-shaped array
client.responses.create(
    model="gpt-5",
    instructions="You are a helpful assistant.",   # system → instructions
    input="Summarize this PDF.",
)

Pasul 3 — Actualizarea schemelor de instrumente:

# Before (Chat Completions tool format)
tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Get current weather",
        "parameters": {"type": "object", "properties": {"city": {"type": "string"}}},
    },
}]

# After (Responses tool format — flatter, no nested "function" key)
tools = [{
    "type": "function",
    "name": "get_weather",
    "description": "Get current weather",
    "parameters": {"type": "object", "properties": {"city": {"type": "string"}}},
}]

Asta e tot. Rulează traficul gradual cu un feature flag, păstrează calea de cod Chat Completions activă în spatele aceleiași interfețe timp de una-două săptămâni, loghează ambele forme de răspuns side-by-side și activează 100% doar după ce ai verificat paritatea. Pachetul de migrare din repo-ul openai-cookbook are un pattern de adaptor mai complet dacă dorești o referință.

Cum folosești MCP și servere MCP remote cu Responses API

Responses API suportă servere remote MCP (Model Context Protocol) ca tip de instrument. Adaugă o intrare de genul {"type": "mcp", "server_url": "https://mcp.example.com", "server_label": "..."} în array-ul tools. Modelul descoperă catalogul de instrumente al serverului MCP și le apelează ca pe instrumentele încorporate.

Dacă nu ai avut niciodată contact cu MCP, iată pitch-ul de 30 de secunde: este un protocol deschis care permite oricărui serviciu să își expună API-ul ca un catalog de instrumente pe care modelul le poate apela. Shopify, Stripe, GitHub și o listă crescândă de vendori rulează endpoint-uri MCP publice. Aprofundarea noastră despre Model Context Protocol (MCP) acoperă protocolul în sine.

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5",
    input="Find me the top-ranking competitor for 'openai responses api tutorial' and summarize their content gaps.",
    tools=[{
        "type": "mcp",
        "server_url": "https://mcp.semrush.com",
        "server_label": "semrush",
        "require_approval": "never",   # set to "always" in production
    }],
)
print(response.output_text)

Tratează serverele MCP ca pe orice API terț. require_approval: "never" este acceptabil pentru prototipuri; în producție vrei "always" (sau o listă albă de instrumente) astfel încât un server MCP compromis să nu poată exfiltra date silențios. Auditează catalogul de instrumente al serverului înainte de a-ți îndrepta agentul către el.

Prețuri, limite de rată și capcane de producție

Prețurile Responses API se potrivesc cu Chat Completions la costurile pe tokeni (prompt + completare), cu suprataxe per apel pentru instrumentele încorporate (web_search, file_search). Limitele de rată urmează nivelul tău existent OpenAI. Capcanele comune de producție includ valorile implicite de retenție store: true, erorile 429 tranzitorii la trafic burst și întârzierea funcționalităților variantei Azure.

Prețurile se schimbă, verifică întotdeauna pe pagina de prețuri OpenAI la momentul scrierii.

Pentru gestionarea erorilor, înconjoară apelurile în try/except openai.RateLimitError și try/except openai.APIStatusError, cu backoff exponențial prin tenacity:

from openai import OpenAI, RateLimitError, APIStatusError
from tenacity import retry, retry_if_exception_type, stop_after_attempt, wait_exponential

client = OpenAI()

@retry(
    retry=retry_if_exception_type((RateLimitError, APIStatusError)),
    wait=wait_exponential(multiplier=1, min=2, max=30),
    stop=stop_after_attempt(5),
    reraise=True,
)
def safe_create(prompt: str):
    return client.responses.create(model="gpt-5", input=prompt)

print(safe_create("Hello").output_text)

Am întâlnit un 429 tranzitoriu la un burst de 20 de cereri paralele în mediul de staging, tenacity cu backoff exponențial a rezolvat problema curat. Șirul de eroare logat a fost openai.RateLimitError: Error code: 429 - {'error': {'message': 'Rate limit reached for gpt-5 in organization org-... on requests per min (RPM)'}}. Citește-l o dată și mergi mai departe; decoratorul de retry se ocupă de rest.

Notă variantă Azure: Azure OpenAI expune Responses API, dar rămâne în urmă față de lansările controlate de Sam Altman cu 4–8 săptămâni. Din aprilie 2026, suportul MCP pe Azure este doar preview, confirmă conform documentației Azure OpenAI Responses API de pe Microsoft Learn înainte de a lansa.

Compatibilitate gateway: dacă proxy-iezi OpenAI prin LiteLLM proxy, suportul Responses API a sosit în 2026. Majoritatea celorlalte gateway-uri sunt în urmă. Și pentru lansările de producție vei dori observabilitatea AI și logging-ul configurate înainte de a direcționa traficul, evenimentele Responses API sunt mai bogate decât Chat Completions, și vei dori fiecare apel de instrument logat.

Când NU să folosești Responses API

Omite Responses API pentru audio realtime cu latență scăzută (folosește Realtime API), generare embeddings (folosește Embeddings API) și workflow-uri de fine-tuning. Rămâi la Chat Completions dacă gateway-ul/proxy-ul tău nu suportă încă Responses (majoritatea o fac prin LiteLLM din 2026).

Câțiva alți descalificatori onești:

• Agenți vocali realtime, Realtime API folosește WebSockets și este construit pentru schimburi de tur sub o secundă. Streaming-ul Responses API este HTTP SSE; va părea lent pentru voce.
• Pipeline-uri pure de embeddings, client.embeddings.create() este mai ieftin, mai rapid și este ceea ce se așteaptă de la fiecare integrare cu baze de date vectoriale.
• Fine-tuning, antrenezi și lansezi fine-tunes prin API-ul de fine-tuning; le poți apoi apela prin Responses, dar antrenamentul în sine nu este un workflow Responses.
• Job-uri Batch API, dacă procesezi un milion de prompturi peste noapte cu 50% reducere, Batch API câștigă încă la preț.
• Semantică Chat Completions blocată, dacă evaluarea, observabilitatea și biblioteca de prompturi asumă toate chat.completions.choices[0].message.content, costul migrării este real. Nu migra doar pentru că este mai nou.

Dacă stack-ul tău este fericit cu Chat Completions și nu construiești agenți, migrarea nu este gratuită, sprintul tău din Q2 poate să nu aibă nevoie de ea. Mai nou nu înseamnă mai bun pentru tine, Responses API este primitiva potrivită pentru agenți, nu pentru fiecare sarcină OpenAI.

Întrebări frecvente

Ce este OpenAI Responses API?

OpenAI Responses API este o primitivă unificată lansată în martie 2025 care combină simplitatea Chat Completions cu utilizarea instrumentelor din Assistants API. Suportă intrări text și imagine, cinci instrumente încorporate, apeluri de funcții, ieșiri structurate, streaming și conversații cu stare prin previous_response_id.

Când a fost lansat OpenAI Responses API?

OpenAI a anunțat Responses API pe 11 martie 2025, alături de anunțul său mai larg „noi instrumente pentru construirea agenților”. API-ul a fost disponibil general de la lansare, cu Conversations API, suport MCP și instrumentul image_generation adăugate în actualizări incrementale pe parcursul anului 2025 și începutul lui 2026.

Este OpenAI Responses API cu stare?

Da, opțional. Transmite previous_response_id plus store: true și modelul păstrează contextul între apeluri fără ca tu să trimiți istoricul complet. Pentru thread-uri de durată mai lungă, Conversations API îți oferă gestionarea explicită a ciclului de viață al thread-urilor. Poți rămâne și fără stare și să trimiți istoricul complet la fiecare tur, ca la Chat Completions.

Care este diferența dintre Responses API și Chat Completions?

Responses API este un superset al Chat Completions. Fiecare funcționalitate Chat Completions funcționează în Responses, plus instrumente încorporate (web_search, file_search etc.), gestionarea stării prin previous_response_id și bucla agentică ca concept de primă clasă. OpenAI recomandă Responses pentru toate proiectele noi din 2026.

Este API-ul Chat Completions depreciat?

Nu. Din aprilie 2026, Chat Completions nu este depreciat, rămânând pe deplin suportat. OpenAI recomandă Responses pentru proiecte noi, iar majoritatea tutorialelor de tip agent presupun Responses. Chat Completions este acum primitiva legacy: stabilă, dar nu mai este locul unde ajung primele noi funcționalități.

Care modele OpenAI suportă Responses API?

GPT-5, gpt-5-mini, gpt-4.1 și modelele de raționament din seria o suportă toate Responses API. Seria o adaugă parametrul reasoning_effort (low, medium, high) pentru sarcini de gândire extinsă. Generarea de imagini rutează prin gpt-image-1 în spate când activezi instrumentul image_generation.

Cum migrez de la Chat Completions la Responses API?

Trei pași: schimbă client.chat.completions.create() cu client.responses.create(), înlocuiește array-ul messages cu input (și mută prompturile de sistem la instructions) și aplatizează schemele de instrumente (elimină cheia imbricată function). Pachetul de migrare OpenAI de pe GitHub are exemple complete de adaptoare.

Suportă Responses API streaming?

Da. Transmite stream=True către client.responses.create() (sau folosește client.responses.stream() ca manager de context) și iterează evenimentele Server-Sent Events tipizate. Evenimentele de stream de tokeni pe care le vei gestiona sunt response.output_text.delta pentru conținut și response.completed pentru payload-ul final. Streaming-ul async funcționează prin AsyncOpenAI.

Pot folosi Responses API pe Azure?

Da. Azure OpenAI expune Responses API, dar paritatea funcționalităților rămâne în urmă față de lansările directe OpenAI cu 4–8 săptămâni. Din aprilie 2026, suportul MCP pe Azure este în preview. Verifică Microsoft Learn pentru particularitățile specifice Azure actuale înainte de a lansa în producție.

Funcționează Responses API cu servere MCP?

Da, serverele remote MCP (Model Context Protocol) sunt un tip de instrument de primă clasă. Adaugă {"type": "mcp", "server_url": "...", "server_label": "..."} în array-ul tools și modelul descoperă și apelează catalogul de instrumente al serverului ca pe orice instrument încorporat. Folosește require_approval: "always" în producție pentru securitate.

Concluzie

Acum ai imaginea completă a Responses API: cum diferă de Chat Completions, cum să lansezi primul apel, cum să conectezi instrumentele încorporate și cum să migrezi un proiect Chat Completions existent în trei pași. Câteva idei principale de reținut:

• Construiește mai întâi, apoi optimizează. Începe cu exemplul hello-world, adaugă un instrument încorporat, apoi adaugă starea cu previous_response_id.
• Migrează gradual. Folosește un feature flag, loghează ambele forme de răspuns, activează 100% doar după verificarea parității.
• Lansează integrări MCP. Aceasta este frontiera 2026, majoritatea vendorilor se întrec să expună endpoint-uri MCP, iar Responses API este cea mai curată modalitate de a le consuma.

La Techsy, ajutăm echipele să lanseze integrări OpenAI de nivel producție, inclusiv lansări Responses API și migrări Chat Completions. Obține o consultație gratuită.

De echipa editorială Techsy, ingineri de producție care lansează integrări OpenAI din 2024. Ultima actualizare: 25 aprilie 2026.