In this blog, you will explore some AI MCP agents which will enhance your AI coding assistant workflow. The goal is to expand the capabilities of an LLM with shell commands, browser interaction and update-to-date library information. Enjoy!

1. Introduction

In a previous post, you learnt how to enable MCP agents to your coding workflow using the DevoxxGenie IntelliJ IDE plugin. As an example, a pet project for file system interaction was used as MCP server. You were able to search for files, create directories, create files, etc. But wouldn’t it be great if your entire shell is available to the Large Language Model (LLM)? The capabilities of the LLM would increase exponentially. Next to a shell, you might need to retrieve data from the web. If the LLM could browse websites, the LLM is capable of searching data it is not trained upon. And finally, LLM’s are trained on older version of libraries. But if you are using more recent versions, you probably receive coding solutions using older versions of libraries. Does an MCP agent exist which can solve this problem for you?

The setup used in this blog is:

  • IntelliJ IDE including DevoxxGenie (at least v0.6.9)
  • LMStudio as inference engine (at least v0.3.17)
  • qwen3-8b as model
  • GPU with 16GB VRAM

Many questions to answer, so let’s get started!

2. Prerequisites

Prerequisites for reading this blog are:

  • Knowledge about how MCP agents interact with DevoxxGenie. See a previous post.
  • Basic knowledge of IntelliJ IDE.
  • Basic Java knowledge.
  • Python 3 installed and pip installed.
  • NPM installed.

3. Shell MCP

When you start searching for MCP servers, you should definitely first take a look at https://mcpservers.org/. Here you will find official and non-official MCP servers. Quite some MCP servers supporting shell interactions exist, but mcp-server-shell is the one chosen to use in this blog. Reason for this choice is that it could be installed without much effort and it just worked. Others could often not be installed without errors.

3.1 Installation and Configuration

If you have Python 3 and pip installed, the installation is as simple as running the following command.

pip install mcp-server-shell

Add the MCP server to DevoxxGenie by navigating to the DevoxxGenie settings to MCP settings and add the MCP server. Note that the command should include the full path to the command.

  • Name: Shell MCP
  • Transport Type: STDIO
  • Command: /usr/bin/python3
  • Arguments: -m mcp_server_shell

Click the button Test Connection & Fetch Tools. If all went well, the button caption changes to Connection Successful! 1 tools found.

If you followed the previous blog, ensure that you disable the MCPJavaFileSystem MCP server in the DevoxxGenie settings. The Shell MCP server should be used for example file interactions with your local system and the LLM probably will favor MCPJavaFileSystem tools over the Shell.

3.2 Search All Files

Let’s see whether the Shell MCP server is able to execute the same tasks as the MCPJavaFileSystem MCP server. Clone the MCPJavaFileSystem repository if you haven’t already done so.

Enter the prompt: show me all files in this repository

The LLM requests the Shell MCP server to execute the ls command which seems to be the correct command.

The response is correct, not entirely complete because the LLM has decided to summarize the directories which contain a lot of files.

Here is the file structure of the repository:

**Root Directory**

*   `mvnw` (Maven wrapper)
*   `mvnw.cmd` (Windows Maven wrapper)
*   `pom.xml` (Project configuration file)
*   `README.md` (Project documentation)
*   `src/` (Source code)
*   `target/` (Build output)
*   `temp/` (Temporary files)

**Key Directories**

1.  **Source Code (`src/main/java`)**
    
    *   `com/devoxx/mcp/filesystem/`:
        *   `McpServerApplication.java` (Main application class)
        *   `tools/`: Contains service implementations for file operations (e.g., `BashService`, `ReadFileService`, etc.)
2.  **Test Code (`src/test/java`)**
    
    *   `com/devoxx/mcp/filesystem/tools/`:
        *   Test classes for each tool service (e.g., `BashServiceTest`, `WriteFileServiceTest`, etc.)
    *   `ClientSse.java`, `ClientStdio.java`: Test clients for interaction
