Como habilitar e configurar o JetBrains AI Assistant em IDEs compatíveis

O JetBrains AI Assistant integra recursos de programação com IA generativa, agentes autônomos de múltiplas etapas e inteligência semântica de código profunda diretamente aos ambientes de desenvolvimento da JetBrains, incluindo IntelliJ IDEA, PyCharm, WebStorm, GoLand, CLion, Rider, PhpStorm, RubyMine, RustRover, DataGrip e DataSpell. Em vez de operar como uma interface de chat isolada ou um preditor genérico de texto, o assistente conecta-se ao índice de projeto interno da IDE, às árvores de sintaxe abstrata (AST) e aos sistemas de controle de versão para fornecer geração de código ciente de contexto, autocompletações de múltiplas linhas, sugestões para a próxima edição (Next Edit Suggestions), criação automatizada de testes e refatoração estrutural. A implantação e configuração bem-sucedidas do JetBrains AI Assistant exigem que desenvolvedores de software e líderes de engenharia verifiquem os pré-requisitos de versão da IDE, concluam a instalação e ativação de licenças em níveis individuais ou corporativos, ajustem os parâmetros de preenchimento no editor, estabeleçam regras de projeto no nível do repositório e configurem limites de segurança em relação a provedores de modelos e ferramentas externas do Model Context Protocol (MCP).

Compatibilidade de IDE e pré-requisitos de versão

Antes de habilitar o JetBrains AI Assistant, os desenvolvedores devem assegurar que seu ambiente local atenda a critérios específicos de tempo de execução, plataforma e governança organizacional.

Ambientes compatíveis e versões de base da IDE

O JetBrains AI Assistant é distribuído como um plugin disponível em todo o ecossistema de produtos da JetBrains. As IDEs compatíveis exigem versões de base específicas:

• IDEs comerciais da JetBrains: Compatível com a versão 2023.3 ou posterior em todas as IDEs comerciais, incluindo IntelliJ IDEA Ultimate, PyCharm Professional, WebStorm, CLion, GoLand, Rider, PhpStorm, RubyMine, RustRover, DataGrip e DataSpell.
• IDEs Community Edition: Requer a versão 2024.1.1 ou posterior para edições Community de código aberto (como IntelliJ IDEA Community Edition ou PyCharm Community Edition). Para vincular uma assinatura organizacional do JetBrains AI em edições Community, as equipes devem executar a versão 2024.2.1 ou mais recente.
• Suporte multiplataforma: Suportado em estações de trabalho de 64 bits em Windows, macOS (Intel e Apple Silicon) e Linux que atendam aos requisitos padrão de sistema da IDE hospedeira.

Topologias de computação: LLMs em nuvem vs. hardware local

Por padrão, o JetBrains AI Assistant executa inferências por meio de modelos de linguagem grandes hospedados na nuvem e gerenciados pelo serviço JetBrains AI ou por provedores de API terceirizados. Nessa configuração, as estações de trabalho dos desenvolvedores apresentam impacto insignificante em CPU, GPU ou consumo de bateria.

No entanto, equipes que utilizam modelos de pesos abertos auto-hospedados (como Ollama ou endpoints privados de inferência compatíveis com OpenAI) devem alocar capacidade computacional dedicada na estação de trabalho, incluindo VRAM dedicada suficiente (normalmente de 8 GB a 24 GB, dependendo da quantização de parâmetros) para suportar o streaming de tokens em tempo real.

Pré-requisitos organizacionais

Para desenvolvedores que utilizam licenças de IDE fornecidas por um empregador ou instituição de ensino, o acesso aos recursos de IA é gerenciado no nível organizacional:

1. Um administrador da organização deve habilitar o serviço JetBrains AI no console corporativo do JetBrains Account.
2. Se a organização mantiver políticas rigorosas de segurança ou governança de propriedade intelectual, os administradores poderão alocar cotas compartilhadas de créditos ou designar provedores terceirizados aprovados antes que os desenvolvedores possam concluir a ativação.

Instalação e ativação do JetBrains AI Assistant

O plugin JetBrains AI Assistant não vem habilitado por padrão em instalações pessoais e não acessará o código-fonte proprietário até que seja explicitamente instalado e ativado.

Métodos de instalação

Os desenvolvedores podem instalar o plugin por meio de três pontos de entrada principais nas IDEs compatíveis:

