Enabling and Configuring JetBrains AI Assistant Across Supported IDEs

JetBrains AI Assistant integrates generative AI coding capabilities, autonomous multi-step agents, and deep semantic code intelligence directly into JetBrains development environments, including IntelliJ IDEA, PyCharm, WebStorm, GoLand, CLion, Rider, PhpStorm, RubyMine, RustRover, DataGrip, and DataSpell. Rather than operating as an isolated chat interface or a generic text predictor, the assistant connects to the IDE's internal project index, Abstract Syntax Trees (AST), and version control systems to deliver context-aware code generation, multi-line autocompletions, next-edit suggestions, automated test authoring, and structural refactoring. Successfully deploying and configuring JetBrains AI Assistant requires software developers and engineering leads to verify IDE version prerequisites, complete installation and licensing activation across individual or enterprise tiers, tune in-editor completion parameters, establish repository-level project rules, and configure security boundaries around model providers and external Model Context Protocol (MCP) tools.

IDE Compatibility and Version Prerequisites

Before enabling JetBrains AI Assistant, developers must ensure their local environment satisfies specific runtime, platform, and organizational criteria.

Supported Environments and IDE Version Baselines

JetBrains AI Assistant is distributed as a plugin available across the JetBrains product suite. Supported IDEs require specific baseline releases:

• Commercial JetBrains IDEs: Compatible with version 2023.3 or later across all commercial IDEs, including IntelliJ IDEA Ultimate, PyCharm Professional, WebStorm, CLion, GoLand, Rider, PhpStorm, RubyMine, RustRover, DataGrip, and DataSpell.
• Community Edition IDEs: Requires version 2024.1.1 or later for open-source Community editions (such as IntelliJ IDEA Community Edition or PyCharm Community Edition). To bind an organizational JetBrains AI subscription within Community editions, teams must run version 2024.2.1 or newer.
• Cross-Platform Support: Supported on 64-bit Windows, macOS (Intel and Apple Silicon), and Linux workstations matching the standard system requirements of the host IDE.

Compute Topologies: Cloud LLMs vs. Local Hardware

By default, JetBrains AI Assistant executes inferences through cloud-hosted large language models managed by the JetBrains AI service or third-party API providers. In this configuration, developer workstations experience negligible additional CPU, GPU, or battery overhead.

However, teams utilizing self-hosted open-weight models (such as Ollama or private OpenAI-compatible inference endpoints) must allocate dedicated workstation compute, including sufficient dedicated VRAM (typically 8 GB to 24 GB depending on parameter quantizations) to support real-time token streaming.

Organizational Prerequisites

For developers using IDE licenses provisioned by an employer or educational institution, access to AI features is governed at the organization level:

1. An organization administrator must enable the JetBrains AI Service within the corporate JetBrains Account administration console.
2. If the organization enforces strict IP governance or security policies, administrators can allocate shared credit pools or designate approved third-party providers before developers can initialize activation.

Installing and Activating JetBrains AI Assistant

The JetBrains AI Assistant plugin is not enabled by default on personal installations and will not access proprietary source code until explicitly installed and activated.

Installation Methods

Developers can install the plugin through three primary entry points in supported IDEs:

1. JetBrains Marketplace (Settings):
   • Navigate to Settings (on Windows/Linux) or Preferences (on macOS) via Ctrl+Alt+S or Cmd+,.
   • Select Plugins in the left sidebar and choose the Marketplace tab.
   • Search for AI Assistant in the search field.
   • Click Install on the official JetBrains plugin entry and restart the IDE if prompted.
2. AI Chat Tool Window:
   • Click the AI Chat icon on the right-hand tool window dock.
   • Click the Install Plugin button displayed within the empty tool window to trigger background installation.
3. JetBrains AI Window Header Widget:
   • In the modern IDE UI header, locate the JetBrains AI status widget.
   • Click Let's Go to download and initialize the plugin automatically.

