Generování odpovědí pomocí rozhraní API pro odpovědi

  • 10 min

Rozhraní API odpovědí OoenAI spojuje funkce ze dvou dříve oddělených rozhraní API (ChatCompletions a Asistentů) v jednotném prostředí. Poskytuje stavové a vícenásobné generování odpovědí, což je ideální pro konverzační aplikace AI. K rozhraní API pro odpovědi můžete přistupovat prostřednictvím klienta kompatibilního s OpenAI pomocí sady Foundry SDK nebo sady OpenAI SDK.

Pochopení rozhraní API pro odpovědi

Rozhraní API pro odpovědi nabízí oproti tradičním dokončováním chatu několik výhod:

  • Stavové konverzace: Udržuje kontext konverzace napříč několika interakcemi.
  • Jednotné prostředí: Kombinuje dokončování chatů a vzory rozhraní API asistentů.
  • Foundry direct models: Funguje s modely hostovanými přímo v Microsoft Foundry, nejen s modely Azure OpenAI
  • Jednoduchá integrace: Přístup prostřednictvím klienta kompatibilního s OpenAI

Poznámka:

Rozhraní API pro odpovědi je doporučeným přístupem pro generování odpovědí umělé inteligence v aplikacích Microsoft Foundry. Ve většině scénářů nahrazuje starší rozhraní API Pro dokončování chatu .

Generování jednoduché odpovědi

Pomocí klienta kompatibilního s OpenAI můžete generovat odpovědi pomocí metody responses.create():

# Generate a response using the OpenAI-compatible client
response = openai_client.responses.create(
    model="gpt-4.1",  # Your model deployment name
    input="What is Microsoft Foundry?"
)

# Display the response
print(response.output_text)

Vstupní parametr přijímá textový řetězec obsahující vaši výzvu. Model vygeneruje odpověď na základě tohoto vstupu.

Principy struktury odpovědí

Objekt odpovědi obsahuje několik užitečných vlastností:

  • output_text: Vygenerovaná textová odpověď
  • ID: Jedinečný identifikátor pro tuto odpověď
  • status: Stav odpovědi (například Dokončeno)
  • usage: Informace o využití tokenů (vstup, výstup a celkový počet tokenů)
  • model: Model použitý k vygenerování odpovědi

K efektivnímu zpracování odpovědí můžete access tyto vlastnosti:

response = openai_client.responses.create(
    model="gpt-4.1",
    input="Explain machine learning in simple terms."
)

print(f"Response: {response.output_text}")
print(f"Response ID: {response.id}")
print(f"Tokens used: {response.usage.total_tokens}")
print(f"Status: {response.status}")

Přidání pokynů

Kromě uživatelského vstupu můžete zadat pokyny (často označované jako výzva systému), které vám pomůžou řídit chování modelu:

response = client.responses.create(
    model="gpt-4.1",
    instructions="You are a helpful AI assistant that answers questions clearly and concisely.",
    input="Explain neural networks."
)

print(response.output_text)

Řízení generování odpovědí

Generování odpovědí můžete řídit pomocí dalších parametrů:

response = openai_client.responses.create(
    model="gpt-4.1",
    instructions="You are a helpful AI assistant that answers questions clearly and concisely.",
    input="Write a creative story about AI.",
    temperature=0.8,  # Higher temperature for more creativity
    max_output_tokens=200  # Limit response length
)

print(response.output_text)
  • teplota: Řídí náhodnost (0.0-2.0). Vyšší hodnoty činí výstup kreativním a pestřejším
  • max_output_tokens: Omezuje maximální počet tokenů v odpovědi.
  • top_p: Alternativou k teplotě pro řízení náhodnosti

Práce s přímými modely Foundry

Při použití klienta FoundrySDK nebo AzureOpenAI pro připojení ke koncovému bodu projektu funguje rozhraní API pro odpovědi s modely Azure OpenAI i s přímými modely Foundry (jako je Microsoft Phi, DeepSeek nebo jiné modely hostované přímo v Microsoft Foundry):