1. JetBrains Marketplace (Settings):
   • Navegue até Settings (no Windows/Linux) ou Preferences (no macOS) via Ctrl+Alt+S ou Cmd+,.
   • Selecione Plugins na barra lateral esquerda e acesse a aba Marketplace.
   • Pesquise por AI Assistant no campo de busca.
   • Clique em Install na entrada oficial do plugin da JetBrains e reinicie a IDE, caso solicitado.
2. Janela de ferramentas AI Chat:
   • Clique no ícone AI Chat na barra de ancoragem lateral de ferramentas à direita.
   • Clique no botão Install Plugin exibido na janela vazia para iniciar a instalação em segundo plano.
3. Widget de cabeçalho da janela JetBrains AI:
   • No cabeçalho da interface moderna da IDE, localize o widget de status JetBrains AI.
   • Clique em Let's Go para baixar e inicializar o plugin automaticamente.

Níveis de licenciamento e cenários de ativação

Uma vez instalado, os desenvolvedores devem ativar o plugin utilizando um modelo de licenciamento apropriado. A JetBrains suporta vários caminhos de autenticação nos cenários de ativação:

Detalhamento dos níveis de licença

• AI Free: Fornece acesso básico a modelos leves em nuvem com créditos mensais limitados de IA, concedidos automaticamente a titulares de assinaturas expiradas ou usuários do plano gratuito.
• AI Pro: A assinatura individual padrão que oferece cotas mensais robustas, roteamento prioritário de modelos e suporte a LLMs de ponta (incluindo GPT-4o, Claude 3.5 Sonnet e Gemini 1.5 Pro). Titulares do JetBrains All Products Pack ou dotUltimate frequentemente recebem privilégios do AI Pro.
• Pro Trial: Licença de avaliação completa de 30 dias vinculada automaticamente a novas contas JetBrains Account na primeira ativação.
• AI Business / Enterprise: Dimensionada para equipes, com faturamento centralizado, controles de alocação de usuários, pools compartilhados de créditos e opções para implantações híbridas on-premises por meio do JetBrains AI Enterprise.

Consentimento legal e aceitação dos termos

Durante a negociação inicial de ativação, os desenvolvedores devem revisar e aceitar os Termos de Serviço do JetBrains AI e a Política de Uso Aceitável. Esses termos formalizam que o código-fonte transmitido para inferência é processado de maneira efêmera, sem ser retido para o treinamento de modelos fundacionais públicos de base.

Configuração central da IDE e ajustes de comportamento

As opções de configuração global do plugin estão centralizadas em Settings | Tools | AI Assistant (ou Preferences | Tools | AI Assistant no macOS). Consultar a referência de configurações permite aos desenvolvedores alinhar a ferramenta com seus hábitos de desenvolvimento.

Settings / Preferences
  ├── Tools
  │     └── AI Assistant
  │           ├── General Features (Name suggestions, pasted code, PR summaries)
  │           ├── Providers & API keys (BYOK, OAuth, Model selection)
  │           ├── Rules (Project-specific instructions)
  │           ├── Prompt Library (Custom prompt templates)
  │           ├── Skills (Debugger and runtime tools)
  │           └── Agents (ACP agent registries)
  └── Editor
        └── General
              └── Code Completion
                    └── Inline (Cloud completion, Next Edit Suggestions)

Alternâncias de recursos de automação

Os desenvolvedores podem ativar ou desativar recursos auxiliares específicos para evitar sugestões intrusivas:

• Provide AI-generated name suggestions: Sugere identificadores de variáveis, funções e classes contextualmente relevantes durante refatorações de símbolos in loco (Shift+F6).
• Suggest converting pasted code to target file language: Detecta automaticamente quando códigos externos (como um trecho de Python colado em um arquivo Java) são inseridos no editor e propõe traduzir a sintaxe para a linguagem do arquivo de destino.
• Generate a title for the shelved changelist: Sintetiza automaticamente títulos descritivos concisos para conjuntos de alterações do Git colocados em espera (shelved) com base na inspeção de diffs.
• GitHub Plugin: Generate PR summaries: Inspeciona commits e arquivos modificados para gerar descrições estruturadas de pull requests ao criar ou revisar PRs pela janela de ferramentas integrada do GitHub.

Personalização de idioma natural

Por padrão, o AI Assistant responde na localidade do sistema ou em inglês. Equipes trabalhando em ambientes multilíngues podem especificar um idioma natural de preferência em Settings | Tools | AI Assistant | Natural Language para garantir que explicações, docstrings e mensagens de commit sejam elaboradas na linguagem de trabalho exigida.

