¿Cómo instalar ChatGPT localmente? Tutorial rápido

5 de septiembre de 2025 por

Dafktech

| Todavía no hay comentarios

Spoiler honesto: no puedes instalar ChatGPT (GPT-4/4o de OpenAI) localmente. Es un servicio en la nube.

Buenas noticias: sí puedes correr modelos open-source estilo ChatGPT (Llama, Mistral, Qwen, Phi-3…) en tu PC con WSL2 (Ubuntu), API local y UI web. Aquí te dejo dos rutas:

Opción A (recomendada): Ollama + Open WebUI → rápido, estable, con interfaz bonita.
Opción B (a tu medida): Flask + Transformers → control total sobre la API.

Iremos al grano y con comandos listos para copiar/pegar.

Requisitos

Windows 11 con WSL2 (Ubuntu).
Internet solo para la primera descarga de modelos.
(Opcional) GPU NVIDIA para acelerar 5-10×.
8–16 GB de RAM (más es mejor), 10–20 GB libres en disco para modelos.

Antes de empezar: WSL2 y GPU en orden

0) Instalar/activar WSL2 (una vez)

En PowerShell (Administrador):

wsl --install -d Ubuntu

Reinicia si te lo pide y abre Ubuntu.

1) Driver NVIDIA en Windows ✅

Instala el driver oficial NVIDIA (compatible con WSL).

Si ya ves tu GPU en Windows, perfecto.

2) Habilitar GPU dentro de WSL (muy importante)

En Ubuntu (WSL):

sudo apt update
sudo apt install -y nvidia-utils-535  # binarios Linux (incluye nvidia-smi)
# (Opcional) CUDA Toolkit si vas a compilar o usar librerías CUDA:
sudo apt install -y nvidia-cuda-toolkit

Reinicia WSL desde Windows:

wsl --shutdown

Vuelve a abrir Ubuntu y prueba:

nvidia-smi

Si ves tu RTX y drivers, ya tienes GPU en WSL.

(Si no, revisa que tu distro sea versión 2: wsl --list --verbose → debe decir “2”).

Opción A (recomendada) — Ollama + Open WebUI en 10–15 min

Por qué: instala modelos con un comando, trae API local y una UI web. Funciona con CPU o GPU.

A1) Instalar Ollama

En Ubuntu (WSL):

curl -fsSL https://ollama.com/install.sh | sh
ollama serve

Déjalo corriendo o ábrelo en otra pestaña cuando lo necesites.

A2) Descargar un modelo (es/en)

# Buen equilibrio calidad/tamaño:
ollama pull llama3.1:8b

# Alternativas:
# ollama pull mistral:7b
# ollama pull qwen2.5:7b-instruct
# ollama pull phi3:3.8b  # muy ligero

A3) Probar por consola

ollama run llama3.1:8b
# Escribe tu prompt y listo.

A4) (Opcional) UI web: Open WebUI con Docker

Instala Docker Desktop (con integración WSL ON) y corre:

docker run -d --name open-webui -p 3000:8080 \
  -e OLLAMA_BASE_URL=http://host.docker.internal:11434 \
  --add-host=host.docker.internal:host-gateway \
  ghcr.io/open-webui/open-webui:latest

Abre: http://localhost:3000

A5) API local “tipo ChatGPT”

Endpoint de texto: http://localhost:11434/api/generate

Ejemplo (curl):

curl -X POST http://localhost:11434/api/generate \
  -H "Content-Type: application/json" \
  -d '{"model":"llama3.1:8b","prompt":"Explica CI/CD en 3 bullets"}'

Ejemplo (Python):

import requests, json
resp = requests.post("http://localhost:11434/api/generate",
    headers={"Content-Type":"application/json"},
    data=json.dumps({"model":"llama3.1:8b","prompt":"Un haiku sobre DevOps"}))
print(resp.text)

A6) (Opcional PRO) docker-compose para levantar UI con un comando

Mantengo Ollama nativo en WSL (mejor compatibilidad con GPU) y solo Open WebUI en contenedor.

docker-compose.yml:

services:
  open-webui:
    image: ghcr.io/open-webui/open-webui:latest
    container_name: open-webui
    restart: unless-stopped
    ports:
      - "3000:8080"
    environment:
      - OLLAMA_BASE_URL=http://host.docker.internal:11434
    extra_hosts:
      - "host.docker.internal:host-gateway"

Lanza todo:

docker compose up -d

Opción B — Tu propia API con Flask + Transformers (100% local)

Para: control total, microservicios, prompts/guardrails propios.

B1) Entorno Python en WSL

sudo apt update && sudo apt upgrade -y
sudo apt install -y python3-venv git
python3 -m venv .venv
source .venv/bin/activate
python -m pip install --upgrade pip

B2) Instalar PyTorch (elige CPU o GPU)

# GPU (CUDA 12.1 — habitual en WSL con RTX):
pip install torch --index-url https://download.pytorch.org/whl/cu121

# (Si NO tienes GPU)
# pip install torch --index-url https://download.pytorch.org/whl/cpu

B3) Dependencias

pip install "transformers>=4.43" "accelerate>=0.30" flask sentencepiece einops
# Opcional: cuantización 8/4 bits en Linux
pip install bitsandbytes

B4) Modelos recomendados

Solo CPU / laptop: microsoft/Phi-3-mini-4k-instruct (ligero y decente).
GPU 8–12 GB: Qwen/Qwen2.5-7B-Instruct o mistralai/Mistral-7B-Instruct-v0.3.

Algunos modelos requieren aceptar licencia en Hugging Face.

B5) Código app.py (limpio y funcional)

from flask import Flask, request, jsonify
import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

