Enhance Development With DevoxxGenie and MCP

Are you interested in adding AI agents to your coding workflow? In this blog, you will learn what MCP agents are and how you can integrate them into your coding workflow. DevoxxGenie will be used, which is a JetBrains IDE plugin supporting AI coding assistance. Enjoy!

Introduction

Using AI coding assistants can help you during development. One of the available AI coding assistants is DevoxxGenie, a plugin for the JetBrains IDEs. A killer feature of DevoxxGenie is the ability to work with local large language models (LLMs). You can interact with your code and an LLM this way without leaving your local environment, not sharing any code with external providers. 

But wouldn't it be great if you could extend the capabilities of an LLM? For example, if the LLM were able to execute tasks on your local machine, like creating files, updating files, running a build, etc. This is possible with the help of AI agents, small applications running on your local system. But how do they communicate with your LLM? This is where Model Context Protocol (MCP) comes into play. So, how does this work?

Consider DevoxxGenie to be the MCP client that sends a prompt (a question about your code) to an LLM.

1. The MCP client must know about the available MCP servers. This means that DevoxxGenie must be aware of the MCP servers you are running or must know which MCP servers you want to be visible to DevoxxGenie. Every MCP server will list the tools it provides to DevoxxGenie.
2. When a prompt is sent to the LLM, DevoxxGenie will include all of the available tools it is aware of in the prompt.
3. The LLM receives the prompt and decides that it needs to invoke a tool in order to respond to the prompt correctly.
4. The LLM finds a tool in the provided list and returns a request to DevoxxGenie to invoke the tool with the necessary arguments.
5. DevoxxGenie sends this request to the correct MCP server, which will execute the request and respond (a success or failure response of a command, or data that has been asked to retrieve, ...).
6. The response is sent back to the LLM, and the LLM can proceed with processing the prompt to generate a final response.

Maybe all of this still sounds a bit vague, but in the remainder of this blog, examples will be shown that will hopefully make it clearer.

Prerequisites

The prerequisites for reading this blog are:

• Familiar with JetBrains IntelliJ IDE
• Basic knowledge of Maven and Java;
• Basic knowledge of DevoxxGenie, you can read a previous blog for more information (DevoxxGenie 0.6.9 is used in this blog)
• Basic knowledge of LLMs, the Qwen3-8b model is used
• Basic knowledge of LMStudio. The examples are executed with version 0.3.17 of LMStudio, which includes support for MCP interaction.

Configure MCP Java File System

When you take a look at the DevoxxGenie plugin settings, you see an entry, MCP Settings (BETA). Initially, MCP will be disabled. At the bottom, you see some information on how to get started with your first MCP server. As an example, the FileSystem MCP will be used. This MCP server is a pet project from the creator of DevoxxGenie, Stephan Jansen.

Navigate to the GitHub page and clone the repository.

Build the source code.

mvn clean verify

After a successful build, the jar-file is present in the target-directory.

Navigate to the DevoxxGenie plugin settings again and click the + sign in order to add an MCP server to DevoxxGenie. Enter the following:

• Name: MCPJavaFileSystem
• Transport Type: STDIO
• Command: this must be the full path to your Java-installation (on Linux: which java will show you the full path)
• Arguments (also here, the full path to the jar-file must be added):
  -Dspring.ai.mcp.server.stdio=true
  -Dspring.main.web-application-type=none
  -Dlogging.pattern.console=
  -jar
  /home/<full path>/MCPJavaFileSystem/target/devoxx-filesystem-0.0.1-SNAPSHOT.jar

Click the button Test Connection and Fetch Tools to verify the correct configuration. If everything went well, the button caption changes into Connection Successful! 9 tools found.

Click the OK button and check Enable MCP Support and Enable MCP Logging.

At the bottom right of the IDE, you see two new icons:

• A tools icon
• An MCP logs icon

The tools icon shows you the available MCP servers.

The Show All Tools button shows all available tools. This is a complete list of all tools of all enabled MCP servers.

The MCP logs icon enables you to view MCP logs. This can be helpful in understanding what is going on in the background.

Search All Files

Now that the configuration is in place, it is time to actually use the MCP server. As an inference engine, LMStudio is used in combination with Qwen3-8b. It is important that you use an inference engine that supports MCP and also a model that supports tool calls. The combination of both determines how well tools call functions. The combination of LMStudio with Qwen3 seems to work very well.

Enter the prompt: "Show me all files in this repository."

In the LMStudio logs, you will notice that the available tools are sent to the LLM.