Limiar de truncamento de mensagens (Message Trimming Threshold)

Ao trabalhar com bases de código volumosas, anexar múltiplos arquivos de código pode rapidamente exceder grandes janelas de contexto. Em Settings | Tools | AI Assistant, os desenvolvedores podem configurar o Message Trimming Threshold (expresso como porcentagem da janela de contexto total do modelo). Caso uma carga útil anexada ultrapasse esse limiar, o AI Assistant trunca automaticamente estruturas externas não críticas, preservando assinaturas de funções e pontos de chamada essenciais, evitando exceções de estouro de tokens de contexto.

Configuração do preenchimento de código no editor e de Next Edit Suggestions

As IDEs da JetBrains adotam uma arquitetura de motor duplo para o preenchimento de código: preenchimento local no dispositivo e preenchimento remoto em nuvem.

Preenchimento local Full Line vs. preenchimento multilinhas em nuvem

Entender a diferença entre os mecanismos de preenchimento é essencial para uma configuração ideal:

1. Full Line Code Completion: Executa integralmente de forma local na estação de trabalho do desenvolvedor, utilizando modelos de redes neurais compactos e específicos para cada linguagem empacotados diretamente com a IDE. Funciona offline sem latência de rede, não consome créditos de IA e não envia código para fora da máquina.
2. Cloud Code Completion: Alimentado pelos LLMs em nuvem do AI Assistant. Gera estruturas de código de várias linhas, corpos completos de métodos, lógica algorítmica e comentários de documentação com base em um contexto mais amplo de arquivo.

Configuração de parâmetros de preenchimento em linha

Para calibrar o preenchimento em linha, navegue até Settings | Editor | General | Code Completion | Inline:

• Enable Cloud-Based Multi-Line Completions: Marque esta opção para permitir que o AI Assistant exiba texto fantasma cinza em uma ou mais linhas conforme você digita.
• Next Edit Suggestions (NES): Quando ativado, o AI Assistant analisa modificações recentes e prevê edições subsequentes, sugerindo alterações correlatas e permitindo que os desenvolvedores saltem diretamente para locais associados (como atualizar a implementação de uma interface após modificar a assinatura de um método).
• Trigger Delay (Debounce): Configura a duração de pausa exigida antes de acionar uma solicitação de preenchimento em nuvem. Desenvolvedores em conexões com alta latência ou conexões móveis tarifadas podem aumentar esse atraso para reduzir chamadas de API desnecessárias.

Atalhos de teclado e controles de aceitação

As sugestões fantasmas em linha podem ser aceitas ou descartadas usando atalhos de teclado convencionais:

• Aceitar sugestão completa: Pressione Tab.
• Aceitar próxima palavra: Pressione Ctrl+Seta para a direita (Windows/Linux) ou Option+Seta para a direita (macOS) para incorporar a sugestão token por token.
• Aceitar próxima linha: Pressione Ctrl+Seta para baixo ou o atalho personalizado atribuído para aceitar as sugestões linha por linha.
• Descartar sugestão: Pressione Esc ou continue digitando caracteres incompatíveis.
• Acionamento manual: Caso as sugestões em linha automáticas estejam desativadas, acione a conclusão sob demanda pressionando Alt+\ (Windows/Linux) ou Option+\ (macOS).

AI Chat, gerenciamento de contexto e regras de projeto

A janela de ferramentas AI Chat atua como um ambiente interativo de programação em pares capaz de raciocinar através de múltiplos arquivos, rastreamentos de pilha (stack traces) e histórico do projeto.

Referenciando contexto com menções

Em vez de copiar e colar fragmentos de código-fonte no prompt do chat, os desenvolvedores devem fornecer contexto direcionado utilizando menções com o símbolo @:

• @file:caminho/para/Arquivo.java: Incorpora o conteúdo de um arquivo de projeto específico à carga útil do prompt.
• @symbol:NomeClasse#nomeMetodo: Injeta a declaração, docstrings e implementação de uma classe, interface ou função específica.
• @folder:src/main/services: Transmite a estrutura de diretórios e interfaces de módulos.
• @commit:hash: Fornece diffs e metadados de commits do Git para revisões de código e análises de regressão.

Consultando a documentação oficial com /docs

Desenvolvedores em busca de orientações sobre a IDE podem consultar a documentação da JetBrains diretamente pelo prompt de chat usando o comando /docs. Por exemplo, ao digitar:

/docs how do I configure remote Docker debugging for GoLand?

