Montar un entorno de desarrollo con IA totalmente local ya no es un experimento: es una opción viable, rápida y privada. En esta guía instalas y conectas Ollama, llama.cpp y Continue.dev para programar con modelos abiertos sin enviar tu código a servidores externos.

Por qué un entorno local en 2026

• Privacidad real: tu código y tus datos nunca salen de tu máquina.
• Coste cero: sin límites de tokens, sin suscripciones, sin facturas sorpresa.
• Control total: eliges el modelo, la cuantización, el contexto y los parámetros de inferencia.
• Offline-first: funciona sin conexión, ideal para viajes, entornos aislados o políticas de seguridad estrictas.

El hardware necesario es modesto: una GPU NVIDIA con 8–12 GB VRAM (RTX 3060 12 GB, 4060 Ti 16 GB) o 16–32 GB de RAM del sistema si usas solo CPU. Para modelos grandes (30B+), 24 GB VRAM o 64 GB RAM son cómodos.

1. Ollama: servidor de modelos local

Ollama gestiona la descarga, cuantización y servicio de modelos GGUF con una API compatible con OpenAI.

Instalación

Linux / WSL:

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

Windows: descarga el instalador desde ollama.com/download.

macOS: brew install ollama o el .pkg oficial.

Arranque y verificación

ollama serve
# En otra terminal:
ollama list
ollama run qwen2.5-coder:7b "escribe una función quicksort en Python"

Modelos recomendados para código (octubre 2026)

Consejo: usa cuantizaciones Q4_K_M o Q5_K_M para mejor equilibrio calidad/VRAM. Q8_0 solo si te sobra memoria.

2. llama.cpp: inferencia ligera y control total

Si quieres control fino (parámetros de sampling, grammars, especulación, batch processing), llama.cpp es la base.

Compilación rápida (Linux/WSL)

git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
make LLAMA_CUBLAS=1   # GPU NVIDIA
# o: make LLAMA_METAL=1  # macOS Apple Silicon
# o: make                # solo CPU

Descargar modelo GGUF (ej. Qwen2.5-Coder-14B-Q4_K_M)

# Desde Hugging Face con huggingface-cli
huggingface-cli download bartowski/Qwen2.5-Coder-14B-GGUF \
  Qwen2.5-Coder-14B-Q4_K_M.gguf \
  --local-dir ./models

Servidor estilo OpenAI

./server -m models/Qwen2.5-Coder-14B-Q4_K_M.gguf \
  --host 0.0.0.0 --port 8080 \
  --ctx-size 32768 --batch-size 512 \
  --ubatch-size 512 --flash-attn

Endpoints disponibles:

• http://localhost:8080/v1/chat/completions
• http://localhost:8080/v1/completions
• http://localhost:8080/v1/models

3. Continue.dev: asistente de código en tu IDE

Continue es la extensión open source que conecta tu editor (VS Code, JetBrains) con cualquier endpoint compatible OpenAI — local o remoto.

Instalación

• VS Code: marketplace "Continue"
• JetBrains: plugin "Continue" desde el marketplace

Configuración ~/.continue/config.json

{
  "models": [
    {
      "title": "Qwen2.5-Coder-14B (Ollama)",
      "provider": "ollama",
      "model": "qwen2.5-coder:14b",
      "apiBase": "http://localhost:11434"
    },
    {
      "title": "Qwen2.5-Coder-14B (llama.cpp)",
      "provider": "openai",
      "model": "Qwen2.5-Coder-14B-Q4_K_M",
      "apiBase": "http://localhost:8080/v1",
      "apiKey": "dummy"
    }
  ],
  "tabAutocompleteModel": {
    "title": "Qwen2.5-Coder-7B (rápido)",
    "provider": "ollama",
    "model": "qwen2.5-coder:7b",
    "apiBase": "http://localhost:11434"
  },
  "contextProviders": [
    { "name": "code" },
    { "name": "docs" },
    { "name": "diff" },
    { "name": "terminal" },
    { "name": "problems" }
  ],
  "slashCommands": [
    { "name": "edit", "description": "Editar selección" },
    { "name": "comment", "description": "Comentar código" },
    { "name": "test", "description": "Generar tests" },
    { "name": "explain", "description": "Explicar selección" }
  ]
}

Flujo de trabajo diario

