← ClaudeR

ClaudeR 0.14.5

pypi · clauder-mcp · current release

41
Tools
0
Resources
0
Templates
0
Prompts

Observation

Observed 2026-09-04T08:47:32.350Z using mcpSecurity-inventory. Status: succeeded. Negotiated protocol: 2025-06-18.

Server capabilities
{
  "experimental": {},
  "tools": {
    "listChanged": false
  }
}

Tools 41

ToolCategoryAnnotationsRisk
annotateAnnotate 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.
Input schema
{
  "type": "object",
  "properties": {
    "annotations": {
      "type": "object",
      "description": "Key-value pairs matching the schema fields (e.g. {\"sentiment\": \"positive\", \"confidence\": \"0.9\"})",
      "additionalProperties": {
        "type": "string"
      }
    }
  },
  "required": [
    "annotations"
  ]
}
Annotations
{
  "readOnlyHint": false,
  "destructiveHint": false,
  "idempotentHint": false,
  "openWorldHint": false
}
—Writes · Non-destructive—
cancel_annotation_jobCancel a running annotation job. The current row finishes before stopping. Already-saved rows are kept and the job is resumable.
Input schema
{
  "type": "object",
  "properties": {
    "job_id": {
      "type": "string",
      "description": "Job ID returned by run_annotation_job."
    }
  },
  "required": [
    "job_id"
  ]
}
Annotations
{
  "readOnlyHint": false,
  "destructiveHint": false,
  "idempotentHint": true,
  "openWorldHint": false
}
—Writes · Non-destructive—
cancel_async_jobTerminate 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.
Input schema
{
  "type": "object",
  "properties": {
    "job_id": {
      "type": "string",
      "description": "The job ID returned by execute_r_async"
    }
  },
  "required": [
    "job_id"
  ]
}
Annotations
{
  "readOnlyHint": false,
  "destructiveHint": true,
  "idempotentHint": true,
  "openWorldHint": false
}
—Writes · Destructive—
check_cross_referencesCheck 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.
Input schema
{
  "type": "object",
  "properties": {
    "document": {
      "type": "string",
      "description": "Path to the manuscript (.docx, .pdf, or plain text)."
    }
  },
  "required": [
    "document"
  ]
}
Annotations
{
  "readOnlyHint": false,
  "destructiveHint": false,
  "idempotentHint": true,
  "openWorldHint": false
}
—Writes · Non-destructive—
check_messagesRead 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.
Input schema
{
  "type": "object",
  "properties": {
    "ack": {
      "type": "boolean",
      "description": "Advance the cursor past returned events (default true)."
    },
    "as_agent": {
      "type": "string",
      "description": "Read as this identity, using its own separate cursor. For personas sharing one MCP connection."
    }
  }
}
Annotations
{
  "readOnlyHint": false,
  "destructiveHint": false,
  "idempotentHint": false,
  "openWorldHint": false
}
—Writes · Non-destructive—
checkpoint_sessionSave 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.
Input schema
{
  "type": "object",
  "properties": {
    "label": {
      "type": "string",
      "description": "Optional short label recorded in the checkpoint filename (e.g. 'before_refit')."
    }
  }
}
Annotations
{
  "readOnlyHint": false,
  "destructiveHint": false,
  "idempotentHint": false,
  "openWorldHint": false
}
—Writes · Non-destructive—
clean_error_logClean 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.
Input schema
{
  "type": "object",
  "properties": {
    "log_path": {
      "type": "string",
      "description": "Path to the ClaudeR session log file"
    },
    "output_path": {
      "type": "string",
      "description": "Optional path to write the cleaned log. If omitted, overwrites the original file."
    }
  },
  "required": [
    "log_path"
  ]
}
Annotations
{
  "readOnlyHint": false,
  "destructiveHint": true,
  "idempotentHint": true,
  "openWorldHint": false
}
—Writes · Destructive—
connect_sessionConnect to a specific RStudio session by name. Use list_sessions first to see available sessions. Subsequent tool calls will be routed to this session.
Input schema
{
  "type": "object",
  "properties": {
    "session_name": {
      "type": "string",
      "description": "Name of the R session to connect to"
    }
  },
  "required": [
    "session_name"
  ]
}
Annotations
{
  "readOnlyHint": false,
  "destructiveHint": false,
  "idempotentHint": true,
  "openWorldHint": false
}
—Writes · Non-destructive—
coordination_rosterList 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.
Input schema
{
  "type": "object",
  "properties": {
    "stale_after_s": {
      "type": "number",
      "description": "Seconds after which an agent is flagged stale (default 900)."
    }
  }
}
Annotations
{
  "readOnlyHint": true,
  "destructiveHint": false,
  "idempotentHint": true,
  "openWorldHint": false
}
—Read only · Non-destructive—
create_task_listCreate a task list for the current analysis
Input schema
{
  "type": "object",
  "properties": {
    "tasks": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "id": {
            "type": "string"
          },
          "description": {
            "type": "string"
          },
          "status": {
            "type": "string",
            "enum": [
              "pending",
              "in_progress",
              "completed"
            ]
          }
        }
      },
      "description": "List of tasks to complete"
    }
  },
  "required": [
    "tasks"
  ]
}
Annotations
{
  "readOnlyHint": false,
  "destructiveHint": false,
  "idempotentHint": false,
  "openWorldHint": false
}
—Writes · Non-destructive—
execute_rExecute R code and return the output
Input schema
{
  "type": "object",
  "properties": {
    "code": {
      "type": "string",
      "description": "R code to execute. Avoid hardcoding values pulled from analyses. Always dynamically pull the value from the object or dataframe."
    }
  },
  "required": [
    "code"
  ]
}
Annotations
{
  "readOnlyHint": false,
  "destructiveHint": false,
  "idempotentHint": false,
  "openWorldHint": false
}
—Writes · Non-destructive—
execute_r_asyncExecute 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.
Input schema
{
  "type": "object",
  "properties": {
    "code": {
      "type": "string",
      "description": "R code to execute asynchronously."
    },
    "inputs": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Optional. Names of objects in the main R session to copy into the background process before running `code`. Connection objects cannot be marshaled."
    },
    "outputs": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Optional. Names of objects the background code will create that should be loaded back into the main R session when get_async_result reports complete."
    }
  },
  "required": [
    "code"
  ]
}
Annotations
{
  "readOnlyHint": false,
  "destructiveHint": false,
  "idempotentHint": false,
  "openWorldHint": false
}
—Writes · Non-destructive—
execute_r_with_plotExecute R code that generates a plot
Input schema
{
  "type": "object",
  "properties": {
    "code": {
      "type": "string",
      "description": "R code to execute that generates a plot"
    }
  },
  "required": [
    "code"
  ]
}
Annotations
{
  "readOnlyHint": false,
  "destructiveHint": false,
  "idempotentHint": false,
  "openWorldHint": false
}
—Writes · Non-destructive—
generate_codebookGenerate 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.
Input schema
{
  "type": "object",
  "properties": {
    "project_dir": {
      "type": "string",
      "description": "Project root to scan. Default: current working directory."
    },
    "data_files": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Optional explicit data files to document instead of scanning scripts."
    },
    "output_path": {
      "type": "string",
      "description": "Output markdown path. Default: <project_dir>/CODEBOOK.md"
    }
  }
}
Annotations
{
  "readOnlyHint": false,
  "destructiveHint": false,
  "idempotentHint": true,
  "openWorldHint": false
}
—Writes · Non-destructive—
generate_notebookTransform 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.
Input schema
{
  "type": "object",
  "properties": {
    "log_path": {
      "type": "string",
      "description": "Path to the session log. Omit to use the current session's log."
    },
    "output_path": {
      "type": "string",
      "description": "Optional output .qmd path. Default: alongside the log with a _notebook.qmd suffix."
    },
    "title": {
      "type": "string",
      "description": "Optional notebook title."
    }
  }
}
Annotations
{
  "readOnlyHint": false,
  "destructiveHint": false,
  "idempotentHint": true,
  "openWorldHint": false
}
—Writes · Non-destructive—
get_active_documentRead 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.
Input schema
{
  "type": "object",
  "properties": {
    "path": {
      "type": "string",
      "description": "Optional: absolute path of the file to read. If it is not the focused document, ClaudeR tries to open and focus it first."
    }
  }
}
Annotations
{
  "readOnlyHint": true,
  "destructiveHint": false,
  "idempotentHint": true,
  "openWorldHint": false
}
—Read only · Non-destructive—
get_annotation_job_statusCheck the status of a running or completed annotation job started with run_annotation_job.
Input schema
{
  "type": "object",
  "properties": {
    "job_id": {
      "type": "string",
      "description": "Job ID returned by run_annotation_job."
    }
  },
  "required": [
    "job_id"
  ]
}
Annotations
{
  "readOnlyHint": true,
  "destructiveHint": false,
  "idempotentHint": true,
  "openWorldHint": false
}
—Read only · Non-destructive—
get_async_resultCheck 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.
Input schema
{
  "type": "object",
  "properties": {
    "job_id": {
      "type": "string",
      "description": "The job ID returned by execute_r_async"
    }
  },
  "required": [
    "job_id"
  ]
}
Annotations
{
  "readOnlyHint": true,
  "destructiveHint": false,
  "idempotentHint": true,
  "openWorldHint": false
}
—Read only · Non-destructive—
get_bibtexFetch 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.
Input schema
{
  "type": "object",
  "properties": {
    "doi": {
      "type": "string",
      "description": "The DOI, with or without the https://doi.org/ prefix."
    }
  },
  "required": [
    "doi"
  ]
}
Annotations
{
  "readOnlyHint": true,
  "destructiveHint": false,
  "idempotentHint": true,
  "openWorldHint": true
}
—Read only · Non-destructive—
get_r_infoGet 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.
Input schema
{
  "type": "object",
  "properties": {
    "what": {
      "type": "string",
      "description": "What information to get: 'packages' (count only), 'variables' (first 20), 'version', or 'all'"
    }
  },
  "required": [
    "what"
  ]
}
Annotations
{
  "readOnlyHint": true,
  "destructiveHint": false,
  "idempotentHint": true,
  "openWorldHint": false
}
—Read only · Non-destructive—
get_session_historyGet execution history for the current R session. Can filter by agent to see what a specific agent has done.
Input schema
{
  "type": "object",
  "properties": {
    "agent_filter": {
      "type": "string",
      "description": "Filter history by agent ID. Use 'self' for own history, 'all' for everything, or a specific agent ID."
    },
    "last_n": {
      "type": "number",
      "description": "Number of recent entries to return (default 20)"
    },
    "include_past": {
      "type": "boolean",
      "description": "Also parse prior session log files on disk, so the audit trail survives R restarts. Entries from past logs are tagged {logfile}. Default false."
    }
  }
}
Annotations
{
  "readOnlyHint": true,
  "destructiveHint": false,
  "idempotentHint": true,
  "openWorldHint": false
}
—Read only · Non-destructive—
get_viewer_contentGet HTML content from the RStudio Viewer pane (HTML widgets like plotly, DT, leaflet). Returns paginated chunks. Call with offset to get more.
Input schema
{
  "type": "object",
  "properties": {
    "max_length": {
      "type": "number",
      "description": "Maximum characters to return (default 10000)"
    },
    "offset": {
      "type": "number",
      "description": "Character offset to start from (default 0). Use to paginate through large content."
    }
  }
}
Annotations
{
  "readOnlyHint": true,
  "destructiveHint": false,
  "idempotentHint": true,
  "openWorldHint": false
}
—Read only · Non-destructive—
insert_textInsert 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.
Input schema
{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "description": "The text to insert"
    },
    "line": {
      "type": "number",
      "description": "Optional: Line number to insert at (1-based). If omitted, inserts at current cursor position."
    },
    "column": {
      "type": "number",
      "description": "Optional: Column number to insert at (1-based). Defaults to 1 if line is specified but column is omitted."
    },
    "path": {
      "type": "string",
      "description": "Optional: absolute path of the file to insert into. ClaudeR opens/focuses it and refuses to write to a different document."
    },
    "save": {
      "type": "boolean",
      "description": "Save the document to disk after inserting (default true)."
    }
  },
  "required": [
    "text"
  ]
}
Annotations
{
  "readOnlyHint": false,
  "destructiveHint": false,
  "idempotentHint": false,
  "openWorldHint": false
}
—Writes · Non-destructive—
list_checkpointsList saved R session checkpoints (file, time, size MB) for the current session, newest last.
Input schema
{
  "type": "object",
  "properties": {}
}
Annotations
{
  "readOnlyHint": true,
  "destructiveHint": false,
  "idempotentHint": true,
  "openWorldHint": false
}
—Read only · Non-destructive—
list_sessionsList available RStudio sessions that this agent can connect to. Shows session name, port, and PID for each active session.
Input schema
{
  "type": "object",
  "properties": {}
}
Annotations
{
  "readOnlyHint": true,
  "destructiveHint": false,
  "idempotentHint": true,
  "openWorldHint": false
}
—Read only · Non-destructive—
load_annotation_dataLoad 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.
Input schema
{
  "type": "object",
  "properties": {
    "csv_path": {
      "type": "string",
      "description": "Path to the CSV file to annotate. Must contain a '_schema' column in the first row."
    }
  },
  "required": [
    "csv_path"
  ]
}
Annotations
{
  "readOnlyHint": false,
  "destructiveHint": false,
  "idempotentHint": false,
  "openWorldHint": false
}
—Writes · Non-destructive—
modify_code_sectionRegex 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.
Input schema
{
  "type": "object",
  "properties": {
    "search_pattern": {
      "type": "string",
      "description": "Pattern to identify the section of code to be modified"
    },
    "replacement": {
      "type": "string",
      "description": "New code to replace the identified section"
    },
    "line_start": {
      "type": "number",
      "description": "Optional: Start line number for the search (1-based indexing)"
    },
    "line_end": {
      "type": "number",
      "description": "Optional: End line number for the search (1-based indexing)"
    },
    "path": {
      "type": "string",
      "description": "Optional: absolute path of the file to edit. ClaudeR opens/focuses it and refuses to edit a different document."
    },
    "save": {
      "type": "boolean",
      "description": "Save the document to disk after the edit (default true). Set false to leave the change unsaved in the buffer."
    }
  },
  "required": [
    "search_pattern",
    "replacement"
  ]
}
Annotations
{
  "readOnlyHint": false,
  "destructiveHint": true,
  "idempotentHint": false,
  "openWorldHint": false
}
—Writes · Destructive—
probe_scriptsSource 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.
Input schema
{
  "type": "object",
  "properties": {
    "script_paths": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Paths to R scripts to source, each in isolation."
    },
    "timeout": {
      "type": "number",
      "description": "Seconds before timing out per script. Default: 60."
    },
    "capture_output": {
      "type": "boolean",
      "description": "Also return the printed output of running each script (capped). Default: false."
    }
  },
  "required": [
    "script_paths"
  ]
}
Annotations
{
  "readOnlyHint": true,
  "destructiveHint": false,
  "idempotentHint": true,
  "openWorldHint": false
}
—Read only · Non-destructive—
read_fileRead 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().
Input schema
{
  "type": "object",
  "properties": {
    "file_path": {
      "type": "string",
      "description": "Path to the file to read. Supports absolute paths and ~ for home directory."
    },
    "start_line": {
      "type": "number",
      "description": "Optional: first line to return (1-based). Omit to start from beginning."
    },
    "end_line": {
      "type": "number",
      "description": "Optional: last line to return (1-based, inclusive). Omit to read to end of file."
    }
  },
  "required": [
    "file_path"
  ]
}
Annotations
{
  "readOnlyHint": true,
  "destructiveHint": false,
  "idempotentHint": true,
  "openWorldHint": false
}
—Read only · Non-destructive—
reconcile_valuesAudit 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.
Input schema
{
  "type": "object",
  "properties": {
    "document": {
      "type": "string",
      "description": "Path to the manuscript or supplement (.docx, .pdf, or plain text)."
    },
    "sources": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Files whose numbers form the ground-truth corpus: session logs, generated table files, script outputs, CSVs."
    },
    "ignore_years": {
      "type": "boolean",
      "description": "Skip 4-digit integers 1900-2100 (citation years). Default true."
    }
  },
  "required": [
    "document",
    "sources"
  ]
}
Annotations
{
  "readOnlyHint": false,
  "destructiveHint": false,
  "idempotentHint": true,
  "openWorldHint": false
}
—Writes · Non-destructive—
restore_sessionRoll 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.
Input schema
{
  "type": "object",
  "properties": {
    "checkpoint": {
      "type": "string",
      "description": "Optional checkpoint filename from list_checkpoints. Omit to restore the most recent."
    }
  }
}
Annotations
{
  "readOnlyHint": false,
  "destructiveHint": true,
  "idempotentHint": false,
  "openWorldHint": false
}
—Writes · Destructive—
run_annotation_jobAnnotate 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.
Input schema
{
  "type": "object",
  "properties": {
    "csv_path": {
      "type": "string",
      "description": "Path to the CSV file. Must have a '_schema' column in the first row."
    },
    "tool": {
      "type": "string",
      "description": "Backend to use: 'claude' (default), 'codex', 'gemini', 'agy' (Antigravity CLI, Google's replacement for Gemini CLI starting 2026-06-18), 'qwen' (Qwen Code CLI), or 'ollama' (local Ollama HTTP server). The CLI tools require their respective binary on PATH; ollama requires `ollama serve` running locally."
    },
    "model": {
      "type": "string",
      "description": "Model name to pass to the backend (optional). For ollama, this is the model tag (e.g. 'qwen2.5', 'llama3.2'). Defaults to 'qwen2.5' for ollama; uses each CLI's own default for the others."
    },
    "timeout": {
      "type": "number",
      "description": "Seconds to wait per row before giving up (default: 60)."
    },
    "reasoning_effort": {
      "type": "string",
      "description": "Codex only: reasoning effort level: 'low', 'medium', 'high' (default), or 'none'."
    },
    "ollama_base_url": {
      "type": "string",
      "description": "Ollama only: base URL of the Ollama server. Defaults to 'http://localhost:11434'. Set this to point at a remote Ollama instance (e.g. a LAN GPU box)."
    }
  },
  "required": [
    "csv_path"
  ]
}
Annotations
{
  "readOnlyHint": false,
  "destructiveHint": false,
  "idempotentHint": false,
  "openWorldHint": false
}
—Writes · Non-destructive—
screening_reportSummarize 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.
Input schema
{
  "type": "object",
  "properties": {
    "pass_a": {
      "type": "string",
      "description": "Path to the first screened CSV (the _annotating.csv output)."
    },
    "pass_b": {
      "type": "string",
      "description": "Optional second screened CSV from a different model family."
    },
    "include_field": {
      "type": "string",
      "description": "Decision column name. Default 'include'."
    },
    "reason_field": {
      "type": "string",
      "description": "Exclusion reason column name. Default 'reason'."
    }
  },
  "required": [
    "pass_a"
  ]
}
Annotations
{
  "readOnlyHint": false,
  "destructiveHint": false,
  "idempotentHint": true,
  "openWorldHint": false
}
—Writes · Non-destructive—
search_citationsSearch 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.
Input schema
{
  "type": "object",
  "properties": {
    "query": {
      "type": "string",
      "description": "Free-text search query (e.g. 'chain of thought prompting Wei 2022')."
    },
    "max_results": {
      "type": "number",
      "description": "Maximum candidates to return (default 5)."
    }
  },
  "required": [
    "query"
  ]
}
Annotations
{
  "readOnlyHint": true,
  "destructiveHint": false,
  "idempotentHint": true,
  "openWorldHint": true
}
—Read only · Non-destructive—
search_project_codeSearch 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.
Input schema
{
  "type": "object",
  "properties": {
    "pattern": {
      "type": "string",
      "description": "Regular expression pattern to search for."
    },
    "file_extensions": {
      "type": "string",
      "description": "Comma-separated file extensions to search. Default: 'R,Rmd,qmd'"
    },
    "root_dir": {
      "type": "string",
      "description": "Root directory to search from. Default: current working directory."
    },
    "max_results": {
      "type": "number",
      "description": "Maximum number of matching lines to return. Default: 50."
    },
    "ignore_case": {
      "type": "boolean",
      "description": "Whether to ignore case. Default: false."
    }
  },
  "required": [
    "pattern"
  ]
}
Annotations
{
  "readOnlyHint": true,
  "destructiveHint": false,
  "idempotentHint": true,
  "openWorldHint": false
}
—Read only · Non-destructive—
send_messageSend 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.
Input schema
{
  "type": "object",
  "properties": {
    "body": {
      "description": "Message payload: a string, or an object for typed signals.",
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "object"
        }
      ]
    },
    "to": {
      "type": "string",
      "description": "Recipient agent id, or 'all' (default)."
    },
    "type": {
      "type": "string",
      "description": "Event type: message (default), signal, status, handoff, question."
    },
    "reply_to": {
      "type": "number",
      "description": "Event id this replies to (threading)."
    },
    "as_agent": {
      "type": "string",
      "description": "Send as this identity, for this call only. Use when several agents or personas share one MCP connection: each passes its own name per call instead of fighting over set_agent_name."
    }
  },
  "required": [
    "body"
  ]
}
Annotations
{
  "readOnlyHint": false,
  "destructiveHint": false,
  "idempotentHint": false,
  "openWorldHint": false
}
—Writes · Non-destructive—
set_agent_nameSet 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.
Input schema
{
  "type": "object",
  "properties": {
    "name": {
      "type": "string",
      "description": "The identity to use: 1-40 chars, letters, digits, dash, underscore; must start with a letter or digit."
    },
    "force": {
      "type": "boolean",
      "description": "Rename a connection that an earlier set_agent_name call already named. Only use this when you are certain you are the only agent on this connection."
    }
  },
  "required": [
    "name"
  ]
}
Annotations
{
  "readOnlyHint": false,
  "destructiveHint": false,
  "idempotentHint": true,
  "openWorldHint": false
}
—Writes · Non-destructive—
suggest_editPropose 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.
Input schema
{
  "type": "object",
  "properties": {
    "search_pattern": {
      "type": "string",
      "description": "Regex pattern identifying the code to change"
    },
    "replacement": {
      "type": "string",
      "description": "Replacement text"
    },
    "path": {
      "type": "string",
      "description": "Optional: absolute path of the file to edit"
    }
  },
  "required": [
    "search_pattern",
    "replacement"
  ]
}
Annotations
{
  "readOnlyHint": false,
  "destructiveHint": false,
  "idempotentHint": false,
  "openWorldHint": false
}
—Writes · Non-destructive—
update_task_statusUpdate the status of a task and optionally add notes
Input schema
{
  "type": "object",
  "properties": {
    "task_id": {
      "type": "string",
      "description": "ID of the task to update"
    },
    "status": {
      "type": "string",
      "enum": [
        "pending",
        "in_progress",
        "completed"
      ],
      "description": "New status for the task"
    },
    "notes": {
      "type": "string",
      "description": "Optional notes about the task progress"
    }
  },
  "required": [
    "task_id",
    "status"
  ]
}
Annotations
{
  "readOnlyHint": false,
  "destructiveHint": false,
  "idempotentHint": true,
  "openWorldHint": false
}
—Writes · Non-destructive—
verify_referencesVerify 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.
Input schema
{
  "type": "object",
  "properties": {
    "file": {
      "type": "string",
      "description": "Path to the manuscript or references file"
    },
    "text": {
      "type": "string",
      "description": "Raw text containing references (alternative to file)"
    },
    "start_line": {
      "type": "integer",
      "description": "Start reading from this line (optional, for targeting the references section)"
    },
    "end_line": {
      "type": "integer",
      "description": "Stop reading at this line (optional)"
    }
  }
}
Annotations
{
  "readOnlyHint": true,
  "destructiveHint": false,
  "idempotentHint": true,
  "openWorldHint": true
}
—Read only · Non-destructive—
wait_for_messageBlock 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').
Input schema
{
  "type": "object",
  "properties": {
    "timeout_s": {
      "type": "number",
      "description": "Max seconds to wait (default 300, cap 1800)."
    },
    "from_agent": {
      "type": "string",
      "description": "Only return events from this agent."
    },
    "type": {
      "type": "string",
      "description": "Only return events of this type."
    },
    "as_agent": {
      "type": "string",
      "description": "Wait as this identity, using its own cursor. For personas sharing one MCP connection."
    }
  }
}
Annotations
{
  "readOnlyHint": false,
  "destructiveHint": false,
  "idempotentHint": false,
  "openWorldHint": false
}
—Writes · Non-destructive—

Resources 0

Resource templates 0

Prompts 0

Let’s talk about MCP security.

Share your details and our security team will contact you.