[IA] Cómo usar LLMs de forma local en tus equipos personales

[DeBilbao]

Para jugar en serio con modelos locales, la nueva arquitectura Blackwell de nVidia es una referencia en términos de potencia, y la RTX PRO 6000 es su versión para estaciones de trabajo, con 24.964 cores CUDA que entregan hasta 4.000 AI TOPS.

Viene equipada con 96GB de VRAM DDR7 con ECC y 1.792GB/s de ancho de banda, se conecta con un bus PCIe 5.0 x16 estándar y consume "solo" 600W.

NVIDIA RTX PRO 6000 Blackwell Workstation Edition

Experience Unparalleled AI and Graphics Performance.

www.nvidia.com

Eso sí, barata no es...

 

[DeBilbao]

Viendo la velocidad a la que avanza esto de la IA y cómo además de interactuar con un modelo a través de un chat, ahora podemos interactuar con un agente al que le damos instrucciones y acceso a herramientas, quizá sería indicado que le dedicáramos un hilo específico, porque su potencial es enorme.

Para quien no sepa de qué hablamos, en este vídeo de Apple para la comunidad de desarrolladores, nos lo cuentan de una forma muy fácil de entender. Está orientado al stack de Apple, pero la estructura es la misma sobre Linux o Windows.

​

Me gusta especialmente cómo visualiza el stack tecnológico en esta estructura de 4 capas, en la que por debajo estaría el hardware físico y por encima nosotros como usuarios.

Aunque esa visión está limitada al hardware de Apple, con equipos con arquitectura Apple Silicon que hablan a través de MLX con el hardware, a través de MLX-LM con el modelo, que se sirve mediante MLX-LM Server u otros a los agentes locales.

Le he mostrado ese esquema al modelo GPT-5.6 Terra y le he pedido que lo convierta en otro que sea más generalista, y me ha devuelto este, que tiene las mismas 4 capas a las que les hemos cambiado el nombre por su función y no por la tecnología que utilizan, que se detalla debajo de cada capa con distintas alternativas. A las 4 capas se le han añadido otras dos transversles.

Y para que veáis "lo simple del ecosistema", le he pedido:

¿Puedes crear una lista exhaustiva de las principales soluciones tecnológicas disponibles para cada una de las capas? Preséntalas en formato tabla, incluyendo 3 columnas que indiquen si están disponibles para macOS, Linux o Windows, y otras 2 columnas que muestren si están disponibles en formato local o Cloud.​

A continuación tienes un inventario amplio —no estrictamente finito, porque el ecosistema cambia rápido— organizado por las cuatro capas del stack y los dos planos transversales. Las marcas indican disponibilidad general; en algunos casos hay limitaciones por arquitectura, acelerador, edición o modo de despliegue.

Leyenda: ✓ disponible y soportado de forma habitual · ◐ disponible con restricciones, experimental o principalmente mediante contenedor/WSL · — no es un destino soportado habitual.

1. Hardware y backend​

Solución / backend	Papel principal	macOS	Linux	Windows	Local	Cloud
Apple Silicon + Metal	GPU y memoria unificada en Mac	✓	—	—	✓	◐
NVIDIA CUDA	Plataforma de cómputo GPU	—	✓	✓	✓	✓
NVIDIA TensorRT	Compilación y optimización de inferencia	—	✓	✓	✓	✓
NVIDIA TensorRT-LLM	Runtime optimizado para LLM en CUDA	—	✓	◐	✓	✓
AMD ROCm / HIP	Plataforma de cómputo GPU AMD	—	✓	◐	✓	✓
Intel oneAPI / SYCL	Backend para CPU, GPU Intel y aceleradores	◐	✓	✓	✓	✓
Intel OpenVINO	Optimización para CPU, GPU, NPU y iGPU Intel	✓	✓	✓	✓	✓
CPU x86-64	Inferencia CPU convencional	✓	✓	✓	✓	✓
CPU ARM64	Inferencia edge, Apple Silicon, ARM servers	✓	✓	◐	✓	✓
Vulkan	Backend gráfico/compute portable	✓	✓	✓	✓	◐
WebGPU	Inferencia en navegador o runtimes compatibles	✓	✓	✓	✓	✓
Google TPU	Aceleración especializada de Google	—	◐	—	—	✓
AWS Inferentia / Trainium	Aceleradores de AWS	—	◐	—	—	✓
AWS Neuron SDK	SDK para Inferentia y Trainium	—	✓	—	◐	✓
Intel Gaudi	Acelerador Habana/Intel para IA	—	✓	—	✓	✓
Huawei Ascend	NPU y stack CANN	◐	✓	◐	✓	✓

​

2. Runtime y motor de inferencia​

Esta capa carga y ejecuta pesos, aplica cuantización, mantiene el KV cache, tokeniza y despacha kernels contra el backend de cómputo. Los formatos no son intercambiables sin más: GGUF favorece llama.cpp; MLX corresponde al ecosistema Apple; y SafeTensors/Hugging Face es el formato dominante para PyTorch, vLLM, SGLang y TensorRT-LLM.

