Gerar respostas com a API de Respostas

10 minutos

A API OoenAI Responses reúne capacidades de duas APIs anteriormente separadas (ChatCompletions e Assistants) numa experiência unificada. Proporciona geração de respostas com estado e múltiplas voltas, tornando-a ideal para aplicações de IA conversacional. Pode aceder à API Respostas através de um cliente compatível com OpenAI, utilizando o SDK Foundry ou o SDK OpenAI.

Compreender a API de Respostas

A API de Respostas oferece várias vantagens em relação aos completamentos de chat tradicionais:

Conversas com estado: Mantém o contexto da conversa ao longo de múltiplos turnos
Experiência unificada: Combina a conclusão de chats e os padrões da API dos Assistentes
Modelos diretos do Foundry: Funciona com modelos alojados diretamente no Microsoft Foundry, não apenas modelos Azure OpenAI
Integração simples: Acesso através de um cliente compatível com OpenAI

Observação

A API de Respostas é a abordagem recomendada para gerar respostas de IA em aplicações Microsoft Foundry. Substitui a antiga API ChatCompletions para a maioria dos cenários.

Gerar uma resposta simples

Com um cliente compatível com OpenAI, pode gerar respostas usando o método 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)

O parâmetro de entrada aceita uma cadeia de texto contendo o seu prompt. O modelo gera uma resposta baseada nessa entrada.

Compreensão da estrutura da resposta

Um objeto resposta contém várias propriedades úteis:

output_text: A resposta de texto gerada
id: Identificador único para esta resposta
estado: Estado da resposta (por exemplo, "concluído")
utilização: Informação de utilização dos tokens (entrada, saída e total de tokens)
modelo: O modelo usado para gerar a resposta

Pode aceder a estas propriedades para gerir respostas de forma eficaz:

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

Adicionar instruções

Para além da entrada do utilizador, pode fornecer instruções (frequentemente referidas como prompt do sistema) para orientar o comportamento do modelo:

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)

Controlo da geração de respostas

Pode controlar a geração de respostas com parâmetros adicionais:

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: Controla a aleatoriedade (0,0-2,0). Valores mais elevados tornam a produção mais criativa e variada
max_output_tokens: Limita o número máximo de tokens na resposta
top_p: Alternativa à temperatura para controlar a aleatoriedade

Trabalhar com modelos diretos da Foundry

Ao usar o cliente FoundrySDK ou AzureOpenAI para se ligar a um endpoint de projeto , a API Responses funciona tanto com modelos Azure OpenAI como com modelos diretos Foundry (como Microsoft Phi, DeepSeek ou outros modelos alojados diretamente no 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)

Criar experiências conversacionais

Para cenários conversacionais mais complexos, pode dar instruções ao sistema e construir conversas com múltiplos turnos.

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

Na realidade, a implementação é provavelmente construída como um ciclo em que o utilizador pode inserir interativamente mensagens com base em cada resposta recebida do modelo:

# 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

A saída deste exemplo é semelhante a esta:

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!

À medida que o utilizador introduz uma nova entrada em cada turno, os dados enviados ao modelo incluem a mensagem do sistema Instruções , a entrada do utilizador e a resposta anterior recebida do modelo. Desta forma, a nova entrada assenta no contexto fornecido pela resposta que o modelo gerou para a entrada anterior.

Alternativa: Encadeamento manual de conversas

Pode gerir as conversas manualmente construindo o histórico de mensagens por si próprio. Esta abordagem dá-lhe mais controlo sobre o contexto incluído:

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

Esta abordagem manual é útil quando precisa:

Personalize quais são as mensagens incluídas no contexto
Implementar a redução de conversas para gerir os limites de tokens
Armazene e restaure o histórico de conversas a partir de uma base de dados

Recuperação de respostas anteriores específicas

A API de Respostas mantém o histórico de respostas, permitindo-lhe recuperar respostas anteriores:

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

Considerações sobre janelas de contexto

O parâmetro previous_response_id liga as respostas entre si, mantendo o contexto da conversa através de múltiplas chamadas API.

É importante notar que manter o histórico de conversas pode aumentar o uso de tokens. Para uma única execução, a janela de contexto ativo pode incluir:

Instruções do sistema (instruções, regras de segurança)
O seu prompt atual
Histórico de conversas (mensagens de utilizador + assistente anteriores)
Esquemas de ferramentas (funções, especificações OpenAPI, ferramentas MCP, etc.)
Saídas de ferramentas (resultados de pesquisa, saída do interpretador de código, ficheiros)
Memória ou documentos recuperados (de armazenamentos de memória, RAG, pesquisa de arquivos)

Todos estes elementos são concatenados, tokenizados e enviados ao modelo juntos em cada pedido. O SDK ajuda-te a gerir o estado, mas não torna automaticamente o uso de tokens mais barato.

Criação de aplicações de chat responsivas

As respostas de um modelo podem demorar algum tempo a ser geradas, dependendo de fatores como o modelo específico utilizado, o tamanho da janela de contexto e o tamanho do prompt. Os utilizadores podem ficar frustrados se a aplicação parecer "congelar" enquanto aguardam uma resposta, por isso é importante considerar a resposta da aplicação na sua implementação.

Respostas de streaming

Para respostas longas, pode usar streaming para receber a saída de forma incremental – para que o utilizador veja respostas parcialmente completas à medida que a saída fica disponível:

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)

Se estiveres a monitorizar o histórico de conversas durante o streaming, podes obter o ID da resposta quando a stream terminar, assim:

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

Utilização assíncrona

Para aplicações de alto desempenho, pode usar um cliente assíncrono que permite fazer chamadas API não bloqueantes. O uso assíncrono é ideal para pedidos de longa duração ou quando pretende tratar múltiplos pedidos em simultâneo sem bloquear a sua aplicação. Para o usar, importe AsyncOpenAI em vez de OpenAI e use await com cada chamada de 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())

O streaming assíncrono funciona da mesma forma:

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

Ao utilizar a API Responses através do Microsoft Foundry SDK, pode construir aplicações sofisticadas de IA conversacional que mantêm o contexto, suportam múltiplos tipos de modelos e proporcionam uma experiência de utilizador responsiva.

Comentários

Esta página foi útil?