/ /

Comienza con la integración de MongoDB Mem0

Puede integrar MongoDB con Mem0 para configurar la memoria a largo plazo de sus agentes de IA que persiste en todas las conversaciones. Este tutorial configura Mem0 para usar MongoDB como su almacén vectorial y luego compila un asistente con memoria aumentada. En este tutorial, realizará las siguientes tareas:

Configura tu entorno.
Utiliza MongoDB como el almacén vectorial Mem0.
Almacenar y recuperar documentos de memoria.
Compile un asistente que personalice sus respuestas en función de las memorias que recupere.

Segundo plano

Mem0 es una capa de memoria de código abierto para agentes y asistentes de IA. En lugar de pasar todo el historial de conversaciones al LLM en cada solicitud, Mem0 extrae hechos discretos de las conversaciones, almacena cada hecho como un documento y recupera solo los hechos más relevantes en el momento de la query.

Cuando configure Mem0 para usar MongoDB como su almacén vectorial, Mem0 conserva estos documentos de memoria en una colección de MongoDB. Utiliza MongoDB búsqueda vectorial para la recuperación semántica y MongoDB Search para la recuperación de palabras clave de texto completo. Mem0 crea ambos índices la primera vez que se conecta a su colección.

Requisitos previos

Para completar este tutorial, debes tener los siguientes recursos:

Uno de los siguientes tipos de clúster de MongoDB:
- Un clúster de Atlas que ejecuta la versión 6.0.11, 7.0.2 o posterior de MongoDB. Es necesario garantizar que la dirección IP esté incluida en la lista de acceso del proyecto Atlas.
- A local Atlas deployment created using Python and Docker. Install atlas-local-lib-py (pip install atlas-local-lib-py) to programmatically create and manage local deployments. To learn more, see the atlas-local-lib-py repository.
- A MongoDB Community cluster with Search and Vector Search installed.
Una llave de API de OpenAI. Debes tener una cuenta de OpenAI con créditos disponibles para las solicitudes de API. Para obtener más información sobre cómo registrar una cuenta de OpenAI, consulta el sitio web de la API de OpenAI.
Python v3.10 o posterior.

Configurar el entorno

Instalar las dependencias.

Ejecuta los siguientes comandos en tu terminal para crear un nuevo directorio llamado mem0-mongodb-project e instalar las dependencias necesarias:

mkdir mem0-mongodb-project
cd mem0-mongodb-project
pip install mem0ai pymongo openai python-dotenv

Mem0 requiere PyMongo v4.13.2 o posterior. El comando anterior instala la última versión de PyMongo.

Establecer las variables de entorno.

En tu directorio mem0-mongodb-project, crea un archivo .env y añade el siguiente código:

OPENAI_API_KEY="<openai-api-key>"
MONGODB_URI="<connection-string>"

Se debe sustituir <connection-string> por la cadena de conexión del clúster Atlas o de la implementación local de Atlas.

Su cadena de conexión debe usar el siguiente formato:

mongodb+srv://<db_username>:<db_password>@<clusterName>.<hostname>.mongodb.net

Para obtener más información, consulta Conectar a un clúster a través de bibliotecas de clientes.

Su cadena de conexión debe usar el siguiente formato:

mongodb://localhost:<port-number>/?directConnection=true

Para obtener más información, consulta Cadenas de conexión.

Cree un archivo de proyecto.

En su directorio mem0-mongodb-project, cree un archivo llamado main.py. Añada el siguiente código a este archivo para cargar las variables de entorno:

from mem0 import Memory
from openai import OpenAI
from dotenv import load_dotenv
import os
load_dotenv()

En pasos futuros, agregará código a este archivo para configurar Mem0 y compilar su asistente.

Almacenar y recuperar datos de memoria

En esta sección, configuras Mem0 para usar MongoDB como su almacén de vectores. Luego, almacenas recuerdos que Mem0 extrae de las conversaciones y los recuperas mediante el uso de la búsqueda semántica.

Configure MongoDB como un almacén vectorial.

Para usar MongoDB como almacén de vectores Mem0, agregue el siguiente código a su archivo main.py:

config = {
    "llm": {
        "provider": "openai",
        "config": {
            "model": "gpt-4o-mini",
            "temperature": 0.1,
            "max_tokens": 2000,
        },
    },
    "embedder": {
        "provider": "openai",
        "config": {
            "model": "text-embedding-3-small",
            "embedding_dims": 1536,
        },
    },
    "vector_store": {
        "provider": "mongodb",
        "config": {
            "mongo_uri": os.environ["MONGODB_URI"],
            "db_name": "mem0_db",
            "collection_name": "agent_memory",
            "embedding_model_dims": 1536,
        },
    },
}
m = Memory.from_config(config)

Este código establece las siguientes claves en el diccionario config:

llm: Especifica gpt-4o-mini como el modelo que extrae hechos de las conversaciones
embedder: Especifica text-embedding-3-small como el modelo que genera las incrustaciones
vector_store: Configura MongoDB como el almacenamiento de vectores

The index should take about one minute to build. While it builds, the index is in an initial sync state. When it finishes building, you can start querying the data in your collection.

Almacene recuerdos de una conversación.

Añada el siguiente código para extraer y almacenar recuerdos de una conversación sobre la reubicación de un usuario:

messages = [
    {"role": "user", "content": "I'm moving to Berlin next month."},
    {"role": "assistant", "content": "I'll remember that you're relocating to Berlin."},
]
result = m.add(messages, user_id="alice")
print(result)

