SSD Nodes Learn Hosting plans →
Guias Matt ConnorPor Matt Connor · Atualizado 2026-11-20

Como hospedar o mem0 em um VPS com Ollama local

Veja o limite real de RAM do mem0, um Compose preso ao localhost, TLS na API e o caminho local com Ollama: 2 GB sem modelo e 8 GB com um modelo 8B.

Quanto realmente custa em RAM alojar o mem0 num VPS

Alojamento próprio do mem0 significa executar três contentores: o servidor FastAPI de memória, o Postgres com a extensão pgvector e um dashboard Next.js. O mem0 é uma camada de memória para agentes. Envia-lhe uma conversa, um modelo de linguagem extrai os factos persistentes dessa conversa e esses factos são armazenados como vetores, para que uma consulta posterior possa recuperar os factos relevantes.

A estimativa de dimensionamento deste artigo, em 2026-10-25, era de aproximadamente 1 GB de memória para os três contentores e de 3 a 4 GB de disco depois de criar as imagens. A recomendação era usar um VPS com 2 GB quando o modelo de linguagem estivesse alojado noutro local. Para um modelo 8B quantizado para 4 bits e executado no mesmo servidor através do Ollama, a estimativa era de cerca de 6 GB apenas para o modelo e 8 GB para uma instalação totalmente local.

Não aceite estes valores com base num artigo de blog, incluindo este. Meça a pilha que realmente instalou.

docker compose ps
docker stats --no-stream
docker system df -v

docker stats mostra a utilização de memória por contentor, subtraindo a cache no Linux. docker system df -v mostra o espaço em disco ocupado por cada imagem e cada volume.

A utilização em estado estável não corresponde ao pico. docker compose up -d --build compila o dashboard Next.js, e essa compilação do Node é o momento que mais memória consome em toda a instalação. Se a compilação terminar com exit code 137, verifique se ocorreu uma terminação por falta de memória. Confirme a causa antes de procurar um erro no Docker:

dmesg -T | grep -i "killed process"

Se um servidor parecer uma solução demasiado complexa para o que precisa, existem opções mais pequenas. um armazenamento local de memória para agentes, sem servidor e memória que reside no próprio Claude Code dispensam ambos a base de dados. Volte aqui quando vários agentes ou vários computadores precisarem de ler as mesmas memórias.

Preciso do Neo4j para a memória de grafos do mem0?

Não. Se um guia lhe disser para adicionar um contentor Neo4j, esse guia é anterior ao código atual.

A memória de grafos no mem0 significava anteriormente uma base de dados de grafos externa, configurada numa chave graph_store com enable_graph definido como true. O novo algoritmo de memória, lançado em abril de 2026, removeu ambas as chaves do SDK de código aberto. A extração de entidades é agora executada no fluxo normal de adição, e as entidades são gravadas numa segunda coleção pgvector com o nome da coleção principal seguido de _entities. Não existe uma etapa de configuração: essa coleção é criada na primeira utilização, pelo que a associação de entidades integrada começa a funcionar na chamada de adição seguinte.

A remoção do armazenamento de grafos elimina um contentor JVM, a respetiva heap e várias centenas de megabytes da imagem. Num VPS com 2 GB, isso pode determinar se o sistema funciona ou começa a usar swap.

Isto é o que deixa de estar disponível. Os resultados da pesquisa incluíam anteriormente um campo relations com as arestas entre entidades. Esse campo deixou de existir. As correspondências de entidades aumentam agora a posição de uma memória na pontuação combinada, mas não existe uma estrutura que possa percorrer. Se a sua aplicação percorria essas relações, o mem0 já não as mantém. Nesse caso, terá de manter uma base de dados de grafos própria fora do mem0 e alimentá-la com o seu próprio código.

O ficheiro compose no repositório é um compose de desenvolvimento

