¿Qué es la IA local?

Lo que cubre este artículo

• Qué es la IA local y cómo difiere de servicios en la nube como ChatGPT
• Qué hardware, modelos y software necesitas para ejecutar IA localmente
• Cómo fluye un prompt a través de tu sistema, desde la descarga hasta la respuesta
• Qué casos de uso merecen la pena y dónde están los límites
• Qué trampas esperan a los principiantes y cómo evitarlas

Introducción: IA local explicada de forma clara

Cuando hoy se habla de IA, usualmente nos referimos a servicios en la nube como ChatGPT, Claude o Gemini. Escribes una pregunta, llega a servidores remotos, el modelo responde y la respuesta vuelve a ti. Funciona bien mientras aceptes que máquinas y empresas extrañas procesen tus datos.

La IA local invierte este principio. El modelo corre directamente en tu ordenador, servidor o mini PC. Tus datos nunca salen de tu red. Tú decides qué software, qué versión y qué modelos usar. Sin facturación por tokens, sin suscripción, sin límites de velocidad.

¿Por qué es relevante ahora? Porque los modelos locales han mejorado enormemente en los últimos dos años. Un modelo de 7B u 8B en un portátil moderno genera respuestas que en 2023 solo podían proporcionar grandes servicios en la nube. Simultáneamente, crecen las preocupaciones sobre privacidad, dependencia de proveedores individuales y costos continuos. La IA local ya no es un nicho, sino una opción realista para desarrolladores, pequeñas empresas y usuarios con conocimientos técnicos.

Este artículo es el punto de partida. Explica los fundamentos, muestra los componentes y te ayuda a decidir si y cómo usar la IA local para tus propósitos. Incluimos enlaces en el texto a artículos más profundos sobre temas específicos.

¿Por qué necesito IA local?

La pregunta parece simple, pero la respuesta depende mucho de tu contexto. Tres ejemplos prácticos muestran cuándo la IA local no es solo conveniente, sino necesaria.

Ejemplo 1: Abogado con contratos sensibles. Un despacho quiere resumir cientos de páginas de contratos, encontrar cláusulas y marcar riesgos. Estos documentos no pueden ir a un proveedor en la nube porque las obligaciones de confidencialidad y las leyes de protección de datos lo prohíben. Con un modelo local en una máquina de escritorio o un pequeño servidor, los documentos permanecen en la oficina. El despacho se beneficia aun así de resúmenes automáticos y análisis de cláusulas.

Ejemplo 2: Desarrollador con código interno. Un ingeniero de software trabaja en un proyecto propietario. El código fuente, comentarios e informes de errores son confidenciales. Los asistentes de código basados en la nube como GitHub Copilot envían fragmentos a servidores externos. Con un modelo de código local como Qwen2.5-Coder o DeepSeek-Coder, el código se queda en el ordenador. El desarrollador obtiene autocompletado, explicaciones de código y tests sin dejar el proyecto.

Ejemplo 3: Empresa con conocimiento interno. Una empresa mediana tiene miles de PDFs, manuales, wikis internos y tickets de soporte. Los empleados buscan diariamente respuestas dispersas en estos documentos. Con un setup RAG local (Retrieval-Augmented Generation), se construye una base de conocimiento interna. Los empleados hacen preguntas, el modelo busca en los documentos propios y responde con referencias. Nada sale de la red corporativa.

Aspecto de costo. La IA en la nube se cobra por token o por suscripción. Quien usa mucho paga rápidamente cientos de euros al mes. La IA local cuesta hardware de una sola vez y electricidad de forma continua. Si ya tienes un ordenador con 16 GB de VRAM o un Mac con 32 GB de memoria unificada, el hardware ya lo tienes. Los costos operativos son entonces marginales. Con uso intensivo, una instalación local se amortiza en pocos meses. Más comparativas en IA local vs. IA en la nube.

¿Qué es IA local? - En pocas palabras

