Создание ответов с помощью API ответов

Завершено

Tip

Дополнительные сведения см. на вкладке "Текст и изображения ".

API Ответы OpenAI объединяет возможности из двух ранее отдельных API (ChatCompletions и Assistants) в едином опыте. Он обеспечивает генерацию ответов с отслеживанием состояния и многоэтапную генерацию, что делает его идеальным для приложений искусственного интеллекта в области общения. Вы можете получить доступ к API ответов через клиент, совместимый с OpenAI, с помощью пакета SDK Foundry или OpenAI SDK.

Общие сведения об API ответов

API ответов предлагает несколько преимуществ по сравнению с традиционными завершениями чата:

• Беседы с отслеживанием состояния: сохраняет контекст беседы на протяжении нескольких этапов.
• Унифицированный опыт. Объединение завершений чата и шаблонов API помощников
• Foundry direct models: работает с моделями, размещенными непосредственно в Microsoft Foundry, а также с моделями Azure OpenAI.
• Простая интеграция: доступ через клиент, совместимый с OpenAI

Замечание

API Responses — это рекомендуемый подход для создания ответов ИИ в приложениях Microsoft Foundry. Он заменяет старый API ChatCompletions для большинства сценариев.

Создание простого ответа

С помощью клиента, совместимого с OpenAI, можно создавать ответы с помощью метода 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)

Входной параметр принимает текстовую строку, содержащую запрос. Модель создает ответ на основе этих входных данных.

Общие сведения о структуре ответа

Объект ответа содержит несколько полезных свойств:

• output_text: созданный текстовый ответ
• идентификатор: уникальный идентификатор для этого ответа
• статус: Статус ответа (например, "завершено")
• использование: сведения об использовании токенов (входные, выходные и общие токены)
• модель: модель, используемая для создания ответа

Вы можете получить доступ к этим свойствам, чтобы эффективно обрабатывать ответы.

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

Добавление инструкций

Помимо входных данных пользователя, можно указать инструкции (часто называемые системным запросом) для руководства по поведению модели:

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)

Контролирование генерации ответов

Вы можете управлять созданием ответов с помощью дополнительных параметров:

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)

• температура: управляет случайностью (0.0-2.0). Более высокие значения делают выходные данные более творческими и разнообразными
• max_output_tokens. Ограничивает максимальное количество маркеров в ответе
• top_p: альтернатива температуре для контроля случайности

Работа с прямыми моделями Foundry

При использовании клиента FoundrySDK или AzureOpenAI для подключения к конечной точке project API ответов работает как с моделями OpenAI, так и с прямыми моделями OpenAI (например, Azure Microsoft Phi, DeepSeek или другими моделями, размещенными непосредственно в 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)

Создание интерфейсов общения

Для более сложных сценариев общения можно предоставить системные инструкции и создать многоэтапные беседы:

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

В действительности реализация, скорее всего, будет создана как цикл, в котором пользователь может интерактивно вводить сообщения на основе каждого ответа, полученного из модели:

# 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 

Выходные данные из этого примера выглядят примерно так:

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!

По мере того как пользователь вводит новые входные данные в каждом шаге, данные, отправленные в модель, включают системное сообщение "Инструкции ", входные данные пользователя и предыдущий ответ, полученный от модели. Таким образом, новые входные данные создаются в контексте, предоставленном ответом модели на предыдущие входные данные.

Альтернатива: ручная цепочка разговоров

Вы можете управлять беседами вручную, создав журнал сообщений самостоятельно. Этот подход обеспечивает более полный контроль над тем, какой контекст включается:

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

Этот подход вручную полезен при необходимости:

• Настройте, какие сообщения включены в контекст
• Реализация обрезки бесед для управления ограничениями токенов
• Хранение и восстановление журнала бесед из базы данных

Получение конкретных предыдущих ответов

API ответов поддерживает журнал ответов, позволяя получить предыдущие ответы:

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

Соображения по окну контекста

Параметр previous_response_id связывает ответы, поддерживая контекст общения в нескольких API вызовах.

Важно отметить, что сохранение журнала бесед может увеличить использование токенов. Для одного запуска активное окно контекста может включать:

• Системные инструкции (инструкции, правила безопасности)
• Текущий запрос
• Журнал бесед (предыдущие сообщения пользователя и помощника)
• Схемы инструментов (функции, спецификации OpenAPI, инструменты MCP и т. д.)
• Выходные данные средства (результаты поиска, выходные данные интерпретатора кода, файлы)
• Полученная память или документы (из хранилищ памяти, RAG, поиска файлов)

Все они объединяются, проходят токенизацию и вместе отправляются в модель по каждому запросу. Пакет SDK помогает управлять состоянием, но он не делает использование токенов дешевле.

Создание адаптивных приложений чата

Ответы от модели могут занять некоторое время на генерацию в зависимости от таких факторов, как используемая модель, размер контекстного окна и размер запроса. Пользователь может быть разочарован, если приложение, кажется, "подвисает" во время ожидания ответа, поэтому важно учитывать отзывчивость приложения при реализации.

Потоковая передача ответов

Для длительных ответов можно использовать потоковую передачу для постепенного получения выходных данных, поэтому пользователь видит частично полные ответы по мере того, как выходные данные становятся доступными:

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)

Если вы отслеживаете журнал бесед при потоковой передаче, вы можете получить идентификатор ответа, когда поток заканчивается, как показано ниже.

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

Асинхронное использование

Для высокопроизводительных приложений можно использовать асинхронный клиент, который позволяет выполнять неблокирующие вызовы API. Асинхронное использование идеально подходит для длительных запросов или для одновременного обработки нескольких запросов без блокировки приложения. Чтобы использовать его, импортируйте AsyncOpenAI вместо OpenAI и используйте await с каждым вызовом 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())

Асинхронная потоковая передача работает так же:

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

Используя API Responses с помощью пакета SDK Microsoft Foundry, вы можете создавать сложные приложения искусственного интеллекта для бесед, которые поддерживают контекст, поддерживают несколько типов моделей и обеспечивают адаптивный интерфейс пользователя.