ScreenshotNeo
Sign in Get a free key

BlogAI agents

How to Run an MCP Server in IntelliJ

Enable IntelliJ’s integrated MCP server for external AI clients, or connect AI Assistant to another MCP server with the right transport and permissions.

By the ScreenshotNeo team1 October 20267 min read

To run IntelliJ as an MCP server, open Settings | Tools | MCP Server, select Enable MCP Server, review the third-party access notice, click Enable, and then click Apply. Configure your external MCP client with IntelliJ’s generated SSE, STDIO, or HTTP Stream settings and restart that client.

There are two different workflows hidden inside this question:

  • IntelliJ as the server: Claude Code, Codex, VS Code, or another MCP client uses tools exposed by the IDE.
  • IntelliJ as the client: AI Assistant connects to a separate MCP server and uses that server’s tools.

JetBrains documents the integrated server for JetBrains IDEs starting with version 2025.2. The current IntelliJ IDEA 2026.2 help says the MCP Server plugin is bundled and enabled by default. See the official MCP documentation for version-specific details.

1. Check your IntelliJ version and plugin

  1. Open Help | About and confirm you are running a release that includes the integrated MCP server.
  2. Open Settings | Plugins | Installed.
  3. Search for MCP Server and confirm the bundled plugin is enabled.
  4. Restart IntelliJ if you enabled or updated the plugin.

If Settings | Tools | MCP Server is missing, first check the plugin and then check the IDE release. JetBrains dates the integrated server to version 2025.2 and later.

2. Enable IntelliJ as an MCP server

  1. Open Settings | Tools | MCP Server.
  2. Select Enable MCP Server.
  3. Read the dialog describing what connected third-party applications can access in projects currently open in IntelliJ.
  4. Click Enable.
  5. Click Apply.

Enabling the server gives an external client access to IDE-provided capabilities. Treat the open projects and exposed tools as the permission boundary: close projects that should not be available and review the tool list before connecting an agent.

3. Connect an external MCP client

Automatic setup for detected clients

In Settings | Tools | MCP Server, use Clients Auto-Configuration when your client appears in IntelliJ’s detected-client list. Select the client, apply the generated configuration, and restart the client. The clients and transports shown can vary by IDE version and installed software.

Manual setup for other clients

  1. Open the MCP Server settings in IntelliJ.
  2. Choose Manual Client Configuration.
  3. Copy the format your client supports: SSE, STDIO, or HTTP Stream.
  4. Paste that configuration into the client’s MCP settings.
  5. Save the configuration and restart the external client.

Use the transport your client actually supports. Do not convert a server-specific configuration into a generic command or URL; copy IntelliJ’s generated values so the endpoint and arguments remain correct.

Global versus project-level configuration

Use a global registration when the client should reach IntelliJ across projects. If the client supports project configuration, use the current-project option when the MCP endpoint should be available only for one repository. Project scope reduces accidental access from unrelated workspaces.

4. Review the tools IntelliJ exposes

Open Settings | Tools | MCP Server | Exposed Tools. Current JetBrains documentation describes tools for tasks such as:

  • Analyzing code
  • Modifying files
  • Running IDE configurations
  • Executing terminal commands

Disable capabilities the connected client does not need. A read-only coding assistant may need code analysis but not file modification or terminal execution.

Brave mode is optional

JetBrains’ optional command-execution setting allows a connected client to execute terminal commands or run IDE configurations without asking for confirmation each time. Enable it only when that interaction model is appropriate for your projects. It is not required to run the MCP server.

5. Run a first connection check

  1. Start IntelliJ with the intended project open.
  2. Confirm the MCP server is enabled.
  3. Start or restart the external client after saving its configuration.
  4. Ask the client to perform a harmless operation, such as listing available IDE tools or describing a project file.
  5. Verify that the request is limited to the project and tools you intended to expose.

If the client reports no tools, inspect its active configuration and IntelliJ’s exposed-tool list before changing transports.

6. Configure IntelliJ AI Assistant as an MCP client

This is the reverse connection direction: IntelliJ AI Assistant launches or connects to a separate MCP server.

  1. Open Settings | Tools | AI Assistant | Model Context Protocol (MCP).
  2. Click Add or add a new server configuration.
  3. Choose the server’s documented transport and enter its server-specific settings.
  4. Choose Global or Current project scope.
  5. Click OK, then Apply.
  6. Check the Status column and reconnect if necessary.

STDIO configuration

A STDIO server is a local process that IntelliJ launches. Enter the executable command and any documented arguments. The server’s own documentation defines required environment variables, working directory, credentials, and file permissions.

{
  "command": "YOUR_SERVER_COMMAND",
  "args": ["DOCUMENTED_ARGUMENT", "VALUE"]
}

Replace the placeholders with the command supplied by that server. There is no universal MCP command that works for every server.

Streamable HTTP configuration

For an HTTP server, enter the server’s documented URL. Confirm whether authentication headers, tokens, or a specific path are required.

