Intermediário 11 minIDE

IntelliJ e JetBrains + Ollama: o assistente de IA local no seu IDE

Integrar o IntelliJ (ou PyCharm, WebStorm, GoLand…) ao Ollama é ter um assistente de código no estilo Copilot, mas que roda na sua máquina: chat sobre seu projeto, autocompletar no fim da linha, refatoração — sem que uma única linha seja enviada a um servidor de terceiros. Este guia seleciona os plugins compatíveis com o Ollama, mostra como conectar tudo por meio de um « proxy AI » e indica quais modelos de código escolher de acordo com sua placa de vídeo.

Por Thomas P.·Atualização 2026-08-27·Testado no Windows, macOS e Linux

#Por que um LLM local no seu IDE

Assistentes na nuvem (GitHub Copilot, JetBrains AI, Cursor) são práticos, mas enviam o contexto do seu código — às vezes o arquivo inteiro, às vezes todo o repositório — para servidores remotos. Para código sob NDA, software proprietário ou simplesmente por princípio, isso é inaceitável. Um LLM local integrado ao IntelliJ resolve o problema pela raiz: o modelo roda na sua GPU, e o prompt e a resposta gerada nunca saem da máquina.

O outro argumento é o custo. Uma assinatura do Copilot ou do JetBrains AI é paga mensalmente, indefinidamente. Uma vez instalado o Ollama e baixado um modelo de código, você usa a compleção de código e conversa sem cotas, sem cobrança por token, inclusive offline. A contrapartida está na qualidade: um pequeno modelo local não se iguala a um modelo de ponta em nuvem, mas um Qwen 3.8 27B ou um Devstral 24B se aproxima dele na compleção e nas conversas do dia a dia.

Privacidade
O código, os prompts e as respostas permanecem locais. Nada é registrado em logs na nuvem.
Sem assinatura
Nenhum custo recorrente após o modelo ser baixado. Uso ilimitado.
Offline
Funciona no trem, em uma rede isolada ou atrás de um proxy corporativo com restrições rigorosas.
Controle do modelo
Você escolhe o tamanho, a quantização e pode mudar de modelo conforme a tarefa.

#Plugins JetBrains que falam com Ollama

O kit Copiloto Local

Este guia leva você ao modelo. O kit leva você ao copiloto que programa no seu editor.

  • Espaço online vitalício
  • PDF + arquivos
  • Atualizações vitalícias
O kit Copiloto Local →ou todos os kits vitalícios — 49 € →

O ecossistema JetBrains não oferece suporte nativo universal ao Ollama: é necessário usar um plugin do marketplace. Três opções cobrem quase todas as necessidades, cada uma com um ponto forte diferente.

ProxyAI (ex-CodeGPT)
O mais completo para uso local. Chat, autocompletar em linha, edição do trecho selecionado e um conector Ollama integrado. É o “proxy AI” mencionado no título: ele faz a ponte entre a IDE e o daemon Ollama.
Continue
Open source, com muitas opções de ajuste por meio de um arquivo de configuração. Chat, autocompletação e ações sobre o código, com suporte de primeira classe ao Ollama como provedor. Ideal se você quiser ajustar cada modelo com precisão.
JetBrains AI Assistant
O assistente oficial da JetBrains. Desde 2025, ele permite se conectar a um modelo local via Ollama ou LM Studio para o modo offline. Útil se você quiser continuar usando a ferramenta da própria JetBrains, mas menos flexível para a conclusão local de código.
i
Um daemon, vários clientes
Todos esses plugins se conectam ao mesmo endpoint do Ollama (http://localhost:11434). Você pode instalar dois em paralelo — por exemplo, ProxyAI para o chat e Continue para o autocompletar — desde que apontem para o mesmo servidor. O modelo é carregado apenas uma vez na VRAM pelo Ollama.

#Pré-requisitos

Supõe-se que Ollama já esteja instalado e funcionando. O restante exige apenas um IDE JetBrains recente e pelo menos um modelo de código baixado.

Um IDE JetBrains 2024.1+
IntelliJ IDEA, PyCharm, WebStorm, GoLand, Rider, PhpStorm… Os plugins acima podem ser instalados em toda a linha por meio do mesmo marketplace.
Ollama funcionando
O daemon instalado e acessível em http://localhost:11434. Teste com o comando ollama list antes de configurar qualquer coisa.
Um modelo de chat/código
qwen3.5:9b é um bom ponto de partida versátil (256k de contexto, visão). Em Q4_K_M, cabe em aproximadamente 6,6 GB de VRAM.
Uma GPU recomendada
O preenchimento automático deve responder em menos de um segundo para ser útil. Uma RTX 3060 de 12 GB roda um 7B com folga; sem GPU, limite-se ao chat, não ao preenchimento automático.
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) é o caminho mais direto para um assistente local completo nos IDEs da JetBrains. Seu conector Ollama gerencia o chat, a edição do trecho selecionado e a autocompletação, sem chave de API nem conta.

  1. 01
    Instalar o plugin
    Settings → Plugins → Marketplace, procure «ProxyAI» (ou «CodeGPT» conforme a versão) e instale-o. Reinicie o IDE se solicitado.
  2. 02
    Escolher o fornecedor Ollama
    Settings → Tools → ProxyAI → Providers. Selecione Ollama (Local) como provedor, em vez das opções de nuvem (OpenAI, Anthropic…).
  3. 03
    Verificar a URL do servidor
    O campo Base URL deve apontar para http://localhost:11434. Se o Ollama estiver rodando em outra máquina da rede, coloque o endereço IP dela no lugar de localhost.
  4. 04
    Selecionar o modelo
    Na lista de modelos, escolha o que você baixou (por exemplo, qwen3.5:9b). O ProxyAI consulta o Ollama para listar os modelos disponíveis.
  5. 05
    Testar o chat
    Abra o painel ProxyAI (ícone na barra lateral), faça uma pergunta sobre um arquivo aberto. A resposta deve chegar localmente, sem aviso de conexão externa.
