M
MCP Directory CURATED DIRECTORY
911 MCP servers indexed
中文
← Back to directory
C

ClaudeR

Community
Connect live R and Python sessions in RStudio or Positron to MCP agents
How to install ↓ Compare GitHub source repository ↗
Category
Dev Tools #176 of 438
Stars
★ 360 Very popular
Transport
stdio (local process)
Runtime
Python 3.9+ · Prebuilt binary uv/uvx for zero-conf
Credentials
Optional API key
License
Other / unspecified
Last commit
Tools
37
56FMRS · C

ClaudeR connects MCP agents to live R sessions in RStudio and Positron and to live Python sessions, letting the agent execute code where your data and models already are, see plots, and read or edit the file open in your editor, with tool coverage spanning execution, editor control, audit, citations, logging, and checkpoints. It also brings research workflows: Reviewer Zero manuscript auditing, a typed multi-agent coordination protocol with a consensus gate, systematic-review screening, grant panel mode, and response-to-reviewers. It ships as the clauder-mcp PyPI package over stdio with uvx-based zero-config setup, and supports Claude Desktop, Claude Code, Codex, Qwen, Antigravity, and Cursor. It positions itself as a supervised power tool: it states plainly that binding to localhost is not a security boundary, that its code validator is a seatbelt rather than a sandbox, and that auditing third-party manuscripts carries prompt-injection risk, so it suits local research users who accept those trade-offs and is unsuitable for shared or multi-user environments needing isolation. The README badge states an MIT license, while the repository license field reports NOASSERTION. The supplied README is truncated in the troubleshooting section.

Strongest · Documentation 14/20 Weakest · Reliability 8/20

Reliability
8/20
Security and permissions
9/20
Maintenance
12/20
Documentation
14/20
Setup experience
13/20
Why each score
Reliability 8/20
Static evidence suggests reasonable diagnosability and partial reproducibility: the README cites a GitHub Actions CI (R functional checks plus a real MCP stdio handshake) guarding every push, and documents concrete failure-mode fixes (Windows liveness probe, output-sink restoration, idempotent async results, log ordering). The manifest version 0.16.0 matches the PyPI package and stdio transport is declared. However, no verifiable execution evidence exists in the supplied material: no committed tests, no CI config body (only a badge reference), no validation beyond the manifest. The 41-tool list and token-cost claims are self-reported and unverifiable. Per the static calibration, reliability cannot exceed 12 without real CI workflows plus committed tests covering key paths. Deducted to 8 because the happy path is plausible but edge cases, tool-vs-declared behavior parity, and dependency controllability lack evidence.
Security and permissions 9/20
The project discloses and partly mitigates real risks: an always-on Origin-header block (prevents drive-by cross-origin POSTs), an opt-in session token (0600 discovery file, X-Clauder-Token), and an explicitly honest statement that validate_code_security() is a regex blocklist 'seatbelt, not a sandbox' that is trivially bypassable. It also devotes a section to prompt-injection risk (arbitrary R execution + untrusted third-party documents + file/network reach). But the overall model is a supervised power tool: the agent executes arbitrary R in the live session, reads any user-readable file, installs packages, makes network calls, with no per-operation confirmation and no sandbox. The token is off by default for backward compatibility, so default deployments remain injectable by any local process. This stops short of a scored red line (no irreversible/remote-command default without confirmation, no credential theft/exfiltration), but least privilege, explicit confirmation, and data-flow scoping are incomplete, hence 9.
Maintenance 12/20
The repository is active: recent versioned releases (R 0.16.0 / clauder-mcp 0.16.0), a changelog-style update log, a referenced CI workflow, dependency pinning (mcp<2 to survive the 2.0.0 break), installer backward-compatibility and upgrade notes, 342 stars and only 17 open issues. Governance gaps remain: the license is NOASSERTION while the README badge claims MIT (an unresolved contradiction), there is no documented security-response channel or disclosure process, and no release signing or supply-chain verification is described. Active maintenance plus these governance gaps yields 12.
Documentation 14/20
Documentation is strong and layered: quick start, per-tool parameter descriptions (41 tools, including start_line/end_line, path, capture_output), Reviewer Zero / Referee Mode protocol examples, dedicated Logging and Security Model sections, an R-vs-Python capability table, and Troubleshooting/Limitations (async has no environment sharing, port conflicts, RStudio Server 8787 clash, uv dependency). It also discloses cost figures (about 4,500 tokens per image, about 8,600 tokens of schema for 41 tools). Deductions: hidden assumptions (user must install uv/devtools, manually paste CLI config), unverifiable capability claims (benchmark 21.3/24 detection, Referee Mode efficacy) with no external evidence, a manifest description narrower than the README (manifest says only 'interactive R coding and data analysis' while the README claims manuscript auditing and multi-agent features), and the MIT-vs-NOASSERTION license contradiction. Score 14 rather than higher because of self-reported performance numbers and the license conflict.
Setup experience 13/20
The install path is clear but multi-step and partly manual: install the R package via devtools::install_github, run claudeAddin() and click Start Server, then per client run install_clauder() (desktop, uvx by default) or install_cli() (CLI, requiring manual copy of printed command/JSON into ~/.gemini configs) and restart the client. uvx enables near-zero-config but needs uv installed, with a use_uvx=FALSE fallback; it claims RStudio/Positron support, R>=4.0, Python>=3.9. Deductions: manual application of CLI config, non-uniform install paths per tool, a Positron-specific suggest_edit behavior difference, and needing to re-run installers after R upgrades. With no execution evidence the static cap is 15; final score 13.

