Overview

This MCP (Model Context Protocol) server module provides a JavaFX-based Canvas renderer that can be embedded in an MCP server process. It lets you create interactive, programmatic drawings using the JavaFX Canvas API and exchange interaction events (mouse, keyboard, draw commands) over MCP. The result is a lightweight visual frontend useful for prototyping visual outputs from AI models, remote drawing UIs, and interactive demos wired to model-driven workflows.

The module is particularly useful when you want a responsive 2D drawing surface with standard JavaFX tooling while retaining the standardized messaging and lifecycle management of an MCP server. You can run it locally for development or on a headless host with appropriate JVM/OS configuration for JavaFX.

Features

Interactive JavaFX Canvas rendering integrated into MCP server runtime
Real-time forwarding of user events (mouse, keyboard) to MCP clients
Programmatic drawing API hooks so model or server components can update the canvas
Example application and utilities to run JavaFX together with Quarkus/Quarkiverse MCP servers
Guidance for headless environments (Monocle / Xvfb) and packaging tips

Installation / Configuration

Clone the example module repository:

git clone https://github.com/quarkiverse/quarkus-mcp-servers.git
cd quarkiverse/quarkus-mcp-servers/jfx

Build and run with Maven (uses the provided Quarkus project layout):

# using the wrapper if present
./mvnw clean package
./mvnw quarkus:dev

Add JavaFX dependencies to your project if you run a custom build (example Maven snippet):

<dependencies>
  <!-- JavaFX controls for Canvas and UI components -->
  <dependency>
    <groupId>org.openjfx</groupId>
    <artifactId>javafx-controls</artifactId>
    <version>20.0.2</version>
  </dependency>
  <!-- add other JavaFX artifacts as needed -->
</dependencies>

Launch JVM with JavaFX modules on the module path (if required):

# Example JVM args for standalone run (adjust path and version)
java --module-path /path/to/javafx-sdk-20/lib \
     --add-modules javafx.controls,javafx.graphics \
     -jar target/your-mcp-jfx-app.jar

Headless servers: use Monocle or run under Xvfb. Example using Xvfb:

# start virtual framebuffer
Xvfb :99 -screen 0 1280x720x24 &
export DISPLAY=:99
java -jar target/your-mcp-jfx-app.jar

Available Resources

Source: https://github.com/quarkiverse/quarkus-mcp-servers/tree/main/jfx
JavaFX documentation: https://openjfx.io
Quarkus documentation (if you integrate with Quarkus-based MCP servers): https://quarkus.io

Example: Minimal Canvas + MCP message bridge

Below is a simplified JavaFX example that shows canvas drawing and sending a generic MCP message (pseudocode for MCP client):

import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.canvas.Canvas;
import javafx.scene.canvas.GraphicsContext;
import javafx.scene.input.MouseEvent;
import javafx.stage.Stage;

public class CanvasMcpApp extends Application {
    private McpClient mcpClient = new McpClient("ws://localhost:8900/mcp");

    @Override
    public void start(Stage stage) {
        Canvas canvas = new Canvas(800, 600);
        GraphicsContext gc = canvas.getGraphicsContext2D();

        canvas.addEventHandler(MouseEvent.MOUSE_PRESSED, e -> {
            gc.fillOval(e.getX()-3, e.getY()-3, 6, 6);
            // send a drawing event to the MCP server/clients
            mcpClient.send(new McpMessage("canvas.draw", Map.of("x", e.getX(), "y", e.getY())));
        });

        stage.setScene(new Scene(new javafx.scene.layout.StackPane(canvas)));
        stage.show();
    }

    public static void main(String[] args) {
        launch();
    }
}

Replace McpClient/McpMessage with the MCP client implementation you use in your project. The key pattern: handle JavaFX events, update Canvas on the JavaFX thread, and forward structured messages over MCP.

Use Cases

Remote whiteboard: let models or remote users draw on a shared Canvas and synchronize edits via MCP messages.
Model visualization: stream model inference results (e.g., bounding boxes, heatmaps) to the Canvas for live inspection.
Interactive demos: build an AI assistant that issues draw commands (lines, shapes) and receives user edits back through MCP.
Testing and telemetry: render runtime telemetry (graphs, debug overlays) from server-side metrics onto a Canvas for debugging.

Tips for smooth integration

Always update UI elements on the JavaFX Application Thread (Platform.runLater or event handlers).
Avoid long-running work on the FX thread. Offload model processing and network IO to background threads.
When deploying headless, prefer Monocle (OpenJFX) or Xvfb and export DISPLAY; ensure you bundle appropriate Java

JavaFX Canvas Drawing for MCP Server