Solución	Backends / formatos habituales	macOS	Linux	Windows	Local	Cloud
MLX	Metal, Apple Silicon, MLX weights	✓	—	—	✓	◐
MLX-LM	MLX, modelos LLM/VLM optimizados para Apple	✓	—	—	✓	◐
llama.cpp	GGUF; CPU, Metal, CUDA, HIP, Vulkan, SYCL	✓	✓	✓	✓	✓
Ollama runtime	GGUF, MLX según plataforma; Metal/CUDA/ROCm/CPU	✓	✓	✓	✓	◐
LM Studio runtime	GGUF, MLX; Metal, CUDA, Vulkan/ROCm según versión	✓	◐	✓	✓	—
PyTorch + Transformers	SafeTensors, BF16, FP16, FP8; CUDA, ROCm, MPS, CPU	✓	✓	✓	✓	✓
vLLM engine	Hugging Face/SafeTensors, AWQ, GPTQ, FP8 y otros	◐	✓	◐	✓	✓
SGLang runtime	Hugging Face/SafeTensors, AWQ, GPTQ, FP8	◐	✓	◐	✓	✓
TensorRT-LLM	TensorRT engines, FP8, INT8, FP4/NVFP4	—	✓	◐	✓	✓
ONNX Runtime GenAI	ONNX; CPU, DirectML, CUDA, Core ML, ROCm	✓	✓	✓	✓	✓
OpenVINO GenAI	OpenVINO IR; CPU, iGPU/NPU Intel	✓	✓	✓	✓	✓
MLC LLM	TVM, CUDA, Metal, Vulkan, WebGPU	✓	✓	✓	✓	✓
ExLlamaV2 / ExLlamaV3	EXL2, CUDA, cuantización para NVIDIA	—	✓	◐	✓	◐
KTransformers	Pesos Hugging Face y offload híbrido CPU/GPU	◐	✓	◐	✓	◐
BitNet / bitnet.cpp	Modelos de muy baja precisión y CPU	✓	✓	✓	✓	◐
Candle	Runtime Rust, CPU/CUDA/Metal	✓	✓	✓	✓	✓
whisper.cpp	STT local, modelos Whisper cuantizados	✓	✓	✓	✓	✓
stable-diffusion.cpp	Generación visual local ligera	✓	✓	✓	✓	◐

Ollama, llama.cpp y LM Studio son los candidatos más transversales para un entorno de estación de trabajo: Ollama cubre macOS, Linux y Windows; llama.cpp puede compilarse contra Metal, CUDA, HIP, Vulkan y SYCL; LM Studio está centrado en escritorio y combina GUI con servidor local compatible con OpenAI.tensorfoundry+2

​

3. Serving y acceso por API​

Solución	Orientación	macOS	Linux	Windows	Local	Cloud
mlx_lm.server	Servidor OpenAI-compatible para MLX-LM	✓	—	—	✓	◐
Ollama API	Daemon local, REST y endpoints OpenAI-compatible	✓	✓	✓	✓	◐
LM Studio Developer / Local Server	Servidor local desde GUI o CLI	✓	◐	✓	✓	—
llama-server / llama.cpp server	Servidor HTTP ligero, OpenAI-compatible	✓	✓	✓	✓	✓
vLLM API Server	Alto rendimiento y concurrencia	◐	✓	◐	✓	✓
SGLang Server	Serving para alta concurrencia y agentes	◐	✓	◐	✓	✓
TensorRT-LLM Serve	Serving NVIDIA de baja latencia	—	✓	◐	✓	✓
NVIDIA Triton Inference Server	Serving multiprotocolo y multmodelo	—	✓	◐	✓	✓
Hugging Face TGI	Serving de modelos Hugging Face	◐	✓	◐	✓	✓
LocalAI	API local multimodal compatible con OpenAI	✓	✓	✓	✓	✓
LiteLLM Proxy	Gateway, routing, observabilidad y normalización API	✓	✓	✓	✓	✓
OpenRouter	Gateway/API de modelos de terceros	✓	✓	✓	—	✓
Together AI	Serving gestionado de modelos abiertos	✓	✓	✓	—	✓
GroqCloud	Serving gestionado de baja latencia	✓	✓	✓	—	✓
Fireworks AI	Serving gestionado y fine-tuning	✓	✓	✓	—	✓
Replicate	Inferencia gestionada por API	✓	✓	✓	—	✓
Hugging Face Inference Endpoints	Endpoints gestionados	✓	✓	✓	—	✓
Amazon Bedrock	Gateway gestionado de modelos en AWS	✓	✓	✓	—	✓
Azure AI Foundry / Model Inference	Gateway y catálogo de modelos Azure	✓	✓	✓	—	✓
Gemini Enterprise Agent Platform	Serving y catálogo de modelos en Google Cloud (antes Vertex AI)	✓	✓	✓	—	✓

Para un único usuario o un laboratorio doméstico, Ollama o LM Studio simplifican la operación. Para una máquina NVIDIA con varios usuarios concurrentes, vLLM o SGLang suelen ser opciones preferentes; TensorRT-LLM es el camino de máxima especialización para NVIDIA. TGI sigue siendo utilizable, pero Hugging Face lo ha situado en mantenimiento y orienta nuevos despliegues hacia vLLM, SGLang, llama.cpp y MLX.bizon-tech+3

​

4. Aplicaciones, agentes y orquestación​

