En este tutorial, creamos una capa de memoria universal a largo plazo para agentes de IA que utilizan Mem0, modelos OpenAI y ChromaDB. Diseñamos un sistema que puede extraer recuerdos estructurados de conversaciones naturales, almacenarlos semánticamente, recuperarlos de forma inteligente e integrarlos directamente en respuestas personalizadas de los agentes. Vamos más allá del simple historial de chat e implementamos una memoria persistente y de ámbito de usuario con control CRUD total, búsqueda semántica, aislamiento multiusuario y configuración personalizada. Finalmente, construimos una arquitectura de agente con memoria aumentada lista para producción que demuestra cómo los sistemas de IA modernos pueden razonar con continuidad contextual en lugar de operar sin estado.
Instalamos todas las dependencias necesarias y configuramos de forma segura nuestra clave API OpenAI. Inicializamos la instancia de Mem0 Memory junto con el cliente OpenAI y las utilidades de la consola enriquecida. Establecemos la base de nuestro sistema de memoria a largo plazo con la configuración predeterminada impulsada por incorporaciones de ChromaDB y OpenAI.
[
{“role”: “user”, “content”: “Hi! I’m Alice. I’m a software engineer who loves Python and machine learning.”},
{“role”: “assistant”, “content”: “Nice to meet you Alice! Python and ML are great areas to be in.”}
],
[
{“role”: “user”, “content”: “I prefer dark mode in all my IDEs and I use VS Code as my main editor.”},
{“role”: “assistant”, “content”: “Good to know! VS Code with dark mode is a popular combo.”}
],
[
{“role”: “user”, “content”: “I’m currently building a RAG pipeline for my company’s internal docs. It’s for a fintech startup.”},
{“role”: “assistant”, “content”: “That’s exciting! RAG pipelines are really valuable for enterprise use cases.”}
],
[
{“role”: “user”, “content”: “I have a dog named Max and I enjoy hiking on weekends.”},
{“role”: “assistant”, “content”: “Max sounds lovely! Hiking is a great way to recharge.”}
]]resultados = []
para i, convo en enumerar (conversaciones): resultado = memoria.add (convo, user_id = USER_ID) extraído = result.get (“resultados”, []) para memoria en extraída: resultados.append(mem) print(f” Conversación {i+1}: {len(extraída)} memoria(s) extraída(s”) print(f”\n✅ Total de memorias almacenadas: {len(resultados)}”)
Simulamos conversaciones realistas de varios turnos y las almacenamos utilizando el canal de extracción automática de memoria de Mem0. Agregamos datos conversacionales estructurados para un usuario específico y permitimos que el LLM extraiga hechos significativos a largo plazo. Verificamos cuántos recuerdos se crean, confirmando que el conocimiento semántico persiste con éxito.
“What programming languages does the user prefer?”,
“What is Alice working on professionally?”,
“What are Alice’s hobbies?”,
“What tools and IDE does Alice use?”,
]
para consulta en consultas: search_results = memoria.search(query=query, user_id=USER_ID, limit=2) table = Table(title=f”🔍 Consulta: {query}”, show_lines=True) table.add_column(“Memory”, style=”white”, max_width=60) table.add_column(“Score”, style=”green”, justify=”center”) para r en search_results.get(“resultados”, []): puntuación = r.get(“puntuación”, “N/A”) puntuación_str = f”{puntuación:.4f}” if isinstance(puntuación, flotante) else str(puntuación) table.add_row(r[“memory”]puntuación_str) consola.print(tabla) print() consola.rule(“[bold cyan]MÓDULO 4: Operaciones CRUD[/bold cyan]”) todas_memorias = memoria.get_all(user_id=USER_ID) memorias_lista = todas_memorias.get(“resultados”, []) print(f”\n📚 Todos los recuerdos para ‘{USER_ID}’:”) para i, mem en enumerar(memories_list): print(f” [{i+1}] ID: {mem[‘id’][:8]}…. → {mem[‘memory’]}”) si lista_recuerdos: first_id = lista_recuerdos[0][“id”]
texto_original = lista_recuerdos[0][“memory”]
print(f”\n✏️ Actualizando memoria: ‘{texto_original}'”) memoria.update(id_memoria=primer_id, datos=texto_original + ” (confirmado)”) actualizado = memoria.get(id_memoria=primer_id) print(f” Después de la actualización: ‘{actualizado[‘memory’]}'”)
Realizamos consultas de búsqueda semántica para recuperar recuerdos relevantes utilizando lenguaje natural. Demostramos cómo Mem0 clasifica los recuerdos almacenados según su puntuación de similitud y devuelve la información más alineada contextualmente. También realizamos operaciones CRUD enumerando, actualizando y validando entradas de memoria almacenadas.
mensajes.extend(session_history[-6:]) mensajes.append({“role”: “usuario”, “contenido”: mensaje_usuario}) respuesta = openai_client.chat.completions.create( model=”gpt-4.1-nano-2025-04-14″, mensajes=mensajes ) asistente_respuesta = respuesta.opciones[0].message.intercambio de contenido = [
{“role”: “user”, “content”: user_message},
{“role”: “assistant”, “content”: assistant_response}
]
memoria.add(exchange, user_id=user_id) session_history.append({“role”: “usuario”, “content”: user_message}) session_history.append({“role”: “asistente”, “content”: asistente_respuesta}) return asistente_respuesta sesión = []
mensajes_demo = [
“Can you recommend a good IDE setup for me?”,
“What kind of project am I currently building at work?”,
“Suggest a weekend activity I might enjoy.”,
“What’s a good tech stack for my current project?”,
]
print(“\n🤖 Iniciando conversación con memoria aumentada con Alice…\n”) para mensaje en demo_messages: print(Panel(f”[bold yellow]Usuario:[/bold yellow] {msg}”, border_style=”amarillo”)) respuesta = chat_with_memory(msg, USER_ID, sesión) print(Panel(f”[bold green]Asistente:[/bold green] {respuesta}”, border_style=”verde”)) imprimir()
Construimos un bucle de chat totalmente mejorado con memoria que recupera recuerdos relevantes antes de generar respuestas. Inyectamos dinámicamente contexto personalizado en el mensaje del sistema y almacenamos cada nuevo intercambio en la memoria a largo plazo. Simulamos una sesión de varios turnos para demostrar la continuidad contextual y la personalización en acción.
[
{“role”: “user”, “content”: “I’m Bob, a data scientist specializing in computer vision and PyTorch.”},
{“role”: “assistant”, “content”: “Great to meet you Bob!”}
],
[
{“role”: “user”, “content”: “I prefer Jupyter notebooks over VS Code, and I use Vim keybindings.”},
{“role”: “assistant”, “content”: “Classic setup for data science work!”}
]]para convo en bob_conversations: memoria.add(convo, user_id=USER_BOB) print(“\n🔐 Probando el aislamiento de memoria entre Alice y Bob:\n”) test_query = “¿Qué herramientas de programación prefiere este usuario?” alice_results = memoria.search(query=test_query, user_id=USER_ID, límite=3) bob_results = memoria.search(query=test_query, user_id=USER_BOB, limit=3) print(“👩 Los recuerdos de Alice:”) para r en alice_results.get(“resultados”, []): imprimir(f” • {r[‘memory’]}”) print(“\n👨 Los recuerdos de Bob:”) para r en bob_results.get(“resultados”, []): imprimir(f” • {r[‘memory’]}”)
Demostramos el aislamiento de la memoria a nivel de usuario presentando un segundo usuario con preferencias distintas. Almacenamos datos de conversación separados y validamos que las búsquedas permanezcan limitadas al user_id correcto. Confirmamos que los espacios de nombres de memoria están aislados, lo que garantiza implementaciones seguras de agentes multiusuario.
[{“role”: “user”, “content”: “I’m a researcher studying neural plasticity and brain-computer interfaces.”}]user_id=”researcher_01″ ) result = custom_memory.search(“¿En qué campo trabaja esta persona?”, user_id=”researcher_01″, limit=2) print(“\n🔍 Resultado de búsqueda de memoria personalizada:”) para r en result.get(“results”, []): imprimir(f” • {r[‘memory’]}”) consola.regla(“[bold cyan]MÓDULO 8: Historia de la Memoria[/bold cyan]”) all_alice = memoria.get_all(user_id=USER_ID) alice_memories = all_alice.get(“resultados”, []) table = Table(title=f”📋 Perfil de memoria completo: {USER_ID}”, show_lines=True, width=90) table.add_column(“#”, style=”dim”, width=3) table.add_column(“ID de memoria”, style=”cyan”, width=12) table.add_column(“Contenido de memoria”, style=”white”) table.add_column(“Creado en”, style=”amarillo”, ancho=12) para i, mem en enumerar(alice_memories): mem_id = mem[“id”][:8] + “…” creado = mem.get(“created_at”, “N/A”) si se creó y se creó != “N/A”: intente: creado = datetime.fromisoformat(created.replace(“Z”, “+00:00”)).strftime(“%m/%d %H:%M”) excepto: creado = str(creado)[:10]
tabla.add_row(cadena(i+1), mem_id, mem[“memory”]creado) console.print(table) console.rule(“[bold cyan]MÓDULO 9: Eliminación de Memoria[/bold cyan]”) all_mems = memoria.get_all(user_id=USER_ID).get(“resultados”, []) si todos_mems: último_mem = todos_mems[-1]
print(f”\n🗑️ Eliminando memoria: ‘{last_mem[‘memory’]}'”) memoria.eliminar(memoria_id=último_mem[“id”]) recuento_actualizado = len(memoria.get_all(user_id=USER_ID).get(“resultados”, [])) print(f”✅ Eliminado. Memorias restantes para {USER_ID}: {updated_count}”) console.rule(“[bold cyan]✅ TUTORIAL COMPLETO[/bold cyan]”) resumen = “”” # 🎓 Resumen del tutorial avanzado de Mem0 ## Lo que aprendió: 1. **Configuración básica**: crear instancias de memoria con configuraciones predeterminadas y personalizadas 2. **Agregar recuerdos**: de conversaciones (extraídas automáticamente por LLM) 3. **Búsqueda semántica**: recuperar recuerdos relevantes mediante consulta en lenguaje natural 4. **Operaciones CRUD**: obtener, actualizar y eliminar recuerdos individuales 5. **Chat con memoria aumentada**: proceso completo: recuperar → responder → almacenar 6. **Aislamiento multiusuario**: espacios de nombres de memoria separados por ID de usuario 7. **Configuración personalizada**: LLM personalizado, incrustador y almacén de vectores 8. **Historial de memoria**: ver perfiles de memoria completos con marcas de tiempo 9. **Limpieza**: eliminar recuerdos específicos o todos ## Conceptos clave: – `memory.add(messages, user_id=…)` – `memory.search(query, user_id=…)` – `memory.get_all(user_id=…)` – `memory.update(memory_id, data)` – `memory.delete(memory_id)` – `Memory.from_config(config)` ## Próximos pasos: – Cambie ChromaDB por Qdrant, Pinecone o Weaviate – Utilice la plataforma Mem0 alojada (app.mem0.ai) para producción – Integre con agentes LangChain, CrewAI o LangGraph – Agregue `agent_id` para el alcance de la memoria a nivel de agente “”” console.print(Markdown(summary))
Creamos una configuración Mem0 totalmente personalizada con parámetros explícitos para el LLM, el incrustador y el almacén de vectores. Probamos la instancia de memoria personalizada y exploramos el historial de la memoria, las marcas de tiempo y los perfiles estructurados. Finalmente, demostramos las operaciones de eliminación y limpieza, completando la gestión del ciclo de vida completo de la memoria del agente a largo plazo.
En conclusión, implementamos una infraestructura de memoria completa para agentes de IA utilizando Mem0 como capa de abstracción de memoria universal. Demostramos cómo agregar, recuperar, actualizar, eliminar, aislar y personalizar recuerdos a largo plazo mientras los integramos en un bucle de chat dinámico. Mostramos cómo la recuperación de la memoria semántica transforma a los asistentes genéricos en sistemas conscientes del contexto capaces de personalización y continuidad entre sesiones. Con esta base establecida, ahora estamos equipados para extender la arquitectura a sistemas multiagente, implementaciones de nivel empresarial, bases de datos vectoriales alternativas y marcos de agentes avanzados, convirtiendo la memoria en una capacidad central en lugar de una idea de último momento.
Consulte el código de implementación completo y el cuaderno. Además, no dude en seguirnos en Twitter y no olvide unirse a nuestro SubReddit de más de 130.000 ML y suscribirse a nuestro boletín. ¡Esperar! estas en telegrama? Ahora también puedes unirte a nosotros en Telegram.
¿Necesita asociarse con nosotros para promocionar su repositorio de GitHub O su página principal de Hugging O su lanzamiento de producto O seminario web, etc.? Conéctate con nosotros