### JDBC Server - Starting and Configuration

Source: https://context7.com/quarkiverse/quarkus-mcp-servers/llms.txt

Instructions on how to start the JDBC server with different database configurations and an example Claude Desktop configuration.

```APIDOC
## JDBC Server

The JDBC server enables LLMs to inspect, query, create, and modify database content using any JDBC-compatible database including PostgreSQL, MySQL, Oracle, SQLite, H2, and many more.

### Starting the JDBC Server

```bash
# Start with an empty in-memory H2 database
jbang jdbc@quarkiverse/quarkus-mcp-servers

# Connect to a live PostgreSQL database
jbang jdbc@quarkiverse/quarkus-mcp-servers jdbc:postgresql://localhost:5432/sakila -u sakila -p p_ssW0rd

# Connect to Oracle database
jbang jdbc@quarkiverse/quarkus-mcp-servers jdbc:oracle:thin:@localhost:1521:orcl

# Download and use a SQLite database from the web
jbang jdbc@quarkiverse/quarkus-mcp-servers jdbc:sqlite:%{https://github.com/lerocha/chinook-database/raw/master/ChinookDatabase/DataSources/Chinook_Sqlite.sqlite}

# Enable detailed logging
jbang -Dquarkus.log.file.enable=true -Dquarkus.log.file.path=${user.home}/mcp-jdbc.log jdbc@quarkiverse/quarkus-mcp-servers jdbc:h2:mem:testdb
```

### Claude Desktop Configuration for JDBC

```json
{
  "mcpServers": {
    "jdbc": {
      "command": "jbang",
      "args": [
        "jdbc@quarkiverse/quarkus-mcp-servers",
        "jdbc:postgresql://localhost:5432/mydb",
        "-u", "myuser",
        "-p", "mypassword"
      ]
    }
  }
}
```
```

--------------------------------

### Start MCP Filesystem Server with Detailed Logging

Source: https://github.com/quarkiverse/quarkus-mcp-servers/blob/main/filesystem/README.md

Example command to start the server with detailed logging enabled, directing output to a specified file. Adjust paths as needed.

```shell
jbang -Dquarkus.log.file.enable=true -Dquarkus.log.file.path=${user.home}/mcp-server-filesystem.log filesystem@quarkiverse/quarkus-mcp-servers [path1] [path2] ...
```

--------------------------------

### Start MCP Filesystem Server with jbang

Source: https://github.com/quarkiverse/quarkus-mcp-servers/blob/main/filesystem/README.md

Use this command to start the server, specifying the paths accessible by the LLM. Ensure jbang is installed and in your PATH.

```shell
jbang filesystem@quarkiverse/quarkus-mcp-servers ~/code/quarkiverse ~/code/jbang
```

--------------------------------

### Get Kubernetes Resource Tool Example Call

Source: https://context7.com/quarkiverse/quarkus-mcp-servers/llms.txt

An example of calling the `resources_get` tool to retrieve a specific Deployment named 'my-app' in the 'production' namespace.

```json
{
  "tool": "resources_get",
  "arguments": {
    "apiVersion": "apps/v1",
    "kind": "Deployment",
    "namespace": "production",
    "name": "my-app"
  }
}
```

--------------------------------

### Connect to Oracle Database

Source: https://github.com/quarkiverse/quarkus-mcp-servers/blob/main/jdbc/README.md

Example command to start the MCP JDBC server and connect to a running Oracle database. Replace the URL with your specific Oracle connection string.

```shell
jbang jdbc@quarkiverse/quarkus-mcp-servers jdbc:oracle:thin:@localhost:1521:orcl
```

--------------------------------

### Start Filesystem Server

Source: https://context7.com/quarkiverse/quarkus-mcp-servers/llms.txt

Start the filesystem server with specified allowed paths or enable detailed logging for debugging.

```bash
# Start with specific allowed paths
jbang filesystem@quarkiverse/quarkus-mcp-servers ~/code/project1 ~/code/project2

# Enable detailed logging
jbang -Dquarkus.log.file.enable=true -Dquarkus.log.file.path=${user.home}/mcp-server-filesystem.log filesystem@quarkiverse/quarkus-mcp-servers ~/

```

--------------------------------

### List Kubernetes Resources Tool Example Calls

Source: https://context7.com/quarkiverse/quarkus-mcp-servers/llms.txt

Examples of calling the `resources_list` tool to retrieve different types of Kubernetes resources. The first example lists Deployments in the 'default' namespace, and the second lists Services without specifying a namespace.

```json
{
  "tool": "resources_list",
  "arguments": {
    "apiVersion": "apps/v1",
    "kind": "Deployment",
    "namespace": "default"
  }
}

{
  "tool": "resources_list",
  "arguments": {
    "apiVersion": "v1",
    "kind": "Service"
  }
}
```

--------------------------------

### Get Kubernetes Configuration Tool Example Call

Source: https://context7.com/quarkiverse/quarkus-mcp-servers/llms.txt

An example of calling the `configuration_get` tool. This returns a Kubernetes Config object containing cluster details.

```json
{
  "tool": "configuration_get",
  "arguments": {}
}
```

--------------------------------

### Create Directory Tool Example Call

Source: https://context7.com/quarkiverse/quarkus-mcp-servers/llms.txt

An example of calling the `create_directory` tool to create a specific directory path. This is useful for setting up project structures.

```json
{
  "tool": "create_directory",
  "arguments": {
    "path": "/Users/developer/projects/app/src/main/resources/templates"
  }
}
```

--------------------------------

### Write File Tool Example Call

Source: https://context7.com/quarkiverse/quarkus-mcp-servers/llms.txt

An example of how to call the `write_file` tool with a specific path and content. Ensure the content is correctly formatted, especially for JSON.

```json
{
  "tool": "write_file",
  "arguments": {
    "path": "/Users/developer/projects/app/config.json",
    "content": "{\n  \"database\": \"postgresql\",\n  \"port\": 5432\n}"
  }
}
```

--------------------------------

### Start Wolfram Alpha MCP Server

Source: https://github.com/quarkiverse/quarkus-mcp-servers/blob/main/wolfram/README.md

Use this command to start the MCP server for Wolfram Alpha. Ensure you have jbang installed and replace ${YOUR_WOLFRAM_APP_ID} with your actual Wolfram Alpha App ID.

```shell
jbang -DWOLFRAM_LLM_API_KEY=${YOUR_WOLFRAM_APP_ID} io.quarkiverse.mcp.servers:mcp-server-wolfram:RELEASE
```

--------------------------------

### Build and Install Quarkus Project

Source: https://github.com/quarkiverse/quarkus-mcp-servers/blob/main/kubernetes/README.md

Standard Maven command to clean and install the Quarkus project. This is the initial step for building and testing.

```bash
mvn clean install
```

--------------------------------

### List Allowed Directories Tool Example Call

Source: https://context7.com/quarkiverse/quarkus-mcp-servers/llms.txt

An example of calling the `list_allowed_directories` tool. This returns a JSON array of accessible directory paths.

```json
{
  "tool": "list_allowed_directories",
  "arguments": {}
}
```

--------------------------------

### Starting the jvminsight Server

Source: https://github.com/quarkiverse/quarkus-mcp-servers/blob/main/jvminsight/README.md

Instructions on how to start the jvminsight MCP server using jbang. It also covers specifying a Java version and configuring security paths.

```APIDOC
## Starting the jvminsight Server

### Description
Instructions on how to start the jvminsight MCP server using jbang. It also covers specifying a Java version and configuring security paths.

### Command
```shell
jbang jvminsight@quarkiverse/quarkus-mcp-servers
```

### Requirements
Requires Java 17 or higher.

### Options

#### Specifying Java Version
To use a specific Java version (e.g., Java 25):
```shell
jbang --java 25 jvminsight@quarkiverse/quarkus-mcp-servers
```

#### Security - Customizing Allowed Paths
Optionally set `-Djvminsight.paths` to a comma-separated list of directories to allow exposure.

Example:
```shell
jbang -Djvminsight.paths=/opt/java17/bin,/opt/java21/bin jvminsight@quarkiverse/quarkus-mcp-servers
```
```

--------------------------------

### Start Wolfram Server with JBang

Source: https://context7.com/quarkiverse/quarkus-mcp-servers/llms.txt

Start the Wolfram server using JBang. Requires setting the Wolfram Alpha App ID as a system property.

```bash
# Set your Wolfram Alpha App ID
jbang -DWOLFRAM_LLM_API_KEY=${YOUR_WOLFRAM_APP_ID} io.quarkiverse.mcp.servers:mcp-server-wolfram:RELEASE
```

--------------------------------

### Run Quarkus Dev with H2 Database Profile

Source: https://github.com/quarkiverse/quarkus-mcp-servers/blob/main/kubernetes/README.md

Starts the Quarkus development server with the H2 database profile enabled for in-memory testing. No external database setup is required.

```bash
mvn quarkus:dev -Dh2
```

--------------------------------

### Run Quarkus Dev with PostgreSQL Profile

Source: https://github.com/quarkiverse/quarkus-mcp-servers/blob/main/kubernetes/README.md

Starts the Quarkus development server with the PostgreSQL profile. Requires a PostgreSQL database running, for example, in a container.

```bash
podman run -p 5432:5432 -d sakiladb/postgres:latest
mvn quarkus:dev -Dpostgresql
```

--------------------------------

### Generate New MCP Server with jbang

Source: https://github.com/quarkiverse/quarkus-mcp-servers/blob/main/README.md

This command initializes a new MCP server project, using the 'jfr' example, within the current directory. It requires jbang to be installed.

```bash
mkdir jfr
cd jfr
jbang init -t mcp jfr
```

--------------------------------

### Kubernetes Server Configuration

Source: https://context7.com/quarkiverse/quarkus-mcp-servers/llms.txt

Instructions and configuration for starting and using the Kubernetes server.

```APIDOC
## Starting the Kubernetes Server

### Description
Start the Kubernetes server using JBang.

### Command
```bash
jbang kubernetes@quarkiverse/quarkus-mcp-servers
```

### Claude Desktop Configuration

```json
{
  "mcpServers": {
    "kubernetes": {
      "command": "jbang",
      "args": [
        "kubernetes@quarkiverse/quarkus-mcp-servers"
      ]
    }
  }
}
```
```

--------------------------------

### Create or Update Kubernetes Resource Tool Example Call

Source: https://context7.com/quarkiverse/quarkus-mcp-servers/llms.txt

An example of calling the `resources_create_or_update` tool to create or update a Kubernetes ConfigMap. The resource definition is provided as a multi-line string.

```json
{
  "tool": "resources_create_or_update",
  "arguments": {
    "resource": "apiVersion: v1\nkind: ConfigMap\nmetadata:\n  name: my-config\n  namespace: default\ndata:\n  key1: value1\n  key2: value2"
  }
}
```

--------------------------------

### Start Kubernetes Server

Source: https://context7.com/quarkiverse/quarkus-mcp-servers/llms.txt

Command to start the Kubernetes server using JBang. This command assumes your kubeconfig is set up correctly.

```bash
# Start the server (uses default kubeconfig)
jbang kubernetes@quarkiverse/quarkus-mcp-servers
```

--------------------------------

### Start MCP JDBC Server with Live Database

Source: https://github.com/quarkiverse/quarkus-mcp-servers/blob/main/jdbc/README.md

Connect to an existing JDBC-compatible database by providing its JDBC URL. Ensure the database is accessible.

```shell
jbang jdbc@quarkiverse/quarkus-mcp-servers [jdbc_url]
```

--------------------------------

### getSystemProperties Tool Definition and Example

Source: https://context7.com/quarkiverse/quarkus-mcp-servers/llms.txt

Defines and provides an example for the 'getSystemProperties' tool, which retrieves system properties of an attached JVM process. It requires a process ID and returns a map of properties.

```java
// Tool definition
@Tool(description = "Get the system properties of a JVM process")
Map<String, String> getSystemProperties(@ToolArg(description = "Process id to inspect") String pid)
```

```json
// Example MCP tool call
{
  "tool": "getSystemProperties",
  "arguments": {
    "pid": "12345"
  }
}
```

```text
// Returns map of system properties: {"java.version": "21.0.1", "java.home": "/usr/lib/jvm/java-21", ...}
```

--------------------------------

### shortResponseQuery Tool Definition and Example

Source: https://context7.com/quarkiverse/quarkus-mcp-servers/llms.txt

Defines and provides an example for the 'shortResponseQuery' tool, which performs a web search and returns a concise response. It takes a search query as input.

```java
// Tool definition
@Tool(description = "Perform a web search to retrieve information online with a short response")
String shortResponseQuery(@ToolArg(description = "Web search query") String q)
```

```json
// Example MCP tool call
{
  "tool": "shortResponseQuery",
  "arguments": {
    "q": "distance from Earth to Mars"
  }
}
```

--------------------------------

### fullResponseQuery Tool Definition and Example

Source: https://context7.com/quarkiverse/quarkus-mcp-servers/llms.txt

Defines and provides an example for the 'fullResponseQuery' tool, which performs a web search and returns a full text response. It takes a search query as input.

```java
// Tool definition
@Tool(description = "Perform a web search to retrieve information online with a full text response")
String fullResponseQuery(@ToolArg(description = "Web search query") String q)
```

```json
// Example MCP tool call
{
  "tool": "fullResponseQuery",
  "arguments": {
    "q": "What is the population of Tokyo?"
  }
}
```

--------------------------------

### attach Tool Definition and Example

Source: https://context7.com/quarkiverse/quarkus-mcp-servers/llms.txt

Defines and provides an example for the 'attach' tool, which attaches to a JVM process for inspection. It returns the PID of the attached process upon success.

```java
// Tool definition
@Tool(description = "Attach to a JVM process, returns the pid of the attached process if successful")
String attach(String pid)
```

```json
// Example MCP tool call
{
  "tool": "attach",
  "arguments": {
    "pid": "12345"
  }
}
```

```text
// Returns: "12345"
```

--------------------------------

### Example JDBC URL for Chinook SQLite Database

Source: https://github.com/quarkiverse/quarkus-mcp-servers/blob/main/jdbc/README.md

This is an example JDBC URL for connecting to the Chinook sample database in SQLite format, which can be downloaded from GitHub.

```sql
jdbc:sqlite:%{https://github.com/lerocha/chinook-database/raw/master/ChinookDatabase/DataSources/Chinook_Sqlite.sqlite}
```

--------------------------------

### Run New Container

Source: https://context7.com/quarkiverse/quarkus-mcp-servers/llms.txt

Starts a new container using a specified image name. You can configure port mappings and environment variables.

```java
// Tool definition
@Tool(description = "Runs a Docker or Podman container with the specified image name")
public String container_run(
    @ToolArg(description = "Docker or Podman container image name to pull", required = true) String imageName,
    @ToolArg(description = "Port mappings to expose. Format: <hostPort>:<containerPort>") List<String> ports,
    @ToolArg(description = "Environment variables. Format: <key>=<value>") List<String> environment)
```

```json
// Example MCP tool call
{
  "tool": "container_run",
  "arguments": {
    "imageName": "postgres:15",
    "ports": ["5432:5432"],
    "environment": ["POSTGRES_PASSWORD=mysecret", "POSTGRES_DB=myapp"]
  }
}
```

--------------------------------

### Launch MCP Server with Logging

Source: https://github.com/quarkiverse/quarkus-mcp-servers/blob/main/jdbc/README.md

Example command to launch the MCP server using jbang with detailed logging enabled and a specific JDBC URL.

```shell
jbang -Dquarkus.log.file.enable=true -Dquarkus.log.file.path=${user.home}/mcp-jdbc.log jdbc@quarkiverse/quarkus-mcp-servers jdbc:h2:mem:testdb
```

--------------------------------

### jps Tool Definition and Example

Source: https://context7.com/quarkiverse/quarkus-mcp-servers/llms.txt

Defines and provides an example for the 'jps' tool, which lists all running JVM processes. The output is a tab-separated list of process IDs and their main classes.

```java
// Tool definition
@Tool(description = "List all running JVM processes")
String jps()
```

```json
// Example MCP tool call
{
  "tool": "jps",
  "arguments": {}
}
```

```text
// Returns tab-separated list:
// 12345	org.springframework.boot.loader.JarLauncher
// 67890	io.quarkus.runner.GeneratedMain
```

--------------------------------

### Start JVM Insight Server with JBang

Source: https://context7.com/quarkiverse/quarkus-mcp-servers/llms.txt

Start the JVM Insight server using JBang. You can specify the Java home, or expose additional tool paths.

```bash
# Start with default Java home
jbang jvminsight@quarkiverse/quarkus-mcp-servers
```

```bash
# Use a specific Java version
jbang --java 21 jvminsight@quarkiverse/quarkus-mcp-servers
```

```bash
# Expose additional tool paths
jbang -Djvminsight.paths=/opt/java17/bin,/opt/java21/bin jvminsight@quarkiverse/quarkus-mcp-servers
```

--------------------------------

### Connect to PostgreSQL with User and Password

Source: https://github.com/quarkiverse/quarkus-mcp-servers/blob/main/jdbc/README.md

Start the MCP JDBC server and connect to a PostgreSQL database, specifying the user and password. Ensure these credentials are correct for your database.

```shell
jbang jdbc@quarkiverse/quarkus-mcp-servers jdbc:postgresql://localhost:5432/sakila -u sakila -p p_ssW0rd
```

--------------------------------

### Run Filesystem Server with jbang

Source: https://github.com/quarkiverse/quarkus-mcp-servers/blob/main/README.md

This command starts the filesystem server, which serves files from a specified path. You can provide one or more paths as arguments.

```shell
jbang filesystem@quarkiverse/quarkus-mcp-servers [path1] [path2] ...
```

--------------------------------

### JFX Server Configuration

Source: https://context7.com/quarkiverse/quarkus-mcp-servers/llms.txt

Configuration details for starting and integrating the JFX Server.

```APIDOC
## JFX Server

### Starting the JFX Server
Use the following command to start the JFX server:
```bash
jbang jfx@quarkiverse/quarkus-mcp-servers
```

### Claude Desktop Configuration for JFX
Configure Claude Desktop to use the JFX server with the following JSON:
```json
{
  "mcpServers": {
    "jfx": {
      "command": "jbang",
      "args": [
        "jfx@quarkiverse/quarkus-mcp-servers"
      ]
    }
  }
}
```
```

--------------------------------

### Run Wolfram Server with jbang

Source: https://github.com/quarkiverse/quarkus-mcp-servers/blob/main/README.md

Execute this command to start the Wolfram server, which performs web searches optimized for LLM use via the Wolfram Alpha API.

```shell
jbang wolfram@quarkiverse/quarkus-mcp-servers
```

--------------------------------

### Start JVM Insight MCP Server with Specific Java Version

Source: https://github.com/quarkiverse/quarkus-mcp-servers/blob/main/jvminsight/README.md

Specify a Java version (e.g., Java 25) when starting the jvminsight MCP server using the --java flag.

```shell
jbang --java 25 jvminsight@quarkiverse/quarkus-mcp-servers
```

--------------------------------

### executeJavaTool Tool Definition and Examples

Source: https://context7.com/quarkiverse/quarkus-mcp-servers/llms.txt

Defines and provides examples for the 'executeJavaTool' tool, which executes Java diagnostic tools like jstack, jmap, or jcmd. It can also list available tools if no tool name is provided.

```java
// Tool definition
@Tool(description = "Execute a Java tool or list all available tools if no tool name is provided")
String executeJavaTool(
    @ToolArg(description = "Tool name to execute, or empty to list all tools") String tool,
    @ToolArg(description = "Arguments to pass to the tool") String... args)
```

```json
// Example MCP tool calls
{
  "tool": "executeJavaTool",
  "arguments": {
    "tool": "jstack",
    "args": ["12345"]
  }
}
```

```json
{
  "tool": "executeJavaTool",
  "arguments": {
    "tool": "jmap",
    "args": ["-histo", "12345"]
  }
}
```

```json
{
  "tool": "executeJavaTool",
  "arguments": {
    "tool": "jcmd",
    "args": ["12345", "VM.flags"]
  }
}
```

--------------------------------

### Launch MCP Server with jbang

Source: https://github.com/quarkiverse/quarkus-mcp-servers/blob/main/containers/README.md

Use this command to launch the MCP server for containers. Ensure jbang is installed and configured.

```shell
jbang containers@quarkiverse/quarkus-mcp-servers
```

--------------------------------

### MCP Tool Call: write_query (INSERT)

Source: https://context7.com/quarkiverse/quarkus-mcp-servers/llms.txt

Example of calling the 'write_query' tool to insert a new record into the 'customers' table. Returns a success message.

```json
{
  "tool": "write_query",
  "arguments": {
    "query": "INSERT INTO customers (name, email, country) VALUES ('Jane Smith', 'jane@example.com', 'Canada')"
  }
}
```

--------------------------------

### Run Quarkus Dev with SQLite Profile and Custom URL

Source: https://github.com/quarkiverse/quarkus-mcp-servers/blob/main/kubernetes/README.md

Starts the Quarkus development server with the SQLite profile. Allows specifying a custom JDBC URL for the SQLite database file.

```bash
mvn quarkus:dev -Dsqlite -Djdbc.url=jdbc:sqlite:./test.db
```

--------------------------------

### MCP Tool Call: list_tables

Source: https://context7.com/quarkiverse/quarkus-mcp-servers/llms.txt

Example of calling the 'list_tables' tool with pagination and schema filtering. Returns JSON containing table metadata.

```json
{
  "tool": "list_tables",
  "arguments": {
    "page": 1,
    "size": 20,
    "schema": "public"
  }
}
```

--------------------------------

### Example JDBC URL for Netflix Movies SQLite Database

Source: https://github.com/quarkiverse/quarkus-mcp-servers/blob/main/jdbc/README.md

This JDBC URL is for a sample movie database based on the Netflix catalog, provided in SQLite format.

```sql
jdbc:sqlite:%{https://github.com/lerocha/netflixdb/releases/download/v1.0.0/netflixdb.sqlite}
```

--------------------------------

### Example JDBC URL for Northwind SQLite Database

Source: https://github.com/quarkiverse/quarkus-mcp-servers/blob/main/jdbc/README.md

This JDBC URL connects to the Northwind sample database, a classic Microsoft sample dataset, in SQLite format.

```sql
jdbc:sqlite:%{https://github.com/jpwhite3/northwind-SQLite3/raw/refs/heads/main/dist/northwind.db}
```

--------------------------------

### List Directory Tool

Source: https://context7.com/quarkiverse/quarkus-mcp-servers/llms.txt

Get a detailed listing of files and directories within a specified path. Requires the path and an McpLog logger.

```java
// Tool definition
@Tool(description = "Get a detailed listing of all files and directories in a specified path...")
String list_directory(@ToolArg(description = "Path to list contents of") String path, McpLog logger)

```

```json
// Example MCP tool call
{
  "tool": "list_directory",
  "arguments": {
    "path": "/Users/developer/projects/app/src/main/java"
  }
}

```

```text
// Returns formatted listing:
// [DIR]  com
// [FILE] App.java
// [FILE] Config.java

```

--------------------------------

### MCP Tool Call: write_query (UPDATE)

Source: https://context7.com/quarkiverse/quarkus-mcp-servers/llms.txt

Example of calling the 'write_query' tool to update an existing record in the 'customers' table. Returns a success message.

```json
{
  "tool": "write_query",
  "arguments": {
    "query": "UPDATE customers SET email = 'newemail@example.com' WHERE customer_id = 1"
  }
}
```

--------------------------------

### Get Kubernetes Configuration Tool Definition

Source: https://context7.com/quarkiverse/quarkus-mcp-servers/llms.txt

Defines the `configuration_get` tool for retrieving the current Kubernetes client configuration. This can be used to inspect cluster details.

```java
// Tool definition
@Tool(description = "Get the current Kubernetes configuration")
public Config configuration_get()
```

--------------------------------

### MCP Tool Call: read_query

Source: https://context7.com/quarkiverse/quarkus-mcp-servers/llms.txt

Example of calling the 'read_query' tool with a specific SQL SELECT statement. Returns results as a JSON array.

```json
{
  "tool": "read_query",
  "arguments": {
    "query": "SELECT * FROM customers WHERE country = 'USA' LIMIT 10"
  }
}
```

--------------------------------

### Clone and Build Quarkus MCP Servers Project

Source: https://github.com/quarkiverse/quarkus-mcp-servers/blob/main/README.md

Standard commands to clone the project repository, navigate into the directory, and build the project using Maven.

```bash
git clone https://github.com/quarkiverse/quarkus-mcp-servers
cd quarkus-mcp-servers
mvn clean install
```

--------------------------------

### Configure MCP Client for Native Filesystem Server (macOS ARM64)

Source: https://github.com/quarkiverse/quarkus-mcp-servers/blob/main/filesystem/README.md

Use this configuration for native executables, specifying the platform-specific binary. Replace '[path1]' and '[path2]' with the desired accessible directories.

```json
{
  "mcpServers": {
    "filesystem": {
      "command": "jbang",
      "args": [
        "mcp-server-filesystem-osx-aarch_64",
        "[path1]",
        "[path2]"
      ]
    }
  }
}
```

--------------------------------

### Get Canvas Image Tool

Source: https://context7.com/quarkiverse/quarkus-mcp-servers/llms.txt

Retrieves the current JFX canvas as a base64-encoded PNG image.

```APIDOC
## getCanvasImage Tool

### Description
Get the current canvas as a base64-encoded PNG image.

### Method
GET (assumed, as it retrieves data)

### Endpoint
/tools/getCanvasImage

### Parameters
No parameters required.

### Request Example
```json
{
  "tool": "getCanvasImage",
  "arguments": {}
}
```

### Response
#### Success Response (200)
- **imageContent** (object) - Contains the base64-encoded PNG data.
  - **base64Data** (string) - The base64 encoded PNG image data.

#### Response Example
```json
{
  "imageContent": {
    "base64Data": "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYAAAAAYAAjCB0C8AAAAASUVORK5CYII="
  }
}
```
```

--------------------------------

### Get Container Logs

Source: https://context7.com/quarkiverse/quarkus-mcp-servers/llms.txt

Retrieves logs from a running container by its name. You can specify the number of lines to return.

```java
// Tool definition
@Tool(description = "Get logs from container")
public List<String> container_logs(
    @ToolArg(description = "The name of the container") String name,
    @ToolArg(description = "The number of lines to return") int lines)
```

```json
// Example MCP tool call
{
  "tool": "container_logs",
  "arguments": {
    "name": "my-postgres-container",
    "lines": 100
  }
}
```

--------------------------------

### Configure Claude Desktop for Containers

Source: https://context7.com/quarkiverse/quarkus-mcp-servers/llms.txt

JSON configuration for Claude Desktop to connect to the containers server. Specifies the command and arguments to launch the server.

```json
{
  "mcpServers": {
    "containers": {
      "command": "jbang",
      "args": [
        "containers@quarkiverse/quarkus-mcp-servers"
      ]
    }
  }
}
```

--------------------------------

### Get Pod Logs

Source: https://context7.com/quarkiverse/quarkus-mcp-servers/llms.txt

Retrieve logs from a specific Kubernetes pod by providing its name and optionally the namespace.

```java
// Tool definition
@Tool(description = "Get the logs of a Kubernetes Pod...")
public String pods_log(
    @ToolArg(description = "Namespace to get the Pod from", required = false) String namespace,
    @ToolArg(description = "Name of the Pod", required = false) String name)
```

```json
// Example MCP tool call
{
  "tool": "pods_log",
  "arguments": {
    "namespace": "default",
    "name": "my-app-pod-abc123"
  }
}
```

--------------------------------

### Claude Desktop Configuration for Filesystem Server

Source: https://context7.com/quarkiverse/quarkus-mcp-servers/llms.txt

Configure Claude Desktop to use the filesystem server by specifying the command and arguments.

```json
{
  "mcpServers": {
    "filesystem": {
      "command": "jbang",
      "args": [
        "filesystem@quarkiverse/quarkus-mcp-servers",
        "/Users/developer/projects",
        "/Users/developer/documents"
      ]
    }
  }
}

```

--------------------------------

### Launch Canvas Tool

Source: https://context7.com/quarkiverse/quarkus-mcp-servers/llms.txt

Launches a new drawing canvas window.

```APIDOC
## launchCanvas Tool

### Description
Launch a new drawing canvas window.

### Method
POST (assumed, as it initiates an action)

### Endpoint
/tools/launchCanvas

### Parameters
No parameters required.

### Request Example
```json
{
  "tool": "launchCanvas",
  "arguments": {}
}
```

### Response
#### Success Response (200)
- **message** (string) - Confirmation message, e.g., "Canvas launched with dimensions: 800x600"

#### Response Example
```json
{
  "message": "Canvas launched with dimensions: 800x600"
}
```
```

--------------------------------

### Directory Tree Tool

Source: https://context7.com/quarkiverse/quarkus-mcp-servers/llms.txt

Generate a recursive JSON tree structure representing files and directories starting from a given root path.

```java
// Tool definition
@Tool(description = "Get a recursive tree view of files and directories as a JSON structure...")
String directory_tree(@ToolArg(description = "Root path to create tree from") String path)

```

```json
// Example MCP tool call
{
  "tool": "directory_tree",
  "arguments": {
    "path": "/Users/developer/projects/app"
  }
}

```

```text
// Returns JSON tree structure:
// {"name": "app", "type": "directory", "children": [{"name": "src", "type": "directory", "children": [...]}]}

```

--------------------------------

### Build Container Image Tool

Source: https://context7.com/quarkiverse/quarkus-mcp-servers/llms.txt

Builds a Docker or Podman image from a Dockerfile. Requires the absolute path to the Dockerfile and optionally accepts a name for the resulting image.

```java
// Tool definition
@Tool(description = "Build a Docker or Podman image from a Dockerfile...")
String image_build(
    @ToolArg(description = "The absolute path to the Dockerfile", required = true) String containerFile,
    @ToolArg(description = "Specifies the name assigned to the resulting image") String imageName)
```

```json
{
  "tool": "image_build",
  "arguments": {
    "containerFile": "/Users/developer/projects/myapp/Dockerfile",
    "imageName": "myapp:latest"
  }
}
```

--------------------------------

### Create Directory Tool Definition

Source: https://context7.com/quarkiverse/quarkus-mcp-servers/llms.txt

Defines the `create_directory` tool for creating new directories or ensuring existing ones are present. Use this to manage directory structures.

```java
// Tool definition
@Tool(description = "Create a new directory or ensure a directory exists...")
String create_directory(@ToolArg(description = "Path of directory to create") String path)
```

--------------------------------

### Get Canvas Image Tool

Source: https://context7.com/quarkiverse/quarkus-mcp-servers/llms.txt

Retrieves the current state of the JFX canvas as a base64-encoded PNG image. This tool does not require any arguments.

```java
// Tool definition
@Tool(description = "Get the current canvas image as base64-encoded string")
ImageContent getCanvasImage()
```

```json
{
  "tool": "getCanvasImage",
  "arguments": {}
}
```

--------------------------------

### List Kubernetes Pods

Source: https://context7.com/quarkiverse/quarkus-mcp-servers/llms.txt

Use the pods_list tool to get all pods in the cluster or pods_list_in_namespace to list pods within a specific namespace.

```java
// Tool definitions
@Tool(description = "List all the Kubernetes pods in the current cluster")
public Collection<Pod> pods_list()

@Tool(description = "List all the Kubernetes pods in the specified namespace")
public Collection<Pod> pods_list_in_namespace(@ToolArg(description = "Namespace to list pods from") String namespace)
```

```json
// Example MCP tool calls
{
  "tool": "pods_list",
  "arguments": {}
}

{
  "tool": "pods_list_in_namespace",
  "arguments": {
    "namespace": "production"
  }
}
```

--------------------------------

### Launch Canvas Tool

Source: https://context7.com/quarkiverse/quarkus-mcp-servers/llms.txt

Launches a new drawing canvas window. This tool does not require any arguments.

```java
// Tool definition
@Tool(description = "Launch a new drawing canvas")
String launchCanvas()
```

```json
{
  "tool": "launchCanvas",
  "arguments": {}
}
```

--------------------------------

### Configure MCP Client for Filesystem Server

Source: https://github.com/quarkiverse/quarkus-mcp-servers/blob/main/filesystem/README.md

Add this configuration to your MCP client's JSON file to connect to the filesystem server. Replace '[path1]' and '[path2]' with the desired accessible directories.

```json
{
  "mcpServers": {
    "filesystem": {
      "command": "jbang",
      "args": [
        "filesystem@quarkiverse/quarkus-mcp-servers",
        "[path1]",
        "[path2]"
      ]
    }
  }
}
```

--------------------------------

### Claude Desktop Configuration

Source: https://github.com/quarkiverse/quarkus-mcp-servers/blob/main/jvminsight/README.md

Configuration snippet for Claude Desktop to connect to the jvminsight MCP server.

```APIDOC
## Claude Desktop Config

Add the following to your `claude_desktop.json` or `server_config.json` file:

```json
{
  "mcpServers": {
    "jdbc": {
      "command": "jbang",
      "args": [
        "mcp-server-jvminsight@quarkiverse/quarkus-mcp-servers"
      ]
    }
  }
}
```
```

--------------------------------

### Describe Table Tool

Source: https://context7.com/quarkiverse/quarkus-mcp-servers/llms.txt

Use this tool to get detailed column information for a specific table. Provide catalog, schema, and table names as arguments.

```java
// Tool definition
@Tool(description = "Describe table")
String describe_table(
    @ToolArg(description = "Catalog name", required = false) String catalog,
    @ToolArg(description = "Schema name", required = false) String schema,
    @ToolArg(description = "Table name") String table)

```

```json
// Example MCP tool call
{
  "tool": "describe_table",
  "arguments": {
    "table": "customers",
    "schema": "public"
  }
}

```

```text
// Returns JSON array of column definitions:
// [{"COLUMN_NAME": "id", "TYPE_NAME": "INTEGER", "COLUMN_SIZE": "10", "NULLABLE": "NO"}, ...]

```

--------------------------------

### Run New Kubernetes Pod

Source: https://context7.com/quarkiverse/quarkus-mcp-servers/llms.txt

Execute a new Kubernetes pod using a specified container image. You can optionally provide a name, namespace, and expose a port.

```java
// Tool definition
@Tool(description = "Run a Kubernetes Pod in the current namespace...")
public Collection<HasMetadata> pods_run(
    @ToolArg(description = "Namespace to run the Pod in", required = false) String namespace,
    @ToolArg(description = "Name of the Pod (Optional)", required = false) String name,
    @ToolArg(description = "Container Image to run in the Pod") String image,
    @ToolArg(description = "TCP/IP port to expose from the Pod container", required = false) Integer port)
```

```json
// Example MCP tool call
{
  "tool": "pods_run",
  "arguments": {
    "namespace": "default",
    "name": "nginx-test",
    "image": "nginx:latest",
    "port": 80
  }
}
```

--------------------------------

### Image Build Tool

Source: https://context7.com/quarkiverse/quarkus-mcp-servers/llms.txt

Builds a container image from a Dockerfile.

```APIDOC
## image_build Tool

### Description
Build a container image from a Dockerfile.

### Method
POST (assumed, as it modifies state)

### Endpoint
/tools/image_build

### Parameters
#### Request Body
- **containerFile** (string) - Required - The absolute path to the Dockerfile
- **imageName** (string) - Optional - Specifies the name assigned to the resulting image

### Request Example
```json
{
  "tool": "image_build",
  "arguments": {
    "containerFile": "/Users/developer/projects/myapp/Dockerfile",
    "imageName": "myapp:latest"
  }
}
```

### Response
#### Success Response (200)
- **message** (string) - Confirmation message, e.g., "Image built successfully: sha256:abc123..."

#### Response Example
```json
{
  "message": "Image built successfully: sha256:abc123..."
}
```
```

--------------------------------

### Create Table Tool

Source: https://context7.com/quarkiverse/quarkus-mcp-servers/llms.txt

Use this tool to create a new table in the database. Provide a valid SQL CREATE TABLE statement as the query argument.

```java
// Tool definition
@Tool(description = "Create new table in the jdbc database")
String create_table(@ToolArg(description = "CREATE TABLE SQL statement") String query)

```

```json
// Example MCP tool call
{
  "tool": "create_table",
  "arguments": {
    "query": "CREATE TABLE orders (id SERIAL PRIMARY KEY, customer_id INT, total DECIMAL(10,2), created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP)"
  }
}

```

```text
// Returns: "Query executed successfully"

```

--------------------------------

### Get Kubernetes Resource Tool Definition

Source: https://context7.com/quarkiverse/quarkus-mcp-servers/llms.txt

Defines the `resources_get` tool for retrieving a specific Kubernetes resource by its name, apiVersion, kind, and optionally namespace. Use this to fetch details of a single resource.

```java
// Tool definition
@Tool(description = "Get a Kubernetes resource in the current cluster...")
public GenericKubernetesResource resources_get(
    @ToolArg(description = "apiVersion of the resources") String apiVersion,
    @ToolArg(description = "kind of the resources") String kind,
    @ToolArg(description = "Namespace to retrieve the resource from", required = false) String namespace,
    @ToolArg(description = "Name of the resource", required = false) String name)
```

--------------------------------

### List Container Images

Source: https://context7.com/quarkiverse/quarkus-mcp-servers/llms.txt

Fetches a list of all available container images. The tool returns a list of Image objects.

```java
// Tool definition
@Tool(description = "Get the current list of images of containers")
public List<Image> images_list()

// Example MCP tool call
{
  "tool": "images_list",
  "arguments": {}
}
```

--------------------------------

### File System Tools

Source: https://context7.com/quarkiverse/quarkus-mcp-servers/llms.txt

Tools for managing files and directories.

```APIDOC
## POST /write_file

### Description
Create or overwrite a file with new content.

### Method
POST

### Endpoint
/write_file

### Parameters
#### Request Body
- **path** (string) - Required - Path where to write the file
- **content** (string) - Required - Content to write to the file

### Request Example
{
  "tool": "write_file",
  "arguments": {
    "path": "/Users/developer/projects/app/config.json",
    "content": "{\n  \"database\": \"postgresql\",\n  \"port\": 5432\n}"
  }
}

### Response
#### Success Response (200)
- **message** (string) - Confirmation message of the file write operation.

#### Response Example
{
  "message": "Successfully wrote to /Users/developer/projects/app/config.json"
}
```

```APIDOC
## POST /create_directory

### Description
Create a new directory or ensure it exists.

### Method
POST

### Endpoint
/create_directory

### Parameters
#### Request Body
- **path** (string) - Required - Path of directory to create

### Request Example
{
  "tool": "create_directory",
  "arguments": {
    "path": "/Users/developer/projects/app/src/main/resources/templates"
  }
}

### Response
#### Success Response (200)
- **message** (string) - Confirmation message of the directory creation.

#### Response Example
{
  "message": "Successfully created directory: /Users/developer/projects/app/src/main/resources/templates"
}
```

```APIDOC
## GET /list_allowed_directories

### Description
List the directories that the server is permitted to access.

### Method
GET

### Endpoint
/list_allowed_directories

### Response
#### Success Response (200)
- **directories** (array of strings) - List of allowed directory paths.

#### Response Example
[
  "/Users/developer/projects",
  "/Users/developer/documents"
]
```

--------------------------------

### Database Info Tool

Source: https://context7.com/quarkiverse/quarkus-mcp-servers/llms.txt

Retrieve metadata about the connected database, including its SQL dialect and capabilities. Run this tool before other database operations.

```java
// Tool definition
@Tool(description = "Get information about the database. Run this before anything else to know the SQL dialect, keywords etc.")
String database_info()

```

```json
// Example MCP tool call
{
  "tool": "database_info",
  "arguments": {}
}

```

```text
// Returns JSON with database metadata:
// {"database_product_name": "PostgreSQL", "database_product_version": "14.5", "driver_name": "PostgreSQL JDBC Driver", ...}

```

--------------------------------

### Configure JVM Insight MCP Server with Custom Paths

Source: https://github.com/quarkiverse/quarkus-mcp-servers/blob/main/jvminsight/README.md

Optionally set jvminsight.paths to a comma-separated list of directories to allow exposure of tools. This enhances security by restricting accessible command paths.

```shell
jbang -Djvminsight.paths=/opt/java17/bin,/opt/java21/bin jvminsight@quarkiverse/quarkus-mcp-servers
```

--------------------------------

### JDBC Server - list_tables Tool

Source: https://context7.com/quarkiverse/quarkus-mcp-servers/llms.txt

Documentation for the `list_tables` tool, used to list database tables with optional filtering and pagination.

```APIDOC
### list_tables Tool

List all tables in the database with optional pagination and schema filtering.

```java
// Tool definition
@Tool(description = "List all tables in the jdbc database")
String list_tables(
    @ToolArg(description = "Page number for pagination (starting from 1)", required = false) Integer page,
    @ToolArg(description = "Number of tables per page (default: 50)", required = false) Integer size,
    @ToolArg(description = "Schema name to filter tables", required = false) String schema,
    McpLog log)

// Example MCP tool call
{
  "tool": "list_tables",
  "arguments": {
    "page": 1,
    "size": 20,
    "schema": "public"
  }
}

// Returns JSON with table metadata:
// {"total_count": 15, "page": 1, "page_size": 20, "tables": [{"TABLE_NAME": "customers", ...}]}
```
```

--------------------------------

### JDBC Server - write_query Tool

Source: https://context7.com/quarkiverse/quarkus-mcp-servers/llms.txt

Documentation for the `write_query` tool, used to execute INSERT, UPDATE, or DELETE queries.

```APIDOC
### write_query Tool

Execute INSERT, UPDATE, or DELETE queries to modify database content.

```java
// Tool definition
@Tool(description = "Execute a INSERT, UPDATE or DELETE query on the jdbc database")
String write_query(@ToolArg(description = "INSERT, UPDATE or DELETE SQL query to execute") String query)

// Example MCP tool calls
{
  "tool": "write_query",
  "arguments": {
    "query": "INSERT INTO customers (name, email, country) VALUES ('Jane Smith', 'jane@example.com', 'Canada')"
  }
}

{
  "tool": "write_query",
  "arguments": {
    "query": "UPDATE customers SET email = 'newemail@example.com' WHERE customer_id = 1"
  }
}

// Returns: "Query executed successfully"
```
```

--------------------------------

### Wolfram Server

Source: https://context7.com/quarkiverse/quarkus-mcp-servers/llms.txt

The Wolfram server enables LLMs to perform web searches using the Wolfram Alpha LLM API.

```APIDOC
## Starting the Wolfram Server

### Description
Starts the Wolfram server. Requires a Wolfram Alpha App ID for authentication.

### Method
Command Line

### Endpoint
N/A

### Parameters

#### Command Line Arguments
- **-DWOLFRAM_LLM_API_KEY** (string) - Required - Your Wolfram Alpha App ID.

### Request Example
```bash
jbang -DWOLFRAM_LLM_API_KEY=${YOUR_WOLFRAM_APP_ID} io.quarkiverse.mcp.servers:mcp-server-wolfram:RELEASE
```

### Response
N/A

## fullResponseQuery Tool

### Description
Performs a web search to retrieve information online with a full text response.

### Method
MCP Tool Call

### Endpoint
N/A

### Parameters

#### Path Parameters
- **q** (string) - Required - The web search query.

### Request Example
```json
{
  "tool": "fullResponseQuery",
  "arguments": {
    "q": "What is the population of Tokyo?"
  }
}
```

### Response
#### Success Response (200)
- **Output** (string) - The full text response from the web search.

#### Response Example
```
"The population of Tokyo is approximately 13.96 million people as of 2023."
```

## shortResponseQuery Tool

### Description
Performs a web search to retrieve information online with a concise response.

### Method
MCP Tool Call

### Endpoint
N/A

### Parameters

#### Path Parameters
- **q** (string) - Required - The web search query.

### Request Example
```json
{
  "tool": "shortResponseQuery",
  "arguments": {
    "q": "distance from Earth to Mars"
  }
}
```

### Response
#### Success Response (200)
- **Output** (string) - A concise response from the web search.

#### Response Example
```
"Approximately 225 million kilometers at its closest approach."
```
```