OpenClaw Grátis
Inteligência Artificial

Guia Completo: OpenClaw Grátis com Ollama Rodando Local

Cassiano Freitas
13 min. leitura

Se você acompanha a revolução da Inteligência Artificial, com certeza está buscando uma forma de rodar o OpenClaw grátis. Depender exclusivamente de APIs pagas na nuvem pode sair caro e levantar questões de privacidade. A solução? Rodar tudo na sua própria máquina de forma segura.

Neste artigo, vou te mostrar o passo a passo exato de como eu transformei meu notebook (um Avell Ion A70 com uma RTX 5050) em um servidor de IA 100% local, gratuito e com memória persistente. Nós vamos usar o OpenClaw (como agente inteligente) integrado ao Ollama (para rodar o modelo Gemma 4 do Google) dentro do WSL2 no Windows.

Seja você é dono de de qualquer máquina com uma placa de vídeo dedicada, este guia é para você. Vou explicar o porquê de cada etapa para deixar tudo bem didático. Vamos lá?

Conteúdo

A Stack e os Requisitos

Antes de colocarmos a mão na massa, vamos entender o que estamos instalando:

  • WSL2: O “Subsistema do Windows para Linux”. Ele permite rodar um ambiente Ubuntu nativo dentro do Windows, o que é crucial para tirar o máximo de performance da IA.
  • Docker & Portainer: O Docker cria “caixas isoladas” (containers) para os nossos programas, e o Portainer é uma interface visual maravilhosa para gerenciar essas caixas.
  • Ollama: O motor que vai executar o modelo de linguagem na sua placa de vídeo.
  • Gemma 4 E2B: O “cérebro” da operação. Um modelo leve (7.2GB) e eficiente do Google.
  • OpenClaw: A camada de “agente”. É ele que dá à IA a capacidade de ter memória longa, acessar ferramentas e navegar na web.

Requisitos mínimos:

  • Windows 10 (build 19041+) ou Windows 11.
  • GPU NVIDIA com pelo menos 6GB de VRAM (A minha RTX 5050 do Avell Ion A70 roda o OpenClaw grátis com folga!).
  • 16GB de RAM e 40GB de espaço em disco.
  • Driver NVIDIA mais recente (535+) instalado no Windows.

Preparando o Terreno com o WSL2

Para rodar ferramentas de IA de ponta, o Linux é o melhor ambiente. O WSL2 nos dá o melhor dos dois mundos.

Instalação do WSL2

Abra o seu PowerShell como Administrador no Windows e digite:

wsl --install

Reinicie o seu computador. Após reiniciar, uma tela de terminal do Ubuntu vai aparecer pedindo para você criar um usuário e uma senha (pode ser qualquer um, mas não esqueça a senha!).

Para confirmar se deu certo, rode no PowerShell:

wsl --version

(Deve aparecer WSL version: 2.x.x)

Verificando o acesso à sua GPU

Abra o terminal do Ubuntu (agora instalado no seu Iniciar) e verifique se o Linux está “enxergando” sua placa de vídeo:

nvidia-smi

Se a sua RTX (ou GTX) aparecer na lista junto com a versão do CUDA, sucesso! Podemos seguir.

Instalando o Docker (O Gerenciador de Containers)

O Docker vai facilitar a instalação de tudo sem bagunçar os arquivos do seu sistema.

Instalando o Docker Engine

No terminal do Ubuntu (WSL), vamos atualizar o sistema e instalar o Docker oficial. Copie e cole os comandos abaixo (você pode colar tudo de uma vez):

# Atualizar pacotes
sudo apt update && sudo apt upgrade -y

# Instalar dependências básicas
sudo apt install -y ca-certificates curl gnupg lsb-release

# Adicionar repositório oficial do Docker
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | \
  sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg

echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] \
  https://download.docker.com/linux/ubuntu \
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# Instalar o Docker
sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io \
  docker-buildx-plugin docker-compose-plugin

# Este comando adiciona seu usuário ao grupo do Docker. 
# Isso evita que você tenha que digitar "sudo" toda vez que for usar o Docker!
sudo usermod -aG docker $USER
newgrp docker

# Iniciar o serviço
sudo service docker start

A Ponte Mágica: NVIDIA Container Toolkit

Por padrão, o Docker não sabe usar sua placa de vídeo. Precisamos instalar este kit da NVIDIA para que os containers tenham acesso à sua GPU (o que é vital para não fritar o processador rodando IA).

# Adicionar repositório NVIDIA
curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | \
  sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg

curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | \
  sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
  sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list

# Instalar o toolkit
sudo apt update
sudo apt install -y nvidia-container-toolkit

# Configurar o Docker para usar o motor da NVIDIA
sudo nvidia-ctk runtime configure --runtime=docker
sudo service docker restart

Teste se o Docker consegue ver sua GPU rodando:

docker run --rm --gpus all nvidia/cuda:12.6.0-base-ubuntu22.04 nvidia-smi

