What is Rlang Mcp Server

rlang-mcp-server is a specialized Model Context Protocol (MCP) server designed to generate data visualizations and execute R scripts using the ggplot2 library.

Use cases

Use cases include generating statistical charts for reports, executing complex data analysis scripts, and creating visualizations for machine learning model outputs.

How to use

To use rlang-mcp-server, integrate it with an MCP client by configuring the MCP settings file to point to the server’s command path. You can run the server in a Docker container to ensure proper stdin/stdout communication.

Key features

Key features include ggplot2 rendering for visualizations, R script execution, support for multiple output formats (PNG, JPEG, PDF, SVG), customization options for image dimensions and resolution, clear error handling, full MCP protocol compliance, and secure Docker integration.

Where to use

rlang-mcp-server can be used in data analysis, statistical reporting, and any application requiring dynamic data visualizations and R script execution.

R-Server MCP

A specialized Model Context Protocol (MCP) server that enables AI models to generate data visualizations using R’s ggplot2 library and execute R scripts.

Overview

This MCP server provides a streamlined interface for creating statistical visualizations and executing R scripts without requiring direct access to an R environment. It exposes two MCP tools:

• render_ggplot: Generates visualizations from R code containing ggplot2 commands
• execute_r_script: Executes any R script and returns the text output

Features

• ggplot2 Rendering: Execute R code containing ggplot2 commands and return the resulting visualization
• R Script Execution: Execute any R script and return the text output
• Format Options: Support for PNG, JPEG, PDF, and SVG output formats
• Customization: Control image dimensions and resolution
• Error Handling: Clear error messages for invalid R code or rendering failures
• MCP Protocol Compliance: Full implementation of the Model Context Protocol
• Docker Integration: Secure execution of R code in isolated containers

Requirements

• Go 1.22 or later
• R 4.0 or later with ggplot2 package
• Docker (for containerized execution)

Building

# Build the Docker image
task docker:build

# Run the server in Docker
task docker:run

Using Docker with stdin/stdout

The server can be run in Docker while preserving stdin/stdout communication, which is essential for MCP:

# Build and run using docker-compose
./start_server.sh --docker

Or set an environment variable:

USE_DOCKER=true ./start_server.sh

This approach ensures that stdin and stdout are properly connected between the host and the container, allowing seamless MCP communication.

Usage

MCP Integration

To use this server with an MCP client, configure it in your MCP settings file:

Local Execution

{
  "mcpServers": {
    "r-server": {
      "command": "/path/to/r-server",
      "disabled": false,
      "autoApprove": []
    }
  }
}

Docker Execution

{
  "mcpServers": {
    "r-server": {
      "command": "/path/to/start_server.sh",
      "args": [
        "--docker"
      ],
      "disabled": false,
      "autoApprove": []
    }
  }
}

The MCP client will automatically communicate with the server using stdio transport, which is the recommended approach for stability and reliability. The dockerized version maintains this communication pattern while providing isolation and dependency management.

License

Creative Commons Attribution-NonCommercial 4.0 International (CC-BY-NC 4.0)

This work is licensed under a Creative Commons Attribution-NonCommercial 4.0 International License.

See the LICENSE file for details.