Cline + Ollama : agente de código 100 % local no VS Código

#Por que usar um agente Cline localmente

Cline (anteriormente Claude Dev) é uma extensão do VS Code que controla um LLM em um ciclo de agente: ele planeja, edita vários arquivos, executa comandos no terminal, lê a saída e faz correções. Diferentemente de uma simples sugestão de autocompletar no próprio código, ele atua como um executor que assume tarefas inteiras — escrever uma função, migrar um módulo, depurar uma stack trace.

Associá-lo ao Ollama em vez de a uma API de nuvem traz três benefícios concretos: seu código proprietário nunca sai do computador, não há custo por token (Cline consome uma quantidade enorme de contexto, o que faz os custos na nuvem subirem rapidamente) e o agente funciona offline. O preço a pagar: um bom modelo de código local exige VRAM, e as configurações padrão do Ollama não são adequadas para uso com agentes.

#Pré-requisitos

VS Code

Versão recente (1.90+). O Cline também funciona em forks compatíveis com Open VSX (VSCodium, Cursor), mas este guia se destina ao VS Code padrão.

Ollama instalado

O daemon deve estar em execução e escutar em http://localhost:11434. Se isso ainda não foi feito, ver nosso guia de instalação do Ollama.

Um GPU com quantidade suficiente de VRAM

No mínimo 16 GB para usar um agente com conforto, 24 GB para os modelos de ponta. Rodar apenas na CPU ainda é possível, mas é lento demais para o ciclo do agente.

Projeto aberto no VS Code

Cline atua no diretório do workspace atual: abra um repositório real, não um arquivo isolado.

#Escolher o modelo de acordo com a VRAM

A escolha do modelo tem prioridade sobre todo o resto: um agente Cline encadeia chamadas a ferramentas, leitura de arquivos e diffs, então precisa de um modelo que siga as instruções e respeite o formato das ferramentas. Três perfis cobrem a maioria das placas em 2026.

24 GB (RTX 4090, 3090, RX 7900 XTX) — Qwen3-Coder 32B

O melhor agente local hoje. Em Q4_K_M, ele ocupa ~19 GB, deixando margem para um contexto de 32k. É o modelo a escolher se sua placa der conta.

16 GB (RTX 4080, 5070 Ti, 4060 Ti 16GB) — Devstral Small 2

Modelo Mistral especializado em agentes de código, otimizado para funcionar em 16 GB em Q4_K_M com contexto útil. O melhor equilíbrio nessa faixa de placas.

Generalista sólido — Qwen 3.6 27B

Se você quiser um único modelo para código e o restante, a variante 27B cabe em 24 GB em Q4 e se sai muito bem como agente. Um nível abaixo de Qwen3-Coder no código puro, mas mais versátil.

Evite modelos abaixo de 14B para uso como agente: eles quebram o formato das chamadas de ferramentas, entram em loop ou propõem diffs que não podem ser aplicados. Um modelo pequeno e rápido é excelente para autocompletar código inline (via Tabby ou Continue), mas não para controlar o Cline.

#1. Preparar o Ollama

Verifique primeiro se o Ollama está rodando, depois baixe o modelo escolhido. Aqui usamos o Qwen3-Coder 32B como exemplo — substitua a tag pela que corresponde à sua VRAM.

# Vérifier que le daemon répond
curl http://localhost:11434/api/version

# Tirer le modèle de code (adapter au tag exact affiché sur ollama.com)
ollama pull qwen3-coder:32b

# Alternatives selon la VRAM
ollama pull devstral-small-2   # 16 Go
ollama pull qwen3.6:27b        # généraliste 24 Go

# Lister ce qui est installé
ollama list

#2. Configurar o contexto do Ollama

É esta etapa que todo mundo erra. Por padrão, o Ollama serve modelos com uma janela de contexto de 4096 tokens. Mas o Cline envia o conteúdo de vários arquivos, o histórico da tarefa e as definições de ferramentas: com 4k, o agente esquece o início da própria tarefa a cada rodada e se torna inutilizável.

É necessário aumentar num_ctx. A forma correta é criar um modelo derivado via Modelfile, para que a configuração seja permanente e independente do Cline.

# Fichier : Modelfile
FROM qwen3-coder:32b

# Contexte élargi pour l'usage agent (32k)
PARAMETER num_ctx 32768