IA local significa que un modelo de lenguaje, un modelo de código o un modelo multimodal corre en tu propio hardware. No se comunica con una API en la nube, sino que se carga y ejecuta mediante software como Ollama, LM Studio o llama.cpp.

Imagina que tienes una biblioteca. Con IA en la nube, vas a una biblioteca pública ajena, mencionas lo que quieres leer, un bibliotecario busca el libro y te da un resumen. El bibliotecario ve exactamente qué lees. Con IA local, tienes la biblioteca en tu sótano. Vas, buscas tú mismo, lees tú mismo. Nadie fuera de tu casa sabe qué lees.

Para ello debes construir los estantes tú mismo (hardware), conseguir los libros tú mismo (descargar modelos) e instalar una sala de lectura (entorno de ejecución). La inversión inicial es mayor, pero también tu autonomía.

La IA local es especialmente apropiada para documentos sensibles, bases de conocimiento internas, entornos de desarrollo y experimentos donde no quieres depender de servidores ajenos.

¿Para quién es la IA local?

La IA local no es para todos. Quien tiene preguntas ocasionales y no procesa datos sensibles, es más rápido con servicios en la nube. Para los siguientes grupos, el funcionamiento local tiene sentido concreto:

• Desarrolladores y desarrolladoras que quieren asistencia de código sin conexión a la nube. Utilizan modelos de código locales directamente en el editor, a través de plugins como Continue o Cline.
• Usuarios preocupados por la privacidad que no quieren que sus preguntas, documentos o ideas terminen en servidores ajenos.
• Pequeñas empresas y despachos que están obligados legal o contractualmente a mantener los datos en la casa.
• Investigadores y estudiantes que desean experimentar con modelos, hacer fine-tuning o entender arquitecturas.
• Autogestionadores de servidor y aficionados al homelab que ya tienen servidores propios e integran IA como otro servicio.
• Equipos en redes protegidas, como organismos públicos, hospitales o empresas industriales con requisitos estrictos de cumplimiento normativo.

Si no entras en ninguno de estos grupos, deberías evaluar honestamente si el esfuerzo compensa. La IA en la nube es más sencilla y económica para usuarios ocasionales.

Términos clave sobre IA local

Antes de entrar en los componentes, aquí están los conceptos centrales que aparecen una y otra vez en este y en los siguientes artículos.

Término	Explicación
LLM	Large Language Model. Un modelo de lenguaje que entiende y genera texto. Ejemplos: Llama, Qwen, Mistral.
Inferencia	La ejecución de un modelo entrenado. El entrenamiento crea el modelo, la inferencia lo utiliza.
Entrenamiento	El proceso que enseña a un modelo a partir de datos. Los usuarios locales generalmente no entrenan, descargan modelos completados.
Ollama	Un entorno de ejecución que descarga, inicia y proporciona modelos mediante API.
LM Studio	Una interfaz gráfica para cargar y probar modelos locales.
GGUF	Un formato de archivo para modelos cuantizados, compatible con llama.cpp.
Cuantización	Reducción de la precisión de los pesos del modelo para disminuir memoria y carga computacional.
Token	Un segmento de texto, aproximadamente una palabra o parte de una palabra. Los modelos procesan tokens, no letras.
Longitud de contexto	Cuánto texto puede procesar el modelo a la vez. Más contexto requiere más memoria.
RAG	Retrieval-Augmented Generation. Una técnica donde el modelo obtiene respuestas de tus propios documentos.
Embedding	Un vector numérico que representa el significado de un texto. Base para RAG y búsqueda.
Base de datos vectorial	Una base de datos que almacena embeddings y los hace buscables semánticamente. Ejemplos: Chroma, Qdrant.

Hay artículos más profundos sobre Cuantización, Longitud de contexto y RAG local.

Componentes esenciales de la IA local

Para que funcione la IA local, necesitas cuatro bloques fundamentales: hardware, modelo, entorno de ejecución y cliente. Cada uno implica decisiones y trampas propias.

Hardware