→
Adicionar contexto ao chat
Selecione o código antes de abrir o chat, ou use o comando para adicionar um arquivo ao contexto: o modelo responderá então com base no seu código específico, em vez de responder sem contexto. Modelos pequenos têm uma janela de contexto limitada — não coloque todo o projeto de uma vez, foque nos arquivos relevantes.

#Continue e o AI Assistant nativo

Se você preferir configurar cada detalhe, o Continue disponibiliza sua configuração em um arquivo em vez de menus. Nesse arquivo, você declara explicitamente o provedor Ollama, o modelo de chat e — separadamente — o modelo de completamento. Isso exige mais texto, mas é muito mais preciso, especialmente para atribuir um modelo pequeno e rápido ao completamento automático e um maior ao chat.

Continue — config.json (trecho)
{
  "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"
  }
}

No JetBrains AI Assistant, o procedimento é mais estruturado: nas configurações do assistente, ative o uso de modelos locais e configure a conexão com o Ollama. Isso é útil para manter uma única ferramenta, mas o assistente nativo continua sendo pensado principalmente para a nuvem da JetBrains; sua funcionalidade de completar código localmente é menos madura que a do ProxyAI ou do Continue. Para um uso sério e 100% local, recomendamos esses dois últimos.

#Quais modelos de código escolher de acordo com sua VRAM

A regra é simples: quanto maior o modelo, melhores são suas respostas, mas maior é seu consumo de VRAM e mais lentamente ele responde. As famílias Qwen 3.5 / Qwen 3.8 cobrem toda a gama e são referências em 2026 para programação com modelos locais; Devstral 24B (especializado em agentes de programação) e Granite 4.2 são boas alternativas. Aqui estão os valores de referência com quantização Q4_K_M (o melhor equilíbrio entre tamanho e qualidade).

Leve 3B — ~2 GB VRAM
granite4.2:3b. Ajuda rápida para resolver problemas, perguntas simples, consumo de recursos muito baixo. Roda até em uma GPU pequena ou na CPU para uso não interativo.
Polivalente 9B — ~6,6 GB de VRAM
qwen3.5:9b. O ponto de equilíbrio: desempenho satisfatório em chat, edição e refatoração, 256k de contexto e visão. Destinado a uma RTX 3060 de 12 GB / 4070 de 12 GB.
Conforto com 12B — ~7,6 GB de VRAM
gemma4:12b. Muito melhor em raciocínio e refatorações que envolvem vários arquivos, multimodal e sob licença Apache 2.0. Funciona bem em uma RTX 4080 de 16 GB.
Topo de linha 27B — ~18 GB de VRAM
qwen3.8:27b. O mais próximo da nuvem para código local (262k de contexto, visão). Exige uma RTX 4090 de 24 GB ou um Mac Apple Silicon com 32 GB ou mais de memória unificada. Dica: altere seu raciocínio para "low", ele tende a refletir demais por padrão.
i
Dois modelos, dois papéis
O chat tolera a latência; a completação não. Por isso, os papéis costumam ser separados: um modelo robusto (Gemma 4 12B ou Qwen 3.8 27B) para o chat e a edição, e um modelo base dedicado (qwen2.5-coder:7b-base) para a autocompletação durante a digitação. O Ollama mantém os dois na memória enquanto couberem na VRAM.

#Autocompletação local: atenção ao FIM

O preenchimento de código no estilo Copilot baseia-se no « fill-in-the-middle » (FIM): o modelo deve completar o código no meio, conhecendo o que vem antes E o que vem depois do cursor. Nem todos os modelos oferecem suporte a isso. As variantes instruct são treinadas para chat, não para FIM — para o preenchimento automático, use as variantes base, especificamente projetadas para isso.