Facilitando a Vida com o Portainer

Gerenciar tudo pelo terminal cansa. O Portainer é um painel visual acessível pelo navegador.

docker volume create portainer_data

docker run -d \
  --name portainer \
  --restart unless-stopped \
  -p 9000:9000 \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v portainer_data:/data \
  portainer/portainer-ce:latest

Agora, abra o navegador no seu Windows e acesse http://localhost:9000. Crie sua conta de administrador. Tudo o que faremos a seguir será através dessa interface amigável!

Conectando Tudo (Redes Docker)

Antes de subir os sistemas, precisamos criar as “pontes” virtuais para que o OpenClaw grátis consiga conversar com o Ollama. No terminal do WSL, rode:

docker network create ollama
docker network create proxy

Instalando o Motor da IA (Ollama)

Agora vamos ao Portainer. Acessando sua Dashboard, vá no menu lateral esquerdo em Stacks -> Add stack.
Nomeie a stack como ollama e cole o código abaixo. Esse código diz ao Docker exatamente como baixar e configurar o servidor do Ollama e uma interface web alternativa.

version: '3.8'

services:
  ollama:
    image: ollama/ollama:latest
    container_name: ollama
    restart: unless-stopped
    environment:
      - NVIDIA_VISIBLE_DEVICES=all
      - NVIDIA_DRIVER_CAPABILITIES=compute,utility
    volumes:
      - ollama_data:/root/.ollama
    networks:
      - ollama
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:11434/api/tags"]
      interval: 15s
      timeout: 10s
      retries: 5
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]

  open-webui:
    image: ghcr.io/open-webui/open-webui:latest
    container_name: open-webui
    restart: unless-stopped
    mem_limit: 1g
    memswap_limit: 1g
    ports:
      - "3000:8080"
    environment:
      - OLLAMA_BASE_URL=http://ollama:11434
    volumes:
      - open_webui_data:/app/backend/data
    networks:
      - ollama
      - proxy
    depends_on:
      ollama:
        condition: service_healthy

networks:
  ollama:
    external: true
  proxy:
    external: true

volumes:
  ollama_data:
    name: ollama_data
  open_webui_data:
    name: open_webui_data

Clique em Deploy the stack.

Baixando o Cérebro (Os Modelos)

Com o Ollama rodando, volte ao terminal do WSL para baixar o modelo Gemma 4 (que processa a linguagem) e o modelo Nomic (que processa as memórias e o contexto):

# Baixando o modelo principal (aprox. 7.2GB, aproveite para pegar um café!)
docker exec ollama ollama pull gemma4:e2b

# Baixando o modelo de memória
docker exec ollama ollama pull nomic-embed-text

O Agente Inteligente (OpenClaw Grátis)

O Ollama é só o motor; o OpenClaw grátis é o “motorista”. É ele que vai lembrar das suas conversas passadas e executar ações.

Segurança em primeiro lugar

Vamos gerar uma senha (token) única para o seu agente. No terminal, rode:

openssl rand -base64 48 | tr -d "=+/" | cut -c1-64

Copie e guarde esse código gerado. Vamos usar logo a seguir.

Subindo o OpenClaw Grátis

Volte ao Portainer, crie outra Stack chamada openclaw e cole:

version: '3.8'

services:
  openclaw:
    image: ghcr.io/openclaw/openclaw:latest
    container_name: openclaw-gateway
    restart: unless-stopped
    ports:
      - "18789:18789"
    environment:
      - TZ=America/Sao_Paulo
      - OPENCLAW_GATEWAY_TOKEN=${OPENCLAW_GATEWAY_TOKEN}
      - OPENCLAW_ALLOWED_ORIGINS=http://localhost:18789,http://127.0.0.1:18789
    volumes:
      - openclaw_config:/home/node/.openclaw
      - /var/run/docker.sock:/var/run/docker.sock
    networks:
      - ollama
      - proxy
    depends_on:
      openclaw-browser:
        condition: service_healthy

  openclaw-browser:
    image: coollabsio/openclaw-browser:latest
    container_name: openclaw-browser
    restart: unless-stopped
    mem_limit: 1g
    memswap_limit: 1g
    environment:
      - TZ=America/Sao_Paulo
      - CHROME_CLI=--remote-debugging-port=9222
    volumes:
      - openclaw_browser_data:/home/chrome
      - openclaw_browser_config:/config
    networks:
      - ollama
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:9222/json"]
      interval: 10s
      timeout: 5s
      retries: 5

networks:
  ollama:
    external: true
  proxy:
    external: true

volumes:
  openclaw_config:
    name: openclaw_config
  openclaw_browser_data:
    name: openclaw_browser_data
  openclaw_browser_config:
    name: openclaw_browser_config

⚠️ Atenção: Logo abaixo da caixa de código no Portainer, procure a seção Environment variables, adicione uma variável com o nome OPENCLAW_GATEWAY_TOKEN e no valor cole aquele token longo que geramos no passo anterior. Depois, clique em Deploy the stack.