El hardware proporciona capacidad de cálculo y memoria. Los modelos locales necesitan principalmente dos cosas: memoria rápida y suficiente VRAM o RAM. Los modelos se distribuyen hoy como archivos cuantizados, es decir, variantes con precisión reducida y menor consumo de memoria.

En concreto: un modelo 7B en cuantización 4-bit requiere aproximadamente 4 a 5 GB de VRAM. Un modelo 13B necesita alrededor de 8 a 10 GB. Un modelo 70B requiere 40 GB o más. La cantidad de VRAM determina qué modelo puedes cargar. Encontrarás más detalles en el artículo Requerimientos de RAM y VRAM.

Ejemplos de hardware:

• Un PC con Windows o Linux con RTX 3060 (12 GB VRAM) es suficiente para modelos hasta aproximadamente 13B en 4-bit.
• Un Mac Studio con M2 Ultra y 128 GB de Unified Memory puede cargar incluso modelos 70B, porque Apple Silicon combina VRAM y RAM.
• Un servidor con dos RTX 4090 (24 GB cada una) es una configuración típica para alojar IA local de forma seria.
• Una mini PC sin GPU dedicada puede ejecutar modelos pequeños en CPU, pero es lento.

Es posible ejecutar en CPU, pero notablemente más lento. Para trabajar sin interrupciones, una GPU dedicada o Apple Silicon con Unified Memory es mucho mejor. Más información en Fundamentos de hardware para IA.

Modelo

El modelo es el archivo entrenado que procesa tus entradas. Los formatos comunes son GGUF, Safetensors u ONNX. Para operación local, GGUF es particularmente difundido porque se cuantiza bien y es compatible con llama.cpp, Ollama y LM Studio.

Ejemplos de modelos:

• Llama 3.1 8B de Meta, versátil para chat y texto.
• Qwen2.5 7B de Alibaba, muy capaz en múltiples idiomas incluyendo alemán.
• Qwen2.5-Coder 7B para tareas de programación.
• Mistral 7B, un versátil compacto.
• DeepSeek-R1, un modelo de razonamiento para tareas complejas.
• Llava, un modelo de visión que puede describir imágenes.

Qué modelo elegir depende de tu tarea. Para chat basta un versátil 7B, para código un modelo especializado, para imágenes un modelo de visión. Puedes mantener varios modelos y cambiar según la tarea.

Entorno de ejecución

El entorno de ejecución se encarga de que el modelo se cargue, ejecute y controle mediante API o interfaz. Sin él, un archivo de modelo es solo un archivo en el disco.

Ejemplos:

• Ollama es el inicio más simple. Lo instalas, ejecutas ollama run llama3.1 y el modelo se carga e inicia. Ollama proporciona automáticamente una API local.
• LM Studio está dirigido a usuarios que quieren interfaz gráfica. Buscas modelos en la búsqueda integrada, los descargas y los pruebas en chat.
• llama.cpp es el motor subyacente, flexible pero requiere más configuración. Si quieres máximo control, tienes acceso aquí.
• vLLM es una alternativa para operación servidor con mayor rendimiento.

Encontrarás una descripción general de todas las opciones en Software de IA local.

Cliente

El cliente es lo que ves como usuario. Puede ser un comando de terminal, una interfaz de chat en el navegador o una aplicación personalizada.

Ejemplos:

• Open WebUI es un proyecto popular que proporciona una interfaz web moderna para Ollama. Se parece a ChatGPT pero funciona localmente.
• Continue es un plugin para VS Code y JetBrains que utiliza modelos locales para asistencia de código.
• Cline es un plugin de VS Code que utiliza modelos locales como agentes. Más sobre agentes en ¿Qué es un agente de IA?.
• Un terminal simple es suficiente para pruebas iniciales. ollama run llama3.1 inicia un chat directo en línea de comandos.

Cómo funciona la IA local paso a paso

Para entender qué ocurre localmente, vamos a recorrer el camino de un prompt desde la entrada hasta la respuesta. Tomemos un ejemplo concreto: haces una pregunta a Llama 3.1 8B ejecutándose localmente para que resuma una sección de contrato.

