LLMs en local: Monta tu copiloto local – Ollama, tu IDE y casos de uso reales

 

Por Daniel Contreras

¡Saludos, entusiasta de la tecnología! En esta segunda entrega pasamos de la teoría a la práctica para que puedas tener tu copiloto local funcionando de verdad en tu entorno diario.

Si en la primera parte definimos el porqué y el mapa del terreno, aquí nos enfocamos en el cómo: instalación de Ollama, integración con IDEs y casos de uso que aportan valor desde el primer día.

En la Parte 1 - LLMs en local: Por qué importan y qué necesitas en 2026 vimos por qué ejecutar LL

Ms en local, qué modelos destacan en 2026 y qué hardware necesitas. Si tu máquina tiene unos 8 GB de VRAM o RAM unificada libres, un modelo 7B (como Llama 3 o Qwen 2.5 Coder) es el punto de partida ideal.

En esta entrega pasamos a la práctica: instalación de Ollama, API en localhost:11434, integración con tu IDE y casos de uso por perfil profesional. Al final tendrás un flujo de punta a punta en unos 15 minutos.

Índice de esta entrega

1. Ollama: guía práctica de instalación y configuración
2. Integración con IDEs: VSCode, Continue, Cline y Cursor
3. Casos de uso prácticos por perfil profesional
4. Tu primer flujo de trabajo en 15 minutos

1. Ollama: guía práctica de instalación y configuración

1.1. Instalación

Ollama se instala en unos segundos. No requiere instalación de Python, CUDA ni dependencias adicionales en la mayoría de los casos: el instalador se encarga de todo. En macOS y Linux:

En Windows, descarga el instalador desde ollama.com.

Verifica la instalación:

En Linux, a veces hay que iniciar el servidor manualmente:

En Mac y Windows suele arrancar automáticamente y quedarse en la bandeja del sistema.

1.2. Tu primer modelo

Elegir el primer modelo puede abrumar: hay decenas de opciones. La regla práctica es empezar pequeño y subir si tu hardware y tus necesidades lo permiten. Un modelo 7B bien cuantizado es suficiente para la mayoría de tareas de desarrollo: refactorización, documentación, generación de boilerplate, sugerencias de código. Solo si necesitas razonamiento muy profundo o tareas que exigen «pensar paso a paso» vale la pena subir a 32B o más.

Para desarrollo, modelos recomendados en 2026:

• Uso general: llama3 (8B) — Rápido, equilibrado, buen español.
• Especializado en código: qwen2.5-coder o deepseek-coder — Excelentes para generación y refactorización.
• Razonamiento: deepseek-r1 — Si necesitas que «piense» antes de responder.
• Máquinas modestas: gemma2:2b o llama3.2:3b — Muy ligeros.

Descarga y ejecuta tu primer modelo:

A partir de ahí puedes chatear en la terminal. Sin internet. Sin latencia de red.

1.3. La API local

 

Ollama expone una API compatible con OpenAI en http://localhost:11434. Esto significa que cualquier cliente que hable el protocolo de OpenAI (incluidas las extensiones de VSCode, Cursor, scripts en Python, etc.) puede conectarse cambiando solo la URL base. No necesitas adaptadores ni wrappers adicionales. Para generar texto:

Para chat (formato OpenAI):

No requiere API key por defecto. Cualquier cliente compatible con OpenAI puede conectarse cambiando la URL base.

1.4. Gestión de modelos

 

Los modelos se almacenan en ~/.ollama (o C:\Users\<usuario>\.ollama en Windows). Un modelo 7B suele ocupar unos 4 GB

1.5. Permisos de red y Ollama en entornos restringidos

En algunos entornos corporativos, Ollama puede tener problemas para enlazar con el IDE si hay restricciones de red o firewall. Si tu portátil tiene muchas aplicaciones abiertas y se queda sin recursos, el modelo puede dejar de responder. En ese caso:

1. Cierra aplicaciones innecesarias para liberar RAM.
2. Usa un modelo más pequeño (3B–7B) si tu máquina es modesta.
3. Variable de entorno: En Linux, si necesitas permitir conexiones desde otros hosts, puedes usar OLLAMA_ORIGINS=* ollama serve para permitir CORS desde cualquier origen (útil para pruebas; en producción, restringe los orígenes).