{
  "url": "https://your-mcp-server.example/mcp"
}

SSE for legacy servers

JetBrains documents SSE for legacy MCP servers. Use SSE only when both the server and client support it and the server’s instructions specify the SSE endpoint.

7. Transport comparison

Transport Where the process runs What you configure Typical consideration
STDIO Local subprocess Command and arguments Check executable path, environment, and filesystem permissions.
Streamable HTTP Local or remote endpoint Server URL and authentication required by that server Check network access, TLS, and proxy settings.
SSE Usually a remote or local HTTP service Legacy SSE endpoint Use only when supported by the server and client.

8. Troubleshooting

The MCP Server settings page is missing

Cause: The plugin is disabled or the IDE release predates the integrated server.
Fix: Check Settings | Plugins | Installed, restart after enabling the bundled plugin, and verify the IDE version is 2025.2 or newer.

The external client cannot connect

Cause: The configuration was saved to the wrong scope, the client uses an unsupported transport, or it was not restarted.
Fix: Recheck global versus project scope, copy the matching IntelliJ-generated transport configuration, save it, and restart the client.

The client connects but sees no tools

Cause: Tools are disabled under Exposed Tools, or the client is connected to a different IntelliJ instance.
Fix: Review the exposed-tool toggles, keep the intended project open, and reconnect the client.

Commands require repeated confirmation

Cause: Brave mode or the relevant command-execution option is disabled.
Fix: Keep confirmations enabled for interactive control, or enable the optional setting only after reviewing the risk for your project.

Where are MCP logs?

Choose Help | Show Log in Explorer/Finder and inspect the mcp subdirectory. Review those logs for spawned-server failures, transport errors, and process exit messages.

AI Assistant cannot connect to an external server

Cause: The server-specific command, URL, arguments, credentials, or scope is incorrect.
Fix: Compare every field with that server’s documentation, check the Status column in MCP settings, and use reconnect after correcting the configuration.

9. Reliability, security, and performance notes

  • Scope: Project-level registration limits accidental use from unrelated repositories.
  • Capabilities: Exposed Tools is the practical allowlist. Disable file editing and terminal tools when they are unnecessary.
  • Prompts: Keep confirmation prompts for command execution unless you have a deliberate reason to remove them.
  • Process health: STDIO servers depend on a working local executable and environment. HTTP transports depend on endpoint reachability, TLS, authentication, and proxy configuration.
  • Debugging: Inspect IntelliJ’s mcp logs before repeatedly changing transports.
  • Project state: Keep the intended project open and verify the client is connected to the expected IDE instance.

10. Capture IntelliJ or documentation pages with an MCP-ready API

If your agent workflow also needs screenshots of IDE documentation, issue pages, or rendered web output, ScreenshotNeo provides a website screenshot API and MCP server. It supports the MCP tools take_screenshot, get_page_info, and capture_pdf for Claude, Cursor, and other MCP clients.

Or skip the browser setup

Use one API request instead of managing a browser. ScreenshotNeo removes cookie-consent banners, newsletter popups, and chat widgets before capture. Bot checks, blank pages, failed loads, timeouts, and cache hits are not billed, and responses identify the result with X-Page-Verdict and X-Billed headers. The API supports PNG, JPEG, WebP, and PDF output.

See the ScreenshotNeo API documentation for all options.

cURL

curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webp

Python

import requests
r = requests.get("https://api.screenshotneo.com/v1/shot", params={"access_key": "YOUR_API_KEY", "url": "https://stripe.com"}, timeout=90)
open("shot.webp", "wb").write(r.content)

Node.js

const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://stripe.com' }); const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);

ScreenshotNeo includes full-page capture with lazy images loaded, CSS-selector element capture, dark mode, device presets, retina scale, custom CSS and JavaScript, click actions, waits, request blocking, custom headers and cookies, timezone and geolocation, transparent backgrounds, resizing, TTL caching, signed links, asynchronous jobs with signed webhooks, bulk capture of up to 100 URLs per call, usage reporting, and PDF controls. Every feature is available on every plan. The free plan includes 1,000 screenshots per month with no card; paid plans start at $5 for 3,000.

Create a free ScreenshotNeo account to get 1,000 screenshots each month with no card.

FAQ

Is IntelliJ’s MCP server the same as AI Assistant’s MCP setting?

No. The MCP Server page makes IntelliJ a server for external clients. The AI Assistant MCP page makes IntelliJ a client of another server.

Do I need Brave mode?

No. It is an optional setting that removes repeated confirmation prompts for terminal commands and IDE run configurations.

Which transport should I choose?

Use the transport supported by both sides. STDIO launches a local process, Streamable HTTP connects to an endpoint, and SSE is documented for legacy servers.

Can I restrict the server to one project?

Use project-level client configuration when the client supports it, and keep only the intended project open in IntelliJ.

Where should I start when a connection fails?

Check the IDE version and plugin, verify scope and transport, restart the client, inspect Exposed Tools, and read the IntelliJ mcp logs.

Keep reading