Received request: POST to /v1/chat/completions with body  {
  "model": "qwen3-8b",
  "messages": [
    {
      "role": "system",
      "content": "You are a software developer IDEA plugin with expe... <Truncated in logs> ...at is correct and relevant to the code or plugin.\n"
    },
    {
      "role": "user",
      "content": "<ProjectPath>\n/home/<project path>... <Truncated in logs> ...>\nlist all files in this directory\n</UserPrompt>\n\n"
    }
  ],
  "temperature": 0,
  "top_p": 0.9,
  "stream": false,
  "max_tokens": 8000,
  "tools": [
    {
      "type": "function",
      "function": {
        "name": "editFile",
        "description": "Make line-based edits to a text file. Each edit re... <Truncated in logs> ... \"oldText----newText\" where ---- is the separator\n",
        "parameters": {
          "type": "object",
          "properties": {
            "path": {
              "type": "string",
              "description": "The path to the file to edit"
            },
            "edits": {
              "type": "string",
              "description": "List of edits to apply, each containing oldText and newText"
            },
            "dryRun": {
              "type": "boolean",
              "description": "If true, only show diff without changing the file"
            }
          },
          "required": [
            "path",
            "edits"
          ]
        }
      }
    },
    ...

When the LLM requests an MCP call, DevoxxGenie will ask for your approval. A human-in-the-loop is very important in these agentic calls. You never know what an LLM will instruct the agent to do, especially when the agent supports destructive operations like deleting files, for example. You can disable this behavior in the settings, but it is strongly advised not to do so.

As you can see, the LLM requests to execute the searchFiles tool with arguments path and pattern. Click the Approve button to continue. If you click the Deny button, the LLM will receive a failed response.

The response is, in the end, the following.

Here is the file structure of the repository:

Core Project Files

pom.xml (Maven build configuration)
README.md (Project documentation)
Source Code

src/main/java/ (Main application code)
com/devoxx/mcp/filesystem/ (Core functionality)
McpServerApplication.java (Main entry point)
Various tool services (EditFile, FetchWebpage, GrepFiles, etc.)
src/main/resources/ (Configuration files)
application.properties
mcp-servers-config.json
Native image configuration for GraalVM
Test Files

src/test/java/ (Unit tests)
Corresponding test classes for all services
Integration tests for client tools (SSE, Stdio)
Version Control

.git/ (Git repository files)
Contains refs, objects, and configuration
IDE Configuration

.idea/ (IntelliJ IDEA project settings)
Includes workspace config, encodings, and VCS settings
This is a standard Maven project structure with Spring Boot components. The main application logic and services are implemented in the src/main/java directory, while tests reside in src/test/java.

The response is correct, maybe not as complete as expected, but certainly not wrong.

On another day, with the same prompt, the following response was returned.

Here's an overview of the repository structure:

**1\. Git Repository Files**

*   `.git/` (version control metadata)
*   `.gitignore`
*   `README.md`

**2\. Source Code (`src/main/java`)**

*   Core application: `McpServerApplication.java`
*   Services:
    *   `AbstractToolService.java`
    *   `BashService.java`
    *   `EditFileService.java`
    *   `FetchWebpageService.java`
    *   `GrepFilesService.java`
    *   `ListDirectoryService.java`
    *   `ReadFileService.java`
    *   `SearchFilesService.java`
    *   `WriteFileService.java`
    *   `CreateDirectoryService.java`

**3\. Test Files (`src/test/java`)**

*   Service tests:
    *   `BashServiceTest.java`
    *   `CreateDirectoryServiceTest.java`
    *   `EditFileServiceTest.java`
    *   `FetchWebpageServiceTest.java`
    *   `GrepFilesServiceTest.java`
    *   `ListDirectoryServiceTest.java`
    *   `ReadFileServiceTest.java`
    *   `SearchFilesServiceTest.java`
    *   `WriteFileServiceTest.java`

**4\. Resources**

*   Configuration files:
    *   `application.properties`
    *   `mcp-servers-config.json`
*   Native image configuration:
    *   `native-image.properties`
    *   `reflect-config.json`
    *   `resource-config.json`

**5\. IDE Configuration**

*   `.idea/` (IntelliJ IDEA project settings)

**6\. Other Files**

*   `pom.xml` (Maven build configuration)
*   `mvnw`, `mvnw.cmd` (Maven wrapper)

Would you like to explore any specific part of this structure in more detail?

This is a complete response, except for the ClientSse and ClientStdio files.

Enter a follow-up prompt: "I want a complete list of the files in the test directory."

Again, it asks to invoke the MCP tool searchFiles, this time with the path of the test directory.

The response now includes all files. See this snippet from the response.

src/test/
├── java/
│   └── com/
│       └── devoxx/
│           └── mcp/
│               └── filesystem/
│                   ├── ClientSse.java
│                   ├── ClientStdio.java
│                   └── tools/
│                       ├── BashServiceTest.java
│                       ├── CreateDirectoryServiceTest.java
│                       ├── EditFileServiceTest.java
│                       ├── FetchWebpageServiceTest.java
│                       ├── GrepFilesServiceTest.java
│                       ├── ListDirectoryServiceTest.java
│                       ├── ReadFileServiceTest.java
│                       ├── SearchFilesServiceTest.java
│                       └── WriteFileServiceTest.java

Create Directory

Now, let's try to create a directory. Enter the prompt: "Create a directory temp in this repository."

Again, the LLM instructs to call a tool, the createDirectory tool, this time.

The directory is correctly created in the repository. Great!

Create File

Let's try to create a file.

Enter the prompt: "Create a file temp.txt in the temp directory."

This time, the tool writeFile is invoked, and the file is created in the temp directory.

Conclusion

In this blog, you learnt how to configure DevoxxGenie to use MCP servers. You also saw how an LLM is able to decide when to use an available tool. Now, think about the possibilities for your coding workflow. If an LLM is able to create, edit files and directories, code can be generated directly in your repository. You can check the diff, you can build the changes immediately, and so on.