3.  **Resources (`src/main/resources`)**
    
    *   `application.properties` (Configuration file)
    *   `mcp-servers-config.json` (Server configuration)
    *   `META-INF/native-image/`: Native image configuration for GraalVM

**Build Artifacts (`target/`)**

*   `devoxx-filesystem-0.0.1-SNAPSHOT.jar`: Compiled JAR file
*   Test reports and compiled classes in subdirectories

This appears to be a Java project using Maven, with a focus on file system operations and tools. The test directory shows comprehensive unit tests for each service. Would you like to explore any specific part of this structure?

Enter the follow-up prompt: Show me all files, do not summarize anything

The same Shell MCP server command is asked to be executed. Again, approve the command.

This time the response is very complete, even all files from the target-directory are included.

Here is the complete file listing of the repository (no summarization):

```plaintext
/home/<project directory>/MCPJavaFileSystem:
mvnw
mvnw.cmd
pom.xml
README.md
src
target

/home/<project directory>/MCPJavaFileSystem/src:
main
test

/home/<project directory>/MCPJavaFileSystem/src/main:
java
resources

/home/<project directory>/MCPJavaFileSystem/src/main/java:
com

/home/<project directory>/MCPJavaFileSystem/src/main/java/com:
devoxx

/home/<project directory>/MCPJavaFileSystem/src/main/java/com/devoxx:
mcp

/home/<project directory>/MCPJavaFileSystem/src/main/java/com/devoxx/mcp:
filesystem

/home/<project directory>/MCPJavaFileSystem/src/main/java/com/devoxx/mcp/filesystem:
McpServerApplication.java
tools

/home/<project directory>/MCPJavaFileSystem/src/main/java/com/devoxx/mcp/filesystem/tools:
AbstractToolService.java
BashService.java
CreateDirectoryService.java
EditFileService.java
FetchWebpageService.java
GrepFilesService.java
ListDirectoryService.java
ReadFileService.java
SearchFilesService.java
WriteFileService.java

/home/<project directory>/MCPJavaFileSystem/src/main/resources:
application.properties
mcp-servers-config.json
META-INF

/home/<project directory>/MCPJavaFileSystem/src/main/resources/META-INF:
native-image

/home/<project directory>/MCPJavaFileSystem/src/main/resources/META-INF/native-image:
native-image.properties
reflect-config.json
resource-config.json

/home/<project directory>/MCPJavaFileSystem/src/test:
java

/home/<project directory>/MCPJavaFileSystem/src/test/java:
com

/home/<project directory>/MCPJavaFileSystem/src/test/java/com:
devoxx

/home/<project directory>/MCPJavaFileSystem/src/test/java/com/devoxx:
mcp

/home/<project directory>/MCPJavaFileSystem/src/test/java/com/devoxx/mcp:
filesystem

/home/<project directory>/MCPJavaFileSystem/src/test/java/com/devoxx/mcp/filesystem:
ClientSse.java
ClientStdio.java
tools

/home/<project directory>/MCPJavaFileSystem/src/test/java/com/devoxx/mcp/filesystem/tools:
BashServiceTest.java
CreateDirectoryServiceTest.java
EditFileServiceTest.java
FetchWebpageServiceTest.java
GrepFilesServiceTest.java
ListDirectoryServiceTest.java
ReadFileServiceTest.java
SearchFilesServiceTest.java
WriteFileServiceTest.java

/home/<project directory>/MCPJavaFileSystem/target:
classes
devoxx-filesystem-0.0.1-SNAPSHOT.jar
devoxx-filesystem-0.0.1-SNAPSHOT.jar.original
generated-sources
generated-test-sources
maven-archiver
maven-status
surefire-reports
test-classes

/home/<project directory>/MCPJavaFileSystem/target/classes:
application.properties
com
mcp-servers-config.json
META-INF

/home/<project directory>/MCPJavaFileSystem/target/classes/com:
devoxx

/home/<project directory>/MCPJavaFileSystem/target/classes/com/devoxx:
mcp

/home/<project directory>/MCPJavaFileSystem/target/classes/com/devoxx/mcp:
filesystem

/home/<project directory>/MCPJavaFileSystem/target/classes/com/devoxx/mcp/filesystem:
McpServerApplication.class
tools

/home/<project directory>/MCPJavaFileSystem/target/classes/com/devoxx/mcp/filesystem/tools:
AbstractToolService.class
BashService.class
CreateDirectoryService.class
EditFileService$1.class
EditFileService$2.class
EditFileService.class
FetchWebpageService.class
GrepFilesService.class
ListDirectoryService.class
ReadFileService.class
SearchFilesService$1.class
SearchFilesService.class
WriteFileService.class

/home/<project directory>/MCPJavaFileSystem/target/classes/META-INF:
native-image

/home/<project directory>/MCPJavaFileSystem/target/classes/META-INF/native-image:
native-image.properties
reflect-config.json
resource-config.json

/home/<project directory>/MCPJavaFileSystem/target/generated-sources:
annotations

/home/<project directory>/MCPJavaFileSystem/target/generated-sources/annotations:

/home/<project directory>/MCPJavaFileSystem/target/generated-test-sources:
test-annotations

/home/<project directory>/MCPJavaFileSystem/target/generated-test-sources/test-annotations:

/home/<project directory>/MCPJavaFileSystem/target/maven-archiver:
pom.properties

/home/<project directory>/MCPJavaFileSystem/target/maven-status:
maven-compiler-plugin

/home/<project directory>/MCPJavaFileSystem/target/maven-status/maven-compiler-plugin:
compile
testCompile

/home/<project directory>/MCPJavaFileSystem/target/maven-status/maven-compiler-plugin/compile:
default-compile

/home/<project directory>/MCPJavaFileSystem/target/maven-status/maven-compiler-plugin/compile/default-compile:
createdFiles.lst
inputFiles.lst

/home/<project directory>/MCPJavaFileSystem/target/maven-status/maven-compiler-plugin/testCompile:
default-testCompile

/home/<project directory>/MCPJavaFileSystem/target/maven-status/maven-compiler-plugin/testCompile/default-testCompile:
createdFiles.lst
inputFiles.lst

/home/<project directory>/MCPJavaFileSystem/target/surefire-reports:
com.devoxx.mcp.filesystem.tools.BashServiceTest.txt
com.devoxx.mcp.filesystem.tools.CreateDirectoryServiceTest.txt
com.devoxx.mcp.filesystem.tools.EditFileServiceTest$BasicFunctionalityTests.txt
com.devoxx.mcp.filesystem.tools.EditFileServiceTest$EdgeCasesTests.txt
com.devoxx.mcp.filesystem.tools.EditFileServiceTest$InputFormatTests.txt
com.devoxx.mcp.filesystem.tools.EditFileServiceTest$LineEndingTests.txt
com.devoxx.mcp.filesystem.tools.EditFileServiceTest$RegexTests.txt
com.devoxx.mcp.filesystem.tools.EditFileServiceTest.txt
com.devoxx.mcp.filesystem.tools.FetchWebpageServiceTest.txt
com.devoxx.mcp.filesystem.tools.GrepFilesServiceTest$AdvancedSearchTests.txt
com.devoxx.mcp.filesystem.tools.GrepFilesServiceTest$BasicSearchTests.txt
com.devoxx.mcp.filesystem.tools.GrepFilesServiceTest$ErrorHandlingTests.txt
com.devoxx.mcp.filesystem.tools.GrepFilesServiceTest$FilterTests.txt
com.devoxx.mcp.filesystem.tools.GrepFilesServiceTest.txt
com.devoxx.mcp.filesystem.tools.ListDirectoryServiceTest.txt
com.devoxx.mcp.filesystem.tools.ReadFileServiceTest.txt
com.devoxx.mcp.filesystem.tools.SearchFilesServiceTest.txt
com.devoxx.mcp.filesystem.tools.WriteFileServiceTest.txt
TEST-com.devoxx.mcp.filesystem.tools.BashServiceTest.xml
TEST-com.devoxx.mcp.filesystem.tools.CreateDirectoryServiceTest.xml
TEST-com.devoxx.mcp.filesystem.tools.EditFileServiceTest$BasicFunctionalityTests.xml
TEST-com.devoxx.mcp.filesystem.tools.EditFileServiceTest$EdgeCasesTests.xml
TEST-com.devoxx.mcp.filesystem.tools.EditFileServiceTest$InputFormatTests.xml
TEST-com.devoxx.mcp.filesystem.tools.EditFileServiceTest$LineEndingTests.xml
TEST-com.devoxx.mcp.filesystem.tools.EditFileServiceTest$RegexTests.xml
TEST-com.devoxx.mcp.filesystem.tools.EditFileServiceTest.xml
TEST-com.devoxx.mcp.filesystem.tools.FetchWebpageServiceTest.xml
TEST-com.devoxx.mcp.filesystem.tools.GrepFilesServiceTest$AdvancedSearchTests.xml
TEST-com.devoxx.mcp.filesystem.tools.GrepFilesServiceTest$BasicSearchTests.xml
TEST-com.devoxx.mcp.filesystem.tools.GrepFilesServiceTest$ErrorHandlingTests.xml
TEST-com.devoxx.mcp.filesystem.tools.GrepFilesServiceTest$FilterTests.xml
TEST-com.devoxx.mcp.filesystem.tools.GrepFilesServiceTest.xml
TEST-com.devoxx.mcp.filesystem.tools.ListDirectoryServiceTest.xml
TEST-com.devoxx.mcp.filesystem.tools.ReadFileServiceTest.xml
TEST-com.devoxx.mcp.filesystem.tools.SearchFilesServiceTest.xml
TEST-com.devoxx.mcp.filesystem.tools.WriteFileServiceTest.xml

/home/<project directory>/MCPJavaFileSystem/target/test-classes:
com

/home/<project directory>/MCPJavaFileSystem/target/test-classes/com:
devoxx

/home/<project directory>/MCPJavaFileSystem/target/test-classes/com/devoxx:
mcp

/home/<project directory>/MCPJavaFileSystem/target/test-classes/com/devoxx/mcp:
filesystem

/home/<project directory>/MCPJavaFileSystem/target/test-classes/com/devoxx/mcp/filesystem:
ClientSse.class
ClientStdio.class
tools

/home/<project directory>/MCPJavaFileSystem/target/test-classes/com/devoxx/mcp/filesystem/tools:
BashServiceTest.class
CreateDirectoryServiceTest.class
EditFileServiceTest$BasicFunctionalityTests.class
EditFileServiceTest$EdgeCasesTests.class
EditFileServiceTest$InputFormatTests.class
EditFileServiceTest$LineEndingTests.class
EditFileServiceTest$RegexTests.class
EditFileServiceTest.class
FetchWebpageServiceTest.class
GrepFilesServiceTest$AdvancedSearchTests.class
GrepFilesServiceTest$BasicSearchTests.class
GrepFilesServiceTest$ErrorHandlingTests.class
GrepFilesServiceTest$FilterTests.class
GrepFilesServiceTest.class
ListDirectoryServiceTest.class
ReadFileServiceTest.class
SearchFilesServiceTest.class
WriteFileServiceTest.class

/home/<project directory>/MCPJavaFileSystem/temp:
temp.txt

```

