Intermedio 11 minIDE

IntelliJ y JetBrains + Ollama: el asistente de IA local en tu IDE

Conectar IntelliJ (o PyCharm, WebStorm, GoLand…) con Ollama permite disponer de un asistente de código al estilo de Copilot que funciona en tu máquina: chat sobre tu proyecto, autocompletado al final de la línea y refactorización, sin que una sola línea se envíe a un servidor de terceros. Esta guía te ayuda a elegir entre los plugins compatibles con Ollama, muestra cómo conectar todo mediante un «proxy AI» e indica qué modelos de código elegir según tu tarjeta gráfica.

Por Thomas P.·Actualización 2026-08-27·Probado en Windows, macOS y Linux

#¿Por qué un LLM local en tu IDE?

Los asistentes en la nube (GitHub Copilot, JetBrains AI, Cursor) son prácticos, pero envían el contexto de tu código —a veces el archivo completo, a veces todo el repositorio— a servidores remotos. Para código sujeto a un NDA, software propietario o simplemente por principio, eso es inaceptable. Un LLM local conectado a IntelliJ soluciona el problema de raíz: el modelo se ejecuta en tu GPU, y ni el prompt ni el texto generado salen nunca de la máquina.

El otro argumento es el costo. Una suscripción a Copilot o JetBrains AI se paga mensualmente, indefinidamente. Una vez instalado Ollama y descargado un modelo de código, puedes completar código y conversar sin cuotas, sin facturación por token, incluso sin conexión. La contrapartida está en la calidad: un modelo local pequeño no iguala a un modelo de vanguardia en la nube, pero un Qwen 3.8 27B o un Devstral 24B se le acerca para el autocompletado y el chat habitual.

Confidencialidad
El código, los prompts y las respuestas permanecen en local. No se registra nada en la nube.
Sin suscripción
Sin costo recurrente una vez descargado el modelo. Uso ilimitado.
Sin conexión
Funciona en el tren, en una red aislada o detrás de un proxy empresarial estricto.
Control del modelo
Eliges el tamaño y la cuantización, y puedes cambiar de modelo según la tarea.

#Los plugins de JetBrains que hablan con Ollama

El kit Copiloto Local

Esta guía te lleva al modelo. El kit te lleva al copiloto que programa en tu editor.

  • Espacio en línea de por vida
  • PDF + archivos
  • Actualizaciones de por vida
El kit Copiloto Local →o todos los kits de por vida — 49 € →

El ecosistema JetBrains no ofrece soporte nativo universal para Ollama: hay que recurrir a un plugin del marketplace. Tres opciones cubren casi todas las necesidades, cada una con un punto fuerte diferente.