Solución	Función	macOS	Linux	Windows	Local	Cloud
Open WebUI	Chat local, RAG, usuarios y herramientas	✓	✓	✓	✓	✓
AnythingLLM	Workspace RAG, agentes y conectores	✓	✓	✓	✓	✓
LM Studio	Desktop UI, chat, servidor y herramientas	✓	◐	✓	✓	—
Jan	Cliente desktop local/remoto	✓	✓	✓	✓	—
Msty	Cliente desktop para modelos locales y cloud	✓	✓	✓	✓	✓
LibreChat	Interfaz web multi-modelo y agentes	✓	✓	✓	✓	✓
Chatbox AI	Cliente desktop para APIs y modelos locales	✓	✓	✓	✓	✓
Jaz	Cliente local nativo de macOS/iOS (antes Enchanted)	✓	—	—	✓	◐
Aider	Agente de programación en terminal	✓	✓	✓	✓	✓
Continue	Asistente/agente para VS Code y JetBrains (ahora es de Cursor)	✓	✓	✓	✓	✓
Cline	Agente autónomo para VS Code	✓	✓	✓	✓	✓
Zoo Code	Agente de código para VS Code (antes Roo Code)	✓	✓	✓	✓	✓
OpenCode	Agente CLI de programación	✓	✓	✓	✓	✓
LangChain	Librería de aplicaciones LLM y agentes	✓	✓	✓	✓	✓
LangGraph	Orquestación stateful de agentes	✓	✓	✓	✓	✓
LlamaIndex	RAG, índices, conectores y workflows	✓	✓	✓	✓	✓
Haystack	Pipelines RAG y agentes	✓	✓	✓	✓	✓
Agent Framework (Microsoft)	Orquestación de agentes y plugins (antes Semantic Kernel)	✓	✓	✓	✓	✓
AutoGen (Microsoft)	Sistemas multiagente	✓	✓	✓	✓	✓
CrewAI	Equipos de agentes y workflows	✓	✓	✓	✓	✓
PydanticAI	Agentes Python tipados y estructurados	✓	✓	✓	✓	✓
DSPy	Programación y optimización de pipelines LLM	✓	✓	✓	✓	✓
Flowise	Constructor visual de RAG y flujos	✓	✓	✓	✓	✓
Langflow	Constructor visual sobre LangChain	✓	✓	✓	✓	✓
Dify	Plataforma de aplicaciones LLM y agentes	✓	✓	✓	✓	✓
n8n	Automatización de workflows con IA	✓	✓	✓	✓	✓
Microsoft Copilot Studio	Agentes empresariales no-code/low-code	✓	✓	✓	—	✓
Google AI Agent Builder	Agentes gestionados en GCP (Antes Vertex AI Builder)	✓	✓	✓	—	✓
Amazon Bedrock Agents	Agentes gestionados en AWS	✓	✓	✓	—	✓

​

Contexto y herramientas​

Este plano transversal es fundamental en IA agéntica: el modelo no debe ser tratado como almacén de conocimiento ni tener acceso implícito e ilimitado a recursos locales. La capa de contexto construye grounding; la de herramientas incorpora acciones delimitadas, autenticadas y auditables.

Solución	Función	macOS	Linux	Windows	Local	Cloud
Model Context Protocol (MCP)	Protocolo para tools, recursos y prompts	✓	✓	✓	✓	✓
MCP Servers	Adaptadores para filesystem, Git, SQL, web, SaaS	✓	✓	✓	✓	✓
Chroma	Base vectorial embebible/local	✓	✓	✓	✓	✓
Qdrant	Base vectorial local o gestionada	✓	✓	✓	✓	✓
Weaviate	Base vectorial y búsqueda híbrida	✓	✓	✓	✓	✓
Milvus	Base vectorial de alto volumen	◐	✓	◐	✓	✓
pgvector	Vectores sobre PostgreSQL	✓	✓	✓	✓	✓
LanceDB	Base vectorial embebida/analítica	✓	✓	✓	✓	✓
FAISS	Biblioteca de similitud vectorial	✓	✓	✓	✓	◐
Elasticsearch	Búsqueda híbrida, vectores y documentos	✓	✓	✓	✓	✓
OpenSearch	Búsqueda híbrida, vectores y documentos	✓	✓	✓	✓	✓
SQLite + sqlite-vec	Vector search ultraligera embebida	✓	✓	✓	✓	—
Neo4j	Grafo de conocimiento y GraphRAG	✓	✓	✓	✓	✓
Mem0	Memoria persistente para agentes	✓	✓	✓	✓	✓
Redis	Caché, memoria, colas y vector search	✓	✓	✓	✓	✓
Unstructured	Ingesta y partición documental	✓	✓	✓	✓	✓
Apache Tika	Extracción de texto y metadatos	✓	✓	✓	✓	✓
Docling	Conversión estructurada de PDF y documentos	✓	✓	✓	✓	✓
Playwright	Automatización controlada de navegador	✓	✓	✓	✓	✓
Browser Use	Browser automation orientada a agentes	✓	✓	✓	✓	✓
Playwright MCP	Navegador expuesto como herramienta MCP	✓	✓	✓	✓	✓

​

Operación, gobierno y evaluación​

Solución	Función	macOS	Linux	Windows	Local	Cloud
Hugging Face Hub	Registro, descarga y versionado de modelos	✓	✓	✓	✓	✓
Ollama Registry	Catálogo y distribución de modelos Ollama	✓	✓	✓	✓	✓
LM Studio Hub	Catálogo y descarga de modelos desde desktop	✓	◐	✓	✓	—
MLX Community	Repositorios de conversiones y modelos MLX	✓	✓	✓	✓	✓
MLflow	Experimentos, registro, evaluación y trazas	✓	✓	✓	✓	✓
Weights & Biases	Experimentos, evaluación y monitorización	✓	✓	✓	✓	✓
LangSmith	Trazas, datasets, evaluación de agentes	✓	✓	✓	✓	✓
Langfuse	Observabilidad LLM open source/gestionada	✓	✓	✓	✓	✓
Phoenix (Arize)	Observabilidad y evaluación LLM	✓	✓	✓	✓	✓
OpenTelemetry	Estándar de trazas, logs y métricas	✓	✓	✓	✓	✓
Grafana + Prometheus	Métricas, dashboards y alertas	✓	✓	✓	✓	✓
Helicone	Gateway, coste y observabilidad de LLM	✓	✓	✓	✓	✓
Promptfoo	Tests, red teaming y evaluación de prompts	✓	✓	✓	✓	✓
DeepEval	Evaluación automatizada de LLM/RAG	✓	✓	✓	✓	✓
Ragas	Evaluación específica de RAG	✓	✓	✓	✓	✓
Guardrails AI	Validación estructurada y seguridad de salida	✓	✓	✓	✓	✓
NeMo Guardrails	Políticas conversacionales y control de flujos	✓	✓	✓	✓	✓
NVIDIA NIM	Microservicios de inferencia NVIDIA	—	✓	◐	✓	✓
Kubernetes + KServe	Serving y escalado de modelos	◐	✓	◐	✓	✓
Ray Serve	Serving distribuido y composición de modelos	✓	✓	✓	✓	✓
BentoML	Empaquetado y serving de modelos	✓	✓	✓	✓	✓

 

