# ClaudeR - RStudio MCP Server [Health: Active]

**Category:** 🧮 Data Science Tools  
**Repository:** https://github.com/IMNMV/ClaudeR  
**GitHub Stars:** 368  
**Views:** 12  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/clauder-rstudio-mcp-server

## Description
Connect RStudio to AI assistants for interactive R coding and data analysis.

## Tools
Capabilities this server exposes over MCP:

- **execute_r** — Execute R code and return the output
- **execute_r_with_plot** — Execute R code that generates a plot
- **get_r_info** — Get a summary of the R environment. Returns package count (not full list), first 20 variables, and R version. Use requireNamespace('pkg') to check for specific packages.
- **get_active_document** — Read the focused RStudio editor BUFFER (not the file on disk). Returns the content, the document path, and 'unsaved_changes' telling you whether the buffer differs from disk. Use this as the source of truth while editing; read_file reports the DISK state, which will be stale until the edit is saved. Errors loudly if no document is open or focused.
- **modify_code_section** — Regex find-and-replace in an RStudio editor document. Saves to disk by default (save=false stages the edit in the buffer only). Pass 'path' to target a specific file instead of whatever happens to be focused. The replacement may change the number of lines. Returns 'saved_to_disk' so you know whether read_file will reflect the change.
- **insert_text** — Insert text into an RStudio editor document at the cursor, or at a given line/column. Saves to disk by default (save=false leaves it unsaved in the buffer). Pass 'path' to target a specific file rather than whatever is focused.
- **suggest_edit** — Propose an edit for the user to APPROVE before it is applied, instead of writing it directly. Uses rstudioapi::showEditSuggestion() when the RStudio build provides it; otherwise stages the change in the editor buffer and deliberately does NOT save, so the user accepts by saving or rejects with Undo. Use this when the user asked to review changes first. After calling it, STOP and wait for the user's decision.
- **create_task_list** — Create a task list for the current analysis
- **update_task_status** — Update the status of a task and optionally add notes
- **clean_error_log** — Clean a ClaudeR session log by removing error blocks and their duplicates. Parses the log, finds errors, checks if a fix follows each error, removes the error blocks and any duplicate code blocks that preceded them. Returns a report of what was found and removed.
- **execute_r_async** — Execute long-running R code in a separate background R process. Returns a job ID immediately and the main session stays fully responsive. Use this for code that may take longer than 25 seconds (e.g., model fitting, simulations, large data processing).

TWO MODES:
1. Auto-marshaled (recommended). Pass `inputs` (object names from the main session to copy into the background) and `outputs` (object names the background code creates that should be loaded back into the main session). The tool handles all saveRDS/readRDS plumbing. Inputs are snapshotted at submit time, so changes in the main session after submit do not affect the running job. Outputs are auto-loaded into the main session when get_async_result returns complete.
2. Manual. Omit `inputs` and `outputs` and write self-contained code that uses saveRDS()/readRDS() to pass data in and out yourself. Backwards-compatible with existing patterns.

The background process never has access to the main session's environment except via the marshaled `inputs`. Connection objects (DB connections, open file handles) cannot be marshaled. The background process must `library()` any packages it needs.

