Cómo conectar Mem0 con Ollama para crear una memoria local

Los modelos de lenguaje no recuerdan automáticamente lo ocurrido en conversaciones anteriores. Cuando cierras una aplicación, cambias de sesión o eliminas los mensajes antiguos de la ventana de contexto, el modelo deja de disponer de esa información.

Una forma de solucionar esta limitación consiste en conectar Mem0 con Ollama. Ollama ejecuta localmente el modelo generativo y el modelo de embeddings, mientras que Mem0 extrae información útil de las conversaciones, la organiza y permite recuperarla cuando vuelva a ser relevante.

En lugar de enviar siempre todo el historial al modelo, la aplicación puede buscar unos pocos recuerdos relacionados con la pregunta actual e introducirlos dentro del prompt. Esto reduce el volumen de contexto y permite mantener preferencias, objetivos o hechos importantes entre sesiones.

La instalación puede funcionar completamente dentro de tu infraestructura si utilizas Ollama, Mem0 OSS y una base de datos local. Sin embargo, la privacidad final dependerá de todos los componentes conectados. Si añades un modelo, reranker, base de datos o servicio administrado externo, parte de la información podría abandonar tu equipo.

Qué hace Mem0 y qué función cumple Ollama

Mem0 y Ollama resuelven problemas diferentes. Ollama se encarga de ejecutar los modelos, mientras que Mem0 proporciona las operaciones necesarias para añadir, buscar, consultar, actualizar y eliminar recuerdos.

Durante el guardado, Mem0 puede analizar una conversación y extraer hechos que puedan resultar útiles posteriormente. Por ejemplo:

• El usuario prefiere respuestas breves.
• Está desarrollando una aplicación en Rust.
• No quiere recomendaciones de películas de terror.
• Su objetivo es completar una carrera en menos de cuatro horas.

Mem0 convierte cada recuerdo en una representación numérica mediante el modelo de embeddings y la almacena junto a su contenido y metadatos. Al realizar una búsqueda, combina la consulta con filtros como el identificador del usuario y devuelve los recuerdos más relacionados.

Las versiones actuales de Mem0 utilizan una extracción principalmente aditiva. Esto significa que una información nueva puede almacenarse sin eliminar automáticamente un recuerdo anterior. Si un dato ha quedado obsoleto y necesitas corregirlo, la aplicación puede utilizar explícitamente las operaciones update() o delete().

Mem0 no sustituye al modelo conversacional. La aplicación debe recuperar los recuerdos, incorporarlos al mensaje de sistema o al contexto y pedir a Ollama que genere la respuesta.

Componentes necesarios para conectar Mem0 con Ollama

Para construir un sistema local necesitas estos componentes:

• Mem0 OSS: administra la extracción, almacenamiento y recuperación de recuerdos.
• Ollama: ejecuta el modelo generativo y el modelo de embeddings.
• Un modelo de lenguaje: interpreta las conversaciones y genera las respuestas.
• Un modelo de embeddings: transforma los recuerdos y consultas en vectores.
• Un almacén vectorial: conserva los vectores y permite buscar recuerdos relacionados.
• Una aplicación: conecta la conversación, la recuperación y el guardado de memoria.

Qdrant y Chroma son dos opciones habituales para el almacenamiento:

Almacén	Uso recomendado
Qdrant	Servicios persistentes, varias aplicaciones y despliegues mediante Docker
Chroma	Pruebas locales y aplicaciones pequeñas con almacenamiento en una carpeta

Qdrant proporciona una API independiente y facilita separar la base vectorial de la aplicación. Chroma puede utilizar una ruta local, por lo que resulta más sencillo para una primera prueba.

Cómo instalar Mem0, Ollama y Qdrant

Primero instala Ollama y comprueba que el servicio esté en ejecución. Después descarga un modelo de lenguaje y otro de embeddings:

ollama pull llama3.1:latest
ollama pull nomic-embed-text:latest

llama3.1:latest es el modelo utilizado en el ejemplo oficial de Mem0, pero puedes sustituirlo por otro modelo instructivo compatible con Ollama. Los modelos pequeños consumen menos memoria, aunque pueden extraer hechos con menor precisión o respetar peor el formato esperado.

Instala las dependencias de Python:

pip install mem0ai qdrant-client openai ollama

Para ejecutar Qdrant en Docker y conservar los datos mediante un volumen, utiliza:

docker volume create qdrant_storage

docker run -d \
  --name qdrant \
  -p 6333:6333 \
  -p 6334:6334 \
  -v qdrant_storage:/qdrant/storage \
  qdrant/qdrant