[DeBilbao]

Como podéis ver, el ecosistema de herramientas es inmenso y además cambia cada dos por tres, así que he continuado mi conversación con GPT-5.6 Terra y le he dicho:

Parece complicado elegir bien y acertar. ¿Puedes hacer una simplificación para quien quiera poner en marcha un laboratorio de experimentación en IA agéntica?​

​

Presenta 4 versiones, una para quien quiera hacerlo en Cloud, y otras tres para quien quiera hacerlo de forma local, con macOS, Linux o Windows.​

Y esta ha sido su respuesta:

Sí: la forma de acertar es no empezar por un stack “completo”, sino por un laboratorio mínimo, intercambiable y observable. Elige una de estas cuatro recetas; todas preservan la misma frontera: un endpoint de modelo compatible con OpenAI + un runtime de agentes + MCP para herramientas.

Regla común​

En las cuatro versiones, empieza con sólo cinco piezas:

1. Un proveedor de inferencia: local o cloud.
2. Un modelo con tool calling fiable.
3. Un marco de agentes: LangGraph o PydanticAI para código; n8n, Dify o Flowise si priorizas interfaz visual.
4. Dos herramientas MCP iniciales: filesystem restringido y Git; añade navegador o bases de datos después.
5. Trazas y evaluación básica: Langfuse local/cloud, o al menos logs estructurados y un pequeño conjunto de tareas de prueba.

MCP es útil como contrato de herramientas: un servidor expone herramientas con nombre y esquema, y el cliente las descubre e invoca. Mantener una API compatible con OpenAI como frontera permite sustituir fácilmente el servidor local o cloud sin reescribir el agente. Ollama ofrece esa compatibilidad y tool calling para modelos que lo soportan.

1. Laboratorio Cloud​

Para quién: quieres máxima calidad de modelos, empezar hoy, colaborar en remoto y no administrar GPUs. Es la opción más rápida para validar ideas de agentes antes de invertir en hardware.

Capa	Selección mínima	Alternativas cuando escales
Modelo e inferencia	API de modelo cloud	OpenAI, Anthropic, Google, Azure, Bedrock, Vertex AI, Groq, Together, Fireworks
Gateway	LiteLLM Proxy	OpenRouter, API gateway del proveedor
Agentes	LangGraph o PydanticAI	OpenAI Agents SDK, AutoGen, CrewAI, Semantic Kernel
Interfaz	Open WebUI o Dify	LibreChat, AnythingLLM, Flowise
Herramientas	MCP: filesystem sandbox + Git + navegador	PostgreSQL, Jira, Slack, Drive, CRM, APIs corporativas
Contexto/RAG	pgvector o Qdrant Cloud	Weaviate Cloud, Pinecone, Elasticsearch
Observabilidad	Langfuse Cloud	LangSmith, Phoenix, W&B Weave

text

[RIGHT]Modelo cloud
     ↓ API
LiteLLM Proxy
     ↓
LangGraph / PydanticAI
     ↙              ↘
MCP tools         Qdrant / pgvector
     ↓
Open WebUI / Dify / n8n[/RIGHT]

Ventajas

• No necesitas gestionar VRAM, drivers, cuantización o despliegues.
• Acceso inmediato a modelos más capaces, útil para diseñar tareas, prompts y evaluaciones.
• Escala de uno a varios usuarios sin rediseñar inicialmente.

Precauciones

• Diseña desde el principio límites de gasto, rate limits y alertas.
• No envíes información sensible a un proveedor cloud sin una política explícita.
• Para herramientas con efectos reales, incorpora confirmación humana: correo, shell, borrados, cambios en Git remoto o acciones sobre sistemas de negocio.

​

2. Laboratorio local macOS​

Para quién: quieres privacidad, bajo mantenimiento, consumo energético contenido y tienes Apple Silicon. Es probablemente tu mejor ruta inicial, dado que ya ejecutas modelos locales con un MacBook Air M5 de 24 GB mediante LM Studio y Ollama.

Capa	Selección mínima	Alternativas cuando escales
Hardware	Mac Apple Silicon con 16–24 GB+ de memoria unificada	Mac Studio para más memoria y modelos mayores
Runtime	Ollama	MLX-LM, llama.cpp, LM Studio
Serving	Ollama API o LM Studio Local Server	mlx_lm.server, llama-server, LiteLLM Proxy
Modelo	Modelo 7B–14B con tool calling	Modelos MLX de tamaño intermedio; cuantizados GGUF
Agentes	PydanticAI o LangGraph	OpenAI Agents SDK, n8n, Dify
Interfaz	LM Studio, Jan u Open WebUI	AnythingLLM, Msty, LibreChat
Contexto	Chroma o SQLite + sqlite-vec	Qdrant, pgvector
Herramientas	MCP filesystem restringido + Git	Playwright MCP, AppleScript, calendarios/APIs personales
Observabilidad	Logs + Langfuse	Phoenix, LangSmith

text

[RIGHT]Apple Silicon + Metal
        ↓
MLX-LM / Ollama / llama.cpp
        ↓
LM Studio Server u Ollama API
        ↓
PydanticAI / LangGraph
        ↙              ↘
MCP local            Chroma / Qdrant
        ↓
Jan · LM Studio · Open WebUI[/RIGHT]

Configuración recomendada para empezar

• Mantén LM Studio como banco visual de pruebas para comparar modelos y medir comportamiento.
• Usa Ollama como endpoint estable para proyectos, scripts y agentes.
• Ejecuta un único modelo de herramientas a la vez; no intentes gestionar un “zoo” de modelos.
• Despliega primero un agente de lectura: búsqueda en una carpeta documental, análisis de repositorios o clasificación de notas.
• Añade agentes que escriben o ejecutan comandos sólo cuando tengas trazas, sandbox y confirmación humana.