uma consulta com RAG (geração aumentada por recuperação) é executada na documentação oficial de produtos da JetBrains, retornando instruções prescritivas com links profundos para os diálogos de configuração da IDE.

Biblioteca personalizada de prompts (Prompt Library)

As equipes frequentemente executam padrões arquiteturais recorrentes, como criar classes de repositório, simular clientes HTTP ou migrar frameworks legados. Os desenvolvedores podem padronizar esses prompts em Settings | Tools | AI Assistant | Prompt Library:

1. Clique em Add (+) para criar um novo modelo de prompt personalizado.
2. Defina um título descritivo (ex.: Generate Spring Data JPA Repository).
3. Insira o texto do modelo, utilizando marcadores dinâmicos como $SELECTION para representar o código em destaque.
4. Associe o prompt aos menus de contexto do editor para rápida execução com um clique.

Impondo padrões por meio de regras de projeto (ai-rules.md)

Para evitar que o AI Assistant gere código em desacordo com as convenções do repositório, as equipes podem definir regras de projeto persistentes em Settings | Tools | AI Assistant | Rules ou commitando um arquivo markdown na raiz do repositório em .jetbrains/ai-rules.md.

Um arquivo de regras eficiente instrui o assistente sobre limites de arquitetura, padrões de estilo e diretrizes de teste:

# Project Architectural Guidelines

## Technology Stack
- Java 21 LTS with Spring Boot 3.3
- Build Tool: Gradle with Kotlin DSL
- Testing: JUnit 5, AssertJ, and Testcontainers (avoid Mockito for integration tests)

## Code Conventions
- Prefer immutable records for Data Transfer Objects (DTOs).
- Enforce explicit constructor injection; do not use field-level `@Autowired`.
- All public REST controllers must return `ResponseEntity<T>` with OpenAPI 3 annotations.
- Handle database operations asynchronously via R2DBC where reactive pipelines are present.

## Security Constraints
- Never log raw authorization tokens, customer personally identifiable information (PII), or passwords.
- Enforce parameter binding on all SQL and JPQL queries to prevent injection vulnerabilities.

O AI Assistant lê .jetbrains/ai-rules.md e anexa suas restrições aos prompts despachados no repositório, garantindo que o código gerado esteja estritamente alinhado aos padrões da equipe.

Agentes de código, ACP e Model Context Protocol (MCP)

As versões mais recentes do JetBrains AI Assistant expandiram seu escopo para além de sugestões passivas de código, incorporando fluxos de trabalho com agentes autônomos e ativos.

Agentes autônomos de codificação

Em Settings | Tools | AI Assistant | Agents, os desenvolvedores podem configurar agentes de programação especializados:

• Junie: Agente proprietário da JetBrains projetado para refatoração em múltiplos arquivos, correção autônoma de bugs e geração de testes. O Junie elabora um plano de execução passo a passo, altera arquivos, executa comandos de terminal local ou executores de teste e apresenta diffs consolidados para revisão humana.
• Claude Agent e OpenAI Codex: Integrações que utilizam contas de provedores ou chaves de API para executar tarefas completas de programação.
• Agent Client Protocol (ACP): Protocolo padronizado que permite a desenvolvedores integrar agentes personalizados ou proprietários diretamente à IDE sem a necessidade de programar plugins adicionais.

Integração de ferramentas via Model Context Protocol (MCP)

Por meio de ferramentas MCP, o AI Assistant pode interagir com ambientes externos, bancos de dados, mecanismos de contêiner e rastreadores corporativos de pendências.

Para garantir a segurança, os desenvolvedores devem configurar explicitamente as permissões de banco de dados em Settings | Tools | AI Assistant:

• Read database schemas: Permite que os agentes MCP inspecionem tabelas, tipos de coluna e índices para estruturar consultas SQL corretas.
• Modify database schemas: Controla se os agentes podem gerar e executar instruções DDL de migração (CREATE, ALTER, DROP).
• Read database data: Permite que os agentes executem consultas e examinem os resultados para investigar problemas de dados.
• Modify database data: Exige autorização explícita antes que um agente execute instruções de alteração como INSERT, UPDATE ou DELETE.

Provedores terceirizados e modelos personalizados (BYOK)

Organizações que desejam centralizar custos com IA ou aproveitar gateways internos de modelos podem desacoplar o AI Assistant das assinaturas em nuvem gerenciadas pela JetBrains utilizando a configuração Bring Your Own Key.