server/docker-compose.yaml declara name: mem0-dev, e é exatamente isso que faz. Leia-o antes de o executar, porque há cinco problemas que o tornam inadequado para um servidor.

  • Compila a partir de server/dev.Dockerfile e monta o seu checkout sobre a imagem com .:/app. Assim, o contentor executa o que estiver nesse diretório, e não o que foi compilado.
  • O comando é 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. Esse comando reinstala mem0ai a partir do PyPI em cada arranque. Assim, a versão executada pelo servidor pode mudar durante um reinício que não pretendia tratar como uma atualização.
  • O mesmo passo do pip faz com que um reinício sem acesso à rede externa falhe antes de o uvicorn arrancar. Nesse caso, o servidor de memória fica indisponível porque o PyPI não estava acessível.
  • --reload inicia o observador de ficheiros do uvicorn. A sua finalidade é reiniciar o processo quando edita código. Em produção, consome memória e mantém um segundo processo sem utilidade. O Dockerfile de produção também inclui --reload no respetivo CMD, por isso substitui o comando de qualquer forma.
  • As portas publicadas são "8888:8000", "8432:5432" e "3000:3000". Uma porta publicada sem um endereço à frente é associada a 0.0.0.0. Por isso, o Postgres fica acessível pela Internet pública na porta 8432 assim que a stack arranca.

Este último ponto merece um aviso próprio. O Docker publica uma porta adicionando as suas próprias regras antes da cadeia gerida pelo ufw. Por isso, ufw deny 8432 não fecha uma porta publicada pelo contentor. A publicação de portas do Docker passa diretamente pelo ufw explica as regras envolvidas.

Um ficheiro Compose para um servidor real

Trabalhe dentro de server/, mantenha init-db.sh no mesmo local e substitua docker-compose.yaml por isto.

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: bridge

Aqui há cinco alterações importantes, e cada uma tem uma razão.

Cada entrada ports começa com 127.0.0.1, para que o kernel aceite essas ligações apenas a partir do próprio servidor. Tudo o que vem do exterior passa pelo reverse proxy, que é o único componente que mantém um certificado.

O Postgres não tem qualquer bloco ports. O contentor mem0 acede-lhe através de mem0_network pelo nome do serviço, por isso publicar 8432 não traz qualquer benefício e deixa uma porta aberta. Use docker compose exec postgres psql -U postgres quando precisar de uma shell.

O histórico passa do bind mount ./history para um volume com nome. Um bind mount associa os dados a um caminho e a um uid neste host, enquanto um volume com nome é um objeto que o Docker pode guardar num snapshot e mover. Volumes com nome versus bind mounts explica quando usar cada opção.

O comando remove --reload e mantém alembic upgrade head. Mantenha este passo de migração. Sem ele, a aplicação arranca com uma base de dados sem tabelas e todos os pedidos falham na primeira consulta.

NEXT_PUBLIC_API_URL é o URL que o browser utiliza, por isso tem de ser o endereço HTTPS público, e não http://mem0:8000. O Next.js inclui os valores NEXT_PUBLIC_ no build, mas a imagem deste dashboard inclui um placeholder e o entrypoint substitui-o pelo valor real do contentor quando este arranca. Por isso, alterá-lo requer docker compose up -d mem0-dashboard, que recria o contentor, e não um novo build. docker compose restart mem0-dashboard reutiliza o contentor antigo, cujos ficheiros já contêm o valor anterior, e o dashboard continua a chamar o host errado.

Os segredos ficam em .env, e .env não fica exposto à 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 .env

Defina POSTGRES_PASSWORD, JWT_SECRET e ADMIN_API_KEY. Deixe AUTH_DISABLED=false. O nome descreve exatamente o que essa flag faz: quando está ativa, o servidor entrega toda a memória que mantém a qualquer pessoa que consiga alcançar a porta. Defina MEM0_TELEMETRY=false se não quiser que o evento de integração inicial seja enviado para montante.

ADMIN_API_KEY é comparado com o cabeçalho X-API-Key usando secrets.compare_digest, e uma correspondência ignora completamente a consulta por chave na base de dados. Os endpoints de memória aceitam essa credencial sem resolver um utilizador; os endpoints que exigem um utilizador recorrem à primeira conta. Os endpoints exclusivos para administradores também a aceitam antes de existir a primeira conta. Trata-se de uma credencial root para toda a API. Trate-a como tal: não a deixe no histórico da shell, não a coloque no git e não a cole num prompt. Ficheiros de ambiente do Compose e onde os segredos escapam deles e manter as chaves da API fora do contexto de um agente aplicam-se diretamente, porque os clientes deste servidor são agentes.