Ollama permite declarar herramientas y recibir tool_calls; tras ejecutar la herramienta, tu aplicación devuelve el resultado al modelo para que continúe la tarea. Eso hace viable un laboratorio enteramente local sin exponer los documentos ni las herramientas fuera de tu red.

3. Laboratorio local Linux​

Para quién: priorizas reproducibilidad, Docker, una GPU NVIDIA/AMD, acceso remoto, automatización y la posibilidad de evolucionar a varios usuarios. Es la opción más equilibrada para un homelab serio o un entorno de equipo pequeño.

Capa	Selección mínima	Alternativas cuando escales
Hardware	Linux + GPU NVIDIA con CUDA	AMD con ROCm; CPU para servicios ligeros
Runtime	llama.cpp u Ollama	vLLM, SGLang, TensorRT-LLM
Serving	Ollama API o llama-server	vLLM API Server, SGLang Server, TGI, Triton
Modelo	GGUF para simplicidad	SafeTensors/AWQ/GPTQ/FP8 para GPU
Agentes	LangGraph o PydanticAI en Python	AutoGen, CrewAI, Semantic Kernel
Interfaz	Open WebUI	Dify, Flowise, LibreChat, AnythingLLM
Contexto	Qdrant en Docker	PostgreSQL + pgvector, Weaviate, OpenSearch
Herramientas	MCP en contenedores separados	Browser MCP, Git, SQL de sólo lectura, APIs internas
Observabilidad	Langfuse + OpenTelemetry	Prometheus, Grafana, Phoenix
Despliegue	Docker Compose	Kubernetes + KServe, Ray Serve

text

[RIGHT]Linux + NVIDIA CUDA
        ↓
vLLM / SGLang / llama.cpp
        ↓
API OpenAI-compatible
        ↓
LangGraph / PydanticAI
   ↙         ↓          ↘
MCP sandbox  Qdrant      Langfuse
        ↓
Open WebUI / Dify[/RIGHT]

Configuración recomendada para empezar

• Si tienes una sola GPU o deseas minimizar complejidad: Ollama + Open WebUI + LangGraph + Qdrant.
• Si tienes una GPU NVIDIA razonablemente potente y prevés concurrencia: vLLM + Open WebUI + LiteLLM + LangGraph + Qdrant.
• Separa por contenedor: servidor de modelos, UI, base vectorial, agente y cada herramienta MCP.
• Expón únicamente el gateway o la UI a la red; no expongas directamente Docker socket, filesystem host o herramientas administrativas.

vLLM y SGLang encajan sobre todo en Linux con GPU y cargas concurrentes; llama.cpp continúa siendo valioso cuando prima la portabilidad y un despliegue contenido.

4. Laboratorio local Windows​

Para quién: tu estación de trabajo principal es Windows, quieres experimentar sin cambiar de sistema, o dispones de una GPU NVIDIA de escritorio. Es una opción muy buena para uso individual y desarrollo; para servicios persistentes complejos, WSL2 suele facilitar la operación.

Capa	Selección mínima	Alternativas cuando escales
Hardware	Windows + GPU NVIDIA	CPU; AMD donde el backend lo admita
Runtime	LM Studio u Ollama	llama.cpp, ONNX Runtime GenAI, MLC LLM
Serving	LM Studio Local Server u Ollama API	llama-server; vLLM dentro de WSL2
Modelo	GGUF cuantizado	SafeTensors en WSL2/CUDA; ONNX
Agentes	PydanticAI, LangGraph o OpenAI Agents SDK	Semantic Kernel, AutoGen, CrewAI
Interfaz	LM Studio o Jan	Open WebUI, AnythingLLM, Dify
Contexto	Chroma o LanceDB	Qdrant/pgvector en Docker Desktop o WSL2
Herramientas	MCP filesystem con directorios permitidos	Git, PowerShell controlado, navegador, SQL read-only
Observabilidad	Langfuse o Phoenix	OpenTelemetry, LangSmith
Despliegue	Aplicaciones nativas + Docker Desktop	WSL2 + Docker Compose

text

[RIGHT]Windows + NVIDIA CUDA
        ↓
LM Studio / Ollama / llama.cpp
        ↓
Servidor local compatible con OpenAI
        ↓
PydanticAI / LangGraph
      ↙                 ↘
MCP con permisos       Chroma / Qdrant
        ↓
LM Studio · Jan · Open WebUI[/RIGHT]

Configuración recomendada para empezar

• Para la ruta más sencilla: LM Studio + un modelo GGUF + PydanticAI + un MCP de filesystem restringido.
• Para incorporar clientes desde otros dispositivos: cambia o complementa con Ollama como servicio API.
• Para RAG y agentes con varios servicios: usa Docker Desktop con WSL2 para Open WebUI, Qdrant y Langfuse.
• Evita conceder al agente acceso completo a PowerShell, al perfil de usuario o a credenciales del sistema.

Qué construir primero​

No empieces con un sistema multiagente. Construye tres experimentos consecutivos y conserva los mismos casos de prueba para comparar modelos, runtimes y hardware:

Fase	Experimento	Qué valida
1. Chat estructurado	Extraer información de una carpeta de 10–30 documentos y devolver JSON validado	Modelo, prompt, contexto y salida estructurada
2. Un agente con lectura	Buscar, leer y sintetizar documentos mediante una herramienta MCP de sólo lectura	Tool calling, permisos y trazabilidad
3. Un workflow supervisado	Analizar un repositorio o conjunto documental y proponer cambios, sin ejecutarlos automáticamente	Planificación, calidad, recuperación ante errores y revisión humana
4. Acción acotada	Crear una rama Git o un borrador de informe tras confirmación explícita	Gobernanza, idempotencia y reversibilidad

