MCP Integration Guide: JetBrains IDEs (IntelliJ, PyCharm, WebStorm) in 2026

JetBrains IDEs — IntelliJ IDEA, PyCharm, WebStorm, GoLand, Rider, and others — are the tools of choice for millions of professional developers. With JetBrains' native MCP support, you can connect these IDEs to any MCP server, giving your AI coding assistant access to databases, repositories, issue trackers, and more directly inside your development environment.

This guide walks through the complete setup process for MCP in JetBrains IDEs, from installation to advanced configuration.

Prerequisites

• JetBrains IDE version 2024.2 or later (MCP support requires the AI Assistant plugin)
• JetBrains AI Assistant subscription (available via JetBrains Toolbox or IDE settings)
• Node.js 18+ or Python 3.10+ installed (required for most MCP servers)

Step 1: Enable the AI Assistant Plugin

MCP support in JetBrains IDEs is provided through the AI Assistant plugin. To enable it:

1. Open your JetBrains IDE (IntelliJ, PyCharm, WebStorm, etc.)
2. Go to Settings / Preferences → Plugins
3. Search for "AI Assistant" in the Marketplace tab
4. Click Install, then restart the IDE
5. After restart, sign in to your JetBrains account when prompted

If you already have the AI Assistant plugin installed, verify you're running version 2.0 or later — MCP support was added in this release.

Step 2: Access MCP Server Configuration

JetBrains stores MCP server configuration in the AI Assistant settings:

1. Open Settings / Preferences (Ctrl+Alt+S on Windows/Linux, ⌘, on macOS)
2. Navigate to Tools → AI Assistant → Model Context Protocol (MCP)
3. You'll see the MCP server configuration panel with an "Add Server" button

Alternatively, MCP servers can be configured via the mcp.json configuration file, which JetBrains IDEs read from the same location as Claude Desktop:

• macOS: ~/Library/Application Support/JetBrains/AIAssistant/mcp.json
• Windows: %APPDATA%\JetBrains\AIAssistant\mcp.json
• Linux: ~/.config/JetBrains/AIAssistant/mcp.json

Step 3: Configure Your First MCP Server

The filesystem MCP server is the recommended starting point — it gives the AI Assistant access to your project files beyond what's already indexed by the IDE.

In the MCP configuration panel, click Add Server and enter:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/path/to/your/projects"
      ]
    }
  }
}

Replace /path/to/your/projects with the root directory of your project workspace. You can specify multiple directories:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Users/yourname/projects",
        "/Users/yourname/documents"
      ]
    }
  }
}

Step 4: Add the GitHub MCP Server

For developers using GitHub, the GitHub MCP server dramatically improves the AI Assistant's ability to reason about issues, PRs, and code changes across your repositories.

First, create a GitHub Personal Access Token with repo and read:org scopes at github.com/settings/tokens.

Then add to your MCP configuration:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/your/projects"]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_your_token_here"
      }
    }
  }
}

With this configured, you can ask the AI Assistant things like "What's the status of PR #847?" or "Create an issue for the bug I just found" directly from the IDE chat.

Step 5: Add a Database MCP Server

JetBrains IDEs already have excellent database tooling (DataGrip integration is built in), but the PostgreSQL MCP server gives the AI Assistant the ability to reason about your database schema when writing queries, generating migrations, or debugging data issues.

{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "POSTGRES_CONNECTION_STRING": "postgresql://user:password@localhost:5432/mydb"
      }
    }
  }
}

Security note: The MCP PostgreSQL server defaults to read-only mode. Never use a superuser or write-access account for MCP — create a dedicated read-only database user for AI access.

Step 6: Add Jira or Linear for Issue Context

One of the most powerful JetBrains MCP configurations is connecting your issue tracker, so the AI Assistant can reference ticket requirements when you're implementing features or fixing bugs.

For Jira (requires API token from id.atlassian.com/manage-profile/security/api-tokens):

{
  "mcpServers": {
    "jira": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-jira"],
      "env": {
        "JIRA_HOST": "https://yourcompany.atlassian.net",
        "JIRA_EMAIL": "you@yourcompany.com",
        "JIRA_API_TOKEN": "your_api_token"
      }
    }
  }
}

For Linear (requires API key from linear.app/settings/api):

{
  "mcpServers": {
    "linear": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-linear"],
      "env": {
        "LINEAR_API_KEY": "your_api_key"
      }
    }
  }
}

With an issue tracker connected, you can say "Implement the requirements from PROJ-1234" and the AI will pull the ticket description, acceptance criteria, and linked design specs directly into its context.

Complete Configuration Example

A typical professional developer setup with JetBrains MCP:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Users/dev/projects"
      ]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_..."
      }
    },
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "POSTGRES_CONNECTION_STRING": "postgresql://readonly:pass@localhost:5432/appdb"
      }
    },
    "linear": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-linear"],
      "env": {
        "LINEAR_API_KEY": "lin_api_..."
      }
    }
  }
}

Using MCP in the AI Assistant Chat

Once configured, MCP servers appear as available tools in the AI Assistant chat panel (View → Tool Windows → AI Assistant). The AI automatically selects relevant MCP tools based on your prompts — you don't need to specify which server to use.

Effective prompts for JetBrains MCP workflows:

• "What issues are assigned to me in Linear right now?" — Pulls your current sprint tasks
• "Implement the feature described in LINEAR-456" — Reads the issue and generates code
• "This query is slow — can you check the schema and suggest optimizations?" — Reads database schema to inform suggestions
• "What changed in this repo since last week?" — Uses Git/GitHub MCP to summarize recent activity
• "Write a migration for adding the columns described in this PR" — Combines GitHub + database schema context

IDE-Specific Notes

IntelliJ IDEA (Java/Kotlin)

The Maven and Gradle build tool integrations in IntelliJ work well alongside MCP — the AI can read your pom.xml or build.gradle via filesystem MCP to understand dependencies when answering questions about library versions or upgrade paths.

PyCharm (Python)

PyCharm users benefit most from combining filesystem MCP with the PostgreSQL server for data science and web development workflows. The AI can read your requirements.txt and cross-reference it with database schema when generating SQLAlchemy models.

WebStorm (JavaScript/TypeScript)

WebStorm's Node.js debugging integration pairs well with MCP — use the GitHub server to pull PR context and the filesystem server to navigate your component library when writing new features.

Troubleshooting

MCP server not appearing in AI Assistant: Restart the IDE after changing the MCP configuration file. JetBrains reads MCP config on startup.

"Command not found" errors: Ensure Node.js is installed and available in the system PATH. On macOS, if you installed Node via nvm, you may need to add the full path to the command field: /Users/yourname/.nvm/versions/node/v20.0.0/bin/node.

Database connection refused: Verify your PostgreSQL connection string is correct and that the database server allows connections from localhost. Check that SSL mode settings match your database configuration.

Token authentication failures: GitHub tokens expire. Regenerate at github.com/settings/tokens and update your MCP config. Jira API tokens don't expire but require the correct email-token pair.

Next Steps

With the core MCP servers running in JetBrains, explore the full MCP server directory for additional integrations relevant to your stack. Popular additions for JetBrains users include Jira for project management, Slack for team communication, and specialized language-server MCP tools for framework-specific assistance.

For other editor setups, see our guides on Cursor, VS Code, and Claude Desktop MCP integration.