ProxyAI (ex-CodeGPT)
El más completo para uso local. Chat, autocompletado en línea, edición del texto seleccionado y un conector Ollama integrado. Es el «proxy AI» mencionado en el título: sirve de puente entre el IDE y el daemon Ollama.
Continue
De código abierto, muy configurable mediante un archivo de configuración. Chat, autocompletado y acciones sobre el código, con integración de Ollama como proveedor de primer nivel. Ideal si quieres ajustar cada modelo con precisión.
JetBrains AI Assistant
El asistente oficial de JetBrains. Desde 2025 puede conectarse a un modelo local mediante Ollama o LM Studio para funcionar sin conexión. Práctico si quieres seguir usando la herramienta de la propia JetBrains, pero menos flexible en el autocompletado local.
i
Un daemon, varios clientes
Todos estos plugins se conectan al mismo endpoint de Ollama (http://localhost:11434). Puedes instalar dos al mismo tiempo —por ejemplo, ProxyAI para el chat y Continue para la completación— siempre que apunten al mismo servidor. Ollama carga el modelo una sola vez en la VRAM.

#Prerrequisitos

Se supone que Ollama ya está instalado y funcionando. El resto se reduce a un IDE JetBrains reciente y al menos un modelo de código descargado.

Un IDE JetBrains 2024.1+
IntelliJ IDEA, PyCharm, WebStorm, GoLand, Rider, PhpStorm… Los plugins mencionados se instalan en toda la gama a través de la misma marketplace.
Ollama funcionando
El daemon instalado y accesible en http://localhost:11434. Prueba con ollama list antes de configurar nada.
Un modelo de chat/código
qwen3.5:9b es un buen punto de partida versátil (256k de contexto, visión). En Q4_K_M cabe en aproximadamente 6,6 GB de VRAM.
Se recomienda una GPU
El autocompletado debe responder en menos de un segundo para ser útil. Una RTX 3060 de 12 GB ejecuta un 7B con soltura; sin GPU, limita el uso al chat, no al autocompletado.
Terminal — preparar Ollama
# Vérifier que le daemon répond
ollama list

# Modèle de code polyvalent (chat + edit)
ollama pull qwen3.5:9b

# Tester l'API que les plugins vont utiliser
curl http://localhost:11434/api/tags

#Configurar ProxyAI + Ollama

ProxyAI (anteriormente CodeGPT) es el camino más directo hacia un asistente local completo en JetBrains. Su conector de Ollama gestiona el chat, la edición del texto seleccionado y el autocompletado, sin clave de API ni cuenta.

  1. 01
    Instalar el plugin
    Settings → Plugins → Marketplace, busca «ProxyAI» (o «CodeGPT» según la versión) e instálalo. Reinicia el IDE si se te solicita.
  2. 02
    Elegir el proveedor Ollama
    Settings → Tools → ProxyAI → Providers. Selecciona Ollama (Local) como proveedor, en lugar de las opciones en la nube (OpenAI, Anthropic…).
  3. 03
    Verificar la URL del servidor
    El campo Base URL debe apuntar a http://localhost:11434. Si Ollama está en otra máquina de la red, coloca su IP en lugar de localhost.
  4. 04
    Seleccionar el modelo
    En la lista de modelos, elige el que has descargado (por ejemplo, qwen3.5:9b). ProxyAI consulta a Ollama para listar los modelos disponibles.
  5. 05
    Probar el chat
    Abre el panel ProxyAI (ícono en la barra lateral), plantea una pregunta sobre un archivo abierto. La respuesta debe llegar localmente, sin advertencia de conexión externa.
→
Añadir contexto al chat
Selecciona código antes de abrir el chat o utiliza el comando para añadir un archivo al contexto: así, el modelo responde sobre tu código concreto en lugar de hacerlo sin contexto. Los modelos pequeños tienen una ventana de contexto limitada: no cargues todo el proyecto de golpe, céntrate en los archivos pertinentes.

#Continue y el AI Assistant nativo

Si prefieres ajustar cada detalle, Continue expone su configuración en un archivo en lugar de en menús. Allí se declaran explícitamente el proveedor Ollama, el modelo de chat y, por separado, el modelo de completación. Requiere más texto, pero es mucho más preciso, especialmente para asignar un modelo pequeño y rápido a la autocompletación y uno más grande al chat.

Continue — config.json (fragmento)
{
  "models": [
    {
      "title": "Qwen 3.5 9B",
      "provider": "ollama",
      "model": "qwen3.5:9b",
      "apiBase": "http://localhost:11434"
    }
  ],
  "tabAutocompleteModel": {
    "title": "Autocomplete",
    "provider": "ollama",
    "model": "qwen2.5-coder:7b-base",
    "apiBase": "http://localhost:11434"
  }
}

En JetBrains AI Assistant, el procedimiento está más pautado: en los ajustes del asistente, activa el uso de modelos locales y configúralo para conectarse a Ollama. Es útil para mantener una sola herramienta, pero el asistente nativo sigue estando pensado principalmente para la nube de JetBrains; su autocompletado local es menos maduro que el de ProxyAI o Continue. Para un uso serio y 100 % local, recomendamos más bien estos dos últimos.

#¿Qué modelos de código elegir según tu VRAM?

La regla es simple: cuanto mayor es el modelo, mejores son sus respuestas, pero más VRAM consume y más lentamente responde. Las familias Qwen 3.5 / Qwen 3.8 cubren toda la gama y son una referencia en 2026 para la programación en local; Devstral 24B (especializado en agentes de programación) y Granite 4.2 son buenas alternativas. Estas son las cifras de referencia con cuantización Q4_K_M (el mejor equilibrio entre tamaño y calidad).

Ligero 3B — ~2 GB VRAM
granite4.2:3b. Resolución rápida de problemas, preguntas sencillas, consumo muy bajo de recursos. Funciona incluso en una GPU pequeña o en CPU para usos no interactivos.
Polivalente 9B — ~6,6 GB de VRAM
qwen3.5:9b. El punto de equilibrio: rendimiento correcto en chat, edición y refactorización, 256k de contexto y visión. Pensado para una RTX 3060 de 12 GB / 4070 de 12 GB.
Confort 12B — ~7,6 GB VRAM
gemma4:12b. Significativamente mejor en razonamiento y refactorizaciones de múltiples archivos, multimodal y bajo licencia Apache 2.0. Funciona bien en un RTX 4080 de 16 GB.
De gama alta 27B — ~18 GB VRAM
qwen3.8:27b. El más cercano a los modelos en la nube para programar en local (262k de contexto, visión). Requiere una RTX 4090 de 24 GB o un Mac con Apple Silicon y 32 GB o más de memoria unificada. Consejo: configura su razonamiento en «low»; tiende a razonar en exceso por defecto.
i
Dos modelos, dos roles
El chat tolera la latencia; el autocompletado no. Por eso a menudo se separan los roles: un modelo potente (Gemma 4 12B o Qwen 3.8 27B) para el chat y la edición, y un modelo base dedicado (qwen2.5-coder:7b-base) para el autocompletado al escribir. Ollama mantiene los dos en memoria siempre que quepan en la VRAM.

#Autocompletado local: atención al FIM

El autocompletado al estilo de Copilot se basa en el «fill-in-the-middle» (FIM): el modelo debe completar el código en un punto intermedio, conociendo lo que precede Y lo que sigue al cursor. No todos los modelos lo admiten. Las variantes instruct están entrenadas para el chat, no para el FIM; para el autocompletado, utiliza las variantes base, diseñadas específicamente para ello.

Terminal — modelos de completación (base = FIM)
# Modèle base de référence pour le FIM (autocomplétion inline)
ollama pull qwen2.5-coder:7b-base

# En Q4_K_M il tient dans ~4,7 Go et reste LA référence 2026 pour la complétion
ollama list
Modelo base, no Instruct
Para el autocompletado, elige qwen2.5-coder:7b-base, que sigue siendo la referencia FIM en 2026. Un modelo instruct generará sugerencias demasiado verbosas o fuera de formato.
Rapidez ante todo
En el autocompletado, la velocidad prima sobre el grado de refinamiento. Un modelo base dedicado que responde en menos de medio segundo es más útil que un modelo de chat grande que tarda 2 segundos.
GPU casi obligatoria
Sin aceleración por hardware, el autocompletado llega demasiado tarde para seguir el ritmo al que escribes. Reserva entonces la IA local para el chat.
!
¿Autocompletado lento o incoherente?
Dos causas comunes: un modelo instruct usado donde se necesita un modelo base (el FIM falla), o un modelo demasiado grande para la GPU que se ejecuta parcialmente en la CPU. Revisa la etiqueta del modelo (-base) y supervisa la VRAM con nvidia-smi mientras escribes.

#Lo que la IA local aún no hace en el IDE

La IA local ha avanzado, pero aún existen diferencias con los asistentes en la nube de gama alta. Conviene conocerlas para ajustar tus expectativas y evitar decepciones.

El razonamiento sobre varios archivos
Los repositorios grandes superan la ventana de contexto de los modelos locales. El modelo ve los archivos que le das, no toda tu arquitectura. Copilot Workspace o Cursor indexan todo el proyecto; en local, esto todavía se hace de forma artesanal.
Modos de agente avanzados
Hacer que el modelo ejecute comandos, lance pruebas e itere en bucle (como en Cline/Cursor Agent) requiere un modelo que maneje de forma fiable el uso de herramientas. Los modelos locales pequeños suelen fallar en estas tareas; hay que optar por un modelo especializado en programación (Devstral 24B, Qwen3-Coder 30B o GLM 4.7 Flash) y aceptar fallos.
La calidad intrínseca al trabajar con código complejo
En algoritmos avanzados o frameworks recientes poco representados en el entrenamiento, un modelo local de 8 a 12B sigue por detrás de un modelo de vanguardia en la nube.
Una integración cuidada en el producto
Detección automática del lenguaje de programación, numerosas acciones contextuales, resolución de PR… las herramientas locales están acortando distancias, pero siguen un paso por detrás de la experiencia refinada de los asistentes comerciales.

En la práctica, la ejecución local destaca en el autocompletado, el chat sobre un archivo, la explicación de código y la refactorización localizada. Para tareas complejas con agentes y el análisis de un repositorio completo, la nube mantiene la ventaja; de ahí el interés de conservar ambas opciones y elegir cuál usar según la sensibilidad del código.

#Solución de problemas

El plugin no lista ningún modelo
No consigue conectarse a Ollama. Comprueba que el daemon esté funcionando (ollama list) y que la URL sea http://localhost:11434. Si Ollama está en otra máquina, inícialo con OLLAMA_HOST=0.0.0.0 y apunta a su IP.
« Connection refused »
Ollama no está arrancado o un firewall bloquea el puerto 11434. Prueba con curl http://localhost:11434/api/tags desde la misma máquina que el IDE.
El modelo no aparece en la lista
La etiqueta no coincide. Copia el nombre exacto devuelto por ollama list, incluyendo la etiqueta (qwen3.5:9b y no qwen3.5).
Respuestas muy lentas
El modelo no cabe por completo en la GPU y pasa a ejecutarse parcialmente en la CPU. Cambia a un tamaño menor o a Q4_K_M y comprueba con nvidia-smi que la GPU se esté utilizando correctamente.
Autocompletado vacío o absurdo
Estás usando un modelo instruct para el FIM. Cambia a una variante -base (qwen2.5-coder:7b-base).
El IDE se ralentiza durante la generación
Dos modelos cargados saturan la VRAM. Reduce el tamaño de uno o activa solo un plugin a la vez.

#Para ir más allá

La calidad del asistente local en el IDE depende del daemon y de la GPU que lo hacen funcionar. Estas guías complementan la puesta en marcha.

Instalar Ollama
Base: instalar y arrancar el daemon que sirve tus modelos de código en el puerto 11434.
Copilot gratuito local: Cline, Tabby & CodeGeeX en VS Code
El equivalente para VS Code, para comparar los enfoques y los plugins entre distintos editores.
Usar Ollama en Claude Code y Cursor
Para conectar los mismos modelos locales en otros asistentes y decidir entre local y nube según la tarea.
¿Esta guía te ha ayudado?

¿Un comentario, un error, una precisión? Avísanos, eso mejora la guía para todos.