Terminal — modelos de completação (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, não instruct
Para a autocompletação, escolha qwen2.5-coder:7b-base, que continua sendo a referência em FIM em 2026. Um modelo instruct produzirá sugestões de autocompletação prolixas ou fora do formato.
Rápido acima de tudo
Na autocompletação, a velocidade importa mais que o refinamento. Um modelo base dedicado que responde em menos de meio segundo é mais útil do que um modelo grande de chat que leva 2 segundos.
GPU quase obrigatória
Sem aceleração de hardware, as sugestões de autocompletar chegam tarde demais para acompanhar a digitação. Reserve então a IA local para o chat.
!
Autocompletar lento ou incoerente?
Duas causas comuns: um modelo instruct usado onde é necessário um modelo base (o FIM falha) ou um modelo grande demais para a GPU, cuja execução passa parcialmente para a CPU. Verifique o tag do modelo (-base) e monitore a VRAM com nvidia-smi enquanto digita.

#O que a IA local ainda não faz na IDE

A IA local avançou, mas ainda há diferenças em relação aos assistentes de ponta na nuvem. Vale a pena conhecê-las para ajustar suas expectativas e evitar decepções.

O raciocínio envolvendo vários arquivos
Os grandes repositórios ultrapassam a janela de contexto dos modelos locais. O modelo vê os arquivos que você lhe fornece, não a sua arquitetura inteira. Copilot Workspace ou Cursor indexam todo o projeto; localmente, isso ainda é feito de forma artesanal.
Modos avançados de agente
Fazer executar comandos, rodar testes e iterar em loop (como no Cline/Cursor Agent) exige um modelo que gerencie o uso de ferramentas de forma confiável. Os pequenos modelos locais frequentemente falham nessa tarefa; é preciso buscar um modelo dedicado à programação (Devstral 24B, Qwen3-Coder 30B ou GLM 4.7 Flash) e aceitar falhas.
A qualidade intrínseca em tarefas de código complexo
Sobre algoritmos avançados ou frameworks recentes pouco representados no treinamento, um modelo local de 8 a 12B continua atrás de um modelo em nuvem de ponta.
A integração refinada ao produto
Detecção automática da linguagem, numerosas ações contextuais, resolução de PR… as ferramentas locais estão diminuindo a diferença, mas ainda ficam um passo atrás da experiência refinada dos assistentes comerciais.

Na prática, a execução local se destaca na completação, no chat sobre um arquivo, na explicação de código e na refatoração localizada. Para tarefas complexas com agentes e a análise de um repositório inteiro, a nuvem mantém a vantagem — daí o interesse em manter as duas opções e direcionar as solicitações conforme a sensibilidade do código.

#Solução de problemas

O plugin não lista nenhum modelo
O plugin não consegue se conectar ao Ollama. Verifique se o daemon está rodando (ollama list) e se a URL é mesmo http://localhost:11434. Se Ollama estiver em outra máquina, inicie-o com OLLAMA_HOST=0.0.0.0 e aponte para o IP dessa máquina.
« Connection refused »
O Ollama não está em execução ou um firewall está bloqueando a porta 11434. Teste com curl http://localhost:11434/api/tags na mesma máquina em que o IDE está rodando.
O modelo não aparece na lista
A tag não corresponde. Copie o nome exato retornado por ollama list, incluindo a tag (qwen3.5:9b e não qwen3.5).
Respostas muito lentas
O modelo não cabe inteiramente na VRAM e é executado parcialmente na CPU. Mude para um modelo menor ou para Q4_K_M e verifique com nvidia-smi se a GPU está de fato sendo utilizada.
Completação vazia ou absurda
Você está usando um modelo instruct para o FIM. Mude para uma variante -base (qwen2.5-coder:7b-base).
O IDE fica lento durante a geração
Dois modelos carregados saturam a VRAM. Reduza o tamanho de um deles ou ative apenas um plugin de cada vez.

#Para se aprofundar

A utilidade do assistente local no IDE depende do daemon e da GPU que o sustentam. Esses guias complementam a configuração.

Instalar Ollama
Base: instalar e iniciar o daemon que serve seus modelos de código na porta 11434.
Copilot gratuito local: Cline, Tabby & CodeGeeX no VS Code
O equivalente no VS Code, para comparar as abordagens e os plugins entre editores.
Usar Ollama em Claude Code e Cursor
Para conectar os mesmos modelos locais em outros assistentes e decidir entre local e nuvem de acordo com a tarefa.
Este guia ajudou você?

Um comentário, um erro ou uma observação? Avise-nos; isso ajuda a melhorar o guia para todos.