Skip to content
Back to search

eclipse-chatgpt-plugin

Eclipse IDE as an MCP Server for AI Agents

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/gradusnikov--eclipse-chatgpt-plugin/badge.svg)](/listings/gradusnikov--eclipse-chatgpt-plugin)

HTML

<a href="/listings/gradusnikov--eclipse-chatgpt-plugin"><img src="/api/listings/gradusnikov--eclipse-chatgpt-plugin/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

1. Enable the HTTP MCP Server

1. Open *Window > Preferences > Assist AI > HTTP MCP Server* 2. Check **Enable HTTP MCP Server** 3. Set **Hostname** and **Port** (defaults: `localhost:8124`) 4. Click **Generate** to create an authentication token 5. Click **Apply** -- the server starts immediately

The status panel shows all available endpoints: - `http://localhost:8124/mcp/eclipse-ide` -- code analysis, navigation, search, testing, builds - `http://localhost:8124/mcp/eclipse-coder` -- file editing, refactoring, patching, formatting - `http://localhost:8124/mcp/eclipse-runner` -- launch, debug, breakpoints, stepping - `http://localhost:8124/mcp/eclipse-context` -- resource cache, file local history, version tracking - `http://localhost:8124/mcp/eclipse-git` -- git status, log, staging, commit, diff, branches, stash

2. Connect Your Agent

Claude Code

Add to your Claude Code MCP settings (`~/.claude.json` or project-level(`.mcp.json` in project root)):

{
  "mcpServers": {
    "eclipse-ide": {
      "command": "npx",
      "args": [
        "-y", "mcp-remote", "http://localhost:8124/mcp/eclipse-ide",
        "--allow-http",
        "--header", "Authorization: Bearer YOUR_TOKEN"
      ]
    },
    "eclipse-coder": {
      "command": "npx",
      "args": [
        "-y", "mcp-remote", "http://localhost:8124/mcp/eclipse-coder",
        "--allow-http",
        "--header", "Authorization: Bearer YOUR_TOKEN"
      ]
    },
    "eclipse-runner": {
      "command": "npx",
      "args": [
        "-y", "mcp-remote", "http://localhost:8124/mcp/eclipse-runner",
        "--allow-http",
        "--header", "Authorization: Bearer YOUR_TOKEN"
      ]
    },
    "eclipse-git": {
      "command": "npx",
      "args": [
        "-y", "mcp-remote", "http://localhost:8124/mcp/eclipse-git",
        "--allow-http",
        "--header", "Authorization: Bearer YOUR_TOKEN"
      ]
    }
  }
}

Github Copilot CLI

Add to your Github Copilot CLI MCP settings (`~/.copilot/mcp-config.json`):

{
  "mcpServers": {
    "eclipse-ide": {
      "type": "http",
      "url": "http://localhost:8124/mcp/eclipse-ide",
      "headers": {
        "Authorization": "YOUR_TOKEN"
      },
      "tools": ["*"]
    },
    "eclipse-coder": {
      "type": "http",
      "url": "http://localhost:8124/mcp/eclipse-coder",
      "headers": {
        "Authorization": "YOUR_TOKEN"
      },
      "tools": ["*"]
    },
    "eclipse-runner": {
      "type": "http",
      "url": "http://localhost:8124/mcp/eclipse-runner",
      "headers": {
        "Authorization": "YOUR_TOKEN"
      },
      "tools": ["*"]
    },
    "eclipse-context": {
      "type": "http",
      "url": "http://localhost:8124/mcp/eclipse-context",
      "headers": {
        "Authorization": "YOUR_TOKEN"
      },
      "tools": ["*"]
    },
    "eclipse-git": {
      "type": "http",
      "url": "http://localhost:8124/mcp/eclipse-git",
      "headers": {
        "Authorization": "YOUR_TOKEN"
      },
      "tools": ["*"]
    }
  }
}

> On Windows with WSL, use `"command": "wsl"` and prepend `"npx"` to the args array.

Claude Desktop

Add to your Claude Desktop configuration file: - Windows: `%APPDATA%\Roaming\Claude\claude_desktop_config.json` - macOS: `~/Library/Application Support/Claude/claude_desktop_config.json` - Linux: `~/.config/Claude/claude_desktop_config.json`

Use the same `mcpServers` format as above.

OpenAI Codex / Other MCP Clients

