You've learned this already. ✅
Click here to view the next lesson.
Capítulo 7: Memoria y Conversaciones de Varios Turnos
Ejercicios Prácticos — Capítulo 7
Ejercicio 1: Implementación de Memoria a Corto Plazo en una Conversación
Tarea:
Crea un asistente simple que recuerde los mensajes previos del usuario y responda apropiadamente usando memoria a corto plazo. Mantén la conversación en una lista local y envía el historial completo en cada turno.
Solución:
import openai
import os
from dotenv import load_dotenv
load_dotenv()
openai.api_key = os.getenv("OPENAI_API_KEY")
conversation = [
{"role": "system", "content": "You are a helpful assistant."}
]
def chat(user_input):
conversation.append({"role": "user", "content": user_input})
response = openai.ChatCompletion.create(
model="gpt-4o",
messages=conversation,
max_tokens=150,
temperature=0.5
)
reply = response["choices"][0]["message"]["content"]
conversation.append({"role": "assistant", "content": reply})
return reply
# Try a multi-turn conversation
print("User: What’s your favorite programming language?")
print("Assistant:", chat("What’s your favorite programming language?"))
print("\nUser: Can you show me a simple example in it?")
print("Assistant:", chat("Can you show me a simple example in it?"))Ejercicio 2: Guardado y Recuperación de Memoria a Largo Plazo
Tarea:
Simular memoria persistente almacenando mensajes en un archivo JSON y recuperándolos al inicio de una nueva sesión.
Solución:
import json
MEMORY_FILE = "user_memory.json"
def save_message(message):
try:
with open(MEMORY_FILE, "r") as f:
memory = json.load(f)
except FileNotFoundError:
memory = []
memory.append(message)
with open(MEMORY_FILE, "w") as f:
json.dump(memory, f, indent=2)
def load_memory():
try:
with open(MEMORY_FILE, "r") as f:
return json.load(f)
except FileNotFoundError:
return []
# Store a sample message
save_message({"role": "user", "content": "How does recursion work?"})
save_message({"role": "assistant", "content": "Recursion is when a function calls itself to solve a problem."})
# Load and review memory
print("Long-Term Memory:", load_memory())Ejercicio 3: Resumir Mensajes Anteriores para Ahorrar Tokens
Tarea:
Utiliza la API de Chat Completions para resumir mensajes antiguos antes de incorporarlos a una nueva conversación para mantenerse dentro de los límites de tokens.
Solución:
def summarize_conversation(history):
summary_prompt = [
{"role": "system", "content": "Summarize this conversation briefly:"},
{"role": "user", "content": "\n".join([f'{m["role"]}: {m["content"]}' for m in history])}
]
response = openai.ChatCompletion.create(
model="gpt-4o",
messages=summary_prompt,
max_tokens=100,
temperature=0.3
)
return {"role": "system", "content": "Summary: " + response["choices"][0]["message"]["content"]}
# Example history
history = [
{"role": "user", "content": "Tell me about machine learning."},
{"role": "assistant", "content": "Machine learning is a subset of AI..."},
{"role": "user", "content": "What is supervised learning?"}
]
# Get a summary
print("Summary:", summarize_conversation(history))Ejercicio 4: Crear un Asistente Usando la API de Asistentes
Tarea:
Crea un asistente utilizando la API de Asistentes de OpenAI que recuerde un hilo y responda con contexto.
Solución:
import openai
import time
# Step 1: Create the assistant
assistant = openai.beta.assistants.create(
name="Memory Coach",
instructions="You are a memory coach that helps users retain information over time.",
model="gpt-4o"
)
# Step 2: Create a thread
thread = openai.beta.threads.create()
# Step 3: Add a message
openai.beta.threads.messages.create(
thread_id=thread.id,
role="user",
content="Help me remember the difference between RAM and ROM."
)
# Step 4: Run the assistant
run = openai.beta.threads.runs.create(
assistant_id=assistant.id,
thread_id=thread.id
)
# Step 5: Wait for completion
while True:
run_status = openai.beta.threads.runs.retrieve(run.id, thread_id=thread.id)
if run_status.status == "completed":
break
time.sleep(1)
# Step 6: Print the assistant’s response
messages = openai.beta.threads.messages.list(thread_id=thread.id)
for msg in messages.data:
if msg.role == "assistant":
print("Assistant:", msg.content[0].text.value)Ejercicio 5: Comparación entre Chat Completions y Asistentes
Tarea:
Ejecuta el mismo prompt usando ambas APIs y compara el manejo del contexto.
Solución:
Versión de Chat Completions:
chat_response = openai.ChatCompletion.create(
model="gpt-4o",
messages=[
{"role": "system", "content": "You are a helpful assistant."},
{"role": "user", "content": "Explain how HTTP works."}
],
max_tokens=150
)
print("Chat Completion Response:", chat_response["choices"][0]["message"]["content"])Versión de Asistentes:
# Thread and assistant are assumed to be created already
openai.beta.threads.messages.create(
thread_id=thread.id,
role="user",
content="Explain how HTTP works."
)
run = openai.beta.threads.runs.create(
assistant_id=assistant.id,
thread_id=thread.id
)
while True:
run_status = openai.beta.threads.runs.retrieve(run.id, thread_id=thread.id)
if run_status.status == "completed":
break
time.sleep(1)
messages = openai.beta.threads.messages.list(thread_id=thread.id)
for msg in messages.data:
if msg.role == "assistant":
print("Assistant Response (Assistants API):", msg.content[0].text.value)Estos ejercicios reforzaron cómo:
- Gestionar la memoria a corto y largo plazo
- Manejar los límites de contexto
- Aplicar la gestión de hilos y tokens
- Elegir entre las APIs de Chat Completions y Asistentes según tus objetivos
Al dominar estos flujos de trabajo, estás bien equipado para construir asistentes más inteligentes y conscientes del contexto que se adaptan a tus usuarios y sus necesidades.
Ejercicios Prácticos — Capítulo 7
Ejercicio 1: Implementación de Memoria a Corto Plazo en una Conversación
Tarea:
Crea un asistente simple que recuerde los mensajes previos del usuario y responda apropiadamente usando memoria a corto plazo. Mantén la conversación en una lista local y envía el historial completo en cada turno.
Solución:
import openai
import os
from dotenv import load_dotenv
load_dotenv()
openai.api_key = os.getenv("OPENAI_API_KEY")
conversation = [
{"role": "system", "content": "You are a helpful assistant."}
]
def chat(user_input):
conversation.append({"role": "user", "content": user_input})
response = openai.ChatCompletion.create(
model="gpt-4o",
messages=conversation,
max_tokens=150,
temperature=0.5
)
reply = response["choices"][0]["message"]["content"]
conversation.append({"role": "assistant", "content": reply})
return reply
# Try a multi-turn conversation
print("User: What’s your favorite programming language?")
print("Assistant:", chat("What’s your favorite programming language?"))
print("\nUser: Can you show me a simple example in it?")
print("Assistant:", chat("Can you show me a simple example in it?"))Ejercicio 2: Guardado y Recuperación de Memoria a Largo Plazo
Tarea:
Simular memoria persistente almacenando mensajes en un archivo JSON y recuperándolos al inicio de una nueva sesión.
Solución:
import json
MEMORY_FILE = "user_memory.json"
def save_message(message):
try:
with open(MEMORY_FILE, "r") as f:
memory = json.load(f)
except FileNotFoundError:
memory = []
memory.append(message)
with open(MEMORY_FILE, "w") as f:
json.dump(memory, f, indent=2)
def load_memory():
try:
with open(MEMORY_FILE, "r") as f:
return json.load(f)
except FileNotFoundError:
return []
# Store a sample message
save_message({"role": "user", "content": "How does recursion work?"})
save_message({"role": "assistant", "content": "Recursion is when a function calls itself to solve a problem."})
# Load and review memory
print("Long-Term Memory:", load_memory())Ejercicio 3: Resumir Mensajes Anteriores para Ahorrar Tokens
Tarea:
Utiliza la API de Chat Completions para resumir mensajes antiguos antes de incorporarlos a una nueva conversación para mantenerse dentro de los límites de tokens.
Solución:
def summarize_conversation(history):
summary_prompt = [
{"role": "system", "content": "Summarize this conversation briefly:"},
{"role": "user", "content": "\n".join([f'{m["role"]}: {m["content"]}' for m in history])}
]
response = openai.ChatCompletion.create(
model="gpt-4o",
messages=summary_prompt,
max_tokens=100,
temperature=0.3
)
return {"role": "system", "content": "Summary: " + response["choices"][0]["message"]["content"]}
# Example history
history = [
{"role": "user", "content": "Tell me about machine learning."},
{"role": "assistant", "content": "Machine learning is a subset of AI..."},
{"role": "user", "content": "What is supervised learning?"}
]
# Get a summary
print("Summary:", summarize_conversation(history))Ejercicio 4: Crear un Asistente Usando la API de Asistentes
Tarea:
Crea un asistente utilizando la API de Asistentes de OpenAI que recuerde un hilo y responda con contexto.
Solución:
import openai
import time
# Step 1: Create the assistant
assistant = openai.beta.assistants.create(
name="Memory Coach",
instructions="You are a memory coach that helps users retain information over time.",
model="gpt-4o"
)
# Step 2: Create a thread
thread = openai.beta.threads.create()
# Step 3: Add a message
openai.beta.threads.messages.create(
thread_id=thread.id,
role="user",
content="Help me remember the difference between RAM and ROM."
)
# Step 4: Run the assistant
run = openai.beta.threads.runs.create(
assistant_id=assistant.id,
thread_id=thread.id
)
# Step 5: Wait for completion
while True:
run_status = openai.beta.threads.runs.retrieve(run.id, thread_id=thread.id)
if run_status.status == "completed":
break
time.sleep(1)
# Step 6: Print the assistant’s response
messages = openai.beta.threads.messages.list(thread_id=thread.id)
for msg in messages.data:
if msg.role == "assistant":
print("Assistant:", msg.content[0].text.value)Ejercicio 5: Comparación entre Chat Completions y Asistentes
Tarea:
Ejecuta el mismo prompt usando ambas APIs y compara el manejo del contexto.
Solución:
Versión de Chat Completions:
chat_response = openai.ChatCompletion.create(
model="gpt-4o",
messages=[
{"role": "system", "content": "You are a helpful assistant."},
{"role": "user", "content": "Explain how HTTP works."}
],
max_tokens=150
)
print("Chat Completion Response:", chat_response["choices"][0]["message"]["content"])Versión de Asistentes:
# Thread and assistant are assumed to be created already
openai.beta.threads.messages.create(
thread_id=thread.id,
role="user",
content="Explain how HTTP works."
)
run = openai.beta.threads.runs.create(
assistant_id=assistant.id,
thread_id=thread.id
)
while True:
run_status = openai.beta.threads.runs.retrieve(run.id, thread_id=thread.id)
if run_status.status == "completed":
break
time.sleep(1)
messages = openai.beta.threads.messages.list(thread_id=thread.id)
for msg in messages.data:
if msg.role == "assistant":
print("Assistant Response (Assistants API):", msg.content[0].text.value)Estos ejercicios reforzaron cómo:
- Gestionar la memoria a corto y largo plazo
- Manejar los límites de contexto
- Aplicar la gestión de hilos y tokens
- Elegir entre las APIs de Chat Completions y Asistentes según tus objetivos
Al dominar estos flujos de trabajo, estás bien equipado para construir asistentes más inteligentes y conscientes del contexto que se adaptan a tus usuarios y sus necesidades.
Ejercicios Prácticos — Capítulo 7
Ejercicio 1: Implementación de Memoria a Corto Plazo en una Conversación
Tarea:
Crea un asistente simple que recuerde los mensajes previos del usuario y responda apropiadamente usando memoria a corto plazo. Mantén la conversación en una lista local y envía el historial completo en cada turno.
Solución:
import openai
import os
from dotenv import load_dotenv
load_dotenv()
openai.api_key = os.getenv("OPENAI_API_KEY")
conversation = [
{"role": "system", "content": "You are a helpful assistant."}
]
def chat(user_input):
conversation.append({"role": "user", "content": user_input})
response = openai.ChatCompletion.create(
model="gpt-4o",
messages=conversation,
max_tokens=150,
temperature=0.5
)
reply = response["choices"][0]["message"]["content"]
conversation.append({"role": "assistant", "content": reply})
return reply
# Try a multi-turn conversation
print("User: What’s your favorite programming language?")
print("Assistant:", chat("What’s your favorite programming language?"))
print("\nUser: Can you show me a simple example in it?")
print("Assistant:", chat("Can you show me a simple example in it?"))Ejercicio 2: Guardado y Recuperación de Memoria a Largo Plazo
Tarea:
Simular memoria persistente almacenando mensajes en un archivo JSON y recuperándolos al inicio de una nueva sesión.
Solución:
import json
MEMORY_FILE = "user_memory.json"
def save_message(message):
try:
with open(MEMORY_FILE, "r") as f:
memory = json.load(f)
except FileNotFoundError:
memory = []
memory.append(message)
with open(MEMORY_FILE, "w") as f:
json.dump(memory, f, indent=2)
def load_memory():
try:
with open(MEMORY_FILE, "r") as f:
return json.load(f)
except FileNotFoundError:
return []
# Store a sample message
save_message({"role": "user", "content": "How does recursion work?"})
save_message({"role": "assistant", "content": "Recursion is when a function calls itself to solve a problem."})
# Load and review memory
print("Long-Term Memory:", load_memory())Ejercicio 3: Resumir Mensajes Anteriores para Ahorrar Tokens
Tarea:
Utiliza la API de Chat Completions para resumir mensajes antiguos antes de incorporarlos a una nueva conversación para mantenerse dentro de los límites de tokens.
Solución:
def summarize_conversation(history):
summary_prompt = [
{"role": "system", "content": "Summarize this conversation briefly:"},
{"role": "user", "content": "\n".join([f'{m["role"]}: {m["content"]}' for m in history])}
]
response = openai.ChatCompletion.create(
model="gpt-4o",
messages=summary_prompt,
max_tokens=100,
temperature=0.3
)
return {"role": "system", "content": "Summary: " + response["choices"][0]["message"]["content"]}
# Example history
history = [
{"role": "user", "content": "Tell me about machine learning."},
{"role": "assistant", "content": "Machine learning is a subset of AI..."},
{"role": "user", "content": "What is supervised learning?"}
]
# Get a summary
print("Summary:", summarize_conversation(history))Ejercicio 4: Crear un Asistente Usando la API de Asistentes
Tarea:
Crea un asistente utilizando la API de Asistentes de OpenAI que recuerde un hilo y responda con contexto.
Solución:
import openai
import time
# Step 1: Create the assistant
assistant = openai.beta.assistants.create(
name="Memory Coach",
instructions="You are a memory coach that helps users retain information over time.",
model="gpt-4o"
)
# Step 2: Create a thread
thread = openai.beta.threads.create()
# Step 3: Add a message
openai.beta.threads.messages.create(
thread_id=thread.id,
role="user",
content="Help me remember the difference between RAM and ROM."
)
# Step 4: Run the assistant
run = openai.beta.threads.runs.create(
assistant_id=assistant.id,
thread_id=thread.id
)
# Step 5: Wait for completion
while True:
run_status = openai.beta.threads.runs.retrieve(run.id, thread_id=thread.id)
if run_status.status == "completed":
break
time.sleep(1)
# Step 6: Print the assistant’s response
messages = openai.beta.threads.messages.list(thread_id=thread.id)
for msg in messages.data:
if msg.role == "assistant":
print("Assistant:", msg.content[0].text.value)Ejercicio 5: Comparación entre Chat Completions y Asistentes
Tarea:
Ejecuta el mismo prompt usando ambas APIs y compara el manejo del contexto.
Solución:
Versión de Chat Completions:
chat_response = openai.ChatCompletion.create(
model="gpt-4o",
messages=[
{"role": "system", "content": "You are a helpful assistant."},
{"role": "user", "content": "Explain how HTTP works."}
],
max_tokens=150
)
print("Chat Completion Response:", chat_response["choices"][0]["message"]["content"])Versión de Asistentes:
# Thread and assistant are assumed to be created already
openai.beta.threads.messages.create(
thread_id=thread.id,
role="user",
content="Explain how HTTP works."
)
run = openai.beta.threads.runs.create(
assistant_id=assistant.id,
thread_id=thread.id
)
while True:
run_status = openai.beta.threads.runs.retrieve(run.id, thread_id=thread.id)
if run_status.status == "completed":
break
time.sleep(1)
messages = openai.beta.threads.messages.list(thread_id=thread.id)
for msg in messages.data:
if msg.role == "assistant":
print("Assistant Response (Assistants API):", msg.content[0].text.value)Estos ejercicios reforzaron cómo:
- Gestionar la memoria a corto y largo plazo
- Manejar los límites de contexto
- Aplicar la gestión de hilos y tokens
- Elegir entre las APIs de Chat Completions y Asistentes según tus objetivos
Al dominar estos flujos de trabajo, estás bien equipado para construir asistentes más inteligentes y conscientes del contexto que se adaptan a tus usuarios y sus necesidades.
Ejercicios Prácticos — Capítulo 7
Ejercicio 1: Implementación de Memoria a Corto Plazo en una Conversación
Tarea:
Crea un asistente simple que recuerde los mensajes previos del usuario y responda apropiadamente usando memoria a corto plazo. Mantén la conversación en una lista local y envía el historial completo en cada turno.
Solución:
import openai
import os
from dotenv import load_dotenv
load_dotenv()
openai.api_key = os.getenv("OPENAI_API_KEY")
conversation = [
{"role": "system", "content": "You are a helpful assistant."}
]
def chat(user_input):
conversation.append({"role": "user", "content": user_input})
response = openai.ChatCompletion.create(
model="gpt-4o",
messages=conversation,
max_tokens=150,
temperature=0.5
)
reply = response["choices"][0]["message"]["content"]
conversation.append({"role": "assistant", "content": reply})
return reply
# Try a multi-turn conversation
print("User: What’s your favorite programming language?")
print("Assistant:", chat("What’s your favorite programming language?"))
print("\nUser: Can you show me a simple example in it?")
print("Assistant:", chat("Can you show me a simple example in it?"))Ejercicio 2: Guardado y Recuperación de Memoria a Largo Plazo
Tarea:
Simular memoria persistente almacenando mensajes en un archivo JSON y recuperándolos al inicio de una nueva sesión.
Solución:
import json
MEMORY_FILE = "user_memory.json"
def save_message(message):
try:
with open(MEMORY_FILE, "r") as f:
memory = json.load(f)
except FileNotFoundError:
memory = []
memory.append(message)
with open(MEMORY_FILE, "w") as f:
json.dump(memory, f, indent=2)
def load_memory():
try:
with open(MEMORY_FILE, "r") as f:
return json.load(f)
except FileNotFoundError:
return []
# Store a sample message
save_message({"role": "user", "content": "How does recursion work?"})
save_message({"role": "assistant", "content": "Recursion is when a function calls itself to solve a problem."})
# Load and review memory
print("Long-Term Memory:", load_memory())Ejercicio 3: Resumir Mensajes Anteriores para Ahorrar Tokens
Tarea:
Utiliza la API de Chat Completions para resumir mensajes antiguos antes de incorporarlos a una nueva conversación para mantenerse dentro de los límites de tokens.
Solución:
def summarize_conversation(history):
summary_prompt = [
{"role": "system", "content": "Summarize this conversation briefly:"},
{"role": "user", "content": "\n".join([f'{m["role"]}: {m["content"]}' for m in history])}
]
response = openai.ChatCompletion.create(
model="gpt-4o",
messages=summary_prompt,
max_tokens=100,
temperature=0.3
)
return {"role": "system", "content": "Summary: " + response["choices"][0]["message"]["content"]}
# Example history
history = [
{"role": "user", "content": "Tell me about machine learning."},
{"role": "assistant", "content": "Machine learning is a subset of AI..."},
{"role": "user", "content": "What is supervised learning?"}
]
# Get a summary
print("Summary:", summarize_conversation(history))Ejercicio 4: Crear un Asistente Usando la API de Asistentes
Tarea:
Crea un asistente utilizando la API de Asistentes de OpenAI que recuerde un hilo y responda con contexto.
Solución:
import openai
import time
# Step 1: Create the assistant
assistant = openai.beta.assistants.create(
name="Memory Coach",
instructions="You are a memory coach that helps users retain information over time.",
model="gpt-4o"
)
# Step 2: Create a thread
thread = openai.beta.threads.create()
# Step 3: Add a message
openai.beta.threads.messages.create(
thread_id=thread.id,
role="user",
content="Help me remember the difference between RAM and ROM."
)
# Step 4: Run the assistant
run = openai.beta.threads.runs.create(
assistant_id=assistant.id,
thread_id=thread.id
)
# Step 5: Wait for completion
while True:
run_status = openai.beta.threads.runs.retrieve(run.id, thread_id=thread.id)
if run_status.status == "completed":
break
time.sleep(1)
# Step 6: Print the assistant’s response
messages = openai.beta.threads.messages.list(thread_id=thread.id)
for msg in messages.data:
if msg.role == "assistant":
print("Assistant:", msg.content[0].text.value)Ejercicio 5: Comparación entre Chat Completions y Asistentes
Tarea:
Ejecuta el mismo prompt usando ambas APIs y compara el manejo del contexto.
Solución:
Versión de Chat Completions:
chat_response = openai.ChatCompletion.create(
model="gpt-4o",
messages=[
{"role": "system", "content": "You are a helpful assistant."},
{"role": "user", "content": "Explain how HTTP works."}
],
max_tokens=150
)
print("Chat Completion Response:", chat_response["choices"][0]["message"]["content"])Versión de Asistentes:
# Thread and assistant are assumed to be created already
openai.beta.threads.messages.create(
thread_id=thread.id,
role="user",
content="Explain how HTTP works."
)
run = openai.beta.threads.runs.create(
assistant_id=assistant.id,
thread_id=thread.id
)
while True:
run_status = openai.beta.threads.runs.retrieve(run.id, thread_id=thread.id)
if run_status.status == "completed":
break
time.sleep(1)
messages = openai.beta.threads.messages.list(thread_id=thread.id)
for msg in messages.data:
if msg.role == "assistant":
print("Assistant Response (Assistants API):", msg.content[0].text.value)Estos ejercicios reforzaron cómo:
- Gestionar la memoria a corto y largo plazo
- Manejar los límites de contexto
- Aplicar la gestión de hilos y tokens
- Elegir entre las APIs de Chat Completions y Asistentes según tus objetivos
Al dominar estos flujos de trabajo, estás bien equipado para construir asistentes más inteligentes y conscientes del contexto que se adaptan a tus usuarios y sus necesidades.