# LLM local GPT4All

## Resumen

[GPT4All](https://github.com/nomic-ai/gpt4all) de Nomic AI es uno de los proyectos de LLM locales 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 más conocido por su pulida aplicación de escritorio, pero también incluye una **biblioteca de Python** (`paquete gpt4all` y un **servidor API compatible con OpenAI** ejecutándose 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 Docker oficial para el componente servidor. Esta guía utiliza una configuración Docker personalizada con el `paquete gpt4all` paquete de Python. Para una alternativa Docker más lista para producción que ejecute los **mismos archivos de modelo GGUF**, consulta la [sección alternativa de LocalAI](#alternative-localai-docker-image) — LocalAI está orientado a Docker y admite el formato de modelo idéntico.

**Características clave:**

* 🔒 100% sin conexión — toda la inferencia se ejecuta localmente
* 🤖 API REST compatible con OpenAI (puerto 4891)
* 📚 LocalDocs — RAG sobre tus propios documentos
* 🧩 Compatible con todos los formatos GGUF populares
* 🐍 API completa en 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**       | Ninguna       | —     | 16 GB | 50 GB SSD      | \~$0.02/h (servidor CPU) |
| **GPU de entrada** | RTX 3060 12GB | 12 GB | 16 GB | 50 GB SSD      | \~$0.10/h                |
| **Recomendado**    | RTX 3090      | 24 GB | 32 GB | 100 GB SSD     | \~$0.20/h                |
| **Gama alta**      | RTX 4090      | 24 GB | 64 GB | 200 GB SSD     | \~$0.35/h                |

> **Nota:** El soporte GPU de GPT4All utiliza CUDA vía llama.cpp internamente. A diferencia de vLLM, **soportan** requiere una capacidad de cómputo CUDA específica — las 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](https://clore.ai)
2. Filtrar: **Docker habilitado**, **GPU**: RTX 3090 (para modelos 7B–13B)
3. Desplegar con la imagen: `nvidia/cuda:12.1.0-runtime-ubuntu22.04`
4. Puertos abiertos: **4891** (API de GPT4All), **22** (SSH)
5. Asigna al menos **50 GB** de espacio en disco

### Paso 2 — Conectar vía SSH

```bash
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 — Construir la imagen Docker de GPT4All

Dado que no existe una imagen Docker oficial de GPT4All, construiremos una:

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

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

ENV DEBIAN_FRONTEND=noninteractive
ENV PYTHONUNBUFFERED=1

# Instalar 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/*

# Hacer de python3.11 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

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

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

WORKDIR /app

# Copiar script del servidor (se montará o incorporará)
COPY server.py .

EXPOSE 4891

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

### Paso 4 — Crear el script del servidor API

```bash
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="GPT4All API Server", 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 el hub de GPT4All si no está presente
        verbose=True
    )
    print("¡Modelo cargado con éxito!")

# --- 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")

    # Formatear mensajes en un único prompt
    prompt_parts = []
    for msg in request.messages:
        if msg.role == "system":
            prompt_parts.append(f"### System:\n{msg.content}")
        elif msg.role == "user":
            prompt_parts.append(f"### Human:\n{msg.content}")
        elif msg.role == "assistant":
            prompt_parts.append(f"### Assistant:\n{msg.content}")
    prompt_parts.append("### Assistant:")
    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

```bash
cd /workspace/gpt4all-server

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

# Descargar un modelo primero (opcional — el servidor también puede auto-descargar)
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

# Ejecutar 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

# Seguir los logs
docker logs -f gpt4all-server
```

### Paso 6 — Probar la API

```bash
# Comprobación de estado
curl http://localhost:4891/health

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

# Completado 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:

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

# Crear directorio de modelos y descargar 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

# Crear configuración del modelo
cat > /workspace/localai-models/mistral-7b.yaml << 'EOF'
name: mistral-7b
parameters:
  model: mistral-7b.gguf
  temperature: 0.7
  top_p: 0.95
  top_k: 40
  max_tokens: 2048
context_size: 4096
f16: true
gpu_layers: 35
threads: 8
EOF

# Ejecutar 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

# Probar LocalAI (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": "¡Hola!"}]
  }'
```

***

## Configuración

### Variables de entorno para el servidor GPT4All