Any client that supports MCP over Streamable HTTP can connect directly to the endpoint URLs. Use the `Authorization: Bearer <token>` header for authentication.

3. What Agents Can Do

With the MCP tools, an external agent can:

- **Read and navigate code** -- project layout, class outlines, method source, type hierarchies, call hierarchies, find references - **Edit code** -- create files, apply unified diffs, replace strings, delete lines, replace entire files

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 550 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. <p align="center"><img src="src/website/logo_110_80.png"></p>
  2. # AssistAI - Eclipse IDE as an MCP Server for AI Agents
  3. AssistAI is an Eclipse IDE plugin that exposes your entire development environment as an **MCP (Model Context Protocol) server**. External AI agents -- Claude Code, OpenAI Codex, Claude Desktop, or any MCP-compatible client -- can read, navigate, edit, build, test, run, and debug your Java projects directly through Eclipse, preserving workspace sync, local history, and incremental compilation.
  4. AssistAI also includes a built-in LLM chat view for quick inline interactions with any supported model.
  5. ## Why MCP through Eclipse?
  6. When AI agents edit files through the filesystem directly, Eclipse doesn't know anything changed. Editors show stale content, incremental compilation misses updates, and local history gaps appear.
  7. AssistAI solves this by routing all operations through Eclipse APIs:
  8. - **Edits go through JDT** -- incremental compilation fires immediately, errors update in real time
  9. - **Refactorings use Eclipse's refactoring engine** -- renames, moves, and package restructures update all references across the workspace
  10. - **File reads reflect the editor buffer** -- agents always see the latest unsaved content, not the on-disk version
  11. - **Local history is preserved** -- every change is tracked, undoable through Eclipse's local history
  12. - **Tests run inside Eclipse** -- JUnit results, console output, and compilation errors are accessible as tool responses
  13. ## Getting Started with External Agents
  14. ### 1. Enable the HTTP MCP Server
  15. 1. Open *Window > Preferences > Assist AI > HTTP MCP Server*
  16. 2. Check **Enable HTTP MCP Server**
  17. 3. Set **Hostname** and **Port** (defaults: `localhost:8124`)
  18. 4. Click **Generate** to create an authentication token
  19. 5. Click **Apply** -- the server starts immediately
  20. The status panel shows all available endpoints:
  21. - `http://localhost:8124/mcp/eclipse-ide` -- code analysis, navigation, search, testing, builds
  22. - `http://localhost:8124/mcp/eclipse-coder` -- file editing, refactoring, patching, formatting
  23. - `http://localhost:8124/mcp/eclipse-runner` -- launch, debug, breakpoints, stepping
  24. - `http://localhost:8124/mcp/eclipse-context` -- resource cache, file local history, version tracking
  25. - `http://localhost:8124/mcp/eclipse-git` -- git status, log, staging, commit, diff, branches, stash
  26. ### 2. Connect Your Agent
  27. #### Claude Code
  28. Add to your Claude Code MCP settings (`~/.claude.json` or project-level(`.mcp.json` in project root)):
  29. ```json
  30. {
  31. "mcpServers": {
  32. "eclipse-ide": {
  33. "command": "npx",
  34. "args": [
  35. "-y", "mcp-remote", "http://localhost:8124/mcp/eclipse-ide",
  36. "--allow-http",
  37. "--header", "Authorization: Bearer YOUR_TOKEN"
  38. ]
  39. },
  40. "eclipse-coder": {
  41. "command": "npx",
  42. "args": [
  43. "-y", "mcp-remote", "http://localhost:8124/mcp/eclipse-coder",
  44. "--allow-http",
  45. "--header", "Authorization: Bearer YOUR_TOKEN"
  46. ]
  47. },
  48. "eclipse-runner": {
  49. "command": "npx",
  50. "args": [
  51. "-y", "mcp-remote", "http://localhost:8124/mcp/eclipse-runner",
  52. "--allow-http",
  53. "--header", "Authorization: Bearer YOUR_TOKEN"
  54. ]
  55. },
  56. "eclipse-git": {
  57. "command": "npx",
  58. "args": [
  59. "-y", "mcp-remote", "http://localhost:8124/mcp/eclipse-git",
  60. "--allow-http",
  61. "--header", "Authorization: Bearer YOUR_TOKEN"
  62. ]
  63. }
  64. }
  65. }
  66. ```
  67. #### Github Copilot CLI
  68. Add to your Github Copilot CLI MCP settings (`~/.copilot/mcp-config.json`):
  69. ```json
  70. {
  71. "mcpServers": {
  72. "eclipse-ide": {
  73. "type": "http",
  74. "url": "http://localhost:8124/mcp/eclipse-ide",
  75. "headers": {
  76. "Authorization": "YOUR_TOKEN"
  77. },
  78. "tools": ["*"]
  79. },
  80. "eclipse-coder": {
  81. "type": "http",
  82. "url": "http://localhost:8124/mcp/eclipse-coder",
  83. "headers": {
  84. "Authorization": "YOUR_TOKEN"
  85. },
  86. "tools": ["*"]
  87. },
  88. "eclipse-runner": {
  89. "type": "http",
  90. "url": "http://localhost:8124/mcp/eclipse-runner",
  91. "headers": {
  92. "Authorization": "YOUR_TOKEN"
  93. },
  94. "tools": ["*"]
  95. },
  96. "eclipse-context": {
  97. "type": "http",
  98. "url": "http://localhost:8124/mcp/eclipse-context",
  99. "headers": {
  100. "Authorization": "YOUR_TOKEN"
  101. },
  102. "tools": ["*"]
  103. },
  104. "eclipse-git": {
  105. "type": "http",
  106. "url": "http://localhost:8124/mcp/eclipse-git",
  107. "headers": {
  108. "Authorization": "YOUR_TOKEN"
  109. },
  110. "tools": ["*"]
  111. }
  112. }
  113. }
  114. ```
  115. > On Windows with WSL, use `"command": "wsl"` and prepend `"npx"` to the args array.
  116. #### Claude Desktop
  117. Add to your Claude Desktop configuration file:
  118. - Windows: `%APPDATA%\Roaming\Claude\claude_desktop_config.json`
  119. - macOS: `~/Library/Application Support/Claude/claude_desktop_config.json`
  120. - Linux: `~/.config/Claude/claude_desktop_config.json`
  121. Use the same `mcpServers` format as above.
  122. #### OpenAI Codex / Other MCP Clients
  123. Any client that supports MCP over Streamable HTTP can connect directly to the endpoint URLs. Use the `Authorization: Bearer <token>` header for authentication.
  124. ### 3. What Agents Can Do
  125. With the MCP tools, an external agent can:
  126. - **Read and navigate code** -- project layout, class outlines, method source, type hierarchies, call hierarchies, find references
  127. - **Edit code** -- create files, apply unified diffs, replace strings, delete lines, replace entire files
  128. - **Refactor** -- rename types/packages, move types, organize imports -- all through Eclipse's refactoring engine
  129. - **Build and test** -- refresh and build the Eclipse workspace, run Maven builds, execute JUnit tests (all, by package, class, or method), read compilation errors, get quick-fix suggestions
  130. - **Search** -- text search, regex search, file glob search, search-and-replace across the workspace
  131. - **Run and debug** -- launch Java applications, set breakpoints (including conditional), step through code, inspect stack traces, evaluate expressions, hot-swap code
  132. - **Access context** -- read JavaDoc, console output, editor selection, effective POM, project dependencies
  133. - **Inspect workspace images** -- return raster resources as native MCP image content for vision-capable agents
  134. - **Browse and restore file history** -- list Local History versions, view old content, restore to any previous version, diff current vs. historical
  135. - **Inspect the resource cache** -- see what files/classes are loaded in the conversation context, read cached content without I/O
  136. - **Manage Git repositories** -- status, log, diff, stage, commit, branch, checkout, stash -- all through EGit, keeping Eclipse workspace in sync
  137. - **Navigate large documents** -- get the heading outline of a Markdown file, then fetch specific sections without loading the entire content
  138. ### 4. Guiding Agents with Eclipse Context
  139. External agents don't know what you're looking at in Eclipse -- unless they ask. AssistAI provides MCP tools that let agents pick up context from your IDE session, so you can guide their work by simply opening files, selecting code, or running programs:
  140. | What you do in Eclipse | Tool the agent calls | What the agent sees |
  141. |------------------------|---------------------|---------------------|
  142. | Open a file in the editor | `getCurrentlyOpenedFile` | Full file content with path, project name, and line numbers |
  143. | Select a code region | `getEditorSelection` | Selected text with start/end line numbers and surrounding file context |
  144. | Run or debug a program | `getConsoleOutput` | Recent stdout/stderr from Eclipse console(s) |
  145. | Have compilation errors | `getCompilationErrors` | All errors/warnings with file, line, and message |
  146. | Open a specific class | `getClassOutline` | Compact structure -- fields, method signatures, line numbers |
  147. **Workflow tip:** When asking an agent to fix something, open the relevant file in Eclipse first, select the problem area, and tell the agent to check your selection. This gives the agent precise context without you having to describe file paths or paste code.
  148. **Token-efficient navigation:** Instead of reading entire files, agents can use `getClassOutline` to see the structure (~30 lines for a 500-line class), then `getMethodSource` to read only the methods they need, or `getFilteredSource` to see the full file with irrelevant methods collapsed to one-line signatures. The `readProjectResource` tool supports `excludeImports` to further reduce token usage.
  149. **Workspace images:** Vision-capable agents can call `readImageResource(projectName, resourcePath)` to receive an image as native MCP `ImageContent` instead of base64 text. The tool supports PNG, JPEG, GIF, BMP, TIFF, and ICO resources up to 20 MiB, and enforces the same `.aiignore`/`.noai` access rules as text reads. For example: `readImageResource(projectName="my-project", resourcePath="docs/architecture.png")`.
  150. **Resource cache:** Files and classes read through Eclipse MCP tools are automatically cached with version tracking and file modification timestamps (tied to Eclipse's Local History). Agents can call `listCachedResources` to see what's already loaded, or `getCachedResource` to re-read cached content instantly -- no disk I/O, no re-parsing.
  151. **Local History:** Eclipse automatically maintains a Local History for every file modified through the IDE. Agents can browse past versions (`getFileHistory`), read historical content (`getFileHistoryContent`), compare with the current version (`compareWithHistory`), or restore to any previous state (`restoreFileVersion`). This is more powerful than a simple undo -- it preserves every edit across the entire session, including changes made by the agent itself.
  152. ## MCP Tool Reference
  153. ### eclipse-coder -- Code Editing
  154. | Tool | Description |
  155. |------|-------------|
  156. | createFile | Creates a new file, adds it to the project, and opens it in the editor |
  157. | insertIntoFile | Inserts content at a specific position in an existing file |
  158. | replaceString | Replaces a specific string in a file, optionally within a line range |
  159. | applyPatch | Atomically applies a validated unified diff, preserves line endings, supports multi-hunk edits, creates an undo backup, and reveals the first changed line |
  160. | formatFile | Formats a file using its registered Eclipse editor formatter (Java, XML, JSON, HTML, SQL, and other supported editors) |
  161. | undoEdit | Restores a file from its backup (undo last edit) |
  162. | createDirectories | Creates a directory structure recursively |
  163. | renameFile | Renames a file in a project |
  164. | deleteFile | Deletes a file from a project |
  165. | replaceFileContent | Replaces the entire content of a file |
  166. | deleteLinesInFile | Deletes a range of lines (1-based indexing) |
  167. | refactorRenameJavaType | Renames a Java type using Eclipse's refactoring, updating all references |
  168. | refactorRenameJavaElement | Renames the method, field, local, parameter, type parameter or type at a line and column, updating all references |
  169. | refactorExtractTypeToNewFile | Extracts a nested Java type to a new top-level Java file using Eclipse's refactoring |
  170. | refactorMoveJavaType | Moves a Java type to a different package, updating all references |
  171. | refactorRenamePackage | Renames a package, updating all declarations and references |
  172. | moveResource | Moves a file or folder to a different location |
  173. | organizeImports | Removes unused imports and sorts existing imports; does not add missing imports |
  174. | organizeImportsInPackage | Removes unused imports and sorts existing imports across a package |
  175. Direct file-editing tools complete a workspace synchronization barrier before returning: the content is saved, the resource is refreshed, pending workspace notifications are checkpointed, cached content is updated, Java compilation units are made consistent, and the editor reveals the changed line. Their response includes the synchronization state and resulting modification stamp. Multi-file operations reveal the primary or first changed file.
  176. ### eclipse-ide -- Code Analysis, Navigation & Build
  177. | Tool | Description |
  178. |------|-------------|
  179. | getSource | Source of a workspace or referenced-library class; prefers attached source JARs and decompiles binaries when source is unavailable |
  180. | explainTypeResolution | Explain how a type resolves in a specific project's JDT classpath: source/binary origin, root, entry, attachment, class file, and source/decompilation strategy |
  181. | getClassOutline | Compact class outline -- declarations and method signatures (no bodies) with line numbers and each member's Javadoc summary |
  182. | getMethodSource | Source of specific methods by name, with overload disambiguation |
  183. | getFilteredSource | Full source with non-selected methods collapsed to signatures |
  184. | readProjectResource | Read a text resource, with optional import block collapsing |
  185. | readImageResource | Return a workspace image as native MCP `ImageContent` (PNG, JPEG, GIF, BMP, TIFF, or ICO; maximum 20 MiB) |
  186. | getJavaDoc | Rendered JavaDoc of a type and its members, inherited text included |
  187. | formatCode | Format code using Eclipse formatter settings |
  188. | getProjectProperties | Project properties and configuration |
  189. | getProjectLayout | File/folder structure with `scopePath` and `maxDepth` support |
  190. | listProjects | All workspace projects with detected natures |
  191. | listMavenProjects | All Maven projects in the workspace |
  192. | getCurrentlyOpenedFile | Currently active file in the editor |
  193. | getEditorSelection | Selected text or lines in the active editor |
  194. | getConsoleOutput | Recent Eclipse console output |
  195. | getMethodCallHierarchy | Call hierarchy (callers) for a method |
  196. | getTypeHierarchy | Type hierarchy (supertypes, interfaces, subtypes) |
  197. | findReferences | All references to a type, method, or field across the workspace |
  198. | getCompilationErrors | Compilation errors from the workspace or a project |
  199. | getQuickFixes | Available quick fixes for compilation errors |
  200. | getImportSuggestions | Import candidates for unresolved types |
  201. | fileSearch | Substring search in workspace files |
  202. | fileSearchRegExp | Regex search in workspace files |
  203. | findFiles | Glob pattern file search |
  204. | searchAndReplace | Search and replace across multiple files |
  205. | runAllTests | Run all tests in a project |
  206. | runPackageTests | Run tests in a specific package |
  207. | runClassTests | Run tests for a specific class |
  208. | runTestMethod | Run a specific test method |
  209. | findTestClasses | Classify plain JUnit and `*PDETest` harness tests; warns about likely PDE-dependent tests that violate the naming convention |
  210. | buildWorkspace | Refresh saved resources and run Eclipse Build All (incremental or full), with observable completion, cancellation and post-build problem counts |
  211. | runMavenBuild | Run a Maven build the way Run As > Maven build does, with the full Maven log in the console; reports exit code, `[ERROR]` lines and the log tail |
  212. | getEffectivePom | Effective POM for a Maven project |
  213. | getProjectDependencies | Maven project dependencies |
  214. | getMarkdownOutline | Heading structure (TOC) of a Markdown file with line numbers and section sizes |
  215. | getMarkdownSection | Read a specific section from a Markdown file by heading name or index |
  216. ### eclipse-runner -- Launch, Debug & Breakpoints
  217. | Tool | Description |
  218. |------|-------------|
  219. | runJavaApplication | Launch in run mode with optional arguments and timeout |
  220. | debugJavaApplication | Launch in debug mode, stops at breakpoints |
  221. | launchConfiguration | Launch an existing saved launch configuration by name (reuses its classpath, VM args, env, working dir, JRebel, etc.) in run or debug mode |
  222. | listLaunchConfigurations | List saved launch configurations (name, type, project, main class) |
  223. | stopApplication | Stop a running/debugging application |
  224. | listActiveLaunches | List all running/debugging applications |
  225. | toggleBreakpoint | Set or remove a line breakpoint |
  226. | setConditionalBreakpoint | Breakpoint with condition expression and optional hit count |
  227. | listBreakpoints | List all breakpoints with status and conditions |
  228. | removeAllBreakpoints | Remove all breakpoints |
  229. | getStackTrace | Stack trace of all threads with local variables |
  230. | evaluateExpression | Evaluate a Java expression in a suspended debug frame |
  231. | resumeDebug | Resume execution of a suspended session |
  232. | stepOver | Step over the current line |
  233. | stepInto | Step into the method call |
  234. | stepReturn | Step out of the current method |
  235. | hotCodeReplace | Push code changes into a running debug session without restarting |
  236. ### eclipse-context -- Resource Cache & Local History
  237. | Tool | Description |
  238. |------|-------------|
  239. | listCachedResources | Lists all resources in the conversation cache -- URIs, types, versions, timestamps, token estimates |
  240. | getCachedResource | Gets cached resource content by URI without disk I/O |
  241. | getCacheStats | Cache statistics: resource count, token usage, limits |
  242. | getFileHistory | Lists Local History versions of a file with timestamps and sizes |
  243. | getFileHistoryContent | Reads the content of a specific Local History version |
  244. | restoreFileVersion | Restores a file to a specific Local History version |
  245. | compareWithHistory | Shows a unified diff between current content and a historical version |
  246. ### eclipse-git -- Git Operations (EGit)
  247. | Tool | Description |
  248. |------|-------------|
  249. | gitStatus | Working tree status -- staged, unstaged, untracked files, branch tracking info |
  250. | gitLog | Commit history from any revision, optionally only the commits touching given project-relative paths |
  251. | gitShow | One commit with its parents and the diff it introduced, per file and as a unified diff |
  252. | gitReadFile | Read a UTF-8 text file from `HEAD`, a branch/tag/commit, or the staged `INDEX` without changing the working tree |
  253. | gitDiff | Unified diff of unstaged or staged changes, or between two revisions, with optional project-relative path filters and whitespace-insensitive comparison |
  254. | gitAdd | Stage project-relative files or folders (comma-separated; '.' for the whole project) |
  255. | gitStagePatch | Stage selected unified-diff hunks directly into the index without changing the working tree |
  256. | gitCommit | Commit staged changes; optionally stage every tracked change first (`-a`) or amend the previous commit |
  257. | gitReset | Unstage project-relative files from the index |
  258. | gitDiscardChanges | Restore tracked files from the index, dropping their uncommitted modifications |
  259. | gitResetToRevision | Move the branch to a revision (soft, mixed or hard) -- undo commits, or abandon a conflicted merge |
  260. | gitBranch | List branches (local or including remote) |
  261. | gitCreateBranch | Create a new branch from HEAD or a specified start point |
  262. | gitDeleteBranch | Delete a branch (with optional force) |
  263. | gitCheckout | Switch to a branch |
  264. | gitMerge | Merge a branch, tag or commit; reports fast-forward, merge commit, squash, conflicts or blocking local changes as structured fields |
  265. | gitRebase | Rebase onto an upstream and drive it through conflicts with CONTINUE, SKIP or ABORT |
  266. | gitCherryPick | Apply existing commits to the current branch as new commits |
  267. | gitRevert | Undo existing commits with new reverse commits |
  268. | gitTag / gitTagList / gitDeleteTag | Create (lightweight or annotated), list and delete tags |
  269. | gitStash | Stash working directory changes |
  270. | gitStashPop | Apply and drop the most recent stash |
  271. | gitStashList | List all stash entries |
  272. | gitRemoteList | List remotes with their fetch and push URLs |
  273. | gitFetch | Fetch from a remote and report every remote-tracking ref that moved |
  274. | gitPull | Fetch and merge, or rebase onto, the upstream; conflicts and blocking changes are reported as files |
  275. | gitPush | Push a branch, optionally recording it as upstream or forcing; a rejection names the remedy |
  276. ### eclipse-pde -- Plug-in Development
  277. | Tool | Description |
  278. |------|-------------|
  279. | getActiveTarget | Show the active PDE target platform |
  280. | setActiveTarget | Load and activate a target definition |
  281. | reloadTarget | Reload the active target after its contents change |
  282. | runJUnitPluginTests | Run a plug-in project's tests in the PDE harness |
  283. | runJUnitPluginTestClass | Run one `*PDETest` class in the PDE harness |
  284. | runJUnitPluginTestClasses | Run selected `*PDETest` classes in one PDE launch, avoiding repeated workbench startup |
  285. | restartMcpServers | Rebuild HTTP MCP servers after a safe delay so the current response can finish |
  286. | reloadWorkspaceBundle | Update an OSGi bundle only when backed by an open workspace project; system, fragment, and installed-only bundles are rejected |
  287. Tests that use Eclipse workspace, JDT, UI, platform, or OSGi runtime services must follow the `*PDETest.java` naming convention so test discovery runs them in the PDE harness.
  288. ### Utility Servers
  289. | Server | Tool | Description |
  290. |--------|------|-------------|
  291. | duck-duck-search | webSearch | Web search via DuckDuckGo |
  292. | memory | think | Scratchpad for reasoning without side effects |
  293. | webpage-reader | readWebPage | Fetch a web page and return it as markdown |
  294. | time | currentTime | Current date and time |
  295. | time | convertTimeZone | Convert time between time zones |
  296. ## Configuration
  297. ### Per-Server Tool Filtering
  298. Each MCP server can have individual tools enabled or disabled to reduce token overhead or exclude irrelevant tools.
  299. 1. Navigate to *Window > Preferences > Assist AI > MCP Servers*
  300. 2. Select a server (works for both built-in and user-defined)
  301. 3. In the **Tools** section, uncheck tools you want to exclude
  302. Changes take effect immediately -- both the internal MCP client and the HTTP server restart automatically. Excluded tools won't appear in `tools/list` responses.
  303. ### Adding External MCP Servers
  304. AssistAI is also an MCP *client* -- you can connect external MCP servers (stdio-based) and use their tools through any of the supported LLMs.
  305. 1. Open *Window > Preferences > Assist AI > MCP Servers* and click **Add**
  306. 2. Configure the server:
  307. ```
  308. Name: server-filesystem
  309. Command: npx -y @modelcontextprotocol/server-filesystem ${workspace_loc}
  310. ```
  311. 3. Define environment variables if needed (e.g., API keys)
  312. The `${workspace_loc}` variable resolves to the workspace folder. Other Eclipse variables are available (`${project_loc}`, etc.).
  313. > **Security:** MCP servers grant LLMs access to read and modify data. Use them cautiously.
  314. ### HTTP MCP Server Security
  315. - **Local network only** by default -- only expose externally if necessary
  316. - **Authentication token** -- always use one when exposing beyond localhost
  317. - **Firewall rules** -- allow connections only from trusted sources
  318. - **HTTPS** -- consider a reverse proxy with TLS for production use
  319. - **Access control** -- connected agents have access to all tools on enabled endpoints
  320. ### AI File Access Control (`.aiignore`)
  321. AssistAI enforces file-level access restrictions so that sensitive files are never sent to AI models -- whether through the built-in chat or external MCP clients. The `AiIgnoreService` uses `.gitignore`-style pattern matching (powered by JGit) to determine which files are excluded.
  322. #### Per-Project Rules
  323. Place a `.aiignore` file in the root of any Eclipse project. The syntax follows `.gitignore` conventions:
  324. ```
  325. # Exclude private keys and certificates
  326. *.pem
  327. *.key
  328. # Exclude secrets directory
  329. secret/
  330. # Exclude all .env files
  331. .env*
  332. # Exclude all properties except application.properties
  333. *.properties
  334. !application.properties
  335. # Exclude credentials anywhere in the tree
  336. **/credentials.json
  337. ```
  338. #### Disabling AI for an Entire Project
  339. Create an empty `.noai` file in the project root. When present, all AI access to the project is denied — no pattern matching is performed.
  340. #### Supported File Names
  341. The service checks for ignore files in this order:
  342. 1. The filename configured in preferences (default: `.aiignore`)
  343. 2. `.aiignore` (fallback if a different name is configured)
  344. 3. `.aiexclude` (legacy fallback)
  345. #### Pattern Syntax
  346. | Pattern | Matches |
  347. |---------|---------|
  348. | `*.pem` | All `.pem` files |
  349. | `secret/` | The `secret` directory (not a file named `secret`) |
  350. | `.env*` | `.env`, `.env.local`, `.env.production` |
  351. | `!file` | Negation - re-includes a previously excluded file |
  352. | `**/name` | `name` at any directory depth |
  353. | `path/to/dir/` | A specific directory path |
  354. Rules are evaluated in order; the **last matching rule wins**. Negation patterns (`!`) can override earlier excludes.
  355. #### Behavior
  356. - Rules are cached per project and automatically reloaded when `.aiignore` or `.noai` files change
  357. - Excluded files cause MCP tools to throw an `AiAccessDeniedException` with a descriptive message
  358. - Global patterns from preferences are prepended to per-project rules
  359. ## Built-in Chat View
  360. AssistAI includes a built-in LLM chat panel for direct interaction without external agents. Open it via *Window > Show View > Other > Code Assist AI > AssistAI Chat*.
  361. Features:
  362. - Refactor, document, or generate tests for selected code via context menu
  363. - Fix compilation errors with LLM guidance
  364. - Discuss code with full file context
  365. - Generate git commit messages from staged changes
  366. - Drag-and-drop images for vision model discussions
  367. - Display images returned by MCP tools as chat attachments
  368. - LaTeX and table rendering in responses
  369. - In-text code completion with Alt+/
  370. - Smart resource caching -- LLM always sees the latest version of attached files
  371. - Customizable pre-defined prompts
  372. - Switch between models on the fly
  373. ### Supported Models
  374. | Provider | Protocol | Sample Models | MCP / Tools | Vision |
  375. |----------|----------|--------------|-------------|--------|
  376. | OpenAI | OpenAI API | gpt-5 | Yes | Yes |
  377. | Anthropic | Claude API | claude-sonnet-4-5-20250929 | Yes | Yes |
  378. | Google | Gemini API | gemini-2.5-flash, gemini-3-pro-preview | Yes | Yes |
  379. | Grok | Grok API | grok-4, grok-code-fast | Yes | Yes |
  380. | Groq | OpenAI API | qwen-qwq-32b, llama3-70b-8192 | Yes | Yes |
  381. | DeepSeek | DeepSeek API | deepseek-chat | Yes | No |
  382. | Local/Self-hosted | OpenAI API | Ollama, LM Studio, etc. | Varies | Varies |
  383. | Other 3rd party | OpenAI API | Together.ai, Anyscale, etc. | Varies | Varies |
  384. Configure models in *Window > Preferences > Assist AI > Models*.
  385. ## Screenshots
  386. 1. claude-code controlling the Eclipse IDE via MCP
  387. ![Eclipse MCP](src/website/how-it-works-mcp.png)
  388. 2. Agentic coding with Eclipse MCP tools
  389. ![Eclipse Coder](src/website/eclipse-coder.gif)
  390. 3. Discussing code in the built-in chat
  391. ![Discuss](src/website/how-it-works-discuss.gif)
  392. 4. Refactoring selected code
  393. ![Refactor](src/website/how-it-works-refactor.gif)
  394. 5. Generating documentation
  395. ![Document](src/website/how-it-works-document.gif)
  396. 6. Generating JUnit tests
  397. ![JUnit Test Generation](src/website/how-it-works-junit.gif)
  398. 7. Git commit message generation
  399. ![Git Commit Message](src/website/how-it-works-gitcomment.gif)
  400. 8. Fixing compilation errors with patches
  401. ![Fix Errors](src/website/how-it-works-fixerrors-1.gif)
  402. 9. Tool calls for context-aware answers
  403. ![Function calling](src/website/how-it-works-function-calls.gif)
  404. 10. Vision model -- discuss images
  405. ![Vision](src/website/how-it-works-vision.png)
  406. 11. LaTeX and table rendering
  407. <img src="src/website/latex-rendering.png" alt="Math rendering" style="zoom:50%;" />
  408. 12. Configuring MCP servers
  409. ![MCP](src/website/mpc-support.png)
  410. ## Installation
  411. ### Eclipse Marketplace
  412. Drag the button below into your running Eclipse workspace:
  413. <p align="center"><a href="https://marketplace.eclipse.org/marketplace-client-intro?mpc_install=5602936" class="drag" title="Drag to your running Eclipse* workspace. *Requires Eclipse Marketplace Client"><img style="width:80px;" typeof="foaf:Image" class="img-responsive" src="https://marketplace.eclipse.org/sites/all/themes/solstice/public/images/marketplace/btn-install.svg" alt="Drag to your running Eclipse* workspace. *Requires Eclipse Marketplace Client" /></a></p>
  414. ### Update Site
  415. 1. In Eclipse, open *Help > Install New Software*
  416. 2. Click *Add*, enter `AssistAI` as Name and `https://gradusnikov.github.io/eclipse-chatgpt-plugin/` as Location
  417. 3. Select "Assist AI" from the plugin list and proceed through the wizard
  418. 4. Accept certificate warnings (self-signed plugin)
  419. ### Initial Setup
  420. 1. Open *Window > Preferences > Assist AI*
  421. 2. Configure your models in *Preferences > Assist AI > Models*
  422. 3. To use with external agents, enable the HTTP MCP Server (see above)

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.