You can continue executing other code with execute_r while the job runs. Use get_async_result to check status when ready.
- **get_async_result** — Check the result of an async R job. Waits ~10 seconds before checking to avoid excessive polling. If the job is still running, call this again.
- **cancel_async_job** — Terminate a running execute_r_async job. Sends SIGTERM (then SIGKILL after a brief grace period) to the background R process and cleans up any marshaled input/output tempfiles. Use this when an async job is hung, taking far longer than expected, or you realized the code has a bug. Safe to call on jobs that have already finished — returns 'not_found' in that case.
- **list_sessions** — List available RStudio sessions that this agent can connect to. Shows session name, port, and PID for each active session.
- **connect_session** — Connect to a specific RStudio session by name. Use list_sessions first to see available sessions. Subsequent tool calls will be routed to this session.
- **read_file** — Read the contents of a file from disk. Handles plain text (R scripts, logs, CSVs) and manuscripts: .docx and .pdf are transparently extracted as structured text with headings prefixed by #s and table cells emitted row-wise as '[Table k, row j] cell | cell | cell', so table content is never lost or concatenated. Returns numbered lines; supports pagination via start_line/end_line for large files. To modify and save changes back, use execute_r with writeLines().
- **search_project_code** — Search for a regex pattern across project source files (.R, .Rmd, .qmd). Returns matching file, line number, and code snippet. Uses base R grep — safe to use even with system() blocked.
- **probe_scripts** — Source one or more R scripts in a clean background session and report what objects are created (names, classes, dimensions). Does NOT affect the main R session. With capture_output=true it also returns the statistics the script prints when run — a clean-room evaluation that stale objects in the live session cannot contaminate. Use that mode to build the ground-truth corpus for reconcile_values and for final audit verdicts.
- **verify_references** — Verify academic references by looking up DOIs in the CrossRef API. Extracts DOIs from a manuscript or references file, queries CrossRef for each, and returns metadata (title, authors, year, journal) for comparison against manuscript claims. References without DOIs are flagged for manual web search verification. Can be used standalone or as part of a Reviewer Zero audit.
- **get_viewer_content** — Get HTML content from the RStudio Viewer pane (HTML widgets like plotly, DT, leaflet). Returns paginated chunks. Call with offset to get more.
- **get_session_history** — Get execution history for the current R session. Can filter by agent to see what a specific agent has done.
- **run_annotation_job** — Annotate a CSV dataset using a fresh subprocess (or Ollama HTTP call) per row, with no context bleed between rows. Each row is scored by a brand-new claude, codex, gemini, agy (Antigravity), qwen, or ollama process that sees only that row. Runs in the background; returns a job ID immediately. Use get_annotation_job_status to check progress and cancel_annotation_job to stop. The original CSV is never modified; results go to {name}_annotating.csv. Resumable: rows already annotated are skipped automatically.
- **get_annotation_job_status** — Check the status of a running or completed annotation job started with run_annotation_job.
- **cancel_annotation_job** — Cancel a running annotation job. The current row finishes before stopping. Already-saved rows are kept and the job is resumable.
- **load_annotation_data** — Load a CSV file for annotation. Creates a working copy (original is never modified), reads the '_schema' column to determine annotation fields, and displays the first unannotated row. Resumes from where it left off if the working copy already exists. After calling this, use the `annotate` tool to annotate each row.
- **annotate** — Annotate the current row. Pass each schema field as a key inside the 'annotations' object. Validates values against the schema, saves to the working CSV, then automatically loads the next row. When all rows are done, returns 'Annotation complete'. If validation fails, returns an error describing the expected format — read it and retry.
- **checkpoint_session** — Save a snapshot of the R global environment to disk so it can be rolled back later with restore_session. Use this BEFORE risky operations: overwriting or removing objects, destructive data transformations, or loading files into existing names. Checkpoints survive R restarts; only the 10 most recent are kept.
- **restore_session** — Roll the R global environment back to a checkpoint created with checkpoint_session. Restores the most recent checkpoint unless one is named. The current state is saved as a 'pre_restore' checkpoint first, so the restore itself is undoable. Objects created after the checkpoint are removed.
- **list_checkpoints** — List saved R session checkpoints (file, time, size MB) for the current session, newest last.
- **screening_report** — Summarize systematic-review screening passes produced by run_annotation_job: decision counts, exclusion reasons, and PRISMA flow numbers. With two passes from DIFFERENT model families, also computes percent agreement and Cohen's kappa between the screeners and assigns the conflict set to 'screening_conflicts' in the R session, so the human only adjudicates disagreements. Run ClaudeR::screening_prompt() first for the full protocol.
- **set_agent_name** — Set this agent's working identity for the rest of the session. Call this FIRST in any multi-agent work, before executing code or sending messages, so execution history, message attribution, presence, and your read cursor all carry your working name (e.g. 'Claude-Stasis') instead of a random per-connection id. Critical when several agents or personas share one MCP connection (subagents), where the default id cannot tell them apart. Pick a short name unique to you and reuse it across sessions. For a permanent name, set the CLAUDER_AGENT_ID environment variable in the MCP server registration instead. A second rename to a different name is refused unless force is true, because that pattern usually means personas sharing one connection, who should pass as_agent per call instead.
- **send_message** — Send a typed message to other agents on this session's coordination log. Prefer typed signals over prose for anything machine-checkable: type='signal' with body={'name': 'KIT_READY', 'tile': '3094,3493'} beats hoping the other agent greps your prose. Works even while the R session is busy (the log is a shared file, not R state), and survives restarts.
- **check_messages** — Read unread coordination events addressed to you (or to all), then advance your read cursor. Each agent has its own cursor; reading never mutates shared state, so agents cannot clobber each other.
- **wait_for_message** — Block until a matching coordination event arrives, or the timeout passes. Use this instead of repeated polling: it returns the instant another agent writes, which removes coordination latency, crossed messages, and the need for a human to schedule polls. Does not touch the R session, so the other agent can keep executing code while you wait. Filter by sender and/or type for rendezvous ('wait until beta sends signal HANDOFF_READY').
- **coordination_roster** — List agents seen on this session's coordination log with last-seen times and staleness. Presence is stamped by every write, so liveness does not depend on manual heartbeats.
- **check_cross_references** — Check a manuscript's internal cross-references: inventories declared tables, figures, theorems/lemmas, appendices, and numbered sections, then verifies every in-text mention ('see Table 4', 'Figures 2 and 3') against that inventory. Flags dangling references (mentioned but nonexistent) and tables/figures never referenced in the text. Classes whose numbering does not survive Word extraction are reported as unverifiable rather than false-flagged. Assigns crossref_registry to the R global environment. Part of Referee Mode; also useful standalone after any manuscript revision.
- **reconcile_values** — Audit backbone: extract EVERY numeric value from a manuscript (.docx/.pdf/text; docx tables cell-separated) and reconcile each against the corpus of numbers in the given source files (analysis logs, generated tables, script outputs, CSVs). Matching respects displayed precision (5038.5 matches 5038.46; 0.967 matches 0.9668), handles commas, percents (also checked as proportions), scientific notation, and thresholds like '< .001'. Assigns a per-value 'values_registry' data.frame to the R global environment; every 'unmatched' row must then be adjudicated (recompute it with execute_r, or record why it cannot come from the sources) before an audit may conclude. Completeness by construction: do not rely on reading carefully.
- **generate_codebook** — Generate a codebook / reproducibility README for a project: scans scripts for library() calls, data-read sites, and saved outputs; reads each data file (.csv/.tsv/.txt/.rds); and writes markdown with a versioned package list, script inventory, per-variable codebook (name, class, n, missingness, summary), and outputs produced. This is the codebook OSF and many journals require alongside shared data.
- **generate_notebook** — Transform a ClaudeR session log into a Quarto lab notebook (.qmd): each executed block becomes a runnable chunk with its timestamp and agent, errored blocks are preserved as non-evaluated chunks, and rendering re-runs the code so outputs and plots regenerate. The generated file contains '<!-- TODO: narration -->' markers: AFTER calling this tool, read the .qmd and replace every marker with a short explanation of what was tried and why (use read_file + execute_r with writeLines, or your own file tools). Then optionally render with quarto to produce the final HTML notebook.
- **search_citations** — Search the OpenAlex scholarly index for works matching a free-text query (title fragments, topic + author, etc.). Returns candidate citations with title, authors, year, venue, DOI, and citation count. Use this to find the correct reference for a claim instead of writing one from memory, then call get_bibtex with the chosen DOI.
- **get_bibtex** — Fetch the canonical BibTeX entry for a DOI via doi.org content negotiation. This returns the registered metadata, not a reconstruction — use it to insert citations after finding the right work with search_citations or verify_references.

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `uvx` (confidence: high):