Paso 1: Descargar el modelo. Al iniciarse por primera vez, Ollama descarga el modelo desde un servidor de registro, por ejemplo registry.ollama.ai. El archivo tiene aproximadamente 4,7 GB y se almacena localmente en tu disco. Después, no necesitas internet.

Paso 2: Cargar el modelo en memoria. Cuando inicias el modelo, Ollama carga los pesos en la VRAM de tu GPU o en la RAM en operación CPU. Con cuantización 4-bit, el modelo 8B ocupa aproximadamente 5 GB. Mientras el modelo está en ejecución, permanece en memoria.

Paso 3: Enviar el prompt. Ingresas tu texto, ya sea a través de Open WebUI o terminal. El cliente envía el prompt a la API local de Ollama, típicamente a http://localhost:11434.

Paso 4: Tokenización. El entorno de ejecución divide tu prompt en tokens. De “Resuma este contrato” se genera una secuencia de números que el modelo puede procesar.

Paso 5: Calcular el modelo. El modelo toma la secuencia de tokens y calcula, token por token, la continuación más probable. Cada nuevo token se basa en todos los anteriores. Esto se llama generación autorregresiva. El cálculo ocurre en tu GPU o CPU.

Paso 6: Devolver la respuesta. Cada token calculado se de-tokeniza, es decir, se convierte nuevamente en texto, y se transmite al cliente. Ves la respuesta aparecer palabra por palabra.

Paso 7: Liberar o mantener memoria. Cuando terminas, el modelo puede permanecer en memoria para la siguiente pregunta, u Ollama lo descarga después de un período de tiempo de espera.

El proceso completo toma algunos segundos con una buena GPU y un modelo 8B para una respuesta corta. Con operación CPU puede tomar 30 segundos o más. La velocidad se mide en tokens por segundo, típicamente entre 20 y 60 en una RTX 3060, entre 5 y 15 en una CPU.

Tipos de modelos locales

Los modelos locales no son todos iguales. Hay diferentes tipos según lo que deben procesar.

LLMs (Large Language Models). Versátiles para texto. Entienden preguntas, escriben textos, responden consultas y pueden razonar. Ejemplos: Llama 3.1, Qwen2.5, Mistral, DeepSeek-R1. Este es el tipo más común para uso local. Más sobre operación en el artículo Ejecutar LLM localmente.

Modelos de código. Especializados en lenguajes de programación. Conocen sintaxis, patrones y bibliotecas. Son adecuados para autocompletado, explicación de código, pruebas y refactorización. Ejemplos: Qwen2.5-Coder, DeepSeek-Coder, CodeLlama.

Modelos de visión. Procesan imágenes junto con texto. Puedes cargar una imagen y el modelo la describe, responde preguntas sobre ella o extrae texto. Ejemplos: Llava, Qwen2-VL, MiniCPM-V.

Modelos de embedding. Generan vectores a partir de texto, necesarios para búsqueda semántica y RAG. No generan respuestas, sino representaciones numéricas. Ejemplos: nomic-embed-text, bge-m3, mxbai-embed-large. Los necesitas cuando construyes una configuración RAG local.

Modelos multimodales. Combinan múltiples tipos de entrada, como texto, imágenes y audio. Son los generalistas entre los modelos. Ejemplos: Qwen2-VL, Llava, Pixtral. Localmente, los modelos multimodales son más exigentes porque requieren más memoria y capacidad de cálculo.

Ventajas y limitaciones

La IA local tiene claras fortalezas, pero también limitaciones. Conocer ambos lados te permite decidir mejor cuándo tiene sentido un despliegue local.

Ventajas:

• Soberanía de datos. Tus datos no salen de tu red. Para documentos sensibles, código interno o notas personales, este es el argumento principal.
• Sin costos de API recurrentes. No pagas por token. Con un uso intensivo, ahorras dinero a medio plazo.
• Control total sobre modelo y versión. Tú decides qué modelo en qué cuantificación se ejecuta. Ningún proveedor cambia el comportamiento de la noche a la mañana.
• Operación offline posible. Tras descargar el modelo, no necesitas internet. Esto importa para viajes, redes aisladas o conexiones inestables.
• Sin límites de velocidad. Los servicios en la nube limitan solicitudes. Localmente, puedes hacer tantas consultas como tu hardware pueda procesar.
• Adaptabilidad. Puedes cuantificar modelos, establecer system prompts, construir RAG y ajustar todo a tus necesidades.

Limitaciones:

• El rendimiento depende del hardware. Sin un sistema adecuado, llegas poco lejos. Los modelos grandes requieren hardware costoso.
• Los mejores modelos funcionan localmente solo de forma limitada. Modelos como GPT-4 o Claude 3.5 Sonnet no están disponibles localmente. Los mejores modelos locales son buenos, pero no alcanzan ese nivel.
• El autodespliegue requiere mantenimiento. Actualizaciones, depuración, gestión de memoria y copias de seguridad corren por tu cuenta.
• La cuantificación cuesta calidad. Los modelos de 4-bit son compactos, pero algo más débiles que los pesos originales. La diferencia es pequeña en chat, pero perceptible en tareas exigentes.
• Sin conocimiento automático de eventos actuales. Los modelos locales tienen una fecha de entrenamiento y no saben qué sucedió después. RAG ayuda aquí, pero es trabajo adicional.
• Consumo de energía. Un servidor con GPU consume electricidad. En operación continua, eso es un factor.

Casos de uso típicos

Aquí hay escenarios concretos donde la IA local tiene sentido, con ejemplos.

1. Base de conocimiento interna con RAG. Una empresa tiene manuales, wikis y documentos de soporte. Los empleados hacen preguntas en una interfaz local, el modelo responde citando fuentes de sus propios documentos. Setup: Ollama, un LLM como Llama 3.1, un modelo de embeddings, una base de datos vectorial como Chroma, y Open WebUI como frontend.

2. Asistencia de código sin nube. Un desarrollador usa Qwen2.5-Coder localmente en VS Code con el plugin Continue. Autocompletado, explicación de código y generación de tests se ejecutan en su máquina. El código fuente nunca sale.

3. Resumen de documentos sensibles. Un despacho carga contratos como PDF en una interfaz local. El modelo crea resúmenes, marca cláusulas de riesgo y responde preguntas sobre el contenido. Ningún documento va a un proveedor en la nube.

4. Traducción offline. Quien trabaja en zonas sin internet estable, por ejemplo viajando o en campo, puede usar modelos locales para traducir. Qwen2.5 domina varios idiomas y funciona offline.

5. Asistente de chat local para notas e ideas. Un usuario mantiene un diario privado, hace lluvia de ideas para proyectos o planifica viajes. No quiere enviar nada a un servicio en la nube. Un modelo local en el portátil es suficiente para estas tareas.

6. Automatización con agentes. Un desarrollador construye un agente que lee archivos, ejecuta scripts y genera reportes. El agente usa un modelo local como cerebro. Más en ¿Qué es un agente de IA?.

7. Aplicaciones de visión para documentos. Un equipo quiere procesar facturas escaneadas. Un modelo de visión local como Qwen2-VL extrae montos, fechas y proveedores de las imágenes y los devuelve como datos estructurados.

Tropiezos típicos con IA local

Quien comienza con IA local se encuentra con problemas comunes. Aquí están los más frecuentes y cómo evitarlos.

1. Modelo demasiado grande para el hardware. Los principiantes cargan un modelo de 70B en una máquina con 8 GB de VRAM. El modelo no se carga o se interrumpe. Solución: Primero verifica tu VRAM, luego elige un modelo apropiado. Regla práctica: un modelo de 4-bit necesita alrededor de 0,6 GB por cada mil millones de parámetros.

2. Respuesta lenta en CPU. Quien no tiene GPU y carga un modelo de 13B espera eternamente. Solución: Usa modelos más pequeños como 3B o 1,5B en CPU, o consigue una GPU. Incluso Apple Silicon es significativamente más rápido que solo CPU.