# ---- CONFIG ----
MODEL_ID = "microsoft/Phi-3-mini-4k-instruct"
device = "cuda" if torch.cuda.is_available() else "cpu"

tokenizer = AutoTokenizer.from_pretrained(MODEL_ID, use_fast=True)
model = AutoModelForCausalLM.from_pretrained(
    MODEL_ID,
    torch_dtype=torch.float16 if device == "cuda" else torch.float32,
    device_map="auto" if device == "cuda" else None
)
if device != "cuda":
    model = model.to(device)

app = Flask(__name__)

def system_wrap(user_prompt: str) -> str:
    system = "Eres un asistente útil, conciso y preciso. Responde en español si no se indica lo contrario."
    return f"<|system|>\n{system}\n<|user|>\n{user_prompt}\n<|assistant|>\n"

@app.route("/health", methods=["GET"])
def health():
    return jsonify({"ok": True, "device": device, "model": MODEL_ID, "cuda": torch.cuda.is_available()})

@app.route("/generate", methods=["POST"])
def generate():
    data = request.get_json(force=True)
    prompt = data.get("prompt", "")
    max_new_tokens = int(data.get("max_new_tokens", 200))
    temperature = float(data.get("temperature", 0.7))
    top_p = float(data.get("top_p", 0.9))

    full_prompt = system_wrap(prompt)
    inputs = tokenizer(full_prompt, return_tensors="pt").to(model.device)

    with torch.no_grad():
        outputs = model.generate(
            **inputs,
            max_new_tokens=max_new_tokens,
            do_sample=True,
            temperature=temperature,
            top_p=top_p,
            pad_token_id=tokenizer.eos_token_id,
            eos_token_id=tokenizer.eos_token_id,
        )

    text = tokenizer.decode(outputs[0], skip_special_tokens=True)
    if "<|assistant|>" in text:
        text = text.split("<|assistant|>")[-1].strip()

    return jsonify({"response": text})

if __name__ == "__main__":
    # Accesible desde Windows en http://localhost:5000
    app.run(host="0.0.0.0", port=5000)

B6) Ejecuta y prueba

python app.py

En otra terminal:

curl -X POST http://localhost:5000/generate \
  -H "Content-Type: application/json" \
  -d '{"prompt":"Escribe un haiku sobre DevOps en español"}'

Cliente Python de ejemplo:

import requests
r = requests.post("http://localhost:5000/generate",
                  json={"prompt":"Explica CI/CD en 3 bullets","max_new_tokens":120})
print(r.json()["response"])

B7) (Opcional) Producción simple

pip install gunicorn
gunicorn -w 1 -b 0.0.0.0:5000 app:app

En WSL, el auto-start cómodo es con Task Scheduler de Windows ejecutando:
wsl.exe -d Ubuntu -e sh -lc "cd /ruta && source .venv/bin/activate && gunicorn -w 1 -b 0.0.0.0:5000 app:app"

Rendimiento, privacidad y costes

Privacidad total: todo corre local.
GPU NVIDIA: 5–10× más rápido.
CPU: usa modelos pequeños (Phi-3 mini).
Cuantización (bitsandbytes): baja RAM/VRAM a cambio de algo de calidad.
Coste: evitas pagar por tokens; el coste es tu hardware y energía.

Troubleshooting exprés (lo que realmente pasa)

nvidia-smi: command not found en WSL → te faltan binarios Linux:

sudo apt install -y nvidia-utils-535
wsl --shutdown  # desde Windows PowerShell

WSL sin GPU → verifica versión:

wsl --list --verbose   # debe decir "2"

“Me quedé sin memoria” → cambia a un modelo más pequeño o usa cuantizado.
Open WebUI no conecta → revisa variable:
- OLLAMA_BASE_URL=http://host.docker.internal:11434
Puertos ocupados → cambia 3000:8080 (UI) o 11434 (API Ollama).

Preguntas frecuentes

¿Puedo usar GPT-4 de OpenAI localmente/offline?

No. GPT-4/4o solo vía API o ChatGPT web.

¿Qué modelo elijo?

Laptop/CPU: microsoft/Phi-3-mini-4k-instruct
GPU 8–12GB: Qwen2.5-7B-Instruct o Mistral-7B-Instruct

¿Es gratis?

Los modelos open-source suelen ser gratuitos; revisa licencias. El coste real es tu hardware.

¿Necesito programar?

Ollama + Open WebUI: casi no.
Flask + Transformers: Python básico.

¿Con cuál me quedo?

Quieres algo usable ya con UI y API → Opción A (Ollama + Open WebUI).
Quieres control total para integrarlo en tus microservicios → Opción B (Flask + Transformers).

Bonus: “todo en uno” para la UI (compose)

Si prefieres levantar solo la UI con un comando (y dejar Ollama nativo en WSL):

docker-compose.yml:

services:
  open-webui:
    image: ghcr.io/open-webui/open-webui:latest
    container_name: open-webui
    restart: unless-stopped
    ports:
      - "3000:8080"
    environment:
      - OLLAMA_BASE_URL=http://host.docker.internal:11434
    extra_hosts:
      - "host.docker.internal:host-gateway"

Lanza:

docker compose up -d

Cierre (sin vueltas)

No instalas GPT-4 local, punto. Sí instalas modelos open-source con API y UI locales, privados, rápidos y personalizables.

Mi consejo: empieza con Ollama + Open WebUI; cuando necesites control fino de prompts, seguridad o flujos, salta a Flask + Transformers.

en DafkNews

Dafktech 5 de septiembre de 2025

Nuestros blogs

Archivo

Iniciar sesión dejar un comentario

Leer siguiente

Levantando n8n con docker en local como un PRO