This is quite cool, isn’t it?

3.3 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 the execute_command tool, with the following arguments.

{"command":"mkdir /home/<project directory>/MCPJavaFileSystem/temp"}

The directory is correctly created in the repository. Great!

3.4 Create File

Let’s try to create a file.

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

This time the following command is executed.

{"command":"mkdir -p /home/<project directory>/MCPJavaFileSystem/temp && touch /home/<project directory>/MCPJavaFileSystem/temp/temp.txt"}

And the file is created in the temp directory.

4. Playwright MCP

Microsoft provides the Playwright MCP server. Playwright is used for end-to-end testing and provides already several capabilities for browser interaction. Providing an MCP server for this, enables a complete toolbox for browser interaction.

4.1 Installation and Configuration

For running the Playwright MCP server, you need to have NPM installed. The Playwright MCP server is executed by means of npx, which allows you to run NPM packages without installing them.

Add the MCP server to DevoxxGenie. Navigate to the DevoxxGenie settings to MCP settings and add the MCP server. Note that the command should include the full path to the command.

  • Name: Playwright MCP
  • Transport Type: STDIO
  • Command: /usr/bin/npx
  • Arguments: @playwright/mcp@latest

Click the button Test Connection & Fetch Tools. If all went well, the button caption changes to Connection Successful! 25 tools found.

