Generación de respuestas con la API de respuestas
La API de respuestas de OoenAI reúne funcionalidades de dos API independientes anteriormente (ChatCompletions y asistentes) en una experiencia unificada. Proporciona una generación de respuestas multiturno y con estado, lo que lo hace ideal para aplicaciones de IA conversacional. Puede acceder a la API de respuestas a través de un cliente compatible con OpenAI mediante el SDK de Foundry o el SDK de OpenAI.
Descripción de la API de respuestas
La API de respuestas ofrece varias ventajas sobre las finalizaciones de chat tradicionales:
- Conversaciones con estado: mantiene el contexto de conversación en varios turnos
- Experiencia unificada: combina finalizaciones de chat y patrones de API de asistentes
- Modelos directos de Foundry: Funciona con modelos alojados directamente en Microsoft Foundry, no solo con modelos de Azure OpenAI.
- Integración Simple: Acceso a través del cliente compatible con OpenAI
Nota:
La API de respuestas es el enfoque recomendado para generar respuestas de IA en aplicaciones de Microsoft Foundry. Reemplaza la API chatCompletions anterior para la mayoría de los escenarios.
Generación de una respuesta sencilla
Con un cliente compatible con OpenAI, puede generar respuestas mediante el 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)
El parámetro de entrada acepta una cadena de texto que contiene el prompt. El modelo genera una respuesta basada en esta entrada.
Descripción de la estructura de respuesta
Un objeto de respuesta contiene varias propiedades útiles:
- output_text: la respuesta de texto generada
- id: identificador único para esta respuesta
- status: estado de respuesta (por ejemplo, "completado")
- usage: información de uso de tokens (entrada, salida y total de tokens)
- model: el modelo usado para generar la respuesta.
Para acceder a estas propiedades y controlar las respuestas 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}")
Adición de instrucciones
Además de la entrada del usuario, puede proporcionar instrucciones (a menudo denominadas indicador del sistema) para guiar el comportamiento del 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)
Control de la generación de respuestas
Puede controlar la generación de respuestas con parámetros adicionales:
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 la aleatoriedad (0.0-2.0). Los valores más altos hacen que la salida sea más creativa y variada
- max_output_tokens: limita el número máximo de tokens en la respuesta.
- top_p: alternativa a la temperatura para controlar la aleatoriedad
Trabajar con modelos directos de Foundry
Al usar el cliente FoundrySDK o AzureOpenAI para conectarse a un punto de conexión de proyecto , la API de respuestas funciona con modelos de Azure OpenAI y modelos directos de Foundry (como Microsoft Phi, DeepSeek u otros modelos hospedados directamente en 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)
Creación de experiencias conversacionales
Para escenarios de conversación más complejos, puede proporcionar instrucciones del sistema y crear conversaciones de varios 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)
En realidad, es probable que la implementación se construya como un bucle en el que un usuario pueda escribir mensajes de forma interactiva en función de cada respuesta recibida del 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
La salida de este ejemplo es similar a la siguiente:
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!
A medida que el usuario escribe una nueva entrada en cada turno, los datos enviados al modelo incluyen el mensaje del sistema De instrucciones , la entrada del usuario y la respuesta anterior recibida del modelo. De esta manera, la nueva entrada se basa en el contexto proporcionado por la respuesta que generó el modelo para la entrada anterior.
Alternativa: encadenamiento manual de conversaciones
Puede administrar las conversaciones manualmente mediante la creación del historial de mensajes usted mismo. Este enfoque proporciona más control sobre qué contexto se incluye:
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}")
Este enfoque manual es útil cuando es necesario:
- Personalización de los mensajes que se incluyen en el contexto
- Implementar la poda de conversaciones para gestionar los límites de tokens
- Almacenar y restaurar el historial de conversaciones desde una base de datos
Recuperación de respuestas anteriores específicas
La API de respuestas mantiene el historial de respuestas, lo que le permite recuperar respuestas 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}")
Consideraciones sobre la ventana de contexto
El parámetro previous_response_id vincula las respuestas juntas, manteniendo el contexto de conversación entre varias llamadas API.
Es importante tener en cuenta que mantener el historial de conversaciones puede aumentar el uso de tokens. Para una sola ejecución, la ventana de contexto activa puede incluir:
- Instrucciones del sistema (instrucciones, reglas de seguridad)
- Su aviso actual
- Historial de conversaciones (mensajes anteriores de usuario y asistente)
- Esquemas de herramientas (funciones, especificaciones de OpenAPI, herramientas de MCP, etc.)
- Salidas de herramientas (resultados de búsqueda, salida del intérprete de código, archivos)
- Memoria o documentos recuperados (desde almacenes de memoria, RAG, búsqueda de archivos)
Todos estos se concatenan, tokenizan y envían al modelo juntos en cada solicitud. El SDK le ayuda a administrar el estado, pero no hace que el uso de tokens sea más barato automáticamente.
Creación de aplicaciones de chat con capacidad de respuesta
Las respuestas de un modelo pueden tardar algún tiempo en generarse en función de factores como el modelo específico que se usa, el tamaño de la ventana de contexto y el tamaño del mensaje. El usuario puede frustrarse si la aplicación parece "inmovilizarse" mientras espera una respuesta, por lo que es importante considerar la capacidad de respuesta de la aplicación en la implementación.
Respuestas de transmisión
Para respuestas largas, puede usar streaming para recibir la salida incrementalmente, por lo que el usuario ve respuestas parcialmente completas a medida que la salida está disponible:
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)
Si está realizando el seguimiento del historial de conversaciones mientras transmite en streaming, puede obtener el identificador de respuesta cuando finalice el flujo, de la siguiente manera:
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
Uso asíncrono
En el caso de las aplicaciones de alto rendimiento, puede usar un cliente asincrónico que le permita realizar llamadas API sin bloqueo. El uso asincrónico es ideal para las solicitudes de larga duración o cuando desea controlar varias solicitudes simultáneamente sin bloquear la aplicación. Para usarlo, importe AsyncOpenAI en lugar de OpenAI y use await con cada llamada 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())
El streaming asincrónico funciona de la misma manera:
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())
Mediante el uso de la API de respuestas a través del SDK de Microsoft Foundry, puede crear aplicaciones sofisticadas de inteligencia artificial conversacional que mantienen el contexto, admiten varios tipos de modelos y proporcionan una experiencia de usuario con capacidad de respuesta.