El puerto 6333 proporciona la API HTTP y el 6334 se utiliza para gRPC. En este ejemplo Mem0 se conecta mediante la API HTTP.

Comprueba que Ollama responde:

curl http://localhost:11434/api/tags

También puedes verificar Qdrant abriendo:

http://localhost:6333/dashboard

No expongas estos puertos directamente a Internet. Si los servicios se ejecutan en equipos diferentes, utiliza una red privada, una VPN o reglas de cortafuegos que permitan únicamente las conexiones necesarias.

Configuración local de Mem0 con Ollama y Qdrant

La configuración debe indicar expresamente que Ollama se utilizará como LLM y como proveedor de embeddings. También debe definir dónde se encuentra Qdrant y qué dimensiones producen los embeddings.

from mem0 import Memory

OLLAMA_URL = "http://localhost:11434"
CHAT_MODEL = "llama3.1:latest"
EMBEDDING_MODEL = "nomic-embed-text:latest"

config = {
    "vector_store": {
        "provider": "qdrant",
        "config": {
            "collection_name": "memoria_agente",
            "host": "localhost",
            "port": 6333,
            "embedding_model_dims": 768,
        },
    },
    "llm": {
        "provider": "ollama",
        "config": {
            "model": CHAT_MODEL,
            "temperature": 0,
            "max_tokens": 2000,
            "ollama_base_url": OLLAMA_URL,
        },
    },
    "embedder": {
        "provider": "ollama",
        "config": {
            "model": EMBEDDING_MODEL,
            "ollama_base_url": OLLAMA_URL,
        },
    },
    "history_db_path": "./mem0_history.db",
    "custom_instructions": """
    Extrae únicamente información que pueda ser útil en conversaciones futuras:
    - Preferencias estables
    - Objetivos y proyectos
    - Restricciones importantes
    - Decisiones confirmadas

    Ignora saludos, conversación casual y hechos temporales sin importancia.
    Devuelve un objeto JSON con la clave facts y una lista de recuerdos.
    """,
}

memory = Memory.from_config(config)

Memory.from_config() obliga a Mem0 a utilizar los proveedores indicados. El constructor Memory() no conecta automáticamente con Mem0 Cloud, pero sí puede aplicar componentes predeterminados basados en OpenAI y solicitar una clave si no los sustituyes.

custom_instructions permite determinar qué información merece almacenarse. Debe incluirse como una propiedad de nivel superior antes de crear la instancia de Memory.

Por qué deben coincidir las dimensiones de los embeddings

El modelo nomic-embed-text produce vectores de 768 dimensiones. Por eso la colección de Qdrant se configura mediante:

embedding_model_dims=768

Si el almacén espera vectores con un tamaño diferente, Qdrant rechazará los datos y Mem0 no podrá guardar o consultar los recuerdos correctamente.

Cuando cambies de modelo de embeddings, comprueba sus dimensiones antes de modificar la configuración. También puede ser necesario crear una colección nueva y volver a generar todos los vectores existentes.

No mezcles embeddings producidos por modelos diferentes dentro de una misma colección. Aunque dos modelos generen vectores con idénticas dimensiones, sus espacios semánticos no tienen por qué ser compatibles.

Cómo guardar y recuperar recuerdos

Para guardar una conversación, pasa una lista de mensajes a memory.add() e indica un identificador estable para el usuario:

mensajes = [
    {
        "role": "user",
        "content": "Estoy desarrollando una aplicación en Rust"
    },
    {
        "role": "assistant",
        "content": "Lo recordaré para adaptar los próximos ejemplos"
    }
]

resultado = memory.add(
    mensajes,
    user_id="usuario_001"
)

print(resultado)

Con infer=True, que es el comportamiento predeterminado, Mem0 utiliza el modelo para extraer recuerdos estructurados. Si quieres conservar el contenido sin aplicar esta extracción, puedes utilizar infer=False.

Para buscar información relacionada:

recuerdos = memory.search(
    "¿Qué lenguaje utiliza en su proyecto?",
    filters={"user_id": "usuario_001"},
    top_k=5
)

for recuerdo in recuerdos["results"]:
    print(recuerdo["memory"])

El filtro por user_id es fundamental. Si una aplicación utilizada por varias personas busca sin aplicar correctamente el identificador, podría recuperar recuerdos pertenecientes a otro usuario.

También puedes utilizar agent_id para separar la memoria de distintos agentes y run_id para dividir conversaciones, proyectos o procesos concretos.

Cómo crear un chat completo con Ollama y Mem0

Para que Ollama utilice los recuerdos, la aplicación debe ejecutar cuatro pasos:

1. Recibir la pregunta del usuario.
2. Buscar recuerdos relacionados mediante Mem0.
3. Añadirlos al contexto enviado a Ollama.
4. Guardar la pregunta y la respuesta como una nueva interacción.

Ollama proporciona una API compatible con el formato de OpenAI. Podemos utilizarla para crear el bucle completo:

from openai import OpenAI

ollama_chat = OpenAI(
    base_url=f"{OLLAMA_URL}/v1",
    api_key="ollama"
)

def chat(mensaje_usuario, user_id):
    resultado = memory.search(
        mensaje_usuario,
        filters={"user_id": user_id},
        top_k=5
    )

    recuerdos = [
        item["memory"]
        for item in resultado["results"]
    ]

    contexto = "\n".join(
        f"- {recuerdo}" for recuerdo in recuerdos
    )

    respuesta = ollama_chat.chat.completions.create(
        model=CHAT_MODEL,
        messages=[
            {
                "role": "system",
                "content": (
                    "Eres un asistente útil. Utiliza los recuerdos "
                    "solo cuando sean relevantes.\n\n"
                    f"Recuerdos del usuario:\n{contexto}"
                ),
            },
            {
                "role": "user",
                "content": mensaje_usuario,
            },
        ],
    ).choices[0].message.content

    memory.add(
        [
            {
                "role": "user",
                "content": mensaje_usuario,
            },
            {
                "role": "assistant",
                "content": respuesta,
            },
        ],
        user_id=user_id,
    )

    return respuesta

Ahora puedes iniciar una conversación:

print(
    chat(
        "Estoy creando un programa de escritorio en Rust",
        user_id="usuario_001"
    )
)

Después de reiniciar la aplicación, el mismo usuario puede preguntar:

print(
    chat(
        "¿Qué lenguaje estoy utilizando en mi proyecto?",
        user_id="usuario_001"
    )
)

Si la memoria se almacenó correctamente, Mem0 recuperará la información y Ollama podrá utilizarla para responder.

Cómo utilizar Chroma en lugar de Qdrant

Para una prueba local pequeña puedes sustituir Qdrant por Chroma. El nombre correcto del proveedor en Mem0 es chroma:

"vector_store": {
    "provider": "chroma",
    "config": {
        "collection_name": "memoria_agente",
        "path": "./chroma_db",
    },
}

La carpeta indicada en path contendrá los datos persistentes de Chroma. Debes incluirla en tus copias de seguridad y evitar borrarla al actualizar la aplicación.

El paquete de Python utilizado por el proyecto continúa llamándose chromadb, pero el identificador que debes escribir dentro de la configuración de Mem0 es chroma.

Cómo corregir o eliminar recuerdos obsoletos

La memoria de un asistente no debería considerarse una fuente infalible. El modelo puede almacenar un hecho mal interpretado, conservar información que ya no es válida o generar varios recuerdos parecidos.

Puedes consultar todas las memorias asociadas a un usuario:

resultado = memory.get_all(
    filters={"user_id": "usuario_001"}
)

for recuerdo in resultado["results"]:
    print(recuerdo["id"], recuerdo["memory"])

Para corregir una memoria concreta:

memory.update(
    memory_id="ID_DEL_RECUERDO",
    data="El usuario está desarrollando una aplicación en Python"
)

Para eliminarla:

memory.delete(
    memory_id="ID_DEL_RECUERDO"
)

Una aplicación destinada a usuarios finales debería proporcionar controles para ver, corregir y borrar los recuerdos almacenados. También conviene establecer una política de caducidad para información temporal.

Cómo mejorar la calidad de los recuerdos

La calidad depende del modelo, las instrucciones, la conversación y la cantidad de información enviada. Utilizar siempre un modelo más grande no garantiza mejores resultados, aunque los modelos muy pequeños pueden perder matices o devolver formatos incorrectos.

Estas prácticas ayudan a mejorar la memoria:

• Utiliza una temperatura baja para que la extracción sea más estable.
• Define con claridad qué categorías merece la pena recordar.
• Excluye saludos, repeticiones y conversación irrelevante.
• Guarda conjuntamente el mensaje del usuario y la respuesta del agente.
• Utiliza identificadores diferentes para usuarios, agentes y proyectos.
• Limita la cantidad de recuerdos recuperados para no saturar el contexto.
• Revisa periódicamente los recuerdos incorrectos, duplicados u obsoletos.
• Prueba las búsquedas con consultas reales antes de ponerlo en producción.

No introduzcas los recuerdos como órdenes de máxima prioridad. Trátalos como información contextual que puede estar incompleta o desactualizada. Esto reduce el riesgo de que un recuerdo manipulado modifique el comportamiento general del agente.