Static review · not runListed 2026-09-18

Read the FMRS scoring method →

Fit and risk

What it can accessReads local filesWrites / deletes local filesRuns commands or codeUses the network

Best for

  • Statisticians and data scientists working in RStudio or Positron who want an agent operating on their live session.
  • Researchers who need to audit the numeric and citation consistency of their own or others' manuscripts.
  • Developers and researchers who want to orchestrate multi-agent workflows on their existing model subscription.
  • Users who prefer local sessions, auditable logs, and zero-config uvx startup.

Not for

  • Anyone exposing the R session on an untrusted network or a shared machine: binding to 127.0.0.1 is not a security boundary.
  • People who need sandboxed code execution: the guardrail is a regex blocklist, not a sandbox, and is trivially bypassable.
  • Users unwilling to accept prompt-injection risk when auditing third-party documents.
  • People who only want editor and audit tooling from a Python session: those tools drive the IDE through rstudioapi and have no Python equivalent.

Required permissions

  • Execute arbitrary R code in the live R session (via execute_r and related tools).
  • Read any file your account can read (read_file, get_viewer_content, and others).
  • Write to and save files open in your editor (modify_code_section, insert_text).
  • Install R packages, overwrite objects in your environment, make network calls, and consume compute.
  • Listen on a local port (default 8787) and write session discovery files under ~/.claude_r_sessions/; when a token is enabled that file is written with mode 0600.

Risks and side effects

  • Binding to 127.0.0.1 is not a security boundary: other local processes, and even any webpage you visit, can POST code to the port, which is arbitrary code execution in your session. ClaudeR always rejects requests carrying an Origin header with a 403, and offers an opt-in session token (X-Clauder-Token).
  • The session token is off by default because enforcing it rejects any bridge older than clauder-mcp 0.6.0, so the local-process vector stays open until you enable it.
  • validate_code_security() is a regex blocklist (system(), system2(), shell(), rstudioapi::terminal, recursive/wildcard deletes) and is trivially bypassable via get("system")(...), do.call, or eval(parse(...)). It is a seatbelt, not a sandbox.
  • Prompt injection: combining tools that pull untrusted third-party content (read_file, get_viewer_content, verify_references, load_annotation_data) with arbitrary R execution, file writes, and network access means a manuscript, CSV, or HTML widget authored by someone else is untrusted input on a path to code execution. Auditing someone else's manuscript is the riskiest shape.
  • The agent can read any file you can read, install packages, and make network calls; work in a project directory and keep credentials out of the working directory.
  • Async jobs run in a separate R process via callr and do not have access to the main session's environment; the agent must write self-contained code using saveRDS, and misuse leads to inconsistent results.

Setup

Before you start