El OpenAI Agents SDK puede servir de punto de partida para definir un agente y añadir herramientas o handoffs gradualmente; además contempla proveedores distintos de OpenAI.

La mejor inversión inicial no es el modelo más grande ni el servidor más rápido: es un conjunto pequeño de tareas repetibles, logs de cada llamada, permisos mínimos para las herramientas y una interfaz de sustitución entre proveedores. De ese modo podrás comparar Cloud, MLX, Ollama, llama.cpp o vLLM con evidencia de tus propios casos de uso, no sólo con benchmarks.

 

[DeBilbao]

He revisado todas las tablas del post #152 para enlazarlas con las webs de cada producto identificado.

Hacerlo ha sido un ejercicio muy interesante para entender mejor el contexto de soluciones en el que se mueve la IA.

Parece difícil imaginar un futuro en donde sobrevivan todos.

Tiempos complicados para elegir en un entorno empresarial.

Publicado en el tema '[IA] Cómo usar LLMs de forma local en tus equipos personales'

El Lunes a la(s) 10:07

Viendo la velocidad a la que avanza esto de la IA y cómo además de interactuar con un modelo a través de un chat, ahora podemos interactuar con un agente al que le damos instrucciones y acceso a herramientas, quizá sería indicado que le dedicáramos un hilo específico, porque su potencial es enorme.

Para quien no sepa de qué hablamos, en este vídeo de Apple para la comunidad de desarrolladores, nos lo cuentan de una forma muy fácil de entender. Está orientado al stack de Apple, pero la estructura es la misma sobre Linux o Windows.

​

Me gusta especialmente cómo...

• DeBilbao

• 

 

[Tozzi]

Volviendo a probar los LLM locales, he actualizado los modelos con Ollama (facilísimo en Mac), pidiéndole que me genere un programa en Basic para el Spectrum, con una petición sencilla e igual para las dos pruebas: "hazme un programa en lenguaje basic del ZX Spectrum (para el micro z80), que sea un juego sencillo como el pang"

Gemma4:26B directamente el Ollama, un código sencillo y directo:

10 BORDER 0: PAPER 7: INK 0: CLS
20 LET px=15: LET py=21: LET bx=10: LET by=10
30 LET vx=1: LET vy=1: LET s=0: LET b=0
40 PRINT AT 0,0;"SCORE:";s
50 PRINT AT py,px;"@";: REM Dibujar jugador
60 LET k$=INKEY$
70 IF k$="o" AND px>0 THEN PRINT AT py,px;" ";: LET px=px-1
80 IF k$="p" AND px<31 THEN PRINT AT py,px;" ";: LET px=px+1
90 IF k$="q" AND b=0 THEN LET b=1: LET sx=px: LET sy=py: PRINT AT sy,sx;".";
100 IF b=1 THEN PRINT AT sy,sx;" ";: LET sx=sx+1: IF sx>31 THEN LET b=0
110 REM --- Lógica de la Bola ---
120 PRINT AT by,bx;" ";: REM Borrar bola vieja
130 LET bx=bx+vx: LET by=by+vy
140 IF bx<0 OR bx>31 THEN LET vx=-vx
150 IF by<1 OR by>22 THEN LET vy=-vy
160 PRINT AT by,bx;"O";: REM Dibujar bola nueva
170 REM --- Colisión Bala con Bola ---
180 IF b=1 AND ABS(sx-bx)<1 AND ABS(sy-by)<1 THEN GOTO 250
190 REM --- Colisión Jugador con Bola ---
200 IF ABS(px-bx)<1 AND ABS(py-by)<1 THEN GOTO 300
210 IF b=0 THEN GOTO 50
220 REM --- Bucle principal ---
230 GOTO 50
240 REM --- Impacto Exitoso ---
250 LET s=s+10: LET b=0: LET bx=RND*30: LET by=RND*20
260 PRINT AT 0,0;"SCORE:";s: PRINT AT py,px;"@";: GOTO 50
270 REM --- Game Over ---
300 PRINT AT 10,10;"GAME OVER";
310 PRINT AT 12,10;"SCORE:";s
320 PAUSE 0
330 RUN

GPT-OSS120B tarda un poquito más pero con resultado más elaborado, esta vez utilizando Claude Code pero tirando directamente del modelo LLM en local a través de Ollama:

10 CLEAR : RANDOMIZE USR &HBCA0 : REM Inicializa memoria y semilla aleatoria
20 DIM Xb(10),Yb(10),Vxb(10),Vyb(10),Sb(10) : REM x,y,veloc.,tamaño de cada globo (máx 10)
30 P=0 : REM número de globos activos
40 PLAYER=150 : REM posición X del jugador (centro)
50 GOSUB 2000 : REM Dibuja marco y jugador
60 GOSUB 3000 : REM Crea los globos iniciales
70 GOSUB 4000 : REM Bucle principal

100 REM ==================== DIBUJO DE MARCO Y JUGADOR ====================
2000 CLS
2010 PRINT AT 0,0;"PANG BASIC (ZX Spectrum)"
2020 FOR I=0 TO 31: PRINT AT 23,I;"-";: NEXT I : REM suelo
2030 PRINT AT 22,PLAYER;"^" : REM jugador
2040 RETURN

2100 REM ==================== CREA GLBO INICIALES ====================
3000 REM crea 3 globos grandes al azar
3010 FOR I=1 TO 3
3020 Xb(I)=INT(RND*256) : REM posición X (0‑255)
3030 Yb(I)=INT(RND*180) : REM posición Y (0‑179)
3040 Vxb(I)=INT(RND*4-2) : REM velocidad X (-2..+1)
3050 Vyb(I)=INT(RND*4-2) : REM velocidad Y (-2..+1)
3060 IF Vxb(I)=0 THEN Vxb(I)=1
3070 IF Vyb(I)=0 THEN Vyb(I)=1
3080 Sb(I)=3 : REM tamaño (3 = grande)
3090 P=P+1
3100 NEXT I
3110 RETURN