# Un peu de déterminisme pour le code
PARAMETER temperature 0.2

# Créer le modèle dérivé
ollama create qwen3-coder-agent -f Modelfile

# Il apparaît désormais dans la liste
ollama list

#3. Instalar Cline

1. 01
   Abrir o Marketplace

   No VS Code, abra o painel Extensions (Ctrl+Shift+X).
2. 02
   Procurar Cline

   Digite « Cline » na barra de pesquisa. A extensão oficial é publicada pela « Cline Bot Inc. » — verifique o publicador para evitar clones.
3. 03
   Instalar e fixar

   Clique em Instalar. Um ícone do Cline aparece na barra lateral de atividades; fixe-o para acessá-lo rapidamente.

#4. Conectar o Cline ao Ollama

O Cline oferece suporte nativo ao Ollama: não é necessário improvisar uma URL de API compatível com a OpenAI. Abra o painel Cline, clique no ícone de configurações e, em seguida, configure o provedor.

1. 01
   API Provider → Ollama

   Na lista suspensa « API Provider », selecione « Ollama ».
2. 02
   URL base

   Deixe http://localhost:11434 (valor padrão). Mude apenas se Ollama estiver rodando em outra máquina ou em um contêiner.
3. 03
   Model

   Selecione qwen3-coder-agent (o modelo derivado criado na etapa 2), não o modelo bruto com 4k de contexto.
4. 04
   Verificar a janela de contexto

   O Cline exibe um campo “Context Window”. Alinhe-o ao num_ctx do Modelfile (32768). Uma diferença entre esses valores faz com que o Cline trunque os prompts antes mesmo de chegarem ao Ollama.

#5. Primeira execução em modo agente

Abra um projeto real, depois dê uma tarefa concreta e limitada para Cline. Os bons primeiros testes são aqueles que envolvem poucos arquivos: adicionar um teste, corrigir um bug identificado, escrever uma pequena função utilitária.

Ajoute une fonction `slugify(texte)` dans src/utils/strings.js qui met en minuscules, remplace les accents et les espaces par des tirets. Écris aussi un test unitaire dans le fichier de tests existant à côté.

Cline vai ler a pasta, propor um diff e pedir que você valide cada edição e cada comando. Aprove cada ação passo a passo na primeira vez para entender seu comportamento. Quando se sentir confiante, você pode ativar a aprovação automática de algumas ações (leitura de arquivos, comandos não destrutivos) nas configurações.

#Armadilhas comuns

O agente esquece sua tarefa

Quase sempre é um problema de contexto: num_ctx muito baixo no Ollama ou Context Window mal configurada no Cline. Alinhe novamente os dois valores.

Os diffs não se aplicam

O modelo é pequeno demais ou tem quantização excessiva para respeitar o formato de edição. Passe para um modelo maior (14B → 27B/32B) ou mude de Q3 para Q4_K_M.

A inferência passa a usar a CPU

O modelo mais o contexto ultrapassam a capacidade da VRAM. Verifique `ollama ps`; reduza num_ctx ou escolha um modelo menor. Um agente executado parcialmente na CPU torna-se inutilizável.

Loops infinitos de chamadas de ferramentas

Alguns modelos executam novamente o mesmo comando. Primeiro, mude para Plan Mode e divida a tarefa em subtarefas menores.

Conexão recusada

O Ollama não está escutando conexões ou está escutando em uma URL diferente da esperada. Teste `curl http://localhost:11434/api/version`. Em um contêiner, exponha a porta e configure o Cline para usar o endereço correto.

#Para se aprofundar

Você tem um agente Cline 100% local que edita seu código sem expor nada. Dois próximos passos naturais: refinar a escolha do modelo e complementar com o preenchimento automático inline que o Cline não oferece.

Melhor LLM local para codar em 2026

Comparativo entre Devstral, Qwen3-Coder e alternativas, com VRAM e qualidade de código — para refinar a escolha do modelo conectado ao Cline.

Continue.dev adquirido por Cursor: migrar para Cline

Se você veio do Continue.dev, o guia dedicado à exportação e à migração da sua configuração para este mesmo setup.

Escolher sua quantização (Q4, Q5, Q8, FP16)

Entender os compromissos entre qualidade e VRAM para acomodar o maior modelo possível na sua placa.