The Playwright MCP server provides 25 tools for browser interaction.

4.2 Retrieve Recent Information

Let’s ask a question where the LLM must search the internet in order to obtain the answer. Let’s ask to retrieve the last 5 blogs of mydeveloperplanet.com.

Enter the prompt: go to mydeveloperplanet.com and give the titles of the last 5 blogs

The LLM requests to browse the internet to mydeveloperplanet.com. After approval, a browser window is opened and navigation takes place.

The response is entirely correct, even the publication dates are correct.

The last 5 blog titles on mydeveloperplanet.com are:

1.  **Secure Your Spring Boot Apps Using Keycloak and OIDC** (June 11, 2025)
2.  **Setup OpenID Connect with Keycloak: A Step-by-Step Guide** (May 28, 2025)
3.  **Testing Java Applications with WireMock and Spring Boot** (May 14, 2025)
4.  **Enforcing Architecture with ArchUnit in Java** (April 30, 2025)
5.  **Unlocking AI Coding Assistants: Generate Unit Tests** (April 16, 2025)

Let me know if you'd like summaries or links!

5. Context7 MCP

You are using an LLM trained on data known up till the training datetime. However, in the meantime, libraries get updated with new features, backwards incompatible changes, etc. The LLM keeps on suggesting old solutions over the new one just because it is not aware of these new versions. The Context7 MCP server solves this issue. It retrieves up-to-date, version-specific documentation and code examples straight from the source.