# Using a Foundry direct model
response = openai_client.responses.create(
    model="microsoft-phi-4",  # Example Foundry direct model
    instructions="You are a helpful AI assistant that answers questions clearly and concisely.",
    input="What are the benefits of small language models?"
)

print(response.output_text)

Vytváření konverzačních prostředí

V případě složitějších konverzačních scénářů můžete poskytnout systémové pokyny a vytvářet vícekrokové konverzace:

# First turn in the conversation
response1 = openai_client.responses.create(
    model="gpt-4.1",
    instructions="You are a helpful AI assistant that explains technology concepts clearly.",
    input="What is machine learning?"
)

print("Assistant:", response1.output_text)

# Continue the conversation
response2 = openai_client.responses.create(
    model="gpt-4.1",
    instructions="You are a helpful AI assistant that explains technology concepts clearly.",
    input="Can you give me an example?",
    previous_response_id=response1.id
)

print("Assistant:", response2.output_text)

Ve skutečnosti se implementace pravděpodobně vytvoří jako smyčka, ve které může uživatel interaktivně zadávat zprávy na základě každé odpovědi přijaté z modelu:

# Track responses
last_response_id = None

# Loop until the user wants to quit
print("Assistant: Enter a prompt (or type 'quit' to exit)")
while True:
    input_text = input('\nYou: ')
    if input_text.lower() == "quit":
        print("Assistant: Goodbye!")
        break

    # Get a response
    response = openai_client.responses.create(
                model=model_name,
                instructions="You are a helpful AI assistant that explains technology concepts clearly.",
                input=input_text,
                previous_response_id=last_response_id
    )
    assistant_text = response.output_text
    print("\nAssistant:", assistant_text)
    last_response_id = response.id

Výstup z tohoto příkladu vypadá nějak takto:

Assistant: Enter a prompt (or type 'quit' to exit)

You: What is machine learning?

Assistant: Machine learning is a type of artificial intelligence (AI) that enables computers to learn from data and improve their performance over time without being explicitly programmed. It involves training algorithms on large datasets to recognize patterns, make predictions, or take actions based on those patterns. This allows machines to become more accurate and efficient in their tasks as they are exposed to more data.

You: Can you give me an example?

Assistant: Certainly! Let's look at a simple example of supervised learning—predicting house prices based on features like size, location, and number of rooms.
Imagine you want to build a machine learning model that can predict the price of a house based on various factors.
...
    { the example provided in the model response may be extensive}
...

You: quit

Assistant: Goodbye!

Když uživatel zadává nový vstup na každém kroku, data odeslaná do modelu zahrnují systémovou zprávu Instrukce , vstup od uživatele a předchozí odpověď přijatou z modelu. Tímto způsobem se nový vstup uzemní v kontextu poskytnutém odpovědí, kterou model vygeneroval pro předchozí vstup.

Alternativa: Manuální řetězení konverzací

Konverzace můžete spravovat ručně vytvořením historie zpráv sami. Tento přístup vám dává větší kontrolu nad tím, jaký kontext je součástí:

try:
    # Start with initial message
    conversation_history = [
        {
            "type": "message",
            "role": "user",
            "content": "What is machine learning?"
        }
    ]
    
    # First response
    response1 = openai_client.responses.create(
        model="gpt-4.1",
        input=conversation_history
    )
    
    print("Assistant:", response1.output_text)
    
    # Add assistant response to history
    conversation_history += response1.output
    
    # Add new user message
    conversation_history.append({
        "type": "message",
        "role": "user", 
        "content": "Can you give me an example?"
    })
    
    # Second response with full history
    response2 = openai_client.responses.create(
        model="gpt-4.1",
        input=conversation_history
    )
    
    print("Assistant:", response2.output_text)

except Exception as ex:
    print(f"Error: {ex}")

Tento ruční přístup je užitečný v případě, že potřebujete:

  • Přizpůsobte, které zprávy jsou zahrnuty v kontextu
  • Implementace prořezávání konverzací pro správu limitů tokenů
  • Ukládání a obnovení historie konverzací z databáze

