GPT4All LLM local

Despliega GPT4All en Clore.ai: ejecuta LLMs locales centrados en la privacidad con un servidor API compatible con OpenAI usando Docker, compatible con modelos GGUF y aceleración CUDA opcional para máximo rendimiento.

Descripción general

GPT4All de Nomic AI es uno de los proyectos locales de LLM de código abierto más populares, con más de 72.000 estrellas en GitHub. Te permite ejecutar modelos de lenguaje grandes completamente sin conexión en tu propio hardware: no se requiere conexión a internet, no se envían datos a terceros.

GPT4All es mejor conocido por su pulida aplicación de escritorio, pero también incluye una biblioteca de Python (gpt4all paquete) y un servidor API compatible con OpenAI que se ejecuta en el puerto 4891. En Clore.ai, puedes desplegar GPT4All en un contenedor Docker en una GPU alquilada, servirlo por HTTP y conectar cualquier cliente compatible con OpenAI.

Nota sobre Docker: GPT4All no publica una imagen oficial de Docker para el componente del servidor. Esta guía usa una configuración Docker personalizada con el gpt4all paquete de Python. Para una alternativa de Docker más lista para producción que ejecute los mismos archivos de modelo GGUF, consulta la sección alternativa de LocalAI — LocalAI es primero Docker y admite el mismo formato de modelo.

Características principales:

• 🔒 100% sin conexión — toda la inferencia se ejecuta localmente

• 🤖 API REST compatible con OpenAI (puerto 4891)

• 📚 LocalDocs — RAG sobre tus propios documentos

• 🧩 Admite todos los formatos de modelo GGUF populares

• 🐍 API completa de Python con pip install gpt4all

• 💬 Hermosa interfaz de escritorio (no relevante para el servidor, pero buena para pruebas locales)

---

Requisitos

Requisitos de hardware

Nivel	GPU	VRAM	RAM	Almacenamiento	Precio de Clore.ai
Solo CPU	Ninguno	—	16 GB	SSD de 50 GB	~$0.02/h (servidor CPU)
GPU de entrada	RTX 3060 12GB	12 GB	16 GB	SSD de 50 GB	$0.03–0.07/h
Recomendado	RTX 3090	24 GB	32 GB	SSD de 100 GB	$0.07–0.21/h
Gama alta	RTX 4090	24 GB	64 GB	SSD de 200 GB	$0.14–0.42/h

Nota: El soporte GPU de GPT4All usa CUDA a través de llama.cpp internamente. A diferencia de vLLM, no no requiere una capacidad de cómputo CUDA específica: RTX 10xx y posteriores generalmente funcionan.

Requisitos de VRAM del modelo (GGUF Q4_K_M)

Modelo	Tamaño en disco	VRAM	GPU mínima
Phi-3 Mini 3.8B	~2.4 GB	~3 GB	RTX 3060
Mistral 7B Instruct	~4.1 GB	~5 GB	RTX 3060
Llama 3.1 8B Instruct	~4.7 GB	~6 GB	RTX 3060
Llama 3 70B Instruct	~40 GB	~45 GB	A100 80GB
Mixtral 8x7B	~26 GB	~30 GB	2× RTX 3090

---

Inicio rápido

Paso 1 — Alquila un servidor GPU en Clore.ai

1. Inicia sesión en clore.ai

2. Filtro: Docker habilitado, GPU: RTX 3090 (para modelos de 7B–13B)

3. Despliega con la imagen: nvidia/cuda:12.8.1-runtime-ubuntu22.04

4. Abrir puertos: 4891 (API de GPT4All), 22 (SSH)

5. Asigna al menos 50 GB de espacio en disco

Paso 2 — Conectarse vía SSH

ssh -p <CLORE_SSH_PORT> root@<CLORE_SERVER_IP>

# Verificar GPU
nvidia-smi
# Debería listar tu GPU con la versión del controlador

Paso 3 — Construye la imagen Docker de GPT4All

Como no hay una imagen Docker oficial de GPT4All, construiremos una:

mkdir -p /workspace/gpt4all-server && cd /workspace/gpt4all-server

cat > Dockerfile << 'EOF'
FROM nvidia/cuda:12.8.1-runtime-ubuntu22.04

ENV DEBIAN_FRONTEND=noninteractive
ENV PYTHONUNBUFFERED=1