1.6. Modelfiles: personalizar parámetros por defecto

Ollama permite crear modelos personalizados con parámetros por defecto usando Modelfiles. Por ejemplo, si quieres un Llama 3 con temperatura baja (más determinista) para código:

Crea un archivo Modelfile:

Luego crea el modelo:

A partir de ahí puedes usar ollama run mi-llama-codigo o referenciar mi-llama-codigo en tu IDE. Los Modelfiles también permiten añadir system prompts por defecto, útiles para definir el «personaje» del modelo (por ejemplo, «Eres un experto en Python. Responde de forma concisa y con ejemplos de código.»).

1.7. Prueba rápida con curl

Antes de configurar tu IDE, verifica que la API responde:

Si ves "response":"..." en la salida JSON, Ollama está funcionando correctamente.

2. Integración con IDEs: VSCode, Continue, Cline y Cursor

2.1. VSCode + Continue: tu copiloto open source

Continue es una extensión open source que convierte VSCode en un IDE con IA. Puede usar Ollama como backend en lugar de OpenAI.

Configuración:

. Instala la extensión Continue desde el Marketplace de VSCode.

. Abre el panel de Continue y pulsa el engranaje para editar config.json.

. Añade tu modelo local:

Truco: Usa un modelo pequeño (p. ej. starcoder2:3b) para el autocompletado por tab y uno más grande para el chat. Así el autocompletado es instantáneo y el chat mantiene buena calidad.

2.2. VSCode + Cline: el agente autónomo

Cline no es solo un chat: es un agente que puede crear archivos, ejecutar comandos en terminal y editar código por sí mismo.

Configuración:

. Instala la extensión Cline.

. En ajustes, selecciona API Provider: Ollama.

. Base URL: http://localhost:11434.

. Model ID: El nombre exacto del modelo, p. ej. llama3 o qwen2.5-coder.

Nota: Cline envía mucho contexto (archivos, estructura del proyecto) en cada turno. Asegúrate de que tu máquina aguante modelos con ventana de contexto amplia.

2.3. Cursor: el caso especial

Cursor es un IDE potente con IA integrada, pero su modelo de negocio está centrado en la nube (Claude, GPT-4). El soporte nativo para modelos locales es limitado o no oficial. La comunidad ha solicitado repetidamente soporte nativo para Ollama; a fecha de 2026, Cursor no ofrece integración oficial, pero el workaround con endpoint personalizado funciona de forma estable en la mayoría de versiones. Si Cursor es tu IDE principal y quieres combinar modelos locales con los de la nube, merece la pena dedicar unos minutos a configurarlo.

Workaround con endpoint personalizado:

. Ve a Settings > Models en Cursor.

. Busca la sección OpenAI API o «Override OpenAI Base URL».

. Base URL: http://localhost:11434/v1 (el /v1 es importante).

. API Key: Cualquier valor (p. ej. ollama); Ollama no la usa.

. Añade el nombre de tu modelo (p. ej. llama3) en la lista de modelos.

En versiones recientes de Cursor, los modelos locales suelen estar disponibles solo en modo Ask (chat), no en el modo Agent completo. Si Cursor rechaza conexiones a localhost, se puede usar ngrok para exponer Ollama como si fuera una API remota.

2.4. Alternativas: CodeGPT, Cody y otras extensiones

Extensiones como CodeGPT o Cody permiten configurar un endpoint OpenAI personalizado. La configuración típica es:

• URL: http://localhost:11434/v1/chat/completions
• API Key: Cualquier texto (Ollama no valida la key)

Con esto, cualquier extensión compatible con la API de OpenAI puede usar tu Ollama local.

 

2.5. Nota sobre Cursor y el modo Ask

En versiones recientes de Cursor, los modelos locales suelen estar disponibles solo en modo Ask (chat), no en el modo Agent completo que permite editar archivos automáticamente. Si necesitas el modo Agent con un modelo local, el workaround con ngrok (exponiendo el puerto 11434) puede permitir que Cursor trate tu Ollama como una API remota. Ten en cuenta las implicaciones de seguridad al exponer tu API a internet.

