ClaudeR - RStudio MCP Server

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.

Cancel a running annotation job. The current row finishes before stopping. Already-saved rows are kept and the job is resumable.

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.

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.

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.

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.

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.

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.

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.

Create a task list for the current analysis

Execute R code and return the output

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.

Execute R code that generates a plot

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.

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.

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.

Check the status of a running or completed annotation job started with run_annotation_job.

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.

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.

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 execution history for the current R session. Can filter by agent to see what a specific agent has done.

Get HTML content from the RStudio Viewer pane (HTML widgets like plotly, DT, leaflet). Returns paginated chunks. Call with offset to get more.

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.

List saved R session checkpoints (file, time, size MB) for the current session, newest last.

List available RStudio sessions that this agent can connect to. Shows session name, port, and PID for each active session.

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.

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.

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.

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().

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.

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.

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.

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.

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.

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.

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.

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.

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.

Update the status of a task and optionally add notes

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.

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').