Os valores carregados de env_file ficam no ambiente do contentor, e docker inspect apresenta-os na íntegra. Qualquer pessoa no grupo docker pode lê-los, e qualquer pessoa no grupo docker tem efetivamente privilégios root no host.

Coloque o TLS à frente da API em vez de abrir a porta 8888

A API responde em 127.0.0.1:8888 e o dashboard em 127.0.0.1:3000. O nginx termina o TLS (transport layer security) na porta 443 e encaminha os pedidos para ambos.

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;
    }
}

O código do navegador do dashboard chama todos os caminhos da API nesse padrão em NEXT_PUBLIC_API_URL, incluindo /entities e /requests. Se deixar um de fora, o nginx encaminha essa chamada para o Next.js. Assim, a página do dashboard que precisa dela recebe um 404 em vez dos dados.

proxy_read_timeout é mais importante do que parece. Uma chamada de adição fica bloqueada enquanto o modelo de linguagem lê a conversa e extrai factos. Um modelo local 8B em CPU demora regularmente mais do que o valor predefinido de 60 segundos do nginx. Nesse caso, o cliente recebe 504 Gateway Time-out enquanto o modelo ainda está a trabalhar e a memória continua a ser gravada. O resultado é uma memória que foi indicada como falhada, embora tenha sido gravada.

Feche o restante com uma política ufw de negação por predefinição, deixando abertas as portas 22, 80 e 443. Emita o certificado com certbot no Ubuntu 24.04 atrás do nginx. A porta 80 tem de continuar acessível porque esse fluxo de trabalho usa o desafio HTTP-01, que o Let's Encrypt executa apenas na porta 80, durante a emissão e novamente em cada renovação. Manter a porta 80 fechada exige mudar para DNS-01 ou usar TLS-ALPN-01 na porta 443 com um cliente ACME compatível. Se o servidor já encaminhar outras aplicações com Traefik a encaminhar várias aplicações Compose, adicione o mem0 a esse router em vez de instalar um segundo proxy.

Teste de funcionamento: adicione uma memória e leia-a novamente

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"}'

Uma resposta válida é um objeto JSON com uma lista results, em que cada entrada contém um id, o texto memory extraído e "event": "ADD". O algoritmo atual retorna apenas eventos ADD. Os eventos UPDATE e DELETE foram removidos, portanto a ausência deles não é um erro.

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}'

O facto sobre o Postgres 17 deve ser retornado com uma pontuação. Passe o identificador dentro de filters, conforme mostrado. Um user_id no nível superior continua a funcionar, e o servidor regista Top-level user_id in /search is deprecated. Use filters={"user_id": "..."} instead. sempre que o utiliza.

Limpe os dados criados para que o teste não polua as pesquisas reais:

curl -sS -X DELETE "http://127.0.0.1:8888/memories?user_id=smoke" \
  -H "X-API-Key: $MEM0_KEY"

Se a pesquisa retornar menos linhas do que esperava, verifique os valores predefinidos antes de culpar a recuperação. Na versão atual, top_k tem o valor predefinido 20, abaixo de 100, e threshold tem o valor predefinido 0.1 em vez de none, pelo que as correspondências fracas são filtradas automaticamente. Depois de isto funcionar com curl, são estes mesmos endpoints que deve ligar a um agente, diretamente ou através de um servidor MCP em execução no mesmo VPS.

Execute o mem0 sem qualquer chave OpenAI

Comece pelo bloqueio, porque irá encontrá-lo nos primeiros cinco minutos. A imagem do servidor inclui um conjunto fixo de bibliotecas de providers, e /configure rejeita tudo o que esteja fora desse 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.

Não precisa de recompilar nada. O Ollama disponibiliza uma API compatível com OpenAI em /v1, com suporte para /v1/chat/completions e /v1/embeddings, e o provider openai do mem0 aceita um openai_base_url. Aponte essa chave para o Ollama e a verificação incluída passa, porque o provider é realmente openai. Apenas o endereço muda.