```json
"mcpServers": {
  "clauder-rstudio-mcp-server": {
    "command": "uvx",
    "args": ["--refresh","clauder-mcp"]
  }
}
```

## Documentation

## What ClaudeR - RStudio MCP Server does

ClaudeR - RStudio MCP Server gives MCP-based agents access to a live R session running in RStudio. Agents can execute R code, inspect the environment, generate plots, read the active editor buffer, and apply or suggest code changes. The server works against the session where data, fitted models, packages, and other objects already exist, so it is suited to interactive analysis and iterative development.

Beyond direct coding, the toolset includes task lists, session history, project-source searching, checkpoint and restore operations, and tools for research workflows. These include reference verification through CrossRef, clean-room script probing, manuscript or file extraction, CSV annotation jobs, systematic-review screening reports, and RStudio Viewer content retrieval.

## How it works

Install the ClaudeR R package, configure an MCP client, and start the server from RStudio with the ClaudeR addin. Calls are routed to the connected RStudio session. The active editor buffer is distinct from the saved file on disk: `get_active_document` reports unsaved changes, while file reads reflect disk contents. Editing tools save by default, or can stage changes in the buffer with `save=false`; `suggest_edit` is intended for changes that require user approval.

Long-running computations can use `execute_r_async`. The background process receives explicitly marshaled input objects and can return named output objects to the main session. It has no access to the main session environment beyond those inputs, and packages needed by the job must be loaded inside that process. Jobs can be checked or cancelled while normal R execution continues.

Multiple agents can share one session, while separate RStudio sessions can be discovered and selected with `list_sessions` and `connect_session`.

## Setup and configuration

Install the R package from GitHub through `devtools`, load `ClaudeR`, then run `install_clauder()` for Claude Desktop or Cursor. For Claude Code CLI setup, use `install_cli(tools = "claude")`. Start the RStudio-side server with `claudeAddin()`.

The project indicates R version 4.0 or newer. The server is designed for RStudio and also supports Positron. Client configuration is handled through the installation helpers or the relevant MCP client setup.

## Tools and capabilities

- Execute R code synchronously, including code that produces plots.
- Inspect R version, package count, variables, session history, and the RStudio Viewer pane.
- Read files from disk, including structured extraction from DOCX and PDF files.
- Search R, R Markdown, and Quarto project source files with regular expressions.
- Modify or insert editor content, target a selected path, and request approval before applying edits.
- Create and update analysis task lists.
- Run, monitor, and cancel background R jobs with optional input and output marshaling.
- Create, list, and restore checkpoints of the R global environment.
- Run isolated script probes, verify DOI references through CrossRef, and generate screening reports.
- Load and annotate CSV rows with schema validation and resumable jobs.

## Limitations and notes

Background jobs cannot marshal database connections or open file handles, and they must load their own packages. Auto-marshaled inputs are snapshots taken when the job starts, so later changes in the main session are not included. A focused RStudio document is required for active-buffer operations unless a target path is supplied where supported.

`get_async_result` waits before checking a job to reduce repeated polling. Annotation jobs process rows in separate fresh subprocesses or supported model processes, preserve the original CSV, and can be resumed. Editing operations that save to disk can leave the editor buffer and file state different depending on the chosen save behavior, so callers should use the returned save status when deciding whether to reread a file.

_Full upstream README: https://allmcps.com/mcp/clauder-rstudio-mcp-server/readme_