Mejor stack de LLM local por caso de uso 2026: Escritura, Código, RAG, Agentes

Decisión rápida: stack por nivel de hardware (abril 2026)

1. 1
   Para 24 GB VRAM: `ollama pull llama3.3:70b` — calidad máxima, equiparable a GPT-4 (2023) en benchmarks de escritura.
2. 2
   Para 16 GB VRAM: `ollama pull mistral-small3.1` — contexto de 128K, mejor calidad por debajo de 24 GB.
3. 3
   Para 8 GB VRAM: `ollama pull llama3.2:8b` — buena calidad de escritura, rápido en hardware de consumo.
4. 4
   Instala OpenWebUI via Docker: `docker run -d -p 3000:8080 ghcr.io/open-webui/open-webui:latest`.
5. 5
   Configura la ventana de contexto (8K–32K tokens) en la configuración de OpenWebUI según la longitud del documento.

1. 1
   Instala vLLM: `pip install vllm`.
2. 2
   Inicia el servidor vLLM con Qwen2.5-Coder-7B: `python -m vllm.entrypoints.openai.api_server --model Qwen/Qwen2.5-Coder-7B-Instruct --port 8000`.
3. 3
   Para 16+ GB VRAM, usa el modelo 14B: `--model Qwen/Qwen2.5-Coder-14B-Instruct`.
4. 4
   Conecta la extensión IDE (VS Code Continue.dev, Cursor, etc.) a `http://localhost:8000/v1`.
5. 5
   Habilita el procesamiento por lotes para revisión de código: procesa 10 archivos en paralelo con una sola llamada API (`vllm` admite batch=10 por defecto).

# Review 10 files in parallel using vLLM batch processing
from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="not-needed")

code_files = [
    ("utils.py", open("utils.py").read()),
    ("models.py", open("models.py").read()),
    # ... up to 10 files
]

# vLLM processes all 10 in parallel (1 batch request)
reviews = []
for filename, code in code_files:
    prompt = f"Review this code for bugs, style, and performance:

{code}"
    response = client.chat.completions.create(
        model="Qwen2.5-Coder-7B-Instruct",
        messages=[{"role": "user", "content": prompt}],
        temperature=0.2,  # Deterministic for review tasks
    )
    reviews.append((filename, response.choices[0].message.content))

