Luo vastauksia Responses API:n avulla

10 minuuttia

OoenAI Responses API yhdistää kahden aiemmin erillisen API:n (ChatCompletions ja Assistants) ominaisuudet yhtenäiseksi kokemukseksi. Se tarjoaa tilallisen ja monikierrokseisen vastetuoton, mikä tekee siitä ihanteellisen keskustelupohjaisiin tekoälysovelluksiin. Voit käyttää Responses API:ta OpenAI-yhteensopivan asiakkaan kautta joko Foundry SDK:lla tai OpenAI SDK:lla.

Responses API:n ymmärtäminen

Responses API tarjoaa useita etuja perinteisiin chatin täydentämiseen verrattuna:

Tilalliset keskustelut: Ylläpitää keskustelukontekstia useiden kierrosten ajan
Yhtenäinen kokemus: Yhdistää chatin täydentämisen ja avustajien API-mallit
Foundry direct models: Työskentelee suoraan Microsoft Foundryssa isännöityjen mallien kanssa, ei pelkästään OpenAI-mallien Azure
Simple integration: Access OpenAI-yhteensopivan asiakasohjelman kautta

Muistio

Responses API on suositeltu tapa tuottaa tekoälyvastauksia Microsoft Foundry -sovelluksissa. Se korvaa vanhemman ChatCompletions-API :n useimmissa tilanteissa.

Yksinkertaisen vastauksen tuottaminen

OpenAI-yhteensopivalla asiakasohjelmalla voit tuottaa vastauksia responses.create() -menetelmällä:

# 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)

Syöteparametri hyväksyy tekstimerkkijonon, joka sisältää kehotteen. Malli tuottaa vastauksen tämän syötteen perusteella.

Vasterakenneen ymmärtäminen

Vasteobjektilla on useita hyödyllisiä ominaisuuksia:

output_text: Generoitu tekstivastaus
id: Yksilöllinen tunniste tälle vastaukselle
tila: Vastauksen tila (esimerkiksi "valmis")
Käyttö: Tokenin käyttötiedot (syöte, tulos ja kokonaistokenit)
Malli: Malli, jota käytetään vasteen tuottamiseen

Voit access näitä ominaisuuksia hoitaaksesi vastaukset tehokkaasti:

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

Ohjeiden lisääminen

Käyttäjän syötteen lisäksi voit antaa ohjeita (joita usein kutsutaan järjestelmäkehotteeksi) mallin käyttäytymisen ohjaamiseksi:

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)

Vasteen generoinnin hallinta

Voit ohjata vasteen generointia lisäparametreilla:

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)

lämpötila: Säätelee satunnaisuutta (0,0–2,0). Korkeammat arvot tekevät tuotoksesta luovemman ja monipuolisemman
max_output_tokens: Rajoittaa maksimimäärää tokeneista vastauksessa
top_p: Vaihtoehto lämpötilalle satunnaisuuden hallintaan

Työskentely Foundryn suorien mallien kanssa

Kun käytetään FoundrySDK- tai AzureOpenAI-asiakasohjelmaa projektin päätepisteeseen yhdistämiseen, Responses-API toimii sekä Azure OpenAI -mallien että Foundryn suorien mallien (kuten Microsoft Phi, DeepSeek tai muiden suoraan Microsoft Foundryssa isännöityjen mallien) kanssa:

# 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)

Keskustelukokemusten luominen

Monimutkaisemmissa keskustelutilanteissa voit antaa järjestelmäohjeita ja rakentaa monikierroskeskusteluja:

# 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)

Todellisuudessa toteutus rakennetaan todennäköisesti silmukaksi, jossa käyttäjä voi interaktiivisesti syöttää viestejä jokaisen mallin saaman vastauksen perusteella:

# 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

Tämän esimerkin tulos näyttää samankaltaiselta:

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!

Kun käyttäjä syöttää uuden syötteen jokaisella vuorolla, malliin lähetettävä data sisältää Instructions-järjestelmäviestin, käyttäjän syötteen sekä mallilta aiemmin saadun vastauksen. Näin uusi syöte perustuu siihen kontekstiin, jonka malli tuotti edelliselle syötteelle.

Vaihtoehto: Manuaalinen keskusteluketjutus

Voit hallita keskusteluja manuaalisesti rakentamalla viestihistorian itse. Tämä lähestymistapa antaa sinulle enemmän hallintaa siihen, mitä kontekstia se sisältää:

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

Tämä manuaalinen lähestymistapa on hyödyllinen, kun tarvitset:

Muokkaa, mitkä viestit sisältyvät kontekstiin
Toteuta keskustelun karsiminen token-rajojen hallintaan
Tallenna ja palauta keskusteluhistoria tietokannasta

Tarkkojen aiempien vastausten hakeminen

Responses-API ylläpitää vastaushistoriaa, jolloin voit hakea aiempia vastauksia:

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

Kontekstin ikkunan huomioon ottavat asiat

previous_response_id-parametri yhdistää vastaukset ja ylläpitää keskustelukontekstia useiden API-kutsujen välillä.

On tärkeää huomata, että keskusteluhistorian pitäminen voi lisätä tokenien käyttöä. Yhden ajon aktiivinen kontekstiikkuna voi sisältää:

Järjestelmäohjeet (ohjeet, turvallisuussäännöt)
Nykyinen tehtäväsi
Keskusteluhistoria (edellinen käyttäjä + avustajaviestit)
Työkaluskeemat (funktiot, OpenAPI-speksit, MCP-työkalut jne.)
Työkalun tulokset (hakutulokset, koodintulkin tulos, tiedostot)
Haettu muisti tai asiakirjat (muistivarastoista, RAG:sta, tiedostohausta)

Kaikki nämä yhdistetään, tokenisoidaan ja lähetetään mallille yhdessä jokaisesta pyynnöstä. SDK auttaa hallitsemaan tilaa, mutta se ei automaattisesti halvenna tokenin käytöstä.

Responsiivisten chat-sovellusten luominen

Mallin vastaukset voivat kestää jonkin aikaa riippuen esimerkiksi käytetystä mallista, kontekstiikkunan koosta ja kehotteen koosta. Käyttäjät saattavat turhautua, jos sovellus näyttää "jumittuvan" odottaessaan vastausta, joten on tärkeää ottaa huomioon sovelluksen reagointikyky toteutuksessa.

Suoratoistovastaukset

Pitkissä vastauksissa voit käyttää suoratoistoa vastaanottamaan tulosta asteittain – jolloin käyttäjä näkee osittain valmiit vastaukset, kun ulostulo tulee saataville:

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)

Jos seuraat keskusteluhistoriaa striimauksen aikana, voit saada vastaustunnuksen striimin päättyessä, kuten näin:

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

Asynkronin käyttö

Suorituskykyisissä sovelluksissa voit käyttää asynkronista asiakasta, jonka avulla voit tehdä ei-estäviä API-kutsuja. Asynkroninen käyttö on ihanteellista pitkäaikaisille pyynnöille tai kun haluat käsitellä useita pyyntöjä samanaikaisesti estämättä sovellustasi. Käyttääksesi sitä, tuo AsyncOpenAI ja OpenAIawait käytä jokaisessa API-kutsussa:

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())

Asynkroninen suoratoisto toimii samalla tavalla:

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())

Käyttämällä Microsoft Foundry SDK:n Responses API:ta voit rakentaa kehittyneitä keskustelevia tekoälysovelluksia, jotka säilyttävät kontekstin, tukevat useita mallityyppejä ja tarjoavat reagoivan käyttäjäkokemuksen.

Palaute

Onko tästä sivusta apua?