Načítání konkrétních předchozích odpovědí

Rozhraní API pro odpovědi udržuje historii odpovědí, takže můžete načíst předchozí odpovědi:

try:   
   
    # Retrieve a previous response
    response_id = "resp_67cb61fa3a448190bcf2c42d96f0d1a8"  # Example ID
    previous_response = openai_client.responses.retrieve(response_id)
    
    print(f"Previous response: {previous_response.output_text}")

except Exception as ex:
    print(f"Error: {ex}")

Aspekty kontextového okna

Parametr previous_response_id propojuje odpovědi společně a udržuje kontext konverzace napříč několika voláními rozhraní API.

Je důležité si uvědomit, že udržování historie konverzací může zvýšit využití tokenů. Pro jedno spuštění může aktivní kontextové okno zahrnovat:

  • Systémové pokyny (pokyny, bezpečnostní pravidla)
  • Aktuální výzva
  • Historie konverzací (předchozí zprávy asistenta + uživatel)
  • Schémata nástrojů (funkce, specifikace OpenAPI, nástroje MCP atd.)
  • Výstupy nástrojů (výsledky hledání, výstup interpretu kódu, soubory)
  • Načtená paměť nebo dokumenty (z úložišť paměti, RAG, hledání souborů)

Všechny jsou zřetězeny, tokenizovány a odesílány do modelu společně při každém požadavku. Sada SDK vám pomůže spravovat stav, ale automaticky nezlevňuje využití tokenů.

Vytváření responzivních chatovacích aplikací

Odpovědi z modelu můžou nějakou dobu trvat, než se vygenerují v závislosti na faktorech, jako je použitý konkrétní model, velikost kontextového okna a velikost výzvy. Uživatel může být frustrovaný, pokud se zdá, že se aplikace zablokuje při čekání na odpověď, takže je důležité zvážit responzivitu aplikace ve vaší implementaci.

Streamující odpovědi

U dlouhých odpovědí můžete k přírůstkovému příjmu výstupu použít streamování, takže uživatel uvidí částečně dokončené odpovědi, jakmile je výstup k dispozici.

stream = openai_client.responses.create(
    model="gpt-4.1",
    input="Write a short story about a robot learning to paint.",
    stream=True
)

for event in stream:
    print(event, end="", flush=True)

Pokud při streamování sledujete historii konverzací, můžete po skončení streamu získat ID odpovědi, například takto:

stream = openai_client.responses.create(
    model="gpt-4.1",
    input="Write a short story about a robot learning to paint.",
    stream=True
)
for event in stream:
                if event.type == "response.output_text.delta":
                    print(event.delta, end="")
                elif event.type == "response.completed":
                    response_id = event.response.id

Asynchronní použití

U vysoce výkonných aplikací můžete použít asynchronního klienta, který umožňuje provádět neblokující volání rozhraní API. Asynchronní použití je ideální pro dlouhotrvající požadavky nebo pokud chcete zpracovávat více požadavků souběžně bez blokování aplikace. Pro použití importujte AsyncOpenAI místo OpenAI a používejte await s každým voláním rozhraní API.

import asyncio
from openai import AsyncOpenAI

client = AsyncOpenAI(
    base_url="https://<resource-name>.openai.azure.com/openai/v1/",
    api_key=token_provider,
)

async def main():
    response = await client.responses.create(
        model="gpt-4.1",
        input="Explain quantum computing briefly."
    )
    print(response.output_text)

asyncio.run(main())

Asynchronní streamování funguje stejným způsobem:

async def stream_response():
    stream = await client.responses.create(
        model="gpt-4.1",
        input="Write a haiku about coding.",
        stream=True
    )
    
    async for event in stream:
        print(event, end="", flush=True)

asyncio.run(stream_response())

Pomocí rozhraní API odpovědí prostřednictvím sady Microsoft Foundry SDK můžete vytvářet sofistikované konverzační aplikace AI, které udržují kontext, podporují více typů modelů a poskytují responzivní uživatelské prostředí.