Generowanie odpowiedzi za pomocą API do generowania odpowiedzi

Interfejs API Odpowiedzi OpenAI łączy funkcje z dwóch wcześniej oddzielnych interfejsów API (ChatCompletions i Asystentów) w zintegrowanym doświadczeniu. Zapewnia stanowe generowanie odpowiedzi z wieloma zwrotami, dzięki czemu idealnie nadaje się do konwersacyjnych aplikacji sztucznej inteligencji. Dostęp do interfejsu API Responses można uzyskać za pośrednictwem klienta zgodnego z OpenAI, używając pakietu SDK Foundry lub pakietu OpenAI SDK.

Omówienie interfejsu API odpowiedzi

API Responses oferuje kilka zalet w porównaniu z tradycyjnymi uzupełnieniami czatu.

• Konwersacje stanowe: utrzymuje kontekst konwersacji na wielu zakrętach
• Ujednolicone środowisko: łączy zakończenia czatu i wzorce API Asystenta
• Foundry direct models: Współpracuje z modelami hostowanymi bezpośrednio w Microsoft Foundry, a nie tylko w modelach Azure OpenAI
• Prosta integracja: dostęp przez klienta zgodnego z OpenAI

Generowanie prostej odpowiedzi

Za pomocą klienta zgodnego z interfejsem OpenAI można wygenerować odpowiedzi przy użyciu 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)

Parametr wejściowy akceptuje ciąg tekstowy zawierający monit. Model generuje odpowiedź na podstawie tych danych wejściowych.

Opis struktury odpowiedzi

Obiekt odpowiedzi zawiera kilka przydatnych właściwości:

• output_text: wygenerowana odpowiedź tekstowa
• id: Unikatowy identyfikator tej odpowiedzi
• status: Stan odpowiedzi (na przykład "ukończono")
• użycie: informacje o użyciu tokenu (dane wejściowe, wyjściowe i łączne tokeny)
• model: model używany do generowania odpowiedzi

Możesz uzyskać dostęp do tych właściwości, aby skutecznie obsługiwać odpowiedzi.

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

Dodawanie instrukcji

Oprócz danych wejściowych użytkownika można podać instrukcje (często nazywane monitem systemowym), aby kierować zachowaniem 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)

Kontrolowanie generowania odpowiedzi

Generowanie odpowiedzi można kontrolować za pomocą dodatkowych parametrów:

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)

• temperatura: Kontroluje losowość (0.0-2.0). Wyższe wartości sprawiają, że dane wyjściowe są bardziej kreatywne i zróżnicowane
• max_output_tokens: ogranicza maksymalną liczbę tokenów w odpowiedzi
• top_p: Alternatywa dla temperatury w celu kontrolowania losowości

Praca z modelami bezpośrednimi programu Foundry

W przypadku używania klienta FoundrySDK lub AzureOpenAI do nawiązywania połączenia z project, interfejs API odpowiedzi współdziała zarówno z modelami Azure OpenAI, jak i modelami bezpośrednimi Foundry (takimi jak Microsoft Phi, DeepSeek lub inne modele hostowane bezpośrednio w 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)

Tworzenie środowisk konwersacyjnych

W przypadku bardziej złożonych scenariuszy konwersacyjnych można udostępniać instrukcje systemowe i tworzyć konwersacje wieloełowe:

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

W rzeczywistości implementacja może zostać skonstruowana jako pętla, w której użytkownik może interaktywnie wprowadzać komunikaty na podstawie każdej odpowiedzi otrzymanej 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 

Dane wyjściowe z tego przykładu wyglądają podobnie do następujących:

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!

Gdy użytkownik wprowadza nowe dane wejściowe z każdej kolei, dane wysyłane do modelu zawierają komunikat systemowy Instrukcje , dane wejściowe od użytkownika i poprzednią odpowiedź odebraną z modelu. W ten sposób nowe dane wejściowe są uziemione w kontekście dostarczonym przez odpowiedź wygenerowaną przez model dla poprzednich danych wejściowych.

Alternatywa: Ręczne łączenie konwersacji

Konwersacje można zarządzać ręcznie, tworząc historię wiadomości samodzielnie. Takie podejście zapewnia większą kontrolę nad tym, jaki kontekst jest uwzględniony:

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

Ta metoda ręczna jest przydatna w następujących przypadkach:

• Dostosuj, które komunikaty są uwzględnione w kontekście.
• Implementowanie przycinania konwersacji w celu zarządzania limitami tokenów
• Przechowywanie i przywracanie historii konwersacji z bazy danych

Pobieranie określonych poprzednich odpowiedzi

Interfejs API odpowiedzi utrzymuje historię odpowiedzi, umożliwiając pobieranie poprzednich odpowiedzi:

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

Zagadnienia dotyczące okna kontekstowego

Parametr previous_response_id łączy odpowiedzi ze sobą, zachowując kontekst konwersacji w wielu wywołaniach interfejsu API.

Należy pamiętać, że utrzymywanie historii konwersacji może zwiększyć użycie tokenu. W przypadku pojedynczego przebiegu aktywne okno kontekstu może obejmować:

• Instrukcje systemowe (instrukcje, reguły bezpieczeństwa)
• Twój obecny monit
• Historia konwersacji (poprzedni użytkownik i komunikaty asystenta)
• Schematy narzędzi (funkcje, specyfikacje interfejsu OpenAPI, narzędzia MCP itp.)
• Dane wyjściowe narzędzi (wyniki wyszukiwania, dane wyjściowe interpretera kodu, pliki)
• Pobrano pamięć lub dokumenty (z magazynów pamięci, RAG, wyszukiwania plików)

Wszystkie te elementy są połączone, tokenizowane i wysyłane do modelu razem na każde żądanie. SDK pomaga w zarządzaniu stanem, ale nie sprawia automatycznie, że użycie tokenu jest tańsze.

Tworzenie dynamicznych aplikacji do czatu

Generowanie odpowiedzi z modelu może zająć trochę czasu, w zależności od czynników, takich jak używany konkretny model, rozmiar okna kontekstu i rozmiar monitu. Użytkownicy mogą stać się sfrustrowani, jeśli aplikacja wydaje się zawieszać się podczas oczekiwania na odpowiedź, dlatego ważne jest, aby rozważyć responsywność aplikacji w implementacji.

Odpowiedzi streamingowe

W przypadku długich odpowiedzi możesz użyć przesyłania strumieniowego, aby odbierać dane wyjściowe przyrostowo — dzięki czemu użytkownik zobaczy częściowo kompletne odpowiedzi, gdy dane wyjściowe staną się dostępne:

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)

Jeśli śledzisz historię konwersacji podczas przesyłania strumieniowego, możesz uzyskać identyfikator odpowiedzi po zakończeniu strumienia, w następujący sposób:

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

Użycie asynchroniczne

W przypadku aplikacji o wysokiej wydajności można użyć klienta asynchronicznego, który umożliwia wykonywanie nieblokujących wywołań interfejsu API. Użycie asynchroniczne jest idealne w przypadku długotrwałych żądań lub obsługi wielu żądań jednocześnie bez blokowania aplikacji. Aby go używać, zaimportuj AsyncOpenAI zamiast OpenAI i używaj await przy każdym wywołaniu 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())

Przesyłanie strumieniowe asynchroniczne działa w taki sam sposób:

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

Korzystając z interfejsu API Responses za pośrednictwem zestawu SDK Microsoft Foundry, można tworzyć zaawansowane aplikacje konwersacyjne sztucznej inteligencji, które utrzymują kontekst, obsługują wiele typów modeli i zapewniają dynamiczne środowisko użytkownika.