Licensing Tiers and Activation Scenarios

Once installed, developers must activate the plugin using an appropriate licensing model. JetBrains supports multiple authentication paths under activation scenarios:

Licensing Tiers Breakdown

• AI Free: Provides basic access to lightweight cloud models with limited monthly AI credits, automatically granted to expired subscription holders or free-tier users.
• AI Pro: The standard individual subscription providing robust monthly quotas, priority model routing, and support for frontier LLMs (including GPT-4o, Claude 3.5 Sonnet, and Gemini 1.5 Pro). Owners of JetBrains All Products Pack or dotUltimate frequently receive AI Pro privileges.
• Pro Trial: A 30-day full-featured evaluation license automatically attached to new JetBrains Accounts upon first activation.
• AI Business / Enterprise: Scaled for teams with centralized billing, user allocation controls, shared credit pools, and options for on-premises hybrid deployments via JetBrains AI Enterprise.

Legal Consent and Terms Acceptance

During the initial activation handshake, developers must review and accept the JetBrains AI Terms of Service and the Acceptable Use Policy. These terms formalize that source code transmitted for inference is processed ephemerally without being retained to train base public foundation models.

Core IDE Configuration and Behavioral Settings

Global configuration options for the plugin are centralized under Settings | Tools | AI Assistant (or Preferences | Tools | AI Assistant on macOS). Reviewing the settings reference allows developers to align the tool with their coding habits.

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)

Automation Feature Toggles

Developers can toggle specific behavioral aids to prevent intrusive suggestions:

• Provide AI-generated name suggestions: Suggests contextually meaningful variable, function, and class identifiers during in-place symbol refactoring (Shift+F6).
• Suggest converting pasted code to target file language: Automatically detects when foreign code (such as a Python snippet pasted into a Java file) is inserted into the editor and prompts to translate syntax to the target file's language.
• Generate a title for the shelved changelist: Automatically synthesizes concise descriptive titles for silently shelved Git changesets based on diff inspection.
• GitHub Plugin: Generate PR summaries: Inspects commits and modified files to generate structured pull request descriptions when creating or reviewing PRs through the built-in GitHub tool window.

Natural Language Customization

By default, AI Assistant responds in the system locale or English. Teams working in multi-lingual environments can specify a preferred natural language under Settings | Tools | AI Assistant | Natural Language to ensure explanations, docstrings, and commit messages are synthesized in their required working language.

Message Trimming Threshold