2.6. Integración desde código: Python y Node.js

Además de usarlo desde el IDE, puedes llamar a Ollama desde tus propios scripts. En Python, la librería ollama simplifica las peticiones:

Instalación: pip install ollama.

En Node.js, puedes usar fetch directamente contra la API

Esto permite integrar el LLM en pipelines de datos, scripts de automatización o aplicaciones internas sin depender de APIs externas.

2.7. Cursor: modos (Ask / Agent / Plan) para trabajar con IA

Cursor no es “un único chat”: incorpora modos de trabajo que cambian el nivel de autonomía, el tipo de tareas y (muy importante) cómo se gestiona el contexto. Con modelos locales esto se nota todavía más, porque su latencia/ventana de contexto pueden variar según el modelo y la cuantización.

• Ask: útil para entender el código (explicaciones, “¿dónde está X?”, revisar un diff, analizar una función) con menor riesgo de cambios involuntarios.
• Agent: útil para hacer cambios (refactors, tocar varios ficheros, ejecutar comandos, iterar sobre errores). Consume más contexto y requiere más supervisión.
• Plan: útil cuando hay incertidumbre o el cambio es grande. La idea es producir un plan revisable antes de tocar el código.

Documentación recomendada:

• Cursor: Agent modes
• Cursor: Agents (conceptos y mentalidad)

3. Casos de uso prácticos por perfil profesional

3.1.Desarrollador Backend

Generación de APIs. Necesitas crear un microservicio REST. Con el modelo local puedes pasarle el esquema de tu base de datos (anonimizado si quieres) y pedirle que genere controladores, rutas y validaciones. La ventaja: el código sensible no sale de tu máquina.

Ejemplo de prompt: «Genera una API RESTful en Flask para gestionar usuarios. Usa SQLAlchemy con SQLite. Incluye endpoints GET /users, POST /users, GET /users/:id. Con validación Pydantic y manejo deerrores.» El modelo entrega un esqueleto funcional que adaptas a tu proyecto.

Optimización de consultas SQL. Pegas una query de 50 líneas que tarda 2 segundos. El modelo sugiere índices, reescrituras o cambios de estrategia. Ejemplo de prompt: «Esta consulta tarda 2 segundos. Analízala y sugiéreme índices o una reescritura para optimizarla en PostgreSQL.»

Generación de tests. Pides tests unitarios para una función o un módulo. El modelo genera una batería básica que luego adaptas a las convenciones del proyecto. Por ejemplo: «Genera tests unitarios para esta función de Python usando pytest. Cubre casos límite y errores.»

3.2. Desarrollador Frontend

Migración de frameworks. Migrar de AngularJS a Angular 18 es un clásico dolor de cabeza. Con el modelo local puedes seleccionar un controlador antiguo y pedir: «Convierte este controlador de AngularJS en un componente standalone de Angular 18 usando Signals.» El modelo reemplaza $scope, $http y patrones obsoletos por las APIs modernas.

Depuración de estilos. Un div no se centra en móviles. Pegas el CSS y pides: «El div .card-header no se centra verticalmente en móviles. Arréglalo usando Flexbox.»

Generación de componentes. Pides un formulario de registro con validaciones, un componente de tabla con ordenación o un modal accesible. El modelo genera el esqueleto que luego ajustas.

Ejemplo con React: «Genera un componente React para un formulario de registro con campos nombre, email y contraseña. Usa useState para el estado, validación básica y manejo de submit.» El modelo entrega JSX con la estructura y la lógica que luego personalizas con tu diseño y tus reglas de validación.

3.3. DevOps

Infraestructura como código. Prompts como «Genera un Dockerfile multi-stage para una app Node.js y un Deployment de Kubernetes con 3 réplicas, livenessProbe en /health y límites de 512Mi RAM» producen YAML y Dockerfiles listos para revisar y adaptar. 

Scripts de automatización. «Escribe un script en Bash que limpie contenedores Docker huérfanos y rote logs de Nginx mayores de 100 MB.» Los modelos especializados en código (DeepSeek Coder, Qwen Coder) suelen dar muy buen resultado. 

CI/CD. «Genera un pipeline de GitHub Actions para un proyecto Python que ejecute tests, lint y despliegue a AWS.» 