3. Confusión sobre formatos. Existen GGUF, Safetensors, ONNX, AWQ, GPTQ. Los principiantes no saben qué cargar. Solución: Para Ollama y LM Studio, GGUF es el estándar. Carga archivos GGUF desde Hugging Face, idealmente con cuantificación Q4_K_M como punto de partida equilibrado.

4. Longitud de contexto sobrestimada. Introduces un documento largo y te preguntas por qué el modelo olvida el principio o se interrumpe. Solución: Verifica la longitud de contexto del modelo y tu entorno de ejecución. Más en el artículo Longitud de contexto.

5. Sin system prompts claros. Sin instrucciones, un modelo se comporta genéricamente. Solución: Define un system prompt que establezca rol, tono y formato. Esto mejora significativamente la calidad.

6. RAG mal configurado. Los embeddings no coinciden con el modelo, la base de datos vectorial está vacía, o los chunks son demasiado grandes. Solución: Usa un modelo de embeddings que se adapte a tu idioma, y prueba primero con cantidades pequeñas de documentos. Más en RAG local.

7. Energía y ruido subestimados. Un servidor con dos GPUs funciona ruidosamente y consume 500 vatios bajo carga. Solución: Antes de comprar, verifica el consumo de energía y el enfriamiento. Para uso doméstico, un Mac o una PC con una GPU suelen ser suficientes.

Hardware, costos y seguridad en IA local

Hardware. La pregunta más importante es: ¿cuánto VRAM o Unified Memory tienes? Esto determina qué modelos pueden ejecutarse. Una RTX 3060 con 12 GB es un inicio sólido. Un Mac con 32 GB de Unified Memory es más flexible. Para modelos de 70B, necesitas 48 GB o más. Detalles en Requisitos de RAM y VRAM y Fundamentos de hardware de IA.

Costos. La IA local no es gratis. Pagas una vez por hardware y continuamente por electricidad. Una PC con RTX 3060 cuesta alrededor de 800 a 1200 euros. Un Mac Studio con 64 GB ronda los 2500 euros. Los costos de energía con uso ocasional son bajos, en operación continua se suman 10 a 30 euros al mes. Frente a una suscripción en la nube de 20 a 50 euros por usuario al mes, una configuración local se amortiza en unos meses con uso intensivo.

Seguridad. La IA local no es automáticamente segura. Un modelo local puede dar respuestas incorrectas, producir alucinaciones o generar sugerencias de código dañinas. Además, algunos entornos de ejecución almacenan historiales de chat localmente. Quien procesa datos sensibles debe asegurar accesos, eliminar regularmente historiales de chat y no exponer el sistema abiertamente a internet. Una configuración local te protege contra fugas de datos a proveedores en la nube, pero no contra los errores del modelo mismo.

Enlaces y recursos útiles sobre IA local

• IA local vs. IA en la nube - Cuándo vale la pena cada enfoque
• Ejecutar LLMs localmente - Guía paso a paso
• Cuantización - Cómo reducir el tamaño de los modelos
• Longitud de contexto - Cuánto texto puede procesar un modelo
• Requisitos de RAM y VRAM - Planifica tu hardware
• Software de IA local - Resumen de todos los entornos de ejecución
• Ollama - La forma más sencilla de empezar
• RAG local - Haz tus documentos consultables
• Fundamentos de hardware para IA - Entiende el hardware
• ¿Qué es un agente de IA? - Agentes con modelos locales

Preguntas frecuentes sobre IA local

¿Necesito obligatoriamente una tarjeta gráfica para IA local?

No. Muchos modelos funcionan en CPU, aunque considerablemente más lento. Para una experiencia fluida y modelos más grandes, una GPU o Apple Silicon es mucho mejor.

¿Cuánta RAM o VRAM necesito?

Depende del modelo. Una variante 7B en cuantización 4-bits requiere aproximadamente 5 GB de VRAM. Un modelo 13B necesita entre 8 y 10 GB. Un modelo 70B requiere 40 GB o más. Encontrarás detalles en el artículo sobre requisitos de RAM y VRAM.