# Instala Python y dependencias del sistema
RUN apt-get update && apt-get install -y \\
    python3.11 \\
    python3.11-dev \\
    python3-pip \\
    curl \\
    wget \\
    git \\
    libgomp1 \\
    && rm -rf /var/lib/apt/lists/*

# Haz que python3.11 sea el predeterminado
RUN update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.11 1 \\
    && update-alternatives --install /usr/bin/python python python3.11 1

# Instala GPT4All con soporte CUDA
RUN pip install --upgrade pip && \
    pip install gpt4all>=2.8.0 fastapi uvicorn aiofiles pydantic

# Crea directorios
RUN mkdir -p /models /workspace /app

WORKDIR /app

# Copia el script del servidor (se montará o se integrará en la imagen)
COPY server.py .

EXPOSE 4891

CMD ["python", "server.py"]
EOF

Paso 4 — Crea el script del servidor API

cat > /workspace/gpt4all-server/server.py << 'PYEOF'
#!/usr/bin/env python3
"""
Servidor API compatible con OpenAI de GPT4All
Se ejecuta en el puerto 4891 (predeterminado de GPT4All)
"""

import os
import time
import json
import asyncio
from typing import Optional, List, Dict, Any
from pathlib import Path

from fastapi import FastAPI, HTTPException
from fastapi.responses import StreamingResponse
from pydantic import BaseModel
import uvicorn
from gpt4all import GPT4All

# Configuración
MODEL_NAME = os.environ.get("MODEL_NAME", "Mistral 7B Instruct v0.1 Q4_0")
MODEL_PATH = os.environ.get("MODEL_PATH", "/models")
API_HOST = os.environ.get("API_HOST", "0.0.0.0")
API_PORT = int(os.environ.get("API_PORT", "4891"))
DEVICE = os.environ.get("DEVICE", "gpu")  # 'gpu', 'cpu', 'metal'
N_CTX = int(os.environ.get("N_CTX", "4096"))

app = FastAPI(title="Servidor API GPT4All", version="1.0.0")

# Instancia global del modelo
model = None

def load_model():
    global model
    print(f"Cargando modelo: {MODEL_NAME}")
    print(f"Ruta del modelo: {MODEL_PATH}")
    print(f"Dispositivo: {DEVICE}")
    model = GPT4All(
        model_name=MODEL_NAME,
        model_path=MODEL_PATH,
        device=DEVICE,
        n_ctx=N_CTX,
        allow_download=True,  # Descarga desde GPT4All hub si no está presente
        verbose=True
    )
    ¡Modelo cargado correctamente!

# --- Modelos Pydantic ---

class Message(BaseModel):
    role: str
    content: str

class ChatCompletionRequest(BaseModel):
    model: str
    messages: List[Message]
    temperature: float = 0.7
    max_tokens: int = 512
    top_p: float = 0.95
    top_k: int = 40
    stream: bool = False

class CompletionRequest(BaseModel):
    model: str
    prompt: str
    temperature: float = 0.7
    max_tokens: int = 512
    stream: bool = False

# --- Rutas de la API ---

@app.get("/health")
async def health():
    return {"status": "ok", "model": MODEL_NAME, "device": DEVICE}

@app.get("/v1/models")
async def list_models():
    return {
        "object": "list",
        "data": [{
            "id": MODEL_NAME,
            "object": "model",
            "created": int(time.time()),
            "owned_by": "gpt4all",
        }]
    }

@app.post("/v1/chat/completions")
async def chat_completions(request: ChatCompletionRequest):
    if model is None:
        raise HTTPException(status_code=503, detail="Modelo no cargado")

    # Formatea los mensajes en un solo prompt
    prompt_parts = []
    for msg in request.messages:
        if msg.role == "system":
            prompt_parts.append(f"### Sistema:\n{msg.content}")
        elif msg.role == "user":
            prompt_parts.append(f"### Humano:\n{msg.content}")
        elif msg.role == "assistant":
            prompt_parts.append(f"### Asistente:\n{msg.content}")
    prompt_parts.append("### Asistente:")
    full_prompt = "\n\n".join(prompt_parts)

    with model.chat_session():
        response_text = model.generate(
            full_prompt,
            max_tokens=request.max_tokens,
            temp=request.temperature,
            top_p=request.top_p,
            top_k=request.top_k,
        )

    return {
        "id": f"chatcmpl-{int(time.time())}",
        "object": "chat.completion",
        "created": int(time.time()),
        "model": request.model,
        "choices": [{
            "index": 0,
            "message": {"role": "assistant", "content": response_text},
            "finish_reason": "stop"
        }],
        "usage": {
            "prompt_tokens": len(full_prompt.split()),
            "completion_tokens": len(response_text.split()),
            "total_tokens": len(full_prompt.split()) + len(response_text.split())
        }
    }

@app.post("/v1/completions")
async def completions(request: CompletionRequest):
    if model is None:
        raise HTTPException(status_code=503, detail="Modelo no cargado")

    response_text = model.generate(
        request.prompt,
        max_tokens=request.max_tokens,
        temp=request.temperature,
    )

    return {
        "id": f"cmpl-{int(time.time())}",
        "object": "text_completion",
        "created": int(time.time()),
        "model": request.model,
        "choices": [{
            "text": response_text,
            "index": 0,
            "finish_reason": "stop"
        }]
    }

if __name__ == "__main__":
    load_model()
    uvicorn.run(app, host=API_HOST, port=API_PORT, log_level="info")
PYEOF

Paso 5 — Construir y ejecutar

cd /workspace/gpt4all-server

# Construye la imagen Docker
docker build -t gpt4all-server:latest .

# Descarga primero un modelo (opcional — el servidor también puede descargarlo automáticamente)
mkdir -p /workspace/models
wget -O /workspace/models/mistral-7b-instruct-v0.1.Q4_0.gguf \\
  https://gpt4all.io/models/gguf/mistral-7b-instruct-v0.1.Q4_0.gguf

# Ejecuta con soporte GPU
docker run -d \\
  --name gpt4all-server \\
  --gpus all \\
  --restart unless-stopped \\
  -p 4891:4891 \\
  -v /workspace/models:/models \\
  -v /workspace/gpt4all-server/server.py:/app/server.py \\
  -e MODEL_NAME="mistral-7b-instruct-v0.1.Q4_0.gguf" \\
  -e MODEL_PATH="/models" \\
  -e DEVICE="gpu" \\
  -e N_CTX="4096" \\
  gpt4all-server:latest

# Sigue los registros
docker logs -f gpt4all-server

Paso 6 — Prueba la API

# Comprobación de salud
curl http://localhost:4891/health

# Lista modelos
curl http://localhost:4891/v1/models

# Finalización de chat
curl http://localhost:4891/v1/chat/completions \\
  -H "Content-Type: application/json" \\
  -d '{
    "model": "mistral-7b-instruct-v0.1.Q4_0.gguf",
    "messages": [
      {"role": "user", "content": "¿Cuál es la capital de Francia?"}
    ],
    "temperature": 0.7,
    "max_tokens": 256
  }'

---

Alternativa: imagen Docker de LocalAI

Para un despliegue Docker más robusto y listo para producción que ejecute los mismos modelos GGUF que GPT4All, LocalAI es la opción recomendada. Tiene una imagen Docker oficial, soporte CUDA y se mantiene activamente:

# Descarga LocalAI con soporte CUDA
docker pull localai/localai:latest-aio-gpu-nvidia-cuda-12

# Crea el directorio de modelos y descarga un modelo GGUF
mkdir -p /workspace/localai-models
wget -O /workspace/localai-models/mistral-7b.gguf \\
  https://huggingface.co/TheBloke/Mistral-7B-Instruct-v0.1-GGUF/resolve/main/mistral-7b-instruct-v0.1.Q4_K_M.gguf

# Crea la configuración del modelo
cat > /workspace/localai-models/mistral-7b.yaml << 'EOF'
nombre: mistral-7b
parámetros:
  modelo: mistral-7b.gguf
  temperatura: 0.7
  top_p: 0.95
  top_k: 40
  max_tokens: 2048
context_size: 4096
f16: true
gpu_layers: 35
threads: 8
EOF

# Ejecuta LocalAI
docker run -d \\
  --name localai \\
  --gpus all \\
  --restart unless-stopped \\
  -p 8080:8080 \
  -v /workspace/localai-models:/build/models \\
  -e DEBUG=true \\
  localai/localai:latest-aio-gpu-nvidia-cuda-12

# Prueba LocalAI (la misma API compatible con OpenAI)
curl http://localhost:8080/v1/chat/completions \\
  -H "Content-Type: application/json" \\
  -d '{
    "model": "mistral-7b",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'

---

Configuración

Variables de entorno para el servidor GPT4All

Variable	Predeterminado	Descripción
MODEL_NAME	mistral-7b-instruct...	Nombre del archivo del modelo o nombre de GPT4All hub
MODEL_PATH	/models	Directorio que contiene archivos de modelo
DEVICE	gpu	gpu, cpu, o metal (macOS)
N_CTX	4096	Tamaño de la ventana de contexto (tokens)
API_HOST	0.0.0.0	Dirección de enlace
API_PORT	4891	Puerto para el servidor API

Configuración con Docker Compose

# /workspace/gpt4all-server/docker-compose.yml
version: '3.8'

services:
  gpt4all-server:
    build: .
    container_name: gpt4all-server
    restart: unless-stopped
    ports:
      - "4891:4891"
    volumes:
      - /workspace/models:/models
      - ./server.py:/app/server.py
    environment:
      - MODEL_NAME=mistral-7b-instruct-v0.1.Q4_0.gguf
      - MODEL_PATH=/models
      - DEVICE=gpu
      - N_CTX=4096
      - API_PORT=4891
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:4891/health"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 120s

docker compose up -d
docker compose logs -f

---

Aceleración GPU

Verificación del uso de GPU

La biblioteca de Python GPT4All usa llama.cpp internamente con soporte CUDA:

# Comprueba el uso de VRAM de la GPU después de cargar el modelo
watch -n 2 nvidia-smi

# Comprueba dentro del contenedor que CUDA esté disponible
docker exec gpt4all-server python3 -c "
from gpt4all import GPT4All
devices = GPT4All.list_gpus()
print('GPUs disponibles:', devices)
"

Selección de capas GPU

El gpu_layers (o n_gpu_layers) controla cuánto del modelo se ejecuta en la GPU frente a la CPU:

# En server.py — fuerza todas las capas a la GPU
model = GPT4All(
    model_name=MODEL_NAME,
    model_path=MODEL_PATH,
    device="gpu",
    n_ctx=N_CTX,
    # Parámetros adicionales de llama.cpp pasados a través de:
    # n_gpu_layers=99  # Todas las capas en la GPU
)

# Reconstruye y reinicia con el máximo de capas GPU
docker stop gpt4all-server && docker rm gpt4all-server
docker run -d \\
  --name gpt4all-server \\
  --gpus all \\
  -p 4891:4891 \\
  -v /workspace/models:/models \\
  -e DEVICE=gpu \\
  -e MODEL_NAME=mistral-7b-instruct-v0.1.Q4_0.gguf \\
  gpt4all-server:latest

Modo de respaldo de CPU

Si no hay ninguna GPU disponible (p. ej., servidor Clore.ai solo con CPU para pruebas):

docker run -d \\
  --name gpt4all-server-cpu \\
  -p 4891:4891 \\
  -v /workspace/models:/models \\
  -e DEVICE=cpu \\
  -e MODEL_NAME=Phi-3-mini-4k-instruct.Q4_0.gguf \\
  gpt4all-server:latest

⚠️ La inferencia en CPU es 10–50× más lenta que en GPU. Para servidores solo con CPU, usa modelos pequeños (Phi-3 Mini, TinyLlama) y espera 2–5 tokens/seg.

---

Consejos y mejores prácticas

📥 Predescarga de modelos

En lugar de depender de la descarga automática al iniciar, predescarga los modelos para reinicios más rápidos:

# Descarga modelos populares de GPT4All
mkdir -p /workspace/models

# Mistral 7B (el más popular, buena calidad)
wget -q -O /workspace/models/mistral-7b-instruct-v0.1.Q4_0.gguf \\
  "https://gpt4all.io/models/gguf/mistral-7b-instruct-v0.1.Q4_0.gguf"

# Phi-3 Mini (el más rápido, el más pequeño)
wget -q -O /workspace/models/Phi-3-mini-4k-instruct.Q4_0.gguf \\
  "https://gpt4all.io/models/gguf/Phi-3-mini-4k-instruct.Q4_0.gguf"

# Llama 3 (la mejor calidad en el rango de 8B)
wget -q -O /workspace/models/Meta-Llama-3-8B-Instruct.Q4_0.gguf \\
  "https://gpt4all.io/models/gguf/Meta-Llama-3-8B-Instruct.Q4_0.gguf"

ls -lh /workspace/models/

🔌 Uso con aplicaciones Python

# Uso directo de Python (sin la API de Docker)
from gpt4all import GPT4All

model = GPT4All(
    model_name="mistral-7b-instruct-v0.1.Q4_0.gguf",
    model_path="/workspace/models",
    device="gpu"
)

# Generación simple
with model.chat_session():
    response = model.generate("Explica la computación en GPU en términos simples", max_tokens=200)
    print(response)

# Usando el servidor API con un cliente OpenAI
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:4891/v1",
    api_key="no necesario"
)

completion = client.chat.completions.create(
    model="mistral-7b-instruct-v0.1.Q4_0.gguf",
    messages=[{"role": "user", "content": "Hello!"}]
)
print(completion.choices[0].message.content)

💰 Optimización de costos en Clore.ai

# RTX 3090 @ $0.07–0.21/h — úsala para modelos de 7B (la mejor relación calidad-precio)
# Rendimiento esperado: ~40 tokens/seg para Mistral 7B Q4
# Costo por 1M tokens generados: ~$0.005 (extremadamente barato frente a OpenAI)

# RTX 4090 @ $0.14–0.42/h — úsala para modelos de 13B o cuando la velocidad importe
# Rendimiento esperado: ~60 tokens/seg para Mistral 7B Q4

# Para procesamiento por lotes: carga el modelo previamente, procesa todos los prompts y apaga
docker run --rm \\
  --gpus all \\
  -v /workspace/models:/models \\
  -v /workspace/prompts:/prompts \\
  gpt4all-server:latest \\
  python3 -c "
from gpt4all import GPT4All
import json

model = GPT4All('mistral-7b-instruct-v0.1.Q4_0.gguf', '/models', device='gpu')
prompts = open('/prompts/batch.txt').readlines()
results = []
for p in prompts:
    with model.chat_session():
        results.append(model.generate(p.strip(), max_tokens=256))
json.dump(results, open('/prompts/results.json', 'w'))
print(f'Procesados {len(results)} prompts')
"

---

Solución de problemas

El modelo no se carga — archivo no encontrado

# Verifica que el archivo del modelo exista y tenga el nombre correcto
ls -lh /workspace/models/
docker exec gpt4all-server ls /models/

# GPT4All distingue mayúsculas y minúsculas en los nombres de modelo
# Usa el nombre exacto del archivo de la salida de ls como MODEL_NAME
docker stop gpt4all-server && docker rm gpt4all-server
docker run -d --gpus all -p 4891:4891 \\
  -v /workspace/models:/models \\
  -e MODEL_NAME=mistral-7b-instruct-v0.1.Q4_0.gguf \\
  gpt4all-server:latest

Error de CUDA: no hay imagen de kernel para esta arquitectura

# Es posible que tu GPU no sea compatible con la versión de CUDA
# Comprueba la capacidad de cómputo de la GPU
nvidia-smi --query-gpu=compute_cap --format=csv,noheader

# Si es < 6.0, usa el modo CPU
docker run -d --gpus all -p 4891:4891 \\
  -v /workspace/models:/models \\
  -e DEVICE=cpu \\
  -e MODEL_NAME=Phi-3-mini-4k-instruct.Q4_0.gguf \\
  gpt4all-server:latest

La API devuelve 503 — el modelo no está cargado

# Revisa los registros de inicio
docker logs gpt4all-server | head -50

# La carga del modelo puede tardar entre 30 y 120 segundos
# Espera y vuelve a intentar:
sleep 60 && curl http://localhost:4891/health

# Comprueba si el archivo del modelo está corrupto
python3 -c "
from gpt4all import GPT4All
m = GPT4All('mistral-7b-instruct-v0.1.Q4_0.gguf', '/workspace/models')
print('Modelo OK:', m)
"

El puerto 4891 no es accesible desde fuera

# Verifica el enlace del puerto
docker ps | grep 4891
# Debería mostrar: 0.0.0.0:4891->4891/tcp

# Comprueba si Clore.ai tiene reglas de firewall
# En la configuración del servidor de Clore.ai, asegúrate de que el puerto 4891 esté listado como abierto

# Prueba internamente:
curl http://127.0.0.1:4891/health

# Nota: Clore.ai asigna los puertos aleatoriamente — usa el puerto que se muestre en el panel de control de tu servidor

---

Lecturas adicionales

• GitHub de GPT4All — Repositorio principal

• Documentación de GPT4All en Python — Referencia de la API de Python

• Explorador de modelos de GPT4All — Examina los modelos disponibles

• Documentación de LocalAI — Alternativa amigable con Docker

• Ollama en Clore.ai — Implementación de LLM en Docker más fácil

• vLLM en Clore.ai — Servidor de inferencia para producción

• Guía de comparación de GPU — Elige la GPU adecuada de Clore.ai

• TheBloke en HuggingFace — Miles de cuantizaciones GGUF

• Formato GGUF explicado — Documentación del formato del modelo

💡 Recomendación: Si quieres la implementación Docker más sencilla para LLM locales, considera Ollama en su lugar — tiene una imagen oficial de Docker, compatibilidad integrada con GPU y está diseñado específicamente para la implementación del lado del servidor. La fortaleza de GPT4All es su hermosa interfaz de escritorio y las funciones de LocalDocs (RAG), que no están disponibles en el modo servidor.