When working with expansive codebases, attaching multiple source files can quickly exceed large context windows. Under Settings | Tools | AI Assistant, developers can configure the Message Trimming Threshold (expressed as a percentage of the model's total context window). If an attached payload exceeds this threshold, AI Assistant automatically trims non-critical outer structures while preserving relevant function signatures and call sites, avoiding out-of-context token exceptions.

Configuring In-Editor Code Completion and Next Edit Suggestions

JetBrains IDEs implement a dual-engine architecture for code completions: local on-device completions and remote cloud completions.

Local Full Line vs. Cloud Multi-Line Completions

Understanding the distinction between completion mechanisms is essential for optimal configuration:

1. Full Line Code Completion: Runs entirely locally on the developer's workstation using compact, language-specific neural network models packaged directly with the IDE. It executes offline with zero network latency and does not consume AI credits or send code off-machine.
2. Cloud Code Completion: Powered by AI Assistant cloud LLMs. It generates multi-line code structures, entire method bodies, algorithmic logic, and accompanying documentation comments based on broader file context.

Configuring Inline Completion Parameters

To fine-tune inline completions, navigate to Settings | Editor | General | Code Completion | Inline:

• Enable Cloud-Based Multi-Line Completions: Check this option to allow AI Assistant to display grayed-out ghost text across one or more lines as you type.
• Next Edit Suggestions (NES): When enabled, AI Assistant analyzes recent modifications and predicts subsequent edits, suggesting follow-up changes and allowing developers to jump directly to related locations (such as updating an interface implementation after modifying a method signature).
• Trigger Delay (Debounce): Configures the pause duration required before triggering a cloud completion request. Developers on high-latency networks or metered mobile connections can increase this delay to reduce unnecessary API roundtrips.

Keystroke Shortcuts and Acceptance Controls

Inline ghost suggestions can be accepted or dismissed using standard keybindings:

• Accept Full Suggestion: Press Tab.
• Accept Next Word: Press Ctrl+Right Arrow (Windows/Linux) or Option+Right Arrow (macOS) to partially accept the completion token by token.
• Accept Next Line: Press Ctrl+Down Arrow or the assigned custom keybinding to incorporate suggestions incrementally.
• Dismiss Suggestion: Press Esc or continue typing incompatible characters.
• Manual Trigger: If automatic inline suggestions are disabled, trigger completion on demand by pressing Alt+\ (Windows/Linux) or Option+\ (macOS).

AI Chat, Context Management, and Project Rules

The AI Chat tool window serves as an interactive pair-programming environment capable of reasoning across files, stack traces, and project history.

Context Referencing with Mentions

Rather than copying and pasting source snippets into the chat prompt, developers should supply targeted context using @ symbol references:

• @file:path/to/File.java: Embeds the content of a specific project file into the prompt payload.
• @symbol:ClassName#methodName: Injects the declaration, docstrings, and implementation of a particular class, interface, or function.
• @folder:src/main/services: Passes directory structures and module interfaces.
• @commit:hash: Supplies Git commit diffs and metadata for code review and regression analysis.

Searching Official Documentation with /docs

Developers seeking IDE guidance can query JetBrains documentation directly from the chat prompt using the /docs command. For example, entering:

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

triggers a retrieval-augmented generation (RAG) query against official JetBrains product documentation, returning prescriptive steps with clickable deep links into the IDE's settings dialogs.

Custom Prompt Library

Teams often execute recurring architectural patterns, such as creating repository classes, mocking HTTP clients, or migrating legacy frameworks. Developers can standardize these prompts via Settings | Tools | AI Assistant | Prompt Library:

1. Click Add (+) to create a new custom prompt template.
2. Define a descriptive title (e.g., Generate Spring Data JPA Repository).
3. Enter the template text, using dynamic placeholders such as $SELECTION to represent highlighted code.
4. Assign the prompt to editor context menus for rapid one-click execution.

Enforcing Standards via Project Rules (ai-rules.md)

To prevent AI Assistant from generating code that violates repository conventions, teams can establish persistent project rules under Settings | Tools | AI Assistant | Rules or by committing a markdown file to the repository root at .jetbrains/ai-rules.md.

An effective rules file instructs the assistant on architectural boundaries, styling guides, and testing patterns:

# 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.

AI Assistant reads .jetbrains/ai-rules.md and appends its constraints to prompts dispatched within the repository, ensuring completions adhere to team standards.

Coding Agents, ACP, and Model Context Protocol (MCP)

Modern releases of JetBrains AI Assistant expand beyond passive code suggestions into active, autonomous agent workflows.

Autonomous Coding Agents

Under Settings | Tools | AI Assistant | Agents, developers can configure specialized coding agents:

• Junie: JetBrains' proprietary agent designed for multi-file refactoring, autonomous bug fixing, and test generation. Junie formulates a step-by-step execution plan, modifies files, runs local terminal commands or test runners, and presents unified diffs for developer review.
• Claude Agent & OpenAI Codex: Integrations utilizing provider accounts or API keys to execute end-to-end coding tasks.
• Agent Client Protocol (ACP): A standardized protocol allowing developers to integrate bespoke or proprietary third-party agents directly into the IDE without writing custom IDE plugins.

Model Context Protocol (MCP) Tools Integration

Through MCP tools, AI Assistant can interact with external environments, databases, container engines, and enterprise issue trackers.

To maintain security, developers must explicitly configure database permissions under Settings | Tools | AI Assistant:

• Read database schemas: Permits MCP agents to inspect tables, column types, and indices to construct accurate SQL queries.
• Modify database schemas: Controls whether agents can generate and execute DDL migration statements (CREATE, ALTER, DROP).
• Read database data: Allows agents to execute queries and inspect query results to debug data issues.
• Modify database data: Requires explicit authorization before an agent can issue INSERT, UPDATE, or DELETE statements.

Third-Party Providers and Custom Models (BYOK)

Organizations seeking to centralize AI expenditure or leverage internal model gateways can decouple AI Assistant from JetBrains-managed cloud subscriptions using the Bring Your Own Key configuration.

Configuring Third-Party Providers

Navigate to Settings | Tools | AI Assistant | Providers & API keys:

1. Click Add Provider and select from supported commercial vendors:
   • OpenAI: Requires an OpenAI platform API key with access to models such as gpt-4o or o1.
   • Anthropic: Requires an Anthropic API key supporting claude-3-5-sonnet or claude-3-opus.
   • Google Cloud Vertex AI: Authenticates via Application Default Credentials (ADC) or service account keys.
2. Enter the credential and test connection latency.
3. Assign models to functional roles (e.g., fast models for inline code completions vs. larger reasoning models for AI Chat and refactoring).

Connecting Local and Custom Endpoints

For air-gapped environments or private data centers, developers can select custom models:

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

1. Launch a local inference server exposing an OpenAI-compatible API (such as Ollama, vLLM, or LM Studio).
2. Under Providers & API keys, add a Custom OpenAI-Compatible provider.
3. Configure the base URL (for example, http://localhost:11434/v1 for Ollama) and specify the loaded model identifier (such as qwen2.5-coder:32b or deepseek-coder-v2).
4. Validate that local completions stream properly into the editor without external WAN egress.

Data Governance, Privacy, and Enterprise Controls

Deploying AI coding assistants in commercial settings requires transparent data privacy and auditing safeguards.

Data Transmission and Model Training Boundaries

JetBrains establishes clear data handling boundaries in its documentation and Trust Center:

• Zero Base-Model Training: Customer source code, context payloads, and generated completions are never retained or utilized by JetBrains or its model partners to train foundation models.
• Ephemeral Processing: Prompts routed through the JetBrains AI service are buffered in memory solely for inference execution and logging compliance, after which they are purged.
• Data Sharing Opt-In: The Send detailed code-related data setting is disabled by default. If manually enabled, telemetry is anonymized and used exclusively for evaluating JetBrains IDE feature performance.

Corporate Firewalls, Proxies, and SSL Inspection

Developer workstations operating within enterprise perimeters must allow outbound secure communication:

• Gateway Endpoints: Whitelist outbound HTTPS (port 443) and WebSocket (WSS) connections to *.jetbrains.com and designated third-party model endpoints.
• Enterprise SSL Inspection: If corporate security appliances intercept TLS connections using internal Certificate Authorities, developers must ensure the corporate CA certificate is added to the host IDE's trusted certificate store (Settings | Tools | Server Certificates) to avoid TLS handshake failures.

Quota Tracking and Disablement Options

The JetBrains AI status widget in the window header provides real-time visibility into usage metrics:

• Subscription Quota: Tracks monthly AI Credits remaining and indicates the monthly reset date.
• Top-Up Credits: Allows individual developers or teams to purchase supplemental credit allocations when intensive agent tasks exhaust baseline quotas.
• Shared Pool Management: Displays credit consumption dynamically when connected to a corporate license server.

If developers need to suspend AI Assistant, options exist to disable features temporarily for a single project via the widget menu, disable cloud completion while keeping local full-line assistance, or uninstall the plugin permanently across the IDE installation.