¿Son los modelos locales peores que ChatGPT?

No necesariamente. Los modelos en la nube grandes suelen tener más parámetros y entrenamiento. Modelos locales como Llama 3.1 8B o Qwen2.5 son suficientes para muchas tareas e incluso superiores a servicios en la nube más antiguos. La diferencia radica principalmente en el hardware requerido y en tareas muy exigentes de razonamiento.

¿Puedo usar mis propios documentos con IA local?

Sí. Con un RAG conectas un modelo local a una base de datos vectorial donde almacenas tus documentos. De esta forma, la IA responde preguntas basándose en tu contenido. Más información en RAG local.

¿Es realmente gratuita la IA local?

No hay costos de API, pero el hardware, la electricidad y el tiempo cuestan dinero. Si tienes una máquina existente con suficiente potencia, los costos operativos son bajos. Con una compra nueva o servidor, la inversión inicial aumenta.

¿Qué modelo debo usar como principiante?

Comienza con Llama 3.1 8B en cuantización 4-bits a través de Ollama. Es compacto, potente y bien documentado. Alternativamente, Qwen2.5 7B si trabajas con múltiples idiomas. Ambos funcionan en hardware desde 8 GB de VRAM.

¿Puedo usar IA local en un laptop?

Sí, si el laptop tiene suficiente memoria. Un Mac con chip M y 16 GB de memoria unificada es una buena opción. Laptops Windows con GPU dedicada de 6 GB VRAM o más funcionan bien con modelos pequeños. Laptops solo con CPU son posibles, pero lentos.

¿Qué tan rápida es la IA local?

En una RTX 3060 con un modelo 8B logras entre 20 y 60 tokens por segundo. En CPU entre 5 y 15. Apple Silicon varía entre 15 y 40 según el modelo. La velocidad depende del hardware, tamaño del modelo y cuantización.

¿Puedo conectar IA local a Internet?

Sí. Puedes configurar Ollama o LM Studio para que sean accesibles desde la red. Hazlo siempre con protección, por ejemplo mediante VPN o reverse proxy con autenticación. Un puerto abierto sin proteger es un riesgo de seguridad.

¿Cuál es la diferencia entre Ollama y LM Studio?

Ollama está orientado a línea de comandos y proporciona una API. LM Studio incluye una interfaz gráfica para buscar, cargar y probar modelos. Ambos utilizan llama.cpp bajo el capó. Para principiantes que prefieren GUI, LM Studio es más sencillo. Para automatización y operación de servidores, Ollama es mejor.

¿Necesito Internet para usar IA local?

Solo para descargar el modelo. Después funciona completamente offline. Esta es una de las grandes ventajas respecto a los servicios en la nube.

¿Puedo ejecutar varios modelos simultáneamente?

Sí, mientras tu memoria lo permita. Cada modelo cargado ocupa VRAM o RAM. Con 16 GB de VRAM puedes mantener un LLM 7B y un modelo de embedding en paralelo. Con varios modelos grandes rápidamente alcanzarás límites.

¿Cómo actualizo un modelo local?

Descargas la nueva versión y reemplazas el archivo antiguo. En Ollama basta ollama pull modellname. No hay actualización automática, tú decides cuándo cambiar.

¿Son seguros los modelos locales para datos sensibles?

Los modelos locales no envían datos hacia afuera. Es una mejora de seguridad respecto a los servicios en la nube. Sin embargo, el modelo puede dar respuestas incorrectas o producir alucinaciones. Verifica siempre las respuestas cuando trabajes con contenido sensible.

Fuentes y literatura adicional

• Documentación de Ollama: https://ollama.com
• Proyecto llama.cpp: https://github.com/ggerganov/llama.cpp
• LM Studio: https://lmstudio.ai
• Hugging Face Model Hub: https://huggingface.co
• Meta Llama: https://llama.meta.com
• Serie de modelos Qwen: https://qwenlm.github.io