Ejemplo de Jenkins pipeline: «Genera un Jenkinsfile para un pipeline de CI/CD con stages: Build (mvn clean package), Test (mvn test), Deploy (kubectl apply).» El modelo genera el Groovy que luego adaptas a tu Jenkins y tus nombres de artefactos.

3.4. Business Analyst / Analista de datos 

Consultas SQL desde lenguaje natural. «Tengo una tabla Ventas con columnas fecha, monto y región. Escríbeme la consulta SQL para el total de ventas por mes en la región Norte.» 

Resúmenes ejecutivos. Pegas un informe técnico largo y pides: «Resume esto en 3 puntos clave para presentar al CTO.» 

Análisis de tendencias. Con datos en CSV o descripciones de tablas, el modelo puede sugerir consultas, métricas o visualizaciones adecuadas. 

Ejemplo de script Python para visualización: Si necesitas un script para graficar tendencias de ventas, puedes pedir algo como: «Genera un script en Python con pandas y matplotlib para cargar un CSV con columnas fecha y monto, agrupar por mes y mostrar un gráfico de líneas.» El modelo genera el esqueleto que luego adaptas a tu estructura de datos real.

 

3.5. Cómo escribir prompts efectivos para modelos locales 

Los modelos locales, especialmente los más pequeños, se benefician de prompts claros y específicos. Algunas prácticas que mejoran los resultados: 

• Sé explícito sobre el contexto: En lugar de «Refactoriza esto», usa «Refactoriza este controlador de AngularJS a un componente de Angular 18 usando Signals. Mantén la misma lógica de negocio.»
• Indica el formato deseado: «Genera una función en Python. Incluye type hints, docstring y manejo de errores para entrada inválida.» 
• Divide tareas complejas: Si pides algo muy grande (por ejemplo, «Migra toda mi aplicación»), el modelo puede perderse. Mejor: «Migra este módulo primero» y luego el siguiente.
• Proporciona ejemplos cuando ayude: «Quiero un endpoint REST como este [pegar ejemplo], pero para la entidad Product en lugar de User.» 
• Pide iteraciones: Si la primera respuesta no encaja, refina: «El código funciona pero usa listas. ¿Puedes reescribirlo usando un dict para mejor rendimiento?»

Los modelos de 7B–8B tienen ventanas de contexto limitadas (típicamente 4K–8K tokens). Si tu prompt es muy largo, recorta: incluye solo el código relevante, no archivos enteros innecesarios. 

• Usa prompts específicos. Cuanto más contexto y detalle des, mejor será el resultado.
• Itera. Si la primera respuesta no encaja, refina el prompt o pide cambios concretos.
• Combina con documentación. En Cursor o Continue, enlaza documentación del framework que uses para que el modelo tenga referencias actualizadas.

 

3.6. Ejemplo completo: migración de AngularJS a Angular 18 

Un caso real que ilustra el poder de la IA local: migrar un controlador de AngularJS a un componente de Angular 18. En Cursor o Continue, con la documentación de Angular enlazada: 

Código original (AngularJS):

Prompt: «Convierte este controlador de AngularJS en un componente standalone de Angular 18. Usa Signals para el estado y HttpClient para las peticiones.» 

Código generado (Angular 18): 

 

El modelo ha reemplazado $scope por signal(), $http por HttpClient e inject, y ha adaptado la sintaxis al estándar moderno. Todo ello sin que el código salga de tu máquina. 

3.7. Generación de tests: un flujo completo 

Otro caso muy común es generar tests para código existente. Supongamos que tienes una función de Python:

Prompt: «Genera tests unitarios para esta función usando pytest. Cubre el caso n=0, n positivo, n negativo (debe lanzar ValueError) y n=1.» 

El modelo puede generar algo como:

Luego tú adaptas los imports a la estructura de tu proyecto y añades los casos que consideres necesarios. La IA hace el trabajo repetitivo; tú aportas el criterio.

4. Tu primer flujo de trabajo en 15 minutos

Si quieres probar todo el flujo de punta a punta sin leer cada sección, sigue estos pasos. Asumimos que tienes un Mac o PC con al menos 8 GB de RAM libre.

Paso 1 (2 min): Instala Ollama.