1. Chat lateral (Ctrl+L): preguntas, arquitectura, debugging.
2. Edición inline (Ctrl+I): selecciona código → pide cambios.
3. Autocompletado: tabulador para sugerencias en tiempo real (usa el modelo pequeño).
4. Comandos slash: /edit, /test, /explain sobre selección.
5. Contexto automático: Continue inyecta archivos abiertos, diffs, errores del terminal y documentación.

4. Unificar todo con un proxy local (opcional)

Si quieres un único endpoint que rote entre Ollama y llama.cpp, usa LiteLLM o Open WebUI como puerta de enlace.

LiteLLM en Docker (configuración mínima)

# docker-compose.yml
services:
  litellm:
    image: ghcr.io/berriai/litellm:main-latest
    ports:
      - "4000:4000"
    environment:
      - OLLAMA_API_BASE=http://host.docker.internal:11434
    command: ["--config", "/app/config.yaml"]
    volumes:
      - ./config.yaml:/app/config.yaml

config.yaml:

model_list:
  - model_name: qwen2.5-coder-14b
    litellm_params:
      model: ollama/qwen2.5-coder:14b
      api_base: http://host.docker.internal:11434
  - model_name: qwen2.5-coder-7b-fast
    litellm_params:
      model: ollama/qwen2.5-coder:7b
      api_base: http://host.docker.internal:11434

Ahora Continue (o cualquier cliente OpenAI) apunta a http://localhost:4000/v1 y tienes balanceo, logging y claves virtuales.

5. Benchmark rápido: elige tu modelo

Ejecuta este prompt en cada candidato y mide latencia y calidad:

Prompt: "Escribe una clase Python AsyncCache con TTL, invalidación por clave y soporte para async with. Incluye type hints, docstrings y un test con pytest."

Regla práctica: para autocompletado usa 7B; para chat/edición usa 14B–22B; para arquitectura difícil, 32B si cabe.

6. Trucos de productividad

Prompts de sistema reutilizables (guárdalos en Continue → Custom Prompts)

## system:code-reviewer
Eres un senior engineer. Revisa el código seleccionado buscando: bugs, rendimiento, seguridad, legibilidad, tests. Devuelve lista numerada con severidad (alta/media/baja) y sugerencia concreta.

## system:refactor
Refactoriza la selección aplicando: principios SOLID, nombres descriptivos, eliminar duplicación, extraer funciones puras. Mantén la API pública. Explica los cambios.

## system:test-gen
Genera tests pytest completos para la selección. Cubre: happy path, edge cases, errores esperados. Usa fixtures y parametrize. Mock dependencias externas.

Context providers útiles

• @codebase: indexa todo el repo (usa embeddings locales con sentence-transformers).
• @terminal: pega el output del último comando fallido y pide fix.
• @problems: lista errores del linter/TS y pide corrección en lote.

Git integration

# Pre-commit hook que pasa el diff a Continue para revisión rápida
cat .git/hooks/pre-commit
#!/bin/bash
git diff --cached | continue --stdin --prompt "Revisa este diff en busca de bugs o malas prácticas. Sé conciso."

7. Mantenimiento y actualizaciones

Limpieza de modelos antiguos

ollama list
ollama rm modelo-antiguo:tag
# O borra directamente ~/.ollama/models/blobs/...

8. Solución de problemas comunes

9. Próximos pasos

• RAG local: indexa tu código con chromadb + sentence-transformers y usa @codebase en Continue.
• Agentes locales: prueba AutoGen, CrewAI o LangGraph con modelos locales vía Ollama/llama.cpp.
• Fine-tuning: unsloth + LoRA en tu GPU para especializar un modelo en tu código base.
• Multi-GPU: llama.cpp soporta tensor parallelism (--tensor-split) si tienes dos GPUs.

Resumen: tu stack local en 3 comandos

# 1. Servidor de modelos
ollama serve &

# 2. (Opcional) llama.cpp para control total
cd llama.cpp && ./server -m models/tu-modelo.gguf --port 8080 &

# 3. Abre tu IDE con Continue instalado → config.json listo → programa en privado

Ya tienes un asistente de código potente, privado y gratuito corriendo en tu máquina. La única dependencia externa es la descarga inicial de los pesos; después, todo es tuyo.

¿Tienes dudas sobre algún paso? ¿Quieres comparar modelos concretos para tu GPU? Deja un comentario y lo vemos juntos.