| Variable     | Valor por defecto        | Descripción                                                |
| ------------ | ------------------------ | ---------------------------------------------------------- |
| `MODEL_NAME` | `mistral-7b-instruct...` | Nombre de archivo del modelo o nombre en el hub de GPT4All |
| `MODEL_PATH` | `/models`                | Directorio que contiene los archivos del 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 de Docker Compose

```yaml
# /workspace/gpt4all-server/docker-compose.yml
versión: '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"]
      intervalo: 30s
      tiempo de espera: 10s
      reintentos: 3
      periodo de inicio: 120s
```

```bash
docker compose up -d
docker compose logs -f
```

***

## Aceleración por GPU

### Verificando el uso de la GPU

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

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

# Comprobar 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)
"
```

### Seleccionando capas de GPU

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

```python
# En server.py — forzar todas las capas a 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 GPU
)
```

```bash
# Reconstruir y reiniciar 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 reserva a CPU

Si no hay GPU disponible (por ejemplo, servidor Clore.ai solo con CPU para pruebas):

```bash
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

### 📥 Pre-descarga de modelos

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

```bash
# Descargar modelos populares de GPT4All
mkdir -p /workspace/models

# Mistral 7B (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 (más rápido, 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 (mejor calidad en la gama 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

```python
# Uso directo en Python (sin la API 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 con 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-necesaria"
)

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

### 💰 Optimización de costes en Clore.ai

```bash
# RTX 3090 @ $0.20/h — usar para modelos 7B (mejor relación calidad/precio)
# Rendimiento esperado: ~40 tokens/seg para Mistral 7B Q4
# Coste por 1M de tokens generados: ~$0.005 (extremadamente barato frente a OpenAI)

# RTX 4090 @ $0.35/h — usar para modelos 13B o cuando la velocidad importe
# Rendimiento esperado: ~60 tokens/seg para Mistral 7B Q4

# Para procesamiento por lotes: precargar el modelo, procesar todos los prompts y apagar
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 carga — archivo no encontrado

```bash
# Comprueba que el archivo del modelo existe y tiene el nombre correcto
ls -lh /workspace/models/
docker exec gpt4all-server ls /models/

# GPT4All distingue mayúsculas y minúsculas en los nombres de los modelos
# Usa el nombre de archivo exacto mostrado por 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

```bash
# Tu GPU puede no ser 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 — modelo no cargado

```bash
# Comprueba los logs de inicio
docker logs gpt4all-server | head -50

# La carga del modelo puede tardar 30–120 segundos
# Espera y reintenta:
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)
"
```

### Puerto 4891 no accesible desde el exterior

```bash
# 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 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 mapea puertos aleatoriamente — usa el puerto mostrado en el panel de tu servidor
```

***

## Lecturas adicionales

* [GitHub de GPT4All](https://github.com/nomic-ai/gpt4all) — Repositorio principal
* [Documentación Python de GPT4All](https://docs.gpt4all.io/) — Referencia de la API en Python
* [Explorador de modelos de GPT4All](https://gpt4all.io/models/gguf/) — Explorar modelos disponibles
* [Documentación de LocalAI](https://localai.io/) — Alternativa amigable con Docker
* [Ollama en Clore.ai](/guides/guides_v2-es/modelos-de-lenguaje/ollama.md) — Despliegue de LLM en Docker más sencillo
* [vLLM en Clore.ai](/guides/guides_v2-es/modelos-de-lenguaje/vllm.md) — Servidor de inferencia para producción
* [Guía de comparación de GPU](/guides/guides_v2-es/primeros-pasos/gpu-comparison.md) — Elige la GPU Clore.ai adecuada
* [TheBloke en HuggingFace](https://huggingface.co/TheBloke) — Miles de cuantizaciones GGUF
* [Formato GGUF explicado](https://github.com/ggerganov/ggml/blob/master/docs/gguf.md) — Documentación del formato de modelo

> 💡 **Recomendación:** Si quieres el despliegue Docker más sencillo para LLMs locales, considera [Ollama](/guides/guides_v2-es/modelos-de-lenguaje/ollama.md) en su lugar — tiene una imagen Docker oficial, soporte GPU incorporado y está específicamente diseñado para despliegue en servidor. La fortaleza de GPT4All es su hermosa UI de escritorio y las funciones LocalDocs (RAG), que no están disponibles en modo servidor.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-es/plataformas-y-agentes-de-ia/gpt4all.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.