Paso 2 (3–5 min): Descarga y prueba un modelo.

Escribe «Explica qué es un API REST en una frase» y comprueba que responde. Sal con /bye.

Paso 3 (2 min): Verifica la API.

Si ves JSON con una respuesta, todo está bien. 

Paso 4 (5 min): Configura VSCode con Continue. 

1. Instala la extensión Continue. 
2. Abre el panel de Continue, pulsa el engranaje y edita config.json. 
3. Añade:

1. Selecciona «Llama 3 Local» en el desplegable de modelos. 
2. Abre un archivo de código, selecciona un fragmento y pregunta en el chat: «Refactoriza este código para mejorar su legibilidad.» 

Paso 5: Si todo funciona, ya tienes un copiloto local. A partir de aquí puedes probar otros modelos (ollama pull qwen2.5-coder), configurar Cline para tareas más complejas o explorar el despliegue en Docker si quieres compartir el servicio con tu equipo.

Preguntas frecuentes

¿Puedo usar Ollama sin GPU? Sí. Funcionará en CPU, pero la inferencia será más lenta. En un Mac con Apple Silicon, la GPU integrada se usa automáticamente. 

¿Ollama consume recursos cuando no lo uso? Cuando un modelo está cargado, ocupa RAM/VRAM. Si no haces peticiones durante un rato, Ollama puede descargar el modelo de memoria para liberar recursos; la siguiente petición tardará un poco más en cargarlo de nuevo. 

¿Los modelos se actualizan solos? No. Debes ejecutar ollama pull nombre-modelo de nuevo para obtener versiones actualizadas. Ollama te avisará si hay una versión más reciente al listar modelos. 

¿Puedo usar varios modelos a la vez? Ollama puede tener varios modelos descargados, pero solo uno cargado en memoria a la vez por defecto. Cada petición especifica qué modelo usar; si cambias de modelo, el anterior se descarga y se carga el nuevo. 

¿Funciona en Windows con WSL? Sí. Puedes instalar Ollama en Windows nativo o en WSL2. La versión Windows tiene instalador gráfico; en WSL2 usas el script de instalación de Linux. 

¿Puedo usar Ollama en un servidor remoto y conectarme desde mi IDE? Sí. Si tienes Ollama corriendo en un servidor (por ejemplo, 192.168.1.100:11434), configura tu IDE con esa URL en lugar de localhost. Asegúrate de que el firewall permita el puerto 11434 y de que estés en una red de confianza. 

¿Qué pasa si mi empresa bloquea la descarga de modelos? Los modelos se descargan desde los servidores de Ollama. Si hay restricciones de red, puede que tengas que usar un proxy o descargar los modelos manualmente desde otra máquina y copiarlos a ~/.ollama/models. La documentación de Ollama explica cómo importar modelos desde archivos GGUF. 

¿Ollama guarda historial de mis conversaciones? Por defecto, Ollama no persiste el historial de chat. Cada petición es independiente a menos que uses la API de chat y pases el historial de mensajes en la misma petición. Las extensiones como Continue o Cline gestionan su propio historial en el IDE. 

¿Puedo usar varios modelos a la vez en Ollama? Ollama carga un modelo a la vez en memoria. Si haces una petición con un modelo distinto al que está cargado, Ollama descargará el actual y cargará el nuevo. El cambio puede tardar unos segundos. Para uso concurrente de varios modelos, necesitarías varias instancias de Ollama en puertos distintos (por ejemplo, una por modelo). 

Siguiente paso: del portátil al equipo 

Ya tienes un copiloto local en tu flujo diario. Cuando pase de «solo yo» a «todo el equipo», o necesites Docker, Kubernetes, optimizar rendimiento o decidir local vs nube con criterio, sigue en la tercera entrega. 

Continúa en la Parte 3: LLM local en producción — Docker, rendimiento, seguridad y estrategia.

Link: Parte 1 - LLMs en local: Por qué importan y qué necesitas en 2026

Despedida 

Con esta segunda parte ya tienes una guía práctica para poner un LLM local a trabajar contigo en el día a día. En la tercera entrega cerraremos con operación en equipo, seguridad, rendimiento y decisión estratégica para entornos reales.