Adicione o Ollama ao mesmo projeto Compose:

  ollama:
    image: ollama/ollama
    restart: unless-stopped
    networks: [mem0_network]
    ports:
      - "127.0.0.1:11434:11434"
    volumes:
      - ollama_models:/root/.ollama

Adicione ollama_models: à chave de nível superior volumes: e, em seguida, descarregue um modelo de chat e um 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-text

Se o Ollama já estiver a executar no host como uma unidade systemd, como em executar o Ollama diretamente numa VPS, não aponte o contentor para 127.0.0.1:11434. Dentro do contentor do mem0, 127.0.0.1 é o próprio contentor do mem0. Dê ao serviço mem0 extra_hosts: ["host.docker.internal:host-gateway"], defina Environment="OLLAMA_HOST=0.0.0.0:11434" num drop-in do systemd para que o Ollama escute num endereço que a bridge consiga alcançar e mantenha 11434 bloqueada na firewall.

Consulte a dimensão dos embeddings do modelo antes de configurar qualquer coisa

Este passo determina se a recuperação funciona.

O armazenamento pgvector do mem0 cria a tabela com uma largura fixa de vetores, vector vector(1536), porque embedding_model_dims assume por predefinição o valor 1536, a largura de text-embedding-3-small da OpenAI. nomic-embed-text devolve 768 valores. O mem0 não compara estes dois números, pelo que a incompatibilidade surge no Postgres durante a primeira inserção:

expected 1536 dimensions, not 768

Também não confie no número deste parágrafo. Consulte o 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']))"

Isto mostra a largura que a sua collection tem de utilizar. Escreva a configuração num ficheiro, porque introduzir uma palavra-passe do Postgres através de quoting da shell é uma forma de colocar erros de digitação em produção.