Runtime：Python 3.9+ · Prebuilt binary uv/uvx for zero-conf

  1. Install the R package in the RStudio console: if (!require("devtools")) install.packages("devtools") then devtools::install_github("IMNMV/ClaudeR").
  2. Configure your AI tool. For desktop apps (Claude Desktop / Cursor) run library(ClaudeR); install_clauder(), or install_clauder(for_cursor = TRUE) for Cursor. For CLI tools run install_cli(tools = "claude"), which also supports "codex", "qwen", "agy", and the legacy "gemini". Both default to running the PyPI package clauder-mcp with uvx; if uvx is unavailable, fall back with use_uvx = FALSE and python_path.
  3. Apply the printed configuration manually: for Claude / Codex / Qwen copy the printed command into your terminal; for Antigravity (agy) put the generated JSON in ~/.gemini/config/mcp_config.json (global) or .agents/mcp_config.json (per-workspace); for legacy Gemini add it to ~/.gemini/settings.json.
  4. Quit and restart your desktop app or terminal sessions so the new settings load.
  5. In RStudio run library(ClaudeR); claudeAddin(), click Start Server in the Viewer pane, and keep the window open. On RStudio Server, port 8787 is the IDE's own port, so choose a different one.

Check that it works

Run claudeAddin() in RStudio and click Start Server, then check that tools like execute_r appear in your client's tool list and ask the agent to call get_r_info to confirm the connection.