Configurando permissões e conexões

Execute os comandos abaixo um a um no seu terminal WSL. Eles servem para dar as permissões corretas para as pastas do OpenClaw e “ensinar” a ele que deve usar o Ollama (e os modelos que baixamos) para pensar.

# 1. Ajuste de permissões
docker run --rm \
  -v openclaw_config:/home/node/.openclaw \
  alpine \
  chown -R 1000:1000 /home/node/.openclaw

# 2. Configurar o gateway
docker run --rm \
  -v openclaw_config:/home/node/.openclaw \
  ghcr.io/openclaw/openclaw:latest \
  node dist/index.js config set --batch-json \
  '[{"path":"gateway.mode","value":"local"},{"path":"gateway.bind","value":"lan"},{"path":"gateway.controlUi.allowedOrigins","value":["http://localhost:18789","http://127.0.0.1:18789"]}]'

docker restart openclaw-gateway

# 3. Conectar OpenClaw com Ollama e Gemma 4
docker exec openclaw-gateway \
  node dist/index.js config set --batch-json \
  '[{"path":"models.providers.ollama.baseUrl","value":"http://ollama:11434"},{"path":"models.providers.ollama.apiKey","value":"ollama"},{"path":"models.providers.ollama.auth","value":"api-key"},{"path":"models.providers.ollama.api","value":"ollama"},{"path":"models.providers.ollama.models","value":[{"id":"gemma4:e2b","name":"Gemma 4 E2B","api":"ollama","reasoning":true,"contextWindow":32768,"contextTokens":32768,"maxTokens":32768,"compat":{"supportsTools":true,"nativeWebSearchTool":true},"input":["text"],"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0}}]}]'

# 4. Configurar a memória semântica
docker exec openclaw-gateway \
  node dist/index.js config set --batch-json \
  '[{"path":"agents.defaults.memorySearch.provider","value":"ollama"},{"path":"agents.defaults.memorySearch.model","value":"nomic-embed-text"},{"path":"agents.defaults.memorySearch.remote.baseUrl","value":"http://ollama:11434"}]'

# Reiniciar para aplicar tudo
docker restart openclaw-gateway

O Grande Momento (Acessando o OpenClaw Grátis)

Abra o seu navegador e acesse:

http://localhost:18789

Cole aquele Token do passo anterior. Você também pode acessar o link desta forma:

http://localhost:18789#token=SEU_TOKEN_AQUI

Se aparecer um aviso de device pairing required com um código (Request ID), vá ao terminal e rode:

docker exec openclaw-gateway \
  node dist/index.js devices approve SEU_REQUEST_ID

Recarregue a página. Bem-vindo ao OpenClaw Grátis, seu assistente de IA pessoal!

Treinando o seu OpenClaw

A mágica do OpenClaw Grátis é o contexto. Na primeira vez que conversar com a IA:

  1. Diga seu nome, com o que você trabalha e detalhes importantes (ex: “Sou Coordenador de Marketing na Emccamp, uso um notebook Avell…”).
  2. Peça para ela assumir uma persona (ex: “Você será minha gerente de agentes, seu nome é Clawdia”).
  3. O comando de ouro: Diga “Salve isso na sua memória”.

Diferente do ChatGPT que esquece as coisas quando você fecha a aba, o OpenClaw escreve arquivos Markdown (como usuario.md e IDENTITY.md) no seu workspace local. Ele literalmente cria um banco de dados sobre você!

Guia Rápido de Sobrevivência (Comandos Úteis)

Guarde estes comandos no bloco de notas, eles salvam vidas no dia a dia:

Status e Logs:

  • Ver uso de GPU do modelo: docker exec ollama nvidia-smi
  • Ver quais modelos estão rodando: docker exec ollama ollama ps
  • Logs do OpenClaw (se algo travar): docker logs -f openclaw-gateway

Soluções Comuns:

  • Erro “origin not allowed” na tela do OpenClaw:
    docker exec openclaw-gateway \ node dist/index.js config set --batch-json \ '[{"path":"gateway.controlUi.allowedOrigins","value":["http://localhost:18789","http://127.0.0.1:18789"]}]' docker restart openclaw-gateway
  • IA usando CPU em vez de GPU (Notebook esquentando muito):
    O modelo pode ser grande demais para a sua VRAM. A RTX 5050 aguenta bem o Gemma 4, mas se acontecer, reinicie o container do Ollama (docker restart ollama).

E é isso! Agora você tem o OpenClaw Grátis, um verdadeiro agente de IA operando diretamente do seu SSD, processado localmente pela sua placa de vídeo, garantindo velocidade incrível e privacidade total. Deixe suas dúvidas nos comentários se esbarrar em algum erro durante a instalação!

TAGS:
Compartilhe este artigo
Nenhum comentário

Deixe um comentário

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *

Você também pode gostar

Sair da versão mobile