Alojar mem0 en un VPS: RAM, Compose y TLS
Aloja mem0 en tu VPS con Compose y localhost: conoce el mínimo real de RAM, configura TLS ante la API y usa Ollama de forma totalmente local.
Cuánta RAM consume realmente alojar mem0 en un VPS
Alojar mem0 por cuenta propia implica ejecutar tres contenedores: el servidor de memoria FastAPI, Postgres con la extensión pgvector y un dashboard de Next.js. mem0 es una capa de memoria para agentes. Se le envía una conversación, un modelo de lenguaje extrae los datos persistentes de esa conversación y esos datos se almacenan como vectores para que una consulta posterior pueda recuperar los relevantes.
Reserve aproximadamente 1 GB de memoria residente para los tres contenedores y entre 3 y 4 GB de disco una vez creadas las imágenes. Un VPS de 2 GB ejecuta esta configuración sin problemas cuando el modelo de lenguaje está en otro lugar. Cuando el modelo se ejecuta en el mismo equipo mediante Ollama, el modelo consume mucho más que el resto: un modelo 8B cuantizado a 4 bits necesita aproximadamente 6 GB por sí solo, por lo que una instalación completamente local requiere al menos 8 GB.
No tome esas cifras de una publicación de blog, incluida esta. Mida la pila que realmente ha creado.
docker compose ps
docker stats --no-stream
docker system df -vdocker stats muestra la memoria residente por contenedor. docker system df -v muestra el espacio de disco que ocupa cada imagen y cada volumen.
El estado estable no representa el pico de consumo. docker compose up -d --build compila el dashboard de Next.js y esa compilación de Node es el momento de mayor consumo de toda la instalación. En un VPS de 1 GB, el asesino de falta de memoria del kernel detiene el proceso y la compilación termina con exit code 137. Confirme la causa antes de buscar un error de Docker:
dmesg -T | grep -i "killed process"Si un servidor le parece una infraestructura excesiva para sus necesidades, existen opciones más pequeñas. un almacén local de memoria para agentes sin ningún servidor y la memoria integrada en Claude Code evitan la base de datos. Vuelva aquí cuando varios agentes o varios equipos necesiten leer las mismas memorias.
¿Necesito Neo4j para la memoria de grafos de mem0?
No. Si una guía le indica que añada un contenedor de Neo4j, esa guía es anterior al código actual.
La memoria de grafos de mem0 antes significaba una base de datos de grafos externa, configurada mediante una clave graph_store con enable_graph establecido en true. El nuevo algoritmo de memoria, publicado en abril de 2026, eliminó ambas claves del SDK de código abierto. La extracción de entidades ahora se ejecuta dentro de la ruta normal de adición, y las entidades se escriben en una segunda colección de pgvector cuyo nombre se basa en el de la colección principal y al que se añade _entities. No hay ningún paso de configuración: esa colección se crea la primera vez que se utiliza, por lo que el enlace de entidades integrado empieza a funcionar en la siguiente llamada de adición.
Eliminar el almacén de grafos evita un contenedor JVM, su heap y varios cientos de megabytes de imagen. En un VPS de 2 GB, esa diferencia puede determinar si el sistema funciona o empieza a usar swap.
Esto es lo que se pierde. Antes, los resultados de búsqueda incluían un campo relations con la lista de relaciones entre entidades. Ese campo ya no existe. Las coincidencias de entidades ahora aumentan la posición de una memoria en la puntuación combinada, y no hay ninguna estructura que se pueda recorrer. Si su aplicación recorría esas relaciones, mem0 ya no las conserva. Deberá mantener una base de datos de grafos propia fuera de mem0 y alimentarla con su propio código.
El archivo compose del repositorio es una configuración de desarrollo
server/docker-compose.yaml declara name: mem0-dev, y eso es exactamente lo que hace. Léalo antes de ejecutarlo, porque contiene cinco aspectos incorrectos para un servidor.
- Compila desde
server/dev.Dockerfiley monta su copia de trabajo sobre la imagen mediante.:/app, por lo que el contenedor ejecuta lo que haya en ese directorio en lugar de lo que compiló. - Su comando es
rm -rf /app/packages && pip install -q --force-reinstall --no-deps mem0ai && alembic upgrade head && uvicorn main:app --host 0.0.0.0 --port 8000 --reload. Esto reinstalamem0aidesde PyPI en cada inicio, por lo que la versión que ejecuta el servidor puede cambiar durante un reinicio que no consideraba una actualización. - El mismo paso de pip implica que un reinicio sin red saliente falle antes de que se ejecute uvicorn. En ese caso, el servidor de memoria queda detenido porque no se puede acceder a PyPI.
--reloadinicia el observador de archivos de uvicorn. Su función es reiniciar el proceso cuando edita el código. En producción, sólo consume memoria y añade un segundo proceso sin utilidad. ElDockerfilede producción también incluye--reloaden suCMD, por lo que debe reemplazar el comando en cualquier caso.- Los puertos publicados son
"8888:8000","8432:5432"y"3000:3000". Un puerto publicado sin una dirección delante se enlaza a0.0.0.0, por lo que Postgres queda accesible desde Internet en el puerto 8432 en cuanto se inicia la pila.
Este último punto requiere su propia advertencia. Docker publica un puerto escribiendo sus propias reglas delante de la cadena que administra ufw, por lo que ufw deny 8432 no cierra un puerto publicado del contenedor. Publicación de puertos de Docker que omite ufw explica las reglas implicadas.
Un archivo de Compose para un servidor real
Trabaje dentro de server/, mantenga init-db.sh en su lugar y sustituya docker-compose.yaml por esto.
name: mem0
services:
mem0:
build:
context: .
dockerfile: Dockerfile
restart: unless-stopped
env_file: .env
ports:
- "127.0.0.1:8888:8000"
networks: [mem0_network]
volumes:
- mem0_history:/app/history
depends_on:
postgres:
condition: service_healthy
command: >
sh -c "alembic upgrade head &&
uvicorn main:app --host 0.0.0.0 --port 8000"
environment:
- PYTHONUNBUFFERED=1
- DASHBOARD_URL=https://mem0.example.com
- APP_DB_NAME=mem0_app
- AUTH_DISABLED=false
- MEM0_TELEMETRY=false
postgres:
image: pgvector/pgvector:pg17
restart: unless-stopped
shm_size: "128mb"
networks: [mem0_network]
environment:
- POSTGRES_USER=${POSTGRES_USER:-postgres}
- POSTGRES_PASSWORD=${POSTGRES_PASSWORD:?set POSTGRES_PASSWORD in .env}
healthcheck:
test: ["CMD-SHELL", "pg_isready -q -U ${POSTGRES_USER:-postgres}"]
interval: 5s
timeout: 5s
retries: 5
volumes:
- postgres_db:/var/lib/postgresql/data
- ./init-db.sh:/docker-entrypoint-initdb.d/init-db.sh
mem0-dashboard:
build: ./dashboard
restart: unless-stopped
ports:
- "127.0.0.1:3000:3000"
networks: [mem0_network]
environment:
- NEXT_PUBLIC_API_URL=https://mem0.example.com
- API_INTERNAL_URL=http://mem0:8000
depends_on:
mem0:
condition: service_started
volumes:
postgres_db:
mem0_history:
networks:
mem0_network:
driver: bridgeAquí importan cinco cambios y cada uno tiene un motivo.
Cada entrada de ports comienza con 127.0.0.1, por lo que el kernel acepta esas conexiones sólo desde el propio servidor. Todo lo externo llega a través del reverse proxy, que es el único componente que contiene un certificado.
Postgres no tiene ningún bloque ports. El contenedor mem0 accede a él mediante mem0_network usando el nombre del servicio, por lo que publicar 8432 no aporta nada y deja un puerto abierto. Use docker compose exec postgres psql -U postgres cuando necesite un shell.
El historial cambia del montaje bind de ./history a un volumen con nombre. Un montaje bind vincula los datos a una ruta y un uid concretos de este host, mientras que un volumen con nombre es un objeto que Docker puede capturar y mover. Volúmenes con nombre frente a montajes bind explica cuándo conviene usar cada uno.
El comando elimina --reload y conserva alembic upgrade head. Mantenga ese paso de migración. Sin él, la aplicación arranca contra una base de datos sin tablas y todas las peticiones fallan en la primera consulta.
NEXT_PUBLIC_API_URL es la URL que utiliza el navegador, por lo que debe ser la dirección HTTPS pública y no http://mem0:8000. Next.js inserta los valores de NEXT_PUBLIC_ durante la compilación, pero la imagen de este dashboard incluye en su lugar un marcador de posición y su entrypoint lo sustituye por el valor real del contenedor cuando este se inicia. Por tanto, cambiarlo requiere docker compose up -d mem0-dashboard, que recrea el contenedor, pero no una compilación nueva. docker compose restart mem0-dashboard reutiliza el contenedor antiguo, cuyos archivos ya contienen el valor anterior, y el dashboard sigue usando el host incorrecto.
Los secretos están en .env, y .env no se expone a Internet
cd server
cp .env.example .env
openssl rand -hex 32 # paste into JWT_SECRET
openssl rand -hex 32 # paste into ADMIN_API_KEY
chmod 600 .envConfigure POSTGRES_PASSWORD, JWT_SECRET y ADMIN_API_KEY. Deje AUTH_DISABLED=false. El nombre describe con precisión lo que hace ese indicador: cuando está activado, el servidor entrega toda la memoria que contiene a cualquiera que pueda acceder al puerto. Configure MEM0_TELEMETRY=false si no quiere que el evento de incorporación se envíe al servicio ascendente.
ADMIN_API_KEY se compara con la cabecera X-API-Key mediante secrets.compare_digest, y una coincidencia omite por completo la búsqueda de la clave por usuario en la base de datos: la petición se ejecuta entonces como el primer usuario creado en el servidor. Es una credencial root para toda la API. Trátela como tal: no la guarde en el historial del shell, no la incluya en git y no la pegue en un indicador. Archivos de entorno de Compose y dónde se filtran los secretos y cómo mantener las claves de API fuera del contexto de un agente se aplican directamente, porque los clientes de este servidor son agentes.
Los valores cargados desde env_file se encuentran en el entorno del contenedor, y docker inspect los muestra completos. Cualquiera que pertenezca al grupo docker puede leerlos, y cualquiera que pertenezca al grupo docker tiene, en la práctica, privilegios root en el host.
Coloque TLS delante de la API en lugar de abrir 8888
La API responde en 127.0.0.1:8888 y el dashboard en 127.0.0.1:3000. nginx termina TLS (seguridad de la capa de transporte) en 443 y reenvía las peticiones a ambos servicios.
server {
listen 443 ssl;
server_name mem0.example.com;
ssl_certificate /etc/letsencrypt/live/mem0.example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/mem0.example.com/privkey.pem;
location ~ ^/(memories|search|configure|reset|generate-instructions|auth|api-keys|entities|requests|docs|openapi.json) {
proxy_pass http://127.0.0.1:8888;
proxy_set_header Host $host;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_read_timeout 180s;
}
location / {
proxy_pass http://127.0.0.1:3000;
proxy_set_header Host $host;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
}
}El código del navegador del dashboard llama a todas las rutas de la API con ese patrón en NEXT_PUBLIC_API_URL, incluidas /entities y /requests. Si omite una, nginx entrega esa llamada a Next.js. Por tanto, la página del dashboard que la necesita recibe un 404 en lugar de los datos.
proxy_read_timeout es más importante de lo que parece. Una llamada de adición se bloquea mientras el modelo de lenguaje lee la conversación y extrae los hechos. Un modelo local de 8B ejecutándose en la CPU tarda habitualmente más que el valor predeterminado de 60 segundos de nginx. Entonces el cliente recibe 504 Gateway Time-out mientras el modelo sigue trabajando y la memoria se sigue escribiendo. El resultado es una memoria que el sistema indicó que había fallado.
Cierre el resto con una política ufw de denegación predeterminada, dejando abiertos 22, 80 y 443. Emita el certificado con certbot en Ubuntu 24.04 detrás de nginx. El puerto 80 debe seguir siendo accesible porque ese flujo de trabajo usa el desafío HTTP-01, que Let's Encrypt ejecuta únicamente en el puerto 80, tanto al emitir el certificado como en cada renovación. Mantener cerrado el puerto 80 implica cambiar al desafío DNS-01. Si el servidor ya expone otras aplicaciones mediante Traefik para enrutar varias aplicaciones de Compose, añada mem0 a ese router en lugar de instalar un segundo proxy.
Prueba básica: añadir una memoria y leerla de nuevo
export MEM0_KEY='<the ADMIN_API_KEY from .env>'
curl -sS -X POST http://127.0.0.1:8888/memories \
-H "Content-Type: application/json" \
-H "X-API-Key: $MEM0_KEY" \
-d '{"messages":[{"role":"user","content":"I deploy with Docker Compose and I run Postgres 17."}],"user_id":"smoke"}'Una respuesta correcta es un objeto JSON con una lista results. Cada entrada contiene un id, el texto memory extraído y "event": "ADD". El algoritmo actual sólo devuelve eventos ADD. Los eventos UPDATE y DELETE se eliminaron, por lo que su ausencia no indica un error.
curl -sS -X POST http://127.0.0.1:8888/search \
-H "Content-Type: application/json" \
-H "X-API-Key: $MEM0_KEY" \
-d '{"query":"which database do I run?","filters":{"user_id":"smoke"},"top_k":5}'El dato sobre Postgres 17 debe devolverse con una puntuación. Pase el identificador dentro de filters, como se muestra. Un user_id de nivel superior sigue funcionando, y el servidor registra Top-level user_id in /search is deprecated. Use filters={...} instead. cada vez que lo utiliza.
Limpie los datos de prueba para que no contaminen las búsquedas reales:
curl -sS -X DELETE "http://127.0.0.1:8888/memories?user_id=smoke" \
-H "X-API-Key: $MEM0_KEY"Si la búsqueda devuelve menos filas de las esperadas, compruebe los valores predeterminados antes de atribuirlo al sistema de recuperación. En la versión actual, top_k tiene un valor predeterminado de 20, frente a 100, y threshold tiene un valor predeterminado de 0.1 en lugar de ninguno, por lo que los resultados débiles se filtran automáticamente. Cuando esto funcione mediante curl, esos mismos endpoints son los que debe conectar a un agente, ya sea directamente o mediante un servidor MCP que se ejecute en el mismo VPS.
Ejecutar mem0 sin ninguna clave de OpenAI
Empiece por el bloqueo, porque aparecerá durante los primeros cinco minutos. La imagen del servidor incluye un conjunto fijo de bibliotecas de proveedores, y /configure rechaza cualquier elemento que no pertenezca a ese conjunto:
LLM provider 'ollama' is not bundled in this image. Bundled providers: openai, anthropic, gemini. To use another provider, install its Python package, rebuild the container, and extend BUNDLED_LLM_PROVIDERS in server/main.py.No tiene que recompilar nada. Ollama expone una API compatible con OpenAI en /v1, con soporte para /v1/chat/completions y /v1/embeddings, y el proveedor openai de mem0 acepta un openai_base_url. Apunte esa clave a Ollama y la comprobación incluida se completará, porque el proveedor es realmente openai. Sólo cambia la dirección.
Añada Ollama al mismo proyecto de Compose:
ollama:
image: ollama/ollama
restart: unless-stopped
networks: [mem0_network]
ports:
- "127.0.0.1:11434:11434"
volumes:
- ollama_models:/root/.ollamaAñada ollama_models: bajo la clave volumes: de nivel superior y, después, descargue un modelo de chat y un modelo de embeddings:
docker compose up -d ollama
docker compose exec ollama ollama pull llama3.1:8b
docker compose exec ollama ollama pull nomic-embed-textSi Ollama ya se ejecuta en el host como una unidad de systemd, como se indica en ejecutar Ollama directamente en un VPS, no apunte el contenedor a 127.0.0.1:11434. Dentro del contenedor de mem0, 127.0.0.1 es el contenedor de mem0. Asigne al servicio de mem0 extra_hosts: ["host.docker.internal:host-gateway"], establezca Environment="OLLAMA_HOST=0.0.0.0:11434" en un drop-in de systemd para que Ollama escuche en una dirección accesible desde el bridge y mantenga cerrado el puerto 11434 en el firewall.
Pregunte al modelo por la dimensión de sus embeddings antes de configurar nada
Este paso determina si la recuperación funcionará.
El almacén pgvector de mem0 crea su tabla con un ancho de vector fijo, vector vector(1536), porque embedding_model_dims tiene 1536 como valor predeterminado, que es el ancho de text-embedding-3-small de OpenAI. nomic-embed-text devuelve 768 valores. Nada dentro de mem0 compara esos dos números, por lo que la discrepancia aparece en Postgres durante la primera inserción:
expected 1536 dimensions, not 768Tampoco confíe en el número de este párrafo. Pregunte al modelo:
curl -sS http://127.0.0.1:11434/v1/embeddings \
-H "Content-Type: application/json" \
-d '{"model":"nomic-embed-text","input":"dimension check"}' \
| python3 -c "import json,sys; print(len(json.load(sys.stdin)['data'][0]['embedding']))"Ese comando muestra el ancho que debe usar la colección. Escriba la configuración en un archivo, porque pegar una contraseña de Postgres mediante el escape de comillas del shell es una forma de introducir errores tipográficos en producción.
{
"vector_store": {
"provider": "pgvector",
"config": {
"host": "postgres",
"port": 5432,
"dbname": "postgres",
"user": "postgres",
"password": "<POSTGRES_PASSWORD from .env>",
"collection_name": "memories_local_768",
"embedding_model_dims": 768
}
},
"llm": {
"provider": "openai",
"config": {
"model": "llama3.1:8b",
"api_key": "ollama",
"openai_base_url": "http://ollama:11434/v1",
"temperature": 0.2
}
},
"embedder": {
"provider": "openai",
"config": {
"model": "nomic-embed-text",
"api_key": "ollama",
"openai_base_url": "http://ollama:11434/v1"
}
}
}curl -sS -X POST http://127.0.0.1:8888/configure \
-H "Content-Type: application/json" \
-H "X-API-Key: $MEM0_KEY" \
-d @config.json
curl -sS http://127.0.0.1:8888/configure -H "X-API-Key: $MEM0_KEY"La segunda llamada vuelve a leer la configuración. Esa es la comprobación de que la escritura se realizó correctamente. Después, repita la prueba de humo anterior.
Hay cuatro detalles en ese JSON que no son evidentes. Cada uno provoca un fallo si se configura incorrectamente.
api_key es la cadena ollama, y Ollama ignora su valor. No puede estar vacía, porque la biblioteca cliente de OpenAI genera un error antes de que ninguna petición salga del proceso si no se establece una clave. Cualquier cadena no vacía funciona.
embedding_model_dims se configura en el almacén de vectores, y deliberadamente no hay ningún embedding_dims en el embedder. mem0 sólo envía el parámetro dimensions de OpenAI cuando se establece embedding_dims, y los backends que no implementan el truncamiento de Matryoshka rechazan ese parámetro directamente. Establezca el ancho cuando se cree la tabla y deje el embedder sin cambios.
collection_name es nuevo. mem0 crea su tabla con CREATE TABLE IF NOT EXISTS, por lo que apuntar un ancho distinto a una colección existente no hace nada: la columna vector(1536) anterior permanece y todas las inserciones fallan. Un cambio de ancho requiere un nombre de colección nuevo o eliminar manualmente la tabla anterior.
El host de openai_base_url es el nombre de servicio de Compose ollama, no localhost. Los contenedores se resuelven entre sí mediante el nombre de servicio en su red compartida.
Coste de una ejecución completamente local
Sea realista sobre la calidad. Las puntuaciones principales de los benchmarks de mem0 proceden de su plataforma gestionada. Según el README, incluye optimizaciones propietarias que no están disponibles en el SDK de código abierto y se ejecuta sobre una pila de modelos cuyo nombre no especifica. El artículo de investigación en el que se basan los resultados originales de LOCOMO ejecutó todas las llamadas al modelo en GPT-4o-mini, un modelo alojado. En cualquier caso, considere esas puntuaciones un límite superior, no una previsión para un modelo 8B en su VPS. Un modelo pequeño escribe hechos más imprecisos y a veces devuelve prosa cuando se solicitó JSON. Esto aparece como una llamada add que devuelve una lista results vacía sin ningún error.
La velocidad es el otro coste. La extracción usando sólo CPU tarda varios segundos por llamada add, y cada mensaje almacenado debe pasar por ella. Un modelo que continúa generando texto después del JSON solicitado empeora el problema, por lo que limitar la respuesta con num_predict establece un límite para la duración de cada llamada add. Si esa latencia es importante, un VPS con una GPU conectada es la solución adecuada. Añadir más núcleos de CPU a un modelo 8B ayuda mucho menos de lo que se suele esperar. Cambiar el modelo es una medida más económica que cambiar la máquina, y Nemotron 3.5 Lightning en un VPS indica la etiqueta que debe descargar, la RAM que necesita y si la ejecución usando sólo CPU es suficientemente rápida para resultar viable.
Se aplica una regla independientemente de lo que elija: nunca mezcle modelos de embeddings dentro de una misma colección. Dos modelos distintos que casualmente compartan el mismo ancho producen vectores que no son comparables. La inserción se completa, la búsqueda devuelve filas y las filas son incorrectas, sin que ningún componente informe de un error.
Backups: hay dos bases de datos, no una
El error más común al hacer una copia de seguridad de mem0 es volcar una sola base de datos. init-db.sh crea mem0_app junto a la base de datos predeterminada postgres, y cada una contiene datos diferentes. La base de datos postgres contiene las colecciones de pgvector, que son las memorias. mem0_app contiene usuarios, sesiones, claves de API y registros de solicitudes. Cada aplicación autohospedada divide su estado de una forma distinta. Por eso, dos servidores de fotos que hacen lo mismo siguen necesitando comandos de copia de seguridad diferentes. Consulte qué datos almacena su aplicación antes de confiar en un volcado. En el otro extremo está algo como una biblioteca de Jellyfin reconstruida como un videoclub de los años 90, que obtiene todo su catálogo de otro servicio y, por tanto, sólo necesita copiar su propia configuración. mem0, en cambio, necesita ambas bases de datos; de lo contrario, la restauración no sirve.
Si restaura sólo postgres, las memorias volverán, pero se perderán todas las cuentas y claves de API. Nada podrá autenticarse para leerlas. Vuelque ambas bases de datos y los roles con un solo comando:
docker compose exec -T postgres pg_dumpall -U postgres --clean \
| gzip > "mem0-$(date +%F).sql.gz"El volumen del historial es independiente de Postgres y necesita su propia copia:
docker run --rm -v mem0_mem0_history:/data -v "$PWD:/backup" \
alpine tar czf /backup/mem0-history.tgz -C /data .Docker antepone el nombre del proyecto a los nombres de los volúmenes. Confirme el suyo con docker volume ls antes de dar por hecho que es mem0_mem0_history.
Restaure la copia en un contenedor temporal y compruebe el número de filas antes de considerarla válida:
gunzip -c mem0-2026-08-03.sql.gz \
| docker compose exec -T postgres psql -U postgres -d postgresUna copia de seguridad que nunca se ha restaurado es sólo una suposición. Cuando los volcados sean correctos, envíelos fuera del servidor con instantáneas de restic en almacenamiento externo, porque una copia de seguridad que permanece en el servidor que protege no protege nada.
Modos de fallo y las cadenas exactas que verá
{"detail":"Authentication required. Provide a Bearer token or X-API-Key header."} indica que falta la cabecera o que está mal escrita. El nombre es X-API-Key y curl envía los nombres de las cabeceras literalmente.
{"detail":"At least one identifier (user_id, agent_id, run_id) is required."} al añadir indica que la solicitud no incluía ninguno de esos campos. Una memoria debe estar asociada a algo, porque la búsqueda filtra exactamente por esos campos.
LLM provider 'ollama' is not bundled in this image con HTTP 400 indica que envió "provider": "ollama". Use "provider": "openai" con openai_base_url apuntando a Ollama.
expected 1536 dimensions, not 768 de Postgres indica que la colección se creó con una dimensión y que el embedder devuelve otra. Configure embedding_model_dims en el almacén vectorial y use un collection_name nuevo.
La búsqueda devuelve filas que no tienen sentido después de cambiar de modelo, sin mostrar ningún error. La dimensión sigue coincidiendo, por lo que la base de datos funciona correctamente, pero dos modelos sitúan la misma frase en posiciones distintas. Cree una colección nueva y vuelva a añadir los datos.
Connection refused en los registros de mem0 al conectarse a Ollama suele indicar 127.0.0.1 en openai_base_url. Dentro del contenedor, esa dirección corresponde al propio contenedor. Use el nombre del servicio o la puerta de enlace del host cuando Ollama se ejecute en el host.
504 Gateway Time-out de nginx al añadir datos indica que el modelo tardó más de proxy_read_timeout. Aumente ese valor y compruebe si la memoria se escribió de todos modos antes de volver a enviar la solicitud.
exit code 137 durante docker compose up --build indica que un proceso terminó con SIGKILL, porque una señal fatal N se informa como 128 + N y SIGKILL es la señal 9. Mientras el dashboard se compila en un VPS pequeño, lo más probable es que la señal la haya enviado el OOM killer. Ejecute la comprobación dmesg de la primera sección antes de actuar. Si muestra que se terminó un proceso, añada swap o compile la imagen en una máquina más grande y súbala a un registro.
error: port 3000 is already in use procede del destino make up del repositorio, que no se inicia cuando los puertos 3000 u 8888 están ocupados. Busque el proceso propietario con lsof -iTCP:3000 -sTCP:LISTEN.
FAQ
¿Sigo necesitando Neo4j para ejecutar mem0 con memoria de grafos?
No. El nuevo algoritmo de memoria, publicado en abril de 2026, eliminó las claves de configuración graph_store y enable_graph del SDK de código abierto. La extracción de entidades se ejecuta durante una operación normal de adición y escribe en una segunda colección de pgvector llamada <collection_name>_entities, por lo que no se necesita una base de datos de grafos externa, ningún contenedor adicional ni un paso de configuración. La contrapartida es que el campo relations ya no existe en los resultados de búsqueda. Ahora las entidades aumentan la clasificación de una memoria en lugar de proporcionar aristas que se puedan recorrer. Por tanto, una aplicación que recorría esas relaciones necesita su propio almacén de grafos fuera de mem0.
¿Cuál es el VPS más pequeño que puede ejecutar un servidor de mem0 autoalojado?
Si el modelo de lenguaje está alojado en otro lugar, 2 GB de RAM y unos 4 GB de espacio libre en disco son suficientes para el contenedor de la API, Postgres y el dashboard. El momento de mayor consumo se produce durante la primera compilación, porque compilar el dashboard de Next.js usa más memoria que ejecutarlo, y un equipo con 1 GB termina la compilación con exit code 137. Si Ollama se ejecuta en el mismo servidor, dimensione el sistema según el modelo: un modelo 8B con cuantización de 4 bits necesita aproximadamente 6 GB por sí solo, por lo que debe planificar 8 GB.
¿Puedo ejecutar mem0 sin una clave de API de OpenAI?
Sí, mediante el endpoint compatible con OpenAI de Ollama. Configurar "provider": "ollama" falla porque la imagen del servidor sólo incluye las bibliotecas openai, anthropic y gemini, y devuelve HTTP 400. En su lugar, conserve "provider": "openai" y configure "openai_base_url": "http://ollama:11434/v1" con cualquier api_key que no esté vacío, tanto para el llm como para el embedder. Ollama ignora la clave y la comprobación del proveedor incluida funciona porque el proveedor realmente es openai.
¿Por qué mem0 no devuelve resultados después de cambiar a un modelo de embeddings local?
Porque la tabla de pgvector se creó con una dimensión fija. embedding_model_dims tiene 1536 de forma predeterminada, nomic-embed-text devuelve 768 y Postgres rechaza la inserción con expected 1536 dimensions, not 768. mem0 crea la tabla con CREATE TABLE IF NOT EXISTS, por lo que cambiar sólo el número no modifica una colección existente. Configure embedding_model_dims con la dimensión real de su modelo, confirme esa dimensión llamando a /v1/embeddings y contando los valores que devuelve, y asigne al almacén vectorial un collection_name nuevo al mismo tiempo.