Optimización del rendimiento

Cada llamada a memory.add() puede ejecutar el modelo para extraer los hechos que deben almacenarse. Por tanto, guardar la memoria aumenta la latencia y el consumo de recursos.

En una aplicación pequeña puedes guardar la conversación después de generar la respuesta. En servicios con varias solicitudes simultáneas es preferible utilizar AsyncMemory, un trabajador en segundo plano o una cola de tareas.

Mem0 proporciona una interfaz asíncrona para evitar bloquear aplicaciones construidas con asyncio o FastAPI:

from mem0 import AsyncMemory

memory = AsyncMemory.from_config(config)

resultado = await memory.search(
    "proyecto actual",
    filters={"user_id": "usuario_001"},
    top_k=5
)

await memory.add(
    mensajes,
    user_id="usuario_001"
)

No envíes el trabajo a un hilo secundario sin gestionar sus excepciones. Si el programa se cierra antes de que termine el guardado, la conversación puede quedar sin registrar. Una cola persistente permite reintentar las operaciones fallidas.

También puedes utilizar modelos distintos para la conversación y la extracción. Un modelo generativo más potente puede encargarse de las respuestas, mientras que uno más pequeño procesa la memoria. Antes de hacerlo, comprueba que el segundo modelo respete correctamente las instrucciones y el formato solicitado.

Errores frecuentes al conectar Mem0 con Ollama

Mem0 solicita una clave de OpenAI

La configuración está incompleta y algún componente continúa utilizando su proveedor predeterminado. Comprueba que hayas configurado tanto llm como embedder con el proveedor ollama.

No se puede conectar con Ollama

Comprueba que la API responda:

curl http://localhost:11434/api/tags

Si Mem0 se ejecuta dentro de Docker, localhost hace referencia a ese contenedor, no al ordenador anfitrión. En Docker Desktop puede ser necesario utilizar:

http://host.docker.internal:11434

Qdrant rechaza los vectores

La colección y el modelo de embeddings utilizan dimensiones diferentes. Con nomic-embed-text, configura 768 dimensiones y crea una colección nueva si la existente se generó con otro tamaño.

Las búsquedas no devuelven recuerdos

Comprueba que utilizas el mismo user_id durante el guardado y la búsqueda. Revisa también el nombre del modelo de embeddings, los filtros y el contenido de resultado["results"].

Mem0 guarda información irrelevante

Añade custom_instructions, reduce la temperatura y define qué categorías debe incluir o excluir. Revisa también si el modelo elegido es capaz de seguir instrucciones estructuradas.

Los recuerdos contradicen información más reciente

Las versiones actuales pueden conservar hechos anteriores en lugar de sobrescribirlos automáticamente. Añade fechas o metadatos y utiliza update() o delete() cuando necesites corregir información.

La memoria desaparece al reemplazar Qdrant

Comprueba que el contenedor utilice un volumen montado en /qdrant/storage. Reiniciar un contenedor no equivale a eliminarlo, pero recrearlo sin almacenamiento persistente puede dejar los datos fuera del nuevo despliegue.

Privacidad y copias de seguridad

Una instalación local evita depender obligatoriamente de las APIs administradas de Mem0, OpenAI u otros proveedores. Aun así, debes proteger la infraestructura como cualquier aplicación que almacene información personal.

• No expongas Ollama ni Qdrant directamente a Internet.
• Cifra los discos y las copias de seguridad cuando contengan datos privados.
• Aplica autenticación y controles de acceso en la aplicación.
• Separa los recuerdos mediante identificadores de usuario fiables.
• Permite consultar y eliminar la información almacenada.
• No guardes contraseñas, claves API ni datos bancarios como recuerdos.
• Registra errores sin incluir conversaciones o recuerdos completos.
• Comprueba si el tratamiento de datos debe cumplir el RGPD.

Con Qdrant debes respaldar el volumen qdrant_storage y el archivo definido mediante history_db_path. Con Chroma debes copiar la carpeta configurada en path y la base de datos del historial.

Conectar Mem0 con Ollama permite crear un asistente que conserva información entre sesiones sin depender necesariamente de servicios externos. Ollama ejecuta los modelos, Mem0 extrae y recupera los recuerdos y Qdrant o Chroma proporciona el almacenamiento persistente.

La parte fundamental no es solamente guardar conversaciones. La aplicación debe recuperar los recuerdos adecuados, introducirlos como contexto, limitar su alcance mediante identificadores y ofrecer mecanismos para corregir o eliminar información. Con estas precauciones puedes construir una memoria local útil, persistente y controlable.