Cuando pasas datos de conversación al método add(), Mem0 utiliza el LLM para extraer hechos de la conversación y guarda cada hecho en tu colección como un documento de memoria independiente.

Almacenar recuerdos de una segunda conversación.

Añade el siguiente código para almacenar recuerdos de una segunda conversación, que Mem0 añade al perfil de memoria del mismo usuario:

messages = [
    {"role": "user", "content": "I prefer concise answers and I use Python daily."},
    {"role": "assistant", "content": "Noted. I'll keep my responses brief and Python-focused."},
]
result = m.add(messages, user_id="alice")
print(result)

Busque las memorias almacenadas.

Para buscar datos de memoria que respondan a una query sobre la reubicación del usuario, agregue el siguiente código a su archivo main.py:

print("\nWaiting for the MongoDB Vector Search index to finish building...")
time.sleep(60)
results = m.search(
    query="When is Alice moving?",
    filters={"user_id": "alice"},
    top_k=5,
)
for mem in results["results"]:
    print(mem["memory"], "- score:", mem["score"])

Antes de ejecutar la query, el código espera 60 segundos para permitir que el índice de búsqueda vectorial de MongoDB termine de crearse.

Devolver el historial completo de la memoria.

Para devolver el historial de memoria completo del usuario sin ejecutar una búsqueda semántica, agregue el siguiente código a su archivo main.py:

all_memories = m.get_all(filters={"user_id": "alice"})
for mem in all_memories["results"]:
    print(mem["id"], mem["memory"])

Tip

Para inspeccionar los documentos de memoria almacenados, explore la colección mem0_db.agent_memory en la interfaz de usuario de Atlas. Para obtener más información, consulte Ver colecciones.

Compilar un asistente con aumento de memoria

Esta sección muestra cómo combinar el almacenamiento de memoria y la recuperación en un asistente que personaliza sus respuestas. Antes de que el asistente responda, recupera los recuerdos más relevantes para el mensaje actual y los añade al mensaje del sistema. Después de responder, almacena el nuevo turno de conversación para que los recuerdos crezcan con cada intercambio.

Recuperar recuerdos y compilar el indicador del sistema.

En su archivo main.py, añada el siguiente código para definir una función que busque los recuerdos más relevantes para un mensaje y los añada al mensaje del sistema:

openai_client = OpenAI()
USER_ID = "alice"
def build_system_prompt(user_message):
    # Retrieve the memories that are most relevant to the message
    relevant = m.search(
        query=user_message,
        filters={"user_id": USER_ID},
        top_k=5,
    )
    memory_text = "\n".join(f"- {mem['memory']}" for mem in relevant["results"])
    # Add the retrieved memories to the system prompt
    system_prompt = "You are a helpful personal assistant."
    if memory_text:
        system_prompt += (
            " Use the following facts to personalize your response:\n"
            f"{memory_text}"
        )
    return system_prompt

Genere una respuesta y almacene el turno de conversación.

Agregue el siguiente código para definir una función que genere una respuesta personalizada y almacene el nuevo turno de conversación como recuerdos:

def chat(user_message):
    # Generate a response
    response = openai_client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role": "system", "content": build_system_prompt(user_message)},
            {"role": "user", "content": user_message},
        ],
    )
    assistant_message = response.choices[0].message.content
    # Store the new conversation turn as memories
    m.add(
        [
            {"role": "user", "content": user_message},
            {"role": "assistant", "content": assistant_message},
        ],
        user_id=USER_ID,
    )
    return assistant_message
print(chat("Can you recommend a programming meetup in my city?"))

El asistente recomienda una reunión de Python en Berlín porque recuperó la ubicación y las preferencias de lenguaje de Alice de MongoDB antes de ensamblar el prompt.

Ejecutar el archivo

Para ejecutar el archivo main.py, ejecute el siguiente comando desde su directorio mem0-mongodb-project:

python main.py

Si el comando se ejecuta correctamente, el resultado se parecerá al siguiente:

# Output from the first add() method that stores relocation data
{'results': [{'id': '...', 'memory': 'User is moving to Berlin around September 2026.', 'event': 'ADD'}]}
# Output from the second add() method that stores user preferences
{'results': [{'id': '...', 'memory': 'Prefers concise answers', 'event': 'ADD'}, {'id': '...', 'memory': 'Uses Python daily', 'event': 'ADD'}]}
Waiting for the MongoDB Vector Search index to finish building...
# Output from the search() method that retrieves the relocation memory
User is moving to Berlin in September 2026. - score: 0.38553877995545677User is moving to Berlin around September 2026. - score: 0.7043201923370361
# Output from the get_all() method that returns the full memory history
<id> User is moving to Berlin around September 2026.
<id> Prefers concise answers
<id> Uses Python daily
# Output from the chat() method that asks the assistant about programming meetups
Since you're moving to Berlin around September 25, 2026, I recommend checking platforms
like Meetup.com or Eventbrite closer to your move for local Python programming meetups.
You can also follow local tech communities on social media for updates on events.

Próximos pasos

Para obtener más información sobre las claves de configuración de Mem0 y el conjunto completo de métodos Memory, consulte Integre MongoDB con Mem0.

Para obtener más información sobre los índices que Mem0 crea en su colección, consulte Crear un índice de búsqueda vectorial de MongoDB y Gestionar índices de búsqueda de MongoDB.

Volver

Mem0

SDK de agentes de OpenAI