{
  "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"

A segunda chamada lê novamente a configuração. Essa é a verificação de que a escrita foi aplicada. Em seguida, repita o teste de funcionamento acima.

Há quatro detalhes nesse JSON que não são óbvios. Cada um deles causa uma falha se for configurado incorretamente.

api_key é a string ollama, e o Ollama ignora o seu valor. Não pode estar vazia, porque a biblioteca cliente OpenAI gera um erro antes de qualquer pedido sair do processo quando não existe uma chave definida. Qualquer string não vazia funciona.

embedding_model_dims deve ser definido no vector store. Não existe deliberadamente nenhum embedding_dims no embedder. O mem0 só envia o parâmetro OpenAI dimensions quando define embedding_dims, e os backends que não implementam truncagem Matryoshka rejeitam esse parâmetro. Defina a largura quando a tabela for criada e deixe o embedder sem essa opção.

collection_name é novo. O mem0 cria a tabela com CREATE TABLE IF NOT EXISTS, pelo que apontar uma largura diferente para uma collection existente não produz qualquer efeito: a coluna vector(1536) antiga permanece e todas as inserções falham. Uma alteração de largura requer um nome de collection novo ou a remoção manual da tabela antiga.

O host em openai_base_url é o nome do serviço Compose ollama, não localhost. Os contentores resolvem-se entre si pelo nome do serviço na rede partilhada.

O custo de executar tudo localmente

Seja realista quanto à qualidade. Os principais resultados de benchmark do mem0 vêm da sua plataforma gerida. O README indica que essa plataforma inclui otimizações proprietárias que não estão disponíveis no SDK open source e que utiliza uma stack de modelos não especificada. O artigo de investigação que sustenta os resultados originais do LOCOMO executou todas as chamadas de modelo no GPT-4o-mini, um modelo alojado. Em qualquer dos casos, trate esses resultados como um limite superior, não como uma previsão para um modelo 8B na sua VPS. Um modelo pequeno escreve factos mais vagos e, por vezes, devolve texto onde foi solicitado JSON. Isto aparece como uma chamada add que devolve uma lista results vazia sem erro.

A velocidade é outro custo. A extração apenas com CPU demora segundos por chamada add e cada mensagem armazenada tem esse custo. Um modelo que continua a produzir texto depois do JSON solicitado piora o problema. Por isso, limitar a resposta com num_predict define um limite para a duração de cada chamada add. Se essa latência for importante, uma VPS com uma GPU associada é a solução adequada. Adicionar mais núcleos de CPU a um modelo 8B ajuda muito menos do que se espera. Alterar o modelo é uma opção mais económica do que alterar a máquina, e o Nemotron 3.5 Lightning numa VPS fornece a tag a descarregar, a RAM necessária e a indicação de se o modo apenas com CPU é suficientemente rápido para utilização normal.

Há uma regra que se aplica independentemente da opção escolhida: nunca misture modelos de embeddings dentro da mesma collection. Dois modelos diferentes que por acaso tenham a mesma largura produzem vetores que não são comparáveis. A inserção é bem-sucedida, a pesquisa devolve linhas e as linhas estão erradas, sem que qualquer componente comunique um erro.

Backups: existem duas bases de dados, não uma

O erro mais comum ao fazer backup do mem0 é descarregar uma única base de dados. init-db.sh cria mem0_app juntamente com a base de dados predefinida postgres, e cada uma armazena dados diferentes. A base de dados postgres armazena as coleções pgvector, que correspondem às memórias. mem0_app armazena utilizadores, sessões, chaves de API e logs de pedidos. Cada aplicação self-hosted divide o seu estado de forma diferente. Por isso, dois servidores de fotografias que fazem o mesmo trabalho continuam a precisar de comandos de backup diferentes. Leia o que a sua aplicação armazena antes de confiar num dump. No extremo oposto está algo como uma biblioteca Jellyfin reconstruída como uma videoteca dos anos 90, que lê todo o seu catálogo a partir de outro serviço e, por isso, precisa sobretudo que a sua própria configuração seja copiada. O mem0, por outro lado, precisa das duas bases de dados; caso contrário, o restauro fica inutilizado.

Restaure apenas postgres e as memórias serão recuperadas, mas todas as contas e chaves de API desaparecerão. Nesse caso, nada poderá autenticar-se para as ler. Faça o dump das duas bases de dados, incluindo as roles, com um único comando:

docker compose exec -T postgres pg_dumpall -U postgres --clean \
  | gzip > "mem0-$(date +%F).sql.gz"

O volume do histórico é separado do Postgres e precisa da sua própria cópia:

docker run --rm -v mem0_mem0_history:/data -v "$PWD:/backup" \
  alpine tar czf /backup/mem0-history.tgz -C /data .

O Docker acrescenta o nome do projeto aos nomes dos volumes. Por isso, confirme o seu com docker volume ls antes de assumir que é mem0_mem0_history.

Restaure os dados num contentor temporário e confirme o número de linhas antes de considerar o backup válido:

gunzip -c mem0-2026-08-03.sql.gz \
  | docker compose exec -T postgres psql -U postgres -d postgres

Um backup que nunca foi restaurado é apenas uma suposição. Depois de confirmar que os dumps estão corretos, envie-os para fora do servidor com snapshots do restic para armazenamento externo, porque um backup guardado no servidor que deveria proteger não protege nada.

Modos de falha e as mensagens exatas que verá

{"detail":"Authentication required. Provide a Bearer token or X-API-Key header."} significa que o cabeçalho está em falta ou tem um erro de escrita. O nome é X-API-Key, e o curl envia os nomes dos cabeçalhos literalmente.

{"detail":"At least one identifier (user_id, agent_id, run_id) is required."} numa operação de adição significa que o pedido não tinha nenhum desses campos. Uma memória tem de estar associada a algo, porque a pesquisa filtra exatamente por esses campos.

LLM provider 'ollama' is not bundled in this image com HTTP 400 significa que enviou "provider": "ollama". Use "provider": "openai" com openai_base_url apontado para o Ollama.

expected 1536 dimensions, not 768 do Postgres significa que a coleção foi criada com uma dimensão e o embedder devolve outra. Defina embedding_model_dims no vector store e use um novo collection_name.

A pesquisa devolve linhas sem sentido depois de uma alteração do modelo, sem qualquer erro. A dimensão continua a corresponder, por isso a base de dados aceita os dados, mas dois modelos colocam a mesma frase em posições diferentes. Crie uma nova coleção e adicione os dados novamente.

Connection refused nos logs do mem0 ao contactar o Ollama normalmente significa 127.0.0.1 em openai_base_url. Dentro do contentor, esse endereço refere-se ao próprio contentor. Use o nome do serviço ou o gateway do host quando o Ollama é executado no host.

504 Gateway Time-out do nginx durante uma operação de adição significa que o modelo demorou mais do que proxy_read_timeout. Aumente esse valor e confirme se a memória foi gravada antes de repetir o pedido.

exit code 137 durante docker compose up --build significa que um processo foi terminado com SIGKILL, porque um sinal fatal N é reportado como 128 + N e SIGKILL corresponde ao sinal 9. Enquanto o dashboard é compilado num VPS pequeno, a causa mais provável é o out-of-memory killer. Execute a verificação dmesg da primeira secção antes de agir. Se essa verificação mostrar um processo terminado, adicione swap ou compile a imagem numa máquina maior e envie-a para um registry.

error: port 3000 is already in use vem do destino make up do repositório, que se recusa a arrancar quando as portas 3000 ou 8888 estão ocupadas. Encontre o processo responsável com lsof -iTCP:3000 -sTCP:LISTEN.

FAQ

Ainda preciso do Neo4j para executar o mem0 com memória de grafos?

Não. O novo algoritmo de memória, lançado em April 2026, removeu as chaves de configuração graph_store e enable_graph do SDK de código aberto. A extração de entidades agora é executada durante uma operação normal de adição e grava os dados numa segunda coleção pgvector chamada <collection_name>_entities. Portanto, não há base de dados de grafos externa, contentor adicional nem etapa de configuração. A desvantagem é que o campo relations deixou de existir nos resultados da pesquisa. As entidades agora aumentam a classificação de uma memória, em vez de fornecerem arestas para percorrer. Por isso, uma aplicação que percorria essas relações precisa do seu próprio armazenamento de grafos fora do mem0.

Qual é o VPS mais pequeno que executa um servidor mem0 autoalojado?

A estimativa de dimensionamento de 2026-10-25 era de 2 GB de RAM e cerca de 4 GB de espaço livre em disco para o contentor da API, o Postgres e o dashboard, com o modelo de linguagem alojado noutro local. O momento mais exigente ocorre durante a primeira compilação, porque compilar o dashboard Next.js usa mais memória do que executá-lo. Se a compilação terminar com exit code 137, verifique se ocorreu uma interrupção por falta de memória. Para executar o Ollama no mesmo servidor, essa estimativa reservava aproximadamente 6 GB para um modelo 8B com quantização de 4 bits e 8 GB para toda a stack. Meça a sua compilação e o seu modelo antes de considerar estas estimativas como requisitos mínimos.

Posso executar o mem0 sem uma chave de API da OpenAI?

Sim, através do endpoint compatível com OpenAI do Ollama. Definir "provider": "ollama" falha porque a imagem do servidor inclui apenas as bibliotecas openai, anthropic e gemini e devolve HTTP 400. Em vez disso, mantenha "provider": "openai" e defina "openai_base_url": "http://ollama:11434/v1" com qualquer valor api_key não vazio, tanto para o llm como para o embedder. O Ollama ignora a chave, e a verificação do provider incluído é aprovada porque o provider é realmente openai.

Por que o mem0 não devolve resultados depois de eu mudar para um modelo local de embeddings?

Porque a tabela pgvector foi criada com uma largura fixa. embedding_model_dims tem o valor padrão 1536, nomic-embed-text devolve 768, e o Postgres rejeita a inserção com expected 1536 dimensions, not 768. O mem0 cria a tabela com CREATE TABLE IF NOT EXISTS, portanto alterar apenas o número não tem efeito numa coleção existente. Defina embedding_model_dims com a largura real do seu modelo, confirme essa largura chamando /v1/embeddings e contando os valores devolvidos, e atribua simultaneamente ao armazenamento vetorial um novo collection_name.

Este artigo foi útil?