Configurando provedores terceirizados

Navegue até Settings | Tools | AI Assistant | Providers & API keys:

1. Clique em Add Provider e selecione um dos fornecedores comerciais compatíveis:
   • OpenAI: Exige uma chave de API da plataforma OpenAI com acesso a modelos como gpt-4o ou o1.
   • Anthropic: Exige uma chave de API da Anthropic com suporte a claude-3-5-sonnet ou claude-3-opus.
   • Google Cloud Vertex AI: Autentica via Application Default Credentials (ADC) ou chaves de conta de serviço.
2. Insira as credenciais e teste a latência da conexão.
3. Atribua modelos às funções desejadas (por exemplo, modelos rápidos para preenchimento de código em linha vs. modelos de raciocínio mais robustos para AI Chat e refatoração).

Conectando endpoints locais e personalizados

Para ambientes isolados (air-gapped) ou data centers privados, os desenvolvedores podem optar por modelos personalizados:

+-------------------------------------------------------------+
|                      Local Workstation                      |
|                                                             |
|  +------------------------+      +-----------------------+  |
|  |     JetBrains IDE      |      |     Ollama Server     |  |
|  |  (AI Assistant Plugin) | ---> | (http://localhost:    |  |
|  |                        | <--- |  11434/v1)            |  |
|  +------------------------+      +-----------------------+  |
+-------------------------------------------------------------+

1. Inicie um servidor local de inferência que exponha uma API compatível com OpenAI (como Ollama, vLLM ou LM Studio).
2. Em Providers & API keys, adicione um provedor Custom OpenAI-Compatible.
3. Configure a URL base (por exemplo, http://localhost:11434/v1 para Ollama) e especifique o identificador do modelo carregado (como qwen2.5-coder:32b ou deepseek-coder-v2).
4. Confirme se as conclusões locais são transmitidas de forma fluida para o editor sem tráfego externo para a WAN.

Governança de dados, privacidade e controles corporativos

Implantar assistentes de código baseados em IA em ambientes corporativos exige salvaguardas claras de privacidade de dados e auditoria.

Transmissão de dados e fronteiras do treinamento de modelos

A JetBrains estipula limites claros de tratamento de dados em sua documentação e no Trust Center:

• Zero treinamento de modelos base: O código-fonte dos clientes, cargas úteis de contexto e códigos gerados nunca são retidos ou usados pela JetBrains ou por seus parceiros provedores para treinar modelos fundacionais base.
• Processamento efêmero: Os prompts roteados pelo serviço JetBrains AI são mantidos em memória exclusivamente para a execução da inferência e conformidade de registros, sendo eliminados em seguida.
• Opt-in para compartilhamento de dados: A opção Send detailed code-related data vem desativada por padrão. Se ativada manualmente, a telemetria é totalmente anonimizada e empregada estritamente na avaliação do desempenho das funcionalidades da IDE da JetBrains.

Firewalls corporativos, proxies e inspeção SSL

Estações de trabalho operando dentro de perímetros corporativos devem permitir tráfego de saída seguro:

• Endpoints de gateway: Adicionar à lista de permissões conexões de saída HTTPS (porta 443) e WebSocket (WSS) para *.jetbrains.com e endpoints de provedores de modelos terceirizados designados.
• Inspeção SSL corporativa: Caso ferramentas de segurança corporativas interceptem conexões TLS usando Autoridades Certificadoras (CA) internas, os desenvolvedores devem incluir o certificado da CA corporativa no repositório de certificados confiáveis da IDE (Settings | Tools | Server Certificates) para evitar falhas de handshake TLS.

Monitoramento de cotas e opções de desativação

O widget de status JetBrains AI no cabeçalho da janela disponibiliza visibilidade em tempo real sobre o consumo:

• Cota da assinatura: Acompanha o saldo de créditos mensais de IA restantes e exibe a data de renovação da cota mensal.
• Créditos suplementares (Top-Up Credits): Permite que desenvolvedores ou equipes comprem créditos adicionais quando fluxos intensivos de agentes esgotarem as cotas básicas.
• Gerenciamento de pool compartilhado: Exibe o consumo dinâmico de créditos quando conectado a um servidor corporativo de licenças.

Caso os desenvolvedores precisem suspender o AI Assistant, existem opções para desativar os recursos temporariamente em um único projeto pelo menu do widget, desabilitar apenas o preenchimento em nuvem mantendo o suporte local do Full Line, ou desinstalar permanentemente o plugin de toda a IDE.