Troubleshooting

  1. Connection issues: ensure your AI tool is configured correctly, the Python path or CLI command is right, and the server is running in the add-in; free the port or restart RStudio if it is in use.
  2. "could not find function install_clauder": restart the R session (Session -> Restart R) and try again.
  3. MCP server failed to start: with uvx, ensure uv is installed (curl -LsSf https://astral.sh/uv/install.sh | sh); with the legacy method this usually means the wrong Python environment was detected, so re-run the installer with the correct python_path or switch to use_uvx = TRUE.
  4. Bridge broke after the mcp 2.0.0 release: clauder-mcp >= 0.6.1 pins mcp<2; run uvx --refresh clauder-mcp.
  5. After upgrading R versions re-run install_cli() or install_clauder() to update the MCP server path; the CLI installer removes stale registrations before adding fresh ones.
  6. The AI can't see results: make sure the add-in window is open and the server is running.
  7. Plots not displaying: instruct the AI to wrap plot objects in print(), or to use execute_r_with_plot.
  8. Long-running code timing out: have the AI use execute_r_async for code taking more than 25 seconds and poll with get_async_result.
  9. "address already in use" after restarting the server: this is a UI bug and the server is still active; switch the port in the Viewer pane or restart RStudio.
  10. Settings don't apply after closing and reopening the add-in UI: the server keeps running in the background; re-running claudeAddin() reconnects with the same port, session name, and execution count, and only Stop Server actually stops it.

Things to try

Once connected, you can ask your AI assistant things like:

  • Perform exploratory data analysis on the dataset named data in my environment and plot a correlation heatmap.
  • Read the manuscript.docx I have open and run reconcile_values to check every number in the text against my code output.
  • Call checkpoint_session first, then use execute_r_async to fit the model and report the results when done.
  • Use verify_references to check the DOIs in this paper's bibliography and flag retracted or mismatched entries.

Tools 37

execute_r writes
Execute R code and return the output.
execute_r_with_plot writes
Execute R code that generates a plot the model can see.
execute_r_async writes
Execute long-running R code (over roughly 25 seconds) asynchronously, returning a job ID for polling.
get_async_result read-only
Poll for the result of an async job, with a built-in delay to throttle polling.
list_sessions read-only
List all active RStudio sessions an agent can connect to.
connect_session writes
Connect to a specific RStudio session by name for multi-session workflows.
get_session_history read-only
View execution history filtered by agent ID.
read_file read-only
Read any file from disk (.R, .qmd, .csv, .log, etc.) without opening it in RStudio; .docx and .pdf are extracted as structured text with headings marked and table cells kept separated, with line pagination.
Show 29 more tools
check_cross_references read-only
Deterministic internal-reference integrity: flags dangling mentions (e.g. "see Table 4" with no Table 4) and tables or figures never referenced in the text.
reconcile_values read-only
The audit backbone: extracts every numeric value from a manuscript and reconciles each against numbers your code actually produced, respecting displayed precision, and returns a per-value registry.
get_active_document read-only
Read the focused editor buffer, returning content, file path, and whether the buffer has unsaved changes.
get_r_info read-only
Get information about the R environment.
modify_code_section writes
Regex find-and-replace in an editor document, handling multi-line patterns, saving to disk by default, and accepting a path to target a specific file.
insert_text writes
Insert text at the cursor or a specific line/column, saving to disk by default.
suggest_edit writes
Propose an edit for the user to approve instead of applying it.
get_viewer_content read-only
Read HTML content from the viewer pane (plotly, DT, leaflet widgets) with pagination support.
clean_error_log writes
Clean a session log by removing error blocks and their duplicate predecessors, leaving only working code and the fixes that followed.
search_project_code read-only
Search a regex pattern across project source files (.R, .Rmd, .qmd), returning file, line number, and snippet.
probe_scripts read-only
Source R scripts in a clean background session and report what objects are created, without affecting the main session.
verify_references read-only
Verify academic references: DOIs checked against CrossRef (with retraction and correction flags), arXiv IDs resolved with a published-version check, and DOI-less entries bibliographically matched.
search_citations read-only
Search the OpenAlex scholarly index for the correct reference for a claim instead of citing from memory.
get_bibtex read-only
Fetch the canonical BibTeX entry for a DOI via doi.org content negotiation.
generate_notebook writes
Turn a session log into a narrated Quarto lab notebook; rendering re-runs the code so outputs and plots regenerate.
generate_codebook writes
Scan a project and emit the codebook OSF and journals require: versioned package list, script inventory, per-variable summaries, and outputs produced.
screening_report writes
Summarize systematic-review screening passes: agreement and Cohen's kappa between two model screeners, PRISMA flow counts, and the conflict set a human must adjudicate.
send_message writes
Send typed multi-agent messages on an append-only shared log.
check_messages read-only
Read message events from the shared coordination log.
wait_for_message read-only
Block until a matching event arrives (rendezvous without polling); works even while the R session is busy.
coordination_roster read-only
Show the live coordination roster of connected agents with last-seen ages.
checkpoint_session writes
Snapshot the R global environment to disk before risky operations; checkpoints survive R restarts.
restore_session writes
Roll the environment back to a checkpoint; the current state is saved first, so a restore is itself undoable.
list_checkpoints read-only
List saved checkpoints for the current session.
create_task_list writes
Generate a task list based on your prompt to prevent omissions in long-context tasks.
update_task_status writes
Track progress for each task in the generated list.
load_annotation_data writes
Load a CSV dataset with a _schema column definition to start an AI annotation session.
annotate writes
Label a single dataset row; the original file is never modified.
set_agent_name writes
Set an agent's working name so execution history, message attribution, presence, and its read cursor all carry that name.

Use cases

Let an agent run code, see plots, and read objects in the R session where your cleaned data and fitted models already live.
Run multiple agents (e.g. Claude Code plus Codex) on one RStudio session with the coordination protocol and consensus gate.
Audit a manuscript for numeric, reference, and reasoning defects with Reviewer Zero, and write findings back as Word comments.
Screen systematic-review titles and abstracts with two independent model screeners and get agreement, kappa, PRISMA counts, and a conflict set.
Turn a session log into a re-runnable Quarto notebook or a clean script, and generate the codebook OSF and journals require.
Label a CSV dataset row by row with an AI agent without the agent writing any code.
Convene a mock grant study section with grant_panel_prompt() against NIH or NSF criteria and get a ranked revision list.
Parse a decision letter into point-by-point reviewer responses with reviewer_response_prompt(), rerunning analyses so answers carry real numbers.

Supported clients

Claude Desktop
Claude Code
Codex
Qwen Code
Antigravity
Gemini CLI
Cursor

Listed from the project's documentation, not tested by this site.

Overview

ClaudeR connects MCP-configured LLM agents such as Claude Code, Codex, and Gemini to the R session you are already working in (RStudio or Positron), and to a live Python session via its companion package. The agent runs code where your cleaned data and fitted models actually are, sees the plots it draws, reads objects in your environment, and can edit the file open in your editor. Several agents can share one session and divide the work, or run separate sessions side by side. It ships additional research workflows: Reviewer Zero for automated manuscript auditing, a multi-agent coordination protocol with a consensus gate, systematic-review screening, grant panel mode, and response-to-reviewers. The Python bridge is published on PyPI as clauder-mcp and runs with uvx for zero-config setup over stdio; the R package installs from GitHub via devtools::install_github("IMNMV/ClaudeR"). Note: the README badge states an MIT license, while the repository license field reports NOASSERTION.

Similar servers

Context7 80 · B

Upstash's official server providing up-to-date third-party library docs for AI coding assistants

★ 64.1k · Tools 2 Compare with this →
Compare with other MCP servers

Source revision 277870ef4845 Data synced 2026-11-02 Read the FMRS scoring method