Comprender la interfaz de chat
Cómo funcionan las interfaces de chat con LLM: roles, turnos y contexto de sesión.
Comprender la interfaz de chat es una lección gratuita de AI Prompt Engineering en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de AI Prompt Engineering, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de AI Prompt Engineering incluye 4 lecciones en total.
Los tres roles
Cada conversación con un LLM se basa en tres roles: system, user y assistant.
El rol system establece las reglas y la personalidad antes de que comience la conversación. El rol user corresponde a los mensajes que usted envía. El rol assistant corresponde a las respuestas del modelo.
import anthropic
client = anthropic.Anthropic(api_key='sk-ant-your-key-here')
message = client.messages.create(
model='claude-opus-4-5',
max_tokens=256,
system='You are a helpful cooking assistant.',
messages=[
{'role': 'user', 'content': 'What is mise en place?'}
]
)
print(message.content[0].text)El mensaje del sistema
El mensaje del sistema es el manual de instrucciones del modelo. Se ejecuta antes del primer turno del usuario y permanece activo durante toda la sesión.
Utilícelo para definir la personalidad, el tono, las restricciones del dominio o el formato de salida. El modelo lo trata como su contexto guía a lo largo de toda la conversación.
import openai
client = openai.OpenAI(api_key='sk-your-key-here')
response = client.chat.completions.create(
model='gpt-4o',
messages=[
{
'role': 'system',
'content': 'You are a senior Python engineer. '
'Always include type hints and docstrings in your examples.'
},
{
'role': 'user',
'content': 'Show me a function that parses JSON safely.'
}
]
)
print(response.choices[0].message.content)Turnos y flujo de la conversación
Una conversación es una secuencia de turnos. Cada turno se alterna: el usuario habla, el asistente responde y el usuario vuelve a hablar.
El modelo recibe todo el historial de turnos en cada solicitud. Eso es lo que hace que parezca un diálogo continuo, pero técnicamente cada llamada a la API no tiene estado y recibe todo el contexto en cada ocasión.
import openai
client = openai.OpenAI(api_key='sk-your-key-here')
# Each call sends the FULL conversation history
history = [
{'role': 'system', 'content': 'You are a geography tutor.'},
{'role': 'user', 'content': 'What is the capital of France?'},
{'role': 'assistant', 'content': 'The capital of France is Paris.'},
{'role': 'user', 'content': 'And its population?'} # follow-up turn
]
response = client.chat.completions.create(
model='gpt-4o',
messages=history
)
print(response.choices[0].message.content)Contexto de la sesión
El contexto de la sesión es la memoria acumulada de la conversación. Cada mensaje del usuario y del asistente se va acumulando en la matriz history.
El modelo no dispone de un almacén de memoria independiente: razona únicamente a partir de lo que ve en la ventana de contexto actual. Si inicia una sesión nueva, el modelo no tendrá memoria de las sesiones anteriores a menos que vuelva a inyectar esa información.
import anthropic
client = anthropic.Anthropic(api_key='sk-ant-your-key-here')
# Simulating 3-turn session context
conversation = [
{'role': 'user', 'content': 'My name is Alex.'},
{'role': 'assistant', 'content': 'Nice to meet you, Alex!'},
{'role': 'user', 'content': 'What is 5 times 7?'},
{'role': 'assistant', 'content': '5 times 7 is 35.'},
{'role': 'user', 'content': 'Can you repeat my name?'} # uses session context
]
response = client.messages.create(
model='claude-opus-4-5',
max_tokens=128,
messages=conversation
)
print(response.content[0].text) # expects: Your name is Alex.Estructura del historial de mensajes
El historial de mensajes es simplemente una lista de diccionarios, cada uno con una clave role y otra clave content.
Usted administra esta lista directamente en el código. Después de cada respuesta del asistente, añade su respuesta y, a continuación, añade el siguiente mensaje del usuario; en la siguiente llamada vuelve a enviar la lista completa.
import openai
client = openai.OpenAI(api_key='sk-your-key-here')
def chat(history, user_message):
history.append({'role': 'user', 'content': user_message})
response = client.chat.completions.create(
model='gpt-4o',
messages=history
)
reply = response.choices[0].message.content
history.append({'role': 'assistant', 'content': reply})
return reply, history
history = [{'role': 'system', 'content': 'You are a math tutor.'}]
reply, history = chat(history, 'What is a prime number?')
print(reply)
print('History length:', len(history))Explicación de los límites de tokens
Cada modelo tiene una ventana de contexto medida en tokens. Un token equivale aproximadamente a 4 caracteres o a 0,75 palabras en inglés.
Tanto su entrada (sistema + todo el historial) como la salida del modelo cuentan para este límite. GPT-4o admite 128k tokens; Claude Opus 4.5 admite 200k. Cuando se alcanza el límite, es necesario eliminar o resumir los mensajes más antiguos.
import tiktoken
# Count tokens before sending to avoid exceeding the limit
encoding = tiktoken.encoding_for_model('gpt-4o')
messages = [
{'role': 'system', 'content': 'You are a helpful assistant.'},
{'role': 'user', 'content': 'Explain quantum entanglement in simple terms.'}
]
total_tokens = 0
for msg in messages:
total_tokens += len(encoding.encode(msg['content']))
total_tokens += 4 # overhead per message
print(f'Estimated input tokens: {total_tokens}')
print(f'GPT-4o limit: 128,000 tokens')
print(f'Budget remaining: {128000 - total_tokens:,} tokens')Qué ocurre al alcanzar el límite de tokens
Cuando el historial de la conversación supera la ventana de contexto, tiene tres opciones:
- Truncar — descartar los mensajes más antiguos
- Resumir — pedirle al modelo que comprima los turnos anteriores en un resumen breve
- Usar una ventana deslizante — conservar solo los últimos N mensajes
Elegir una estrategia incorrecta puede hacer que el modelo pierda contexto crucial y proporcione respuestas incoherentes.
def trim_history(history, max_messages=10, keep_system=True):
'''Keep the system message and the last N non-system messages.'''
system_msgs = [m for m in history if m['role'] == 'system']
non_system = [m for m in history if m['role'] != 'system']
if len(non_system) > max_messages:
non_system = non_system[-max_messages:]
print(f'Trimmed to last {max_messages} messages.')
return system_msgs + non_system if keep_system else non_system
history = [{'role': 'system', 'content': 'You are a tutor.'}]
for i in range(15):
history.append({'role': 'user', 'content': f'Question {i}'})
history.append({'role': 'assistant', 'content': f'Answer {i}'})
trimmed = trim_history(history, max_messages=6)
print('Trimmed history length:', len(trimmed))El contexto de varios turnos en la práctica
Veamos el contexto en acción. En una conversación de varios turnos, el modelo utiliza cada mensaje anterior para responder correctamente a las preguntas de seguimiento.
Por eso puede decir «explique eso de forma más sencilla» sin repetir a qué se refería con «eso»: el modelo ve todo el historial y sabe a qué se refiere.
import openai
client = openai.OpenAI(api_key='sk-your-key-here')
history = [{'role': 'system', 'content': 'You are a science teacher.'}]
# Turn 1
history.append({'role': 'user', 'content': 'What is photosynthesis?'})
r1 = client.chat.completions.create(model='gpt-4o', messages=history)
reply1 = r1.choices[0].message.content
history.append({'role': 'assistant', 'content': reply1})
# Turn 2 — refers to prior answer without repeating it
history.append({'role': 'user', 'content': 'Can you explain that using only 3 bullet points?'})
r2 = client.chat.completions.create(model='gpt-4o', messages=history)
print(r2.choices[0].message.content)API sin estado, UX con estado
Esta es una idea clave: la API es completamente sin estado. El servidor no recuerda nada entre llamadas.
Los productos de chat, como ChatGPT, crean la ilusión de memoria almacenando el historial de la conversación en su propia base de datos e inyectándolo de nuevo en cada llamada a la API. Puede crear el mismo mecanismo por su cuenta.
# Illustration: two isolated API calls vs one with history
import openai
client = openai.OpenAI(api_key='sk-your-key-here')
# ❌ WITHOUT history — model has no memory
r1 = client.chat.completions.create(
model='gpt-4o',
messages=[{'role': 'user', 'content': 'My dog is named Biscuit.'}]
)
r2 = client.chat.completions.create(
model='gpt-4o',
messages=[{'role': 'user', 'content': "What's my dog's name?"}]
)
print('Without history:', r2.choices[0].message.content) # will not know
# ✅ WITH history injected
r3 = client.chat.completions.create(
model='gpt-4o',
messages=[
{'role': 'user', 'content': 'My dog is named Biscuit.'},
{'role': 'assistant', 'content': 'Got it, your dog is named Biscuit!'},
{'role': 'user', 'content': "What's my dog's name?"}
]
)
print('With history:', r3.choices[0].message.content)Consejos prácticos para usar la interfaz de chat
Para aprovechar al máximo la interfaz de chat:
- Coloque las instrucciones persistentes en el mensaje de sistema, en lugar de repetirlas en cada turno del usuario
- Mantenga los turnos anteriores concisos: un historial demasiado extenso consume tokens rápidamente
- Inicie una nueva sesión al cambiar de tema para evitar la contaminación del contexto
- Al reanudar un proyecto largo, inyecte solo el subconjunto relevante del contexto anterior
# Good practice: compact system message + focused history
import anthropic
client = anthropic.Anthropic(api_key='sk-ant-your-key-here')
system = (
'You are a concise Python code reviewer. '
'Reply with: 1) one-line verdict, 2) top 3 issues, 3) fixed snippet.'
)
response = client.messages.create(
model='claude-opus-4-5',
max_tokens=512,
system=system,
messages=[
{'role': 'user', 'content': 'def add(a,b): return a+b\nprint(add(1,2))'}
]
)
print(response.content[0].text)Repaso: la interfaz de chat
Repasemos las ideas clave sobre el funcionamiento de la interfaz de chat:
- Tres roles: system establece las reglas, user envía los prompts y assistant responde
- El historial completo se envía en cada llamada a la API: el servidor no tiene estado
- Los límites de tokens restringen el contexto; recórtelo o resúmalo cuando se aproxime a ellos
- El contexto de la sesión es simplemente una lista que administra en su propio código
- Inicie sesiones nuevas al cambiar de tema para mantener limpio el contexto
# Summary: minimal chat loop skeleton
import openai
client = openai.OpenAI(api_key='sk-your-key-here')
history = [{'role': 'system', 'content': 'You are a helpful assistant.'}]
def ask(question):
history.append({'role': 'user', 'content': question})
res = client.chat.completions.create(model='gpt-4o', messages=history)
answer = res.choices[0].message.content
history.append({'role': 'assistant', 'content': answer})
return answer
print(ask('Hello! What can you help me with?'))Comprobación de conocimientos
Compruebe su comprensión del funcionamiento de la interfaz de chat.
Un usuario inicia una sesión completamente nueva y pregunta a la IA: «¿Qué discutimos ayer?» La IA no tiene memoria de la sesión de ayer. ¿Por qué?
Lo que ha aprendido
Ahora comprende los fundamentos de toda interacción de chat con IA:
- La estructura de roles system/user/assistant que da forma a cada conversación
- Cómo se envía el historial completo de mensajes en cada llamada para simular la memoria
- Por qué la API es sin estado y cómo los productos de chat construyen memoria sobre ella
- Cómo los límites de tokens restringen el contexto y cómo administrarlos
Este modelo mental le ayudará a crear mejores prompts y aplicaciones más inteligentes basadas en IA.
Preguntas frecuentes
¿La lección «Comprender la interfaz de chat» es gratis?
Sí — el texto completo de «Comprender la interfaz de chat» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de AI Prompt Engineering, actualiza a CoddyKit PRO. El curso de AI Prompt Engineering incluye 4 lecciones en total.
¿Qué aprenderé en «Comprender la interfaz de chat»?
Cómo funcionan las interfaces de chat con LLM: roles, turnos y contexto de sesión. Practicas AI Prompt Engineering con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar AI Prompt Engineering?
No se requiere experiencia previa. AI Prompt Engineering en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.
¿Cuánto tiempo toma la lección «Comprender la interfaz de chat»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de AI Prompt Engineering?
Sí. Cada lección de AI Prompt Engineering incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Comprender la interfaz de chat
- Tipos de solicitudes que puede gestionar la IA
- Cómo genera respuestas la IA
- Qué no puede hacer la IA