for filename, review in reviews:
    print(f"=== {filename} ===
{review}
")

1. 1
   Instala LlamaIndex (`pip install llama-index`).
2. 2
   Carga documentos (PDF, TXT, markdown) en LlamaIndex.
3. 3
   Divide los documentos en chunks (1024 tokens por defecto), genera embeddings con un modelo local u OpenAI (respaldo).
4. 4
   Almacena los embeddings en la vector DB Qdrant (se ejecuta localmente via Docker).
5. 5
   Consulta via LlamaIndex: recupera los top-K documentos similares y envía el contexto al LLM.
6. 6
   Envuelve en un endpoint FastAPI para UI web o integración con IDE.

1. 1
   Instala LangGraph (`pip install langchain langgraph`).
2. 2
   Define las herramientas (búsqueda web, calculadora, E/S de archivos) como firmas de funciones.
3. 3
   Crea el grafo del agente con el LLM como nodo de decisión y las herramientas como nodos de acción.
4. 4
   Usa el backend vLLM para llamadas LLM de baja latencia en bucles ajustados.
5. 5
   Ejecuta el bucle del agente: LLM → selección de herramienta → ejecución → repetir hasta completar.

1. 1
   Despliega vLLM con `--served-model-name model-name` en un puerto fijo.
2. 2
   Configura nginx para balancear la carga entre 2+ instancias de vLLM (una por GPU si tienes múltiples GPUs).
3. 3
   Usa el endpoint `/v1/chat/completions` compatible con OpenAI para compatibilidad con clientes.
4. 4
   Monitorea mediante el endpoint de scrape de Prometheus (vLLM exporta latencia de solicitudes y métricas de throughput).
5. 5
   Configura el rate limiting por usuario con el algoritmo token bucket.

1. 1
   Realiza fine-tuning con la librería `peft` (LoRA) para reducir el uso de VRAM.
2. 2
   Entrenamiento: se necesita 4× la VRAM del modelo (estado del optimizador, gradientes). Ejecuta por separado de la inferencia.
3. 3
   Exporta el adaptador LoRA a HuggingFace Hub o al sistema de archivos local.
4. 4
   Carga el modelo ajustado en Ollama: `ollama create mymodel -f Modelfile`.
5. 5
   O usa HuggingFace TRL (Transformers Reinforcement Learning) para RLHF.

1. 1
   Ollama: llama a `/api/generate` con `stream: true`. Los tokens llegan como JSON delimitado por saltos de línea.
2. 2
   vLLM: usa `/v1/chat/completions` con `stream: true`. Devuelve un stream SSE compatible con OpenAI.
3. 3
   Frontend: usa la API EventSource (JavaScript) para consumir el stream y actualizar la UI por token.
4. 4
   Deshabilita el procesamiento por lotes (batch=1) para la menor latencia posible.

Lectura relacionada

• Mejor asistente de código IA para LLM local — Elección de IDE para tu stack de código (Cursor, Continue.dev, Cody).
• Mejores LLM locales para código 2026 — Rankings HumanEval: Qwen2.5-Coder vs DeepSeek-Coder.
• Configuración RAG local 2026 — Guía completa de implementación con LlamaIndex + Qdrant + Ollama.
• Agentes LLM locales con LangGraph — Framework de workflows de agentes con ejemplos paso a paso.
• Ollama vs LM Studio — Comparativa de backends: CLI vs GUI, velocidad, procesamiento por lotes.
• Open WebUI vs SillyTavern — Comparativa de UI de chat: profesional vs roleplay.
• ¿Cuánta VRAM necesitan los LLM locales? — Requisitos de hardware por tamaño de modelo y caso de uso.

Errores comunes al elegir un stack de LLM

• Usar Ollama para API de producción sin vLLM: Ollama tiene un límite de <10 req/seg. Para producción con 10+ usuarios concurrentes, vLLM es obligatorio. Prueba el throughput bajo carga antes de desplegar.
• Ejecutar LangGraph sin backend vLLM: Los agentes de LangGraph realizan 10+ llamadas LLM secuenciales. Ollama introduce cuellos de botella de latencia. Combina siempre LangGraph con vLLM para tiempos de respuesta por debajo del segundo.
• Mezclar Ollama + vLLM en la misma GPU sin gestión de memoria: Ambas herramientas cargan pesos en la VRAM. Dos instancias de un modelo 70B consumen 32 GB. Usa GPUs separadas o cuantiza fuertemente (Q2) para que ambos quepan.
• Elegir la ventana de contexto incorrecta para escribir: El contexto por defecto de 4K limita las sesiones de brainstorming. Para escritura de texto largo, configura una ventana de 16K–32K tokens en OpenWebUI. Compromiso: inferencia más lenta (2–3× más lento por token).
• Asumir que todos los backends son igual de rápidos: vLLM y Ollama usan kernels diferentes. En el mismo hardware, vLLM es 2–3× más rápido para inferencia. La diferencia de velocidad está en el backend, no en el frontend (OpenWebUI, LM Studio son solo UIs).

Fuentes

• Ollama GitHub — Documentación oficial, especificación de la API de streaming y biblioteca de modelos.
• vLLM GitHub — Compatibilidad con la API de OpenAI, procesamiento por lotes y documentación de continuous batching.
• Informe técnico de Qwen2.5-Coder — Alibaba Qwen. Puntuación HumanEval del 82%, especializado en tareas de código. Licencia Apache 2.0.
• Documentación de LlamaIndex — Framework de indexación de documentos, chunking y recuperación RAG.
• Documentación de LangGraph — Framework de workflows de agentes, máquinas de estado, patrones de uso de herramientas.
• Documentación de Qdrant — Base de datos vectorial para almacenamiento local de embeddings, lista para Docker, Apache 2.0.
• Documentación de Continue.dev — Extensión IDE para VS Code y JetBrains usando backends LLM locales.