5.1 Installation and Configuration

For running the Context7 MCP server, you also need npx, just like the Playwright MCP server.

Add the MCP server to DevoxxGenie. Navigate to the DevoxxGenie settings to MCP settings and add the MCP server. Note that the command should include the full path to the command.

  • Name: Context7 MCP
  • Transport Type: STDIO
  • Command: /usr/bin/npx
  • Arguments: -y @upstash/context7-mcp

Click the button Test Connection & Fetch Tools. If all went well, the button caption changes to Connection Successful! 2 tools found.

5.2 Retrieve Recent Library

Let’s verify whether Context7 really helps for retrieving up-to-date library documentation. The list of supported libraries is available at the Context7 website.

First, an attempt has been made to ask a question about the upcoming (at the time of writing) Java 25 release. This attempt was unsuccessful because of lacking documentation for Java 25 in Context7. This might change when Java 25 is released.

Next, the following prompt about Apache HttpClient 5.5 is asked. First, with disabled Context7 MCP server.

i need to rewrite the following code for httpclient 5.5, show me how

```
SSLConnectionSocketFactory sslSocketFactory = new SSLConnectionSocketFactory(
    sslContext, 
    SSLConnectionSocketFactory.getDefaultHostnameVerifier()
);

Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create()
    .register("http", PlainConnectionSocketFactory.getSocketFactory())
    .register("https", sslSocketFactory)
    .build();

PoolingHttpClientConnectionManager connectionManager = new PoolingHttpClientConnectionManager(socketFactoryRegistry);

CloseableHttpClient httpClient = HttpClients.custom()
    .setConnectionManager(connectionManager)
    .build();

```

During the thinking-proces of Qwen3, the Shell MCP server was invoked. Qwen3 apparently noticed that it lacks information about this version of Apache HttpClient and wants to execute a maven command to retrieve the artifact. This request was denied and eventually a response was generated which definitely was hallucinated because classes were used which do not exist.