3200 REM ==================== BUCLE PRINCIPAL ====================
4000 REM 50 ciclos por segundo aprox.
4010 T=TIME : REM marca de tiempo para control de velocidad
4020 GOSUB 5000 : REM leer teclado y mover jugador
4030 GOSUB 6000 : REM mover globos y dibujar
4040 GOSUB 7000 : REM comprobar disparo y colisiones
4050 IF (TIME-T)<20 THEN PAUSE 20-(TIME-T) : REM retardo (~50 fps)
4060 GOTO 4010

4100 REM ==================== LEE TECLADO ====================
5000 K$=INKEY$
5010 IF K$="A" THEN PLAYER=PLAYER-2 : IF PLAYER<0 THEN PLAYER=0
5020 IF K$="D" THEN PLAYER=PLAYER+2 : IF PLAYER>255 THEN PLAYER=255
5030 IF K$="S" THEN GOSUB 8000 : REM disparo
5040 PRINT AT 22,PLAYER;"^" : REM redraw jugador (sobrescribe posible globo)
5050 RETURN

4200 REM ==================== MUEVE Y DIBUJA GLOBOS ====================
6000 FOR I=1 TO P
6010 REM borra globo anterior
6020 IF Sb(I)>0 THEN PLOT Xb(I),Yb(I),0
6030 REM actualiza posición
6040 Xb(I)=Xb(I)+Vxb(I) : Yb(I)=Yb(I)+Vyb(I)
6050 REM rebotes en bordes
6060 IF Xb(I)<0 OR Xb(I)>255 THEN Vxb(I)=-Vxb(I)
6070 IF Yb(I)<0 OR Yb(I)>179 THEN Vyb(I)=-Vyb(I)
6080 REM dibuja globo nuevo (tamaño como color)
6090 IF Sb(I)>0 THEN PLOT Xb(I),Yb(I),Sb(I)
6100 NEXT I
6110 RETURN

4300 REM ==================== DISPARO ====================
8000 REM dispara una línea vertical desde el jugador
8010 FOR Y=21 TO 0 STEP -1
8020 PLOT PLAYER,Y,2 : REM color 2 (rojo) = disparo
8030 FOR I=1 TO P
8040 IF Sb(I)>0 AND Xb(I)=PLAYER AND Y=Yb(I) THEN GOSUB 9000
8050 NEXT I
8060 PAUSE 2
8070 PLOT PLAYER,Y,0 : REM borra disparo
8080 NEXT Y
8090 RETURN

4400 REM ==================== COLISIÓN DISPARO → DIVIDE GLobo ====================
9000 REM globo golpeado en I
9010 IF Sb(I)=1 THEN REM globo pequeño desaparece
9020 PLOT Xb(I),Yb(I),0
9030 Sb(I)=0
9040 GOTO 9100
9050 END IF
9060 REM globo grande o medio → se divide
9070 Snew=Sb(I)-1 : REM nuevo tamaño (2→1 o 3→2)
9080 REM crea dos nuevos globos
9090 Xb(I)=Xb(I) : Yb(I)=Yb(I) : Sb(I)=Snew : Vxb(I)=-Vxb(I) : REM primero invierte X
9100 FOR J=P+1 TO P+1 : REM segundo globo
9110 Xb(J)=Xb(I) : Yb(J)=Yb(I) : Sb(J)=Snew
9120 Vxb(J)=INT(RND*4-2) : IF Vxb(J)=0 THEN Vxb(J)=1
9130 Vyb(J)=INT(RND*4-2) : IF Vyb(J)=0 THEN Vyb(J)=1
9140 NEXT J
9150 P=P+1
9160 RETURN

Utilizando casi al máximo GPU y memoria con GPT, pero bastante rápido en ambos casos:



PD: Le he dicho que haga lo mismo a Qwen 3.8 con 27B y todavía sigue pensando....

 

[Hinomura Krycek]

Y?

Has probado el juego en el Spectrum?

 

[Tozzi]

No, tengo que teclearlo le he pedido que me haga un simulador web del spectrum para hacer pruebas rápidas y casi lo consigue, ha localizado un código javascript de Speccy para montarlo y todo

 

[TheReeler]

Pero a ver... dile que te haga el MP3 o WAV resultante con el archivo para ser cargado por fuente de audio. Luego grabas el sonido en una cinta o te haces un cable directo (salida auriculares / entrada Spectrum).

 

[DeBilbao]

No, tengo que teclearlo le he pedido que me haga un simulador web del spectrum para hacer pruebas rápidas y casi lo consigue, ha localizado un código javascript de Speccy para montarlo y todo

Este emulador online está muy bien. He generado una cinta con el código que has generado con gpt-oss-20b, aunque he tenido que corregirle la secuencia de numeración.

ZX84 - Z80 Computer Emulator

Para generar la cinta (pang.tap), a partir del código (pang.bas) puedes usar zmakebas

GitHub - z00m128/zmakebas: zmakebas converts a Spectrum BASIC program written as a text file into an actual speccy BASIC file.

zmakebas converts a Spectrum BASIC program written as a text file into an actual speccy BASIC file. - z00m128/zmakebas

github.com

No he visto que tengan el binario, pero si descargas el archivo source.zip y lo descomprimes, solo tienes que situarte en el directorio generado desde el terminal y ejecutar el comando make para compilarlo, el comando chmod +x para convertirlo en ejecutable y ejecutarlo precedido de un ./ con esta estructura de comando:

./zmakebas -o pang.tap pang.bas

El conversor da un error porque no respeta la secuencia de numeración de líneas, y es que la numeración de los comentarios está mal. Lo he corregido manualmente:

10 CLEAR : RANDOMIZE USR &HBCA0 : REM Inicializa memoria y semilla aleatoria
20 DIM Xb(10),Yb(10),Vxb(10),Vyb(10),Sb(10) : REM x,y,veloc.,tamaño de cada globo (máx 10)
30 P=0 : REM número de globos activos
40 PLAYER=150 : REM posición X del jugador (centro)
50 GOSUB 2000 : REM Dibuja marco y jugador
60 GOSUB 3000 : REM Crea los globos iniciales
70 GOSUB 4000 : REM Bucle principal

100 REM ==================== DIBUJO DE MARCO Y JUGADOR ====================
2000 CLS
2010 PRINT AT 0,0;"PANG BASIC (ZX Spectrum)"
2020 FOR I=0 TO 31: PRINT AT 23,I;"-";: NEXT I : REM suelo
2030 PRINT AT 22,PLAYER;"^" : REM jugador
2040 RETURN

2100 REM ==================== CREA GLBO INICIALES ====================
3000 REM crea 3 globos grandes al azar
3010 FOR I=1 TO 3
3020 Xb(I)=INT(RND*256) : REM posición X (0‑255)
3030 Yb(I)=INT(RND*180) : REM posición Y (0‑179)
3040 Vxb(I)=INT(RND*4-2) : REM velocidad X (-2..+1)
3050 Vyb(I)=INT(RND*4-2) : REM velocidad Y (-2..+1)
3060 IF Vxb(I)=0 THEN Vxb(I)=1
3070 IF Vyb(I)=0 THEN Vyb(I)=1
3080 Sb(I)=3 : REM tamaño (3 = grande)
3090 P=P+1
3100 NEXT I
3110 RETURN

3999 REM ==================== BUCLE PRINCIPAL ====================
4000 REM 50 ciclos por segundo aprox.
4010 T=TIME : REM marca de tiempo para control de velocidad
4020 GOSUB 5000 : REM leer teclado y mover jugador
4030 GOSUB 6000 : REM mover globos y dibujar
4040 GOSUB 7000 : REM comprobar disparo y colisiones
4050 IF (TIME-T)<20 THEN PAUSE 20-(TIME-T) : REM retardo (~50 fps)
4060 GOTO 4010

4999 REM ==================== LEE TECLADO ====================
5000 K$=INKEY$
5010 IF K$="A" THEN PLAYER=PLAYER-2 : IF PLAYER<0 THEN PLAYER=0
5020 IF K$="D" THEN PLAYER=PLAYER+2 : IF PLAYER>255 THEN PLAYER=255
5030 IF K$="S" THEN GOSUB 8000 : REM disparo
5040 PRINT AT 22,PLAYER;"^" : REM redraw jugador (sobrescribe posible globo)
5050 RETURN

5999 REM ==================== MUEVE Y DIBUJA GLOBOS ====================
6000 FOR I=1 TO P
6010 REM borra globo anterior
6020 IF Sb(I)>0 THEN PLOT Xb(I),Yb(I),0
6030 REM actualiza posición
6040 Xb(I)=Xb(I)+Vxb(I) : Yb(I)=Yb(I)+Vyb(I)
6050 REM rebotes en bordes
6060 IF Xb(I)<0 OR Xb(I)>255 THEN Vxb(I)=-Vxb(I)
6070 IF Yb(I)<0 OR Yb(I)>179 THEN Vyb(I)=-Vyb(I)
6080 REM dibuja globo nuevo (tamaño como color)
6090 IF Sb(I)>0 THEN PLOT Xb(I),Yb(I),Sb(I)
6100 NEXT I
6110 RETURN

7999 REM ==================== DISPARO ====================
8000 REM dispara una línea vertical desde el jugador
8010 FOR Y=21 TO 0 STEP -1
8020 PLOT PLAYER,Y,2 : REM color 2 (rojo) = disparo
8030 FOR I=1 TO P
8040 IF Sb(I)>0 AND Xb(I)=PLAYER AND Y=Yb(I) THEN GOSUB 9000
8050 NEXT I
8060 PAUSE 2
8070 PLOT PLAYER,Y,0 : REM borra disparo
8080 NEXT Y
8090 RETURN

8999 REM ==================== COLISIÓN DISPARO → DIVIDE GLobo ====================
9000 REM globo golpeado en I
9010 IF Sb(I)=1 THEN REM globo pequeño desaparece
9020 PLOT Xb(I),Yb(I),0
9030 Sb(I)=0
9040 GOTO 9100
9050 END IF
9060 REM globo grande o medio → se divide
9070 Snew=Sb(I)-1 : REM nuevo tamaño (2→1 o 3→2)
9080 REM crea dos nuevos globos
9090 Xb(I)=Xb(I) : Yb(I)=Yb(I) : Sb(I)=Snew : Vxb(I)=-Vxb(I) : REM primero invierte X
9100 FOR J=P+1 TO P+1 : REM segundo globo
9110 Xb(J)=Xb(I) : Yb(J)=Yb(I) : Sb(J)=Snew
9120 Vxb(J)=INT(RND*4-2) : IF Vxb(J)=0 THEN Vxb(J)=1
9130 Vyb(J)=INT(RND*4-2) : IF Vyb(J)=0 THEN Vyb(J)=1
9140 NEXT J
9150 P=P+1
9160 RETURN

 

[Tozzi]

Gracias! Mucho más sencillo así

Anoche tuve problemas con cloudflare (supongo por futbol) y no podía descargar modelos nuevos de ollama para probar

 

[DeBilbao]

Ahora solo hace falta saber cómo ejecutarlo...

El teclado del ZX Spectrum es un infierno, y usarlo desde el Mac mucho más...




Si pulso Shift + 1 salgo del editor a este menú

Pero no sé dónde escribir RUN para que lo ejecute.