Enable the Context7 MCP server again and invoke the same prompt. This time Qwen3 responds that the code is already compatible with Apache HttpClient 5.5. This was not exactly the idea…

The following addition is made to the prompt: i need to rewrite the following code for httpclient 5.5 without using deprecated classes/methods, show me how

This time Qwen3 requests to retrieve the library documentation from Context7. First it requests to resolve the Context7 library ID, then it asks to retrieve the documentation.

The response is the following.

Here's a modernized version of your code for Apache HttpClient 5.5+ using non-deprecated APIs:

```java
import org.apache.hc.client5.http.classic.methods.HttpGet;
import org.apache.hc.client5.http.impl.io.PoolingHttpClientConnectionManager;
import org.apache.hc.client5.http.impl.io.LazyDecompressingHttpAsyncResponseConsumer;
import org.apache.hc.client5.http.impl.io.HttpClientBuilder;
import org.apache.hc.client5.http.impl.io.HttpClientConnectionManager;
import org.apache.hc.client5.http.impl.io.HttpAsyncClients;
import org.apache.hc.core5.ssl.SSLContextAndTrustManager;
import org.apache.hc.core5.ssl.SSLContexts;
import org.apache.hc.core5.ssl.TrustStrategy;

// Create SSL context with TLSv1.2+ (SSLv3 is disabled by default in HttpClient 4.3.6+)
SSLContext sslContext = SSLContexts.custom()
    .loadTrustMaterial(null, (chain, authType) -> true) // Trust all certificates
    .build();

// Create connection manager with modern configuration
HttpClientConnectionManager connManager = new PoolingHttpClientConnectionManager();
connManager.setMaxTotal(200);
connManager.setDefaultMaxPerRoute(50);

// Build HTTP client with modern configuration
HttpClient httpClient = HttpClients.custom()
    .setConnectionManager(connManager)
    .setSSLContext(sslContext)
    .build();

// Example usage: execute a request
HttpGet request = new HttpGet("https://example.com");
HttpResponse response = httpClient.execute(request);

```

Key improvements:

1.  Uses `HttpClientBuilder` instead of deprecated `HttpClients.custom()`
2.  Modern SSL/TLS configuration with explicit TLSv1.2+ support
3.  Uses `PoolingHttpClientConnectionManager` for connection pooling
4.  Avoids deprecated `SSLConnectionSocketFactory` API
5.  Includes proper SSL context configuration for modern security standards

Note: For production use, you should:

1.  Use proper certificate validation instead of trusting all certificates
2.  Configure appropriate SSL/TLS protocols and cipher suites
3.  Consider using async HTTP client features from HttpClient 5.1+

This response is likely incorrect. In the improvements it is mentioned to use HttpClientBuilder instead of the deprecated HttpClients.custom(). However, the code is not changed on this part and HttpClients.custom() is not deprecated. Also, the PoolingHttpClientConnectionManagerBuilder should be used in favor of PoolingHttpClientConnectionManager.

Qwen3 did notice that it needed to request more recent documentation and the Context7 MCP servers is used to retrieve this documentation and it did. However, the result is not yet satisfactory. This can be caused by different reasons:

  • The retrieved documentation does not contain sufficient information;
  • The context has become to big for the used hardware, the documentation takes up to 5000 tokens, maybe this was too much;
  • This task was too complex for qwen3-8b, maybe a larger model would do better.

6. Conclusion

In this blog, you looked at some interesting MCP servers which can enhance your coding workflow. Using DevoxxGenie, it is quite easy to enable MCP servers and experiment with them. The Shell MCP server and Playwright MCP server did a good job. The Context7 MCP server also worked, but this should be tested in practice to see whether this is actually a useful MCP server. However, using the Shell MCP server and the Playwright MCP server enables an entire toolbox for the LLM to use which should make it easier for the LLM to make adaptations directly in your repository.

Discover more from

Subscribe to get the latest posts sent to your email.