What can you do with this server?

The CERN ROOT MCP Server enables LLMs and MCP-compliant clients to interact with, inspect, analyze, and extract data from CERN ROOT files used in high-energy physics research. It provides the following capabilities: * List Files – Browse ROOT files within a named resource, with optional glob pattern filtering. * Inspect File – Examine the full structure and contents of a ROOT file (Trees, RNTuples, Branches, Histograms). * List Branches – List all branches within a TTree or RNTuple, with optional pattern filtering. * Validate File – Check the integrity of a ROOT file to ensure it is not corrupted. * Read Branches – Extract branch data with support for entry range selection and cut expressions (filters). * Get Branch Statistics – Compute statistical summaries for branches, including support for derived/computed variables via custom expressions. * Export Data – Export branch data to JSON, CSV, or Parquet formats, with optional compression and cut-based filtering. * Switch Mode – Toggle between core mode (lightweight file I/O and basic stats) and extended mode (full analysis: histograms, fitting, kinematics, correlations) at runtime without restarting. * Get Server Info – Retrieve current server mode, available capabilities, and native ROOT installation status. In extended mode, additional advanced physics analysis is available: generating and plotting 1D/2D histograms, fitting data distributions, computing kinematic quantities, and analyzing correlations. When native ROOT integration is enabled, it also supports execution of arbitrary PyROOT/Python code, ROOT's RDataFrame for efficient computation, and C++ ROOT macros.

How do I use CERN ROOT MCP Server?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@CERN ROOT MCP Server Plot the muon pT distribution from sample.root" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

CERN ROOT MCP Server

by MohamedElashri

Overview Schema Related Servers Score Discussions

Python

Hybrid

PyPI License Language

Repository Mirror: This repository is mirrored to CERN GitLab for CERN users. PyPI releases are published via GitHub Actions using attestation-based trusted publishing.

ROOT-MCP empowers Large Language Models (LLMs) to natively understand and analyze CERN ROOT files.

By exposing a set of specialized tools via the Model Context Protocol (MCP) or a token-efficient CLI interface, it turns Claude (and other MCP-compliant agents) into capable physics research assistants that can:

Inspect ROOT file structures (Trees, RNTuples, Branches, Histograms)
Analyze data distributions (Compute Histograms, Statistics)
Compute kinematic quantities (Invariant Mass)
Visualize results (Plot 1D/2D histograms directly)
Filter data using physics cuts ("selections")

Why this matters: Instead of asking an LLM to "write a script" that you have to debug and run, you can ask the LLM to "Check the muon pT distribution in this file" and it will just do it.

Two Interfaces: MCP Server and CLI

ROOT-MCP provides two ways to interact with ROOT files:

1. MCP Server (for Claude Desktop and MCP clients)

Full JSON-RPC protocol support
Structured input/output for programmatic use
Best for: MCP-compliant LLM clients, automated workflows

2. ROOT CLI (`root-cli`)

Human-readable output by default
Simpler architecture (no server process)
Best for: Direct LLM interaction, debugging, scripting

Both interfaces share the same backend and support all 17 analysis tools.

Related MCP server: XRootD MCP Server

Quick Start

1. Install

pip install root-mcp

Optional: For remote file access via XRootD protocol:

pip install "root-mcp[xrootd]"

2. Configure

Fastest path — no config file needed:

# MCP Server
root-mcp --data-path /path/to/your/data

# CLI (token-efficient)
root-cli -d /path/to/your/data ls

Or set an environment variable once:

export ROOT_MCP_DATA_PATH=/path/to/your/data

ROOT CLI (Recommended for LLM Interaction)

The CLI provides a token-efficient, human-readable interface that provides significant token savings compared to the MCP JSON protocol.

Basic Usage

# List files
root-cli ls

# Inspect a file
root-cli inspect /data/sample.root

# Create histogram with fit
root-cli histogram /data/sample.root events muon_pt --bins 100 --fit gaussian

# Read data with selection
root-cli read /data/sample.root events met muon_pt --selection "met > 50"

# Plot results
root-cli plot1d /tmp/root_mcp/muon_pt_hist.json -o plot.png --title "Muon pT"

Example LLM Workflow

Ask your LLM: "Plot the muon pT distribution"

The LLM generates:

root-cli histogram /data/sample.root events muon_pt --bins 50 && \
root-cli plot1d /tmp/root_mcp/muon_pt_hist.json -o muon_pt.png --title "Muon pT Distribution"

Documentation

See docs/skills/root-cli.md for complete command reference with examples.

MCP Server

Zero-config one-liners:

# Core mode (lightweight, no scipy/matplotlib needed)
root-mcp --data-path /data --mode core

# Explicit stdio transport (same runtime as the compatibility default)
root-mcp serve-stdio --data-path /data

# Extended mode with native ROOT, restricted to one directory
root-mcp --data-path /data --enable-root --allowed-root /data

# Remote XRootD resource, no YAML needed
root-mcp --resource cms=root://xrootd.cern.ch//store --allow-remote --mode extended

# Docker / container — fully env-var driven
ROOT_MCP_DATA_PATH=/data ROOT_MCP_MODE=extended ROOT_MCP_EXPORT_PATH=/exports root-mcp

# Quiet server (only warnings+) with a cache increase
root-mcp --data-path /data --log-level WARNING --cache-size 100

root-mcp serve-http serves the MCP Streamable HTTP endpoint for central deployments. It requires explicit auth, Origin validation, restrictive central policy, and safe bind-address settings before it starts.

For shared deployments, start with the operator docs: docs/operator/central_deployment.md and docs/operator/security_checklist.md. Restrictive starter configs and Kubernetes manifests live in examples/central/.

Operators can preview and apply export retention with root-mcp cleanup-exports --config /etc/root-mcp/config.yaml --dry-run. The external HTTP smoke script at scripts/smoke_external_http_client.py starts a temporary central server and checks it with the MCP Streamable HTTP client.

Generate a starter config (optional):

root-mcp init --permissive   # creates config.yaml pre-filled with current directory

Manual config file — for persistent settings, remote resources, or native ROOT:

server:
  mode: "extended"   # "core" or "extended"

resources:
  - name: "my_analysis"
    uri: "file:///path/to/data"
    allowed_patterns: ["*.root"]

security:
  allowed_roots: []  # empty = any local path is accessible (permissive)

Local-use warning: The permissive allowed_roots: [] default is intended for trusted local stdio sessions. Do not expose that configuration as a shared HTTP service; restrict roots and require an authenticated deployment profile before central or multi-user use.

Mode Selection:

mode: "core" — Lightweight: file operations and basic statistics
mode: "extended" — Full analysis: histograms, fitting, kinematics, correlations

Switch modes at runtime with the switch_mode tool — no restart required.

Run with Claude Desktop

Add to your claude_desktop_config.json:

{
  "mcpServers": {
    "root-mcp": {
      "command": "root-mcp",
      "args": ["--data-path", "/path/to/your/data"]
    }
  }
}

Or with a persistent config file:

{
  "mcpServers": {
    "root-mcp": {
      "command": "root-mcp",
      "env": {
        "ROOT_MCP_CONFIG": "/path/to/config.yaml"
      }
    }
  }
}

Architecture

ROOT-MCP organizes analysis capabilities into analysis tiers:

Core Mode: File I/O, data reading, and basic statistics
Extended Mode: Full analysis capabilities including fitting, kinematics, and correlations

The mode is controlled via configuration, and the server automatically loads only the components you need. Runtime mode switching is also available.

Optional Native ROOT Support

ROOT-MCP can optionally integrate with a native ROOT/PyROOT installation to unlock capabilities beyond what uproot provides:

run_root_code: Execute arbitrary PyROOT/Python code and get structured results
run_rdataframe: Compute histograms using ROOT's RDataFrame (no boilerplate needed)
run_root_macro: Execute C++ ROOT macros via gROOT.ProcessLine

This feature is entirely optional — ROOT-MCP works fully without ROOT installed. When ROOT is available and enabled, these additional tools appear automatically.

Requirements: A working ROOT installation (via conda-forge, system package, or binary tarball). ROOT is not pip-installable at this time.

Enable it by setting enable_root: true in your config.yaml:

features:
  enable_root: true

# Optional: tune execution settings
root_native:
  execution_timeout: 60
  working_directory: "/tmp/root_mcp_native"

Use get_server_info to check ROOT availability at runtime:

{
  "root_native_available": true,
  "root_native_enabled": true,
  "root_version": "6.32/02",
  "root_features": {"rdataframe": true, "roofit": true, "tmva": false}
}

Documentation

The full documentation site is built with Sphinx and covers installation, configuration, all 20 MCP tools, LLM integration patterns, and the developer guide with auto-generated API reference.

Read online: The docs are hosted at root-mcp docs

pip install "root-mcp[docs]"
./scripts/build_docs.sh
# open docs/_build/html/index.html

For live-reload while writing docs:

cd docs && make livehtml

Highlights:

User Guide — installation, quickstart, modes, configuration, LLM integration
Tool Reference — complete catalogue of all tools and their JSON payloads
CLI Reference — complete command reference for root-cli with examples
Developer Guide — architecture, module overview, dev setup, contributing
API Reference — auto-generated from source docstrings

Citation

If you use ROOT-MCP in your research, please cite:

@software{root_mcp,
  title = {ROOT-MCP: Production-Grade MCP Server for CERN ROOT Files},
  author = {Mohamed Elashri},
  year = {2025},
  url = {https://github.com/MohamedElashri/root-mcp}
}

License

MIT License - see LICENSE for details.

Available Tools

9 tools

export_dataC

Export branch data to JSON, CSV, or Parquet

ParametersJSON Schema

Name	Required	Description
`path`	Yes	File path
`tree_name`	Yes	Tree name
`branches`	Yes
`output_path`	Yes	Output file path
`format`	Yes
`selection`	No	Optional cut expression
`compress`	No	Compress output

TDQS

C2.9/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations available. Description does not disclose side effects (e.g., file overwrite), authentication needs, rate limits, or output behavior. For a write operation, this is a significant gap.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Single sentence, no redundancy. Could be more structured (e.g., list key points) but adequate for a simple export function.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Missing context on export behavior (server-side save vs download), output format details, compression effect, and selection expression. Incomplete for a 7-parameter tool with no output schema.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 71% (5/7 params described). Description adds no extra meaning beyond schema; it only lists formats already in enum. Baseline 3 appropriate as schema handles most parameter understanding.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

Description clearly states action (export branch data) and formats (JSON, CSV, Parquet). It distinguishes from siblings like read_branches (reading vs export) but does not explicitly contrast with get_branch_stats or validate_file.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use export_data vs alternatives (e.g., read_branches). No prerequisites, limitations, or suggested scenarios provided.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_branch_statsC

Get statistics for branches (supports derived variables via defines)

ParametersJSON Schema

Name	Required	Description
`path`	Yes	File path
`tree_name`	Yes	Tree name
`branches`	Yes
`selection`	No	Optional cut expression
`defines`	No	Derived variable definitions (dict of name: expression)

TDQS

C2.9/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden. It discloses support for derived variables via 'defines', but does not state whether the operation is read-only, what happens to the data source, or any side effects. The description is too brief to cover necessary behavioral traits.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, well-structured sentence that front-loads the purpose. Every word adds value with no redundancy, achieving maximum conciseness.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Despite the tool having no output schema, the description fails to explain what statistics are returned. It does not cover the required parameters (path, tree_name, branches) or the optional 'selection' and 'defines' parameters sufficiently. For a statistics tool, the return format and typical usage are missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 80% and the schema already describes all parameters. The description adds no extra meaning beyond the schema; it only mentions 'defines' as a capability. Baseline 3 is appropriate since the schema does the heavy lifting.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description 'Get statistics for branches' clearly indicates the tool returns statistical data about branches, which distinguishes it from listing or reading branches. The mention of 'supports derived variables via defines' adds specificity, but it does not explicitly differentiate from siblings like list_branches or read_branches.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives such as list_branches (for listing branches) or export_data (for data export). There is no mention of prerequisites, restrictions, or scenarios where this tool is preferred.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_server_infoA

Get server mode and capabilities

ParametersJSON Schema

Name	Required	Description	Default
No parameters

TDQS

A3.6/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description must convey behavioral context. It indicates a read operation ('Get'), but lacks details about authentication, rate limits, or any side effects. For a simple info tool, this is minimally adequate but does not go beyond the basic implication.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is very concise, using only a few words. It is front-loaded with the key action and resource. Every part contributes to purpose. Could be slightly more structured (e.g., complete sentence), but effective.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no output schema, the description explicitly states what the tool returns ('server mode and capabilities'). This is sufficient for a simple, parameterless tool. No missing context for usage.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

There are no parameters, so the input schema is trivially fully covered. The description does not need to add parameter details. The baseline for 0 parameters is 4, and no additional info is required.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description specifies 'Get server mode and capabilities', which clearly indicates the tool's purpose. It uses a verb ('Get') and names the resource ('server mode and capabilities'). While it doesn't explicitly differentiate from siblings, the name and description imply it's a general server info tool, distinct from branch stats or file operations.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description does not provide explicit guidance on when to use this tool versus alternatives. However, the purpose is clear enough that an agent could infer to use it when needing server capabilities. Lacks mention of exclusions or specific contexts.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

inspect_fileC

Inspect ROOT file structure and contents

ParametersJSON Schema

Name	Required	Description	Default
`path`	Yes	File path

TDQS

C2.6/5.0

Behavior1/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description must fully disclose behavior, but it provides none. It does not mention whether the tool is read-only, what happens on errors, permissions required, or output format.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness3/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence with no wasted words, but it omits critical information. While concise, it fails to earn its place by providing incomplete guidance.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's simplicity (1 param, no output schema, no annotations), the description should explain what 'inspect' entails and what the output looks like. It lacks behavioral and output details, making it incomplete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema covers the single parameter fully with a description. The tool description adds no additional meaning beyond the schema, so baseline score of 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states the verb 'inspect' and the resource 'ROOT file structure and contents', making the purpose clear. However, it does not differentiate from sibling tools like list_files or read_branches, which could overlap in functionality.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus alternatives. It lacks context such as prerequisites, expected scenarios, or when not to use it.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

list_branchesC

List branches in a TTree or RNTuple

ParametersJSON Schema

Name	Required	Description
`path`	Yes	File path
`tree_name`	Yes	Tree name
`pattern`	No	Optional glob pattern

TDQS

C2.9/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries full burden, but it only says 'list branches' without disclosing that it is a read-only operation, potential errors, or performance implications. Minimal behavioral disclosure.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is very short and to the point, with no fluff. It could be slightly more informative while remaining concise.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Without an output schema, the description should clarify what 'list' returns (e.g., branch names only or with metadata). It fails to specify the return format, leaving the agent uncertain about the tool's output.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the baseline is 3. The description adds no extra meaning beyond the schema; for example, it does not clarify the glob pattern format or file path conventions.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states it lists branches in a TTree or RNTuple, providing a specific verb and resource. However, it does not differentiate from sibling tools like 'read_branches' which may imply a different action (reading data vs listing names).

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is given on when to use this tool versus alternatives, such as 'read_branches' for data retrieval or 'inspect_file' for metadata. It lacks any context for selection.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

list_filesC

List ROOT files in a resource

ParametersJSON Schema

Name	Required	Description	Default
`resource`	Yes	Resource name
`pattern`	No	Optional glob pattern

TDQS

C2.9/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries full burden. It only states 'List ROOT files' without disclosing behavior like whether directories are included, pagination, or read-only nature. Minimal transparency beyond the basic action.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single concise sentence with no wasted words. It is front-loaded and efficient.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's simplicity, the description is too terse. It fails to explain what a 'resource' is, whether it lists directories, or what 'ROOT' entails. Leaves significant gaps for an AI agent.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% with descriptions for both parameters, so baseline is 3. The description adds 'ROOT' context but does not provide additional parameter semantics beyond what the schema already offers.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb 'list' and resource 'files' with scope 'ROOT', distinguishing it from siblings like inspect_file (single file) and list_branches (branches). However, the term 'resource' is not defined, causing slight ambiguity.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use this tool versus alternatives. For example, it does not clarify when to choose list_files over inspect_file or validate_file. Explicit context is missing.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

read_branchesB

Read branch data from a TTree or RNTuple

ParametersJSON Schema

Name	Required	Description
`path`	Yes	File path
`tree_name`	Yes	Tree name
`branches`	Yes
`entry_start`	No	Start entry
`entry_stop`	No	Stop entry
`selection`	No	Optional cut expression

TDQS

B3.1/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The description 'Read branch data' gives no behavioral details beyond the basic action. With no annotations, it fails to disclose that it is read-only, whether it reads all entries by default, or performance implications. Critical traits are omitted.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single clear sentence with no wasted words. It is appropriately sized, though could be slightly improved with structured formatting.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no annotations, no output schema, and six parameters, the description is too sparse. It does not explain return values, data format, behavior for missing parameters, or edge cases, leaving substantial gaps.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is high (83%) with descriptions for most parameters. However, the tool description adds no additional meaning beyond those in the schema, so it provides marginal value. Baseline 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb 'read' and the resource 'branch data', and specifies the context 'from a TTree or RNTuple'. It differentiates from sibling 'list_branches' which likely lists branches without reading data.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus siblings like 'export_data' or 'get_branch_stats'. There are no prerequisites, exclusions, or alternative recommendations.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

switch_modeC

Switch between core and extended modes

ParametersJSON Schema

Name	Required	Description	Default
`mode`	Yes

TDQS

C2.5/5.0

Behavior1/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, and the description does not disclose any behavioral traits such as side effects, permissions required, or whether switching is destructive. The verb 'switch' implies a state change but offers no details.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness3/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence, which is concise but overly minimal. It earns its place but lacks useful detail beyond the tool name.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple tool with one parameter and no output schema, the description should at least explain what each mode does or the effect of switching. Without that, an agent cannot fully understand when or why to use this tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters1/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%. The description does not explain the meaning of 'mode' or the two enum values ('core', 'extended'). The schema already lists the parameter but adds no additional context.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Description clearly states the verb 'switch' and resource 'mode', specifying the two modes (core and extended). It distinctly separates from all sibling tools which focus on data export, statistics, file inspection, etc.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use this tool versus alternatives, nor the context in which switching modes is appropriate. The description lacks any prerequisites or usage scenarios.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

validate_fileC

Validate ROOT file integrity

ParametersJSON Schema

Name	Required	Description	Default
`path`	Yes	File path

TDQS

C2.9/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries full burden. It fails to disclose behavioral traits like whether the tool performs a read-only check, what 'integrity' entails, or what happens with invalid files.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Extremely concise (5 words) and front-loaded. However, it borders on under-specification for an agent.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the lack of annotations and output schema, the description is insufficient. The agent lacks information about return values, side effects, and usage conditions for a simple but important validation tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% with the 'path' parameter described as 'File path'. The description adds no additional meaning beyond the schema, resulting in a baseline score.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description 'Validate ROOT file integrity' clearly specifies the action (validate) and resource (ROOT file integrity). It distinguishes the tool's purpose from siblings like 'inspect_file' which may check structure, though not explicitly.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use this tool versus alternatives such as 'inspect_file' or 'read_branches'. No exclusions or prerequisites mentioned.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.

9 tool updatesv0.1.7May 29, 2026
- First observedexport_data
- First observedget_branch_stats
- First observedget_server_info
- First observedinspect_file
- First observedlist_branches
- First observedlist_files
- First observedread_branches
- First observedswitch_mode
- First observedvalidate_file

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

B3.3/5.0

Disambiguation5/5

Each tool targets a distinct operation: listing files, inspecting structure, listing branches, reading data, computing statistics, exporting data, validating files, switching modes, and getting server info. No two tools have overlapping purposes.

Naming Consistency5/5

All tool names follow a consistent verb_noun pattern with underscore separators (e.g., list_branches, get_branch_stats). The pattern is uniform across all 9 tools.

Tool Count5/5

9 tools cover the essential operations for exploring and extracting ROOT data without being excessive. The count is well-matched to the domain's scope.

Completeness4/5

The tool set covers the main workflow: file discovery, structure inspection, branch listing, data reading, statistics, export, and validation. Minor gaps like applying cuts during reads are missing, but the core functionality is solid.

Maintenance

ActivityMaintained

ResponsivenessNo issues

Resources

GitHub Repository

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

mcp A
ai.llmse
Public MCP server for the LLM Search Engine
Search RAG Systems Developer Tools
102
hithereiamaliff-mcp-nextcloudOAuth
ai.smithery
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
Cloud Storage File Systems Workplace & Productivity
237
mcp-aichatOAuth
io.github.AceDataCloud
MCP server for AI dialogue using various LLM models via AceDataCloud
AI & Machine Learning
2
strata
ai.klavis
MCP server for progressive tool usage at any scale (see https://klavis.ai)
Agent Orchestration Autonomous Agents Developer Tools
25,748

Related MCP Servers

mcp-cli-catalog
Shell Access
abcpro1
A
license
Not graded
quality
D
maintenance
An MCP server that publishes CLI tools on your machine for discoverability by LLMs
Updated 10 months ago (2025-11-16 20:50 UTC)
14
1
MIT
XRootD MCP Server
File Systems Research & Data Databases
eic
A
license
A
quality
B
maintenance
An MCP server providing access to XRootD file systems, allowing LLMs to browse directories, read file metadata, and access contents via the root:// protocol. It supports advanced features like campaign discovery, file searching, and ROOT file analysis for scientific data management.
Updated 2 days ago (2026-09-05 15:43 UTC)
18
1
MIT
CERN GitLab MCP Server
Version Control CI/CD & DevOps Research & Data
MohamedElashri
A
license
A
quality
A
maintenance
An MCP server that connects LLMs to CERN GitLab to discover and analyze High Energy Physics code, documentation, and analysis examples. It provides 14 tools for repository browsing, dependency parsing, and CI/CD configuration analysis.
Updated 10 days ago (2026-08-28 22:28 UTC)
15
4
AGPL 3.0
rucio-mcp
Research & Data Data Platforms
kratsg
A
license
Not graded
quality
B
maintenance
An MCP server that exposes Rucio distributed data management operations as tools for LLMs. Designed for ATLAS physicists working with grid data on analysis facilities, but usable with any Rucio instance.
Updated 11 days ago (2026-08-28 02:33 UTC)
5
Apache 2.0

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/MohamedElashri/root-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server

Two Interfaces: MCP Server and CLI

1. MCP Server (for Claude Desktop and MCP clients)

2. ROOT CLI (root-cli)

Quick Start

1. Install

2. Configure

ROOT CLI (Recommended for LLM Interaction)

Basic Usage

Example LLM Workflow

Documentation

MCP Server

Zero-config one-liners:

Run with Claude Desktop

Architecture

Optional Native ROOT Support

Documentation

Citation

License

Available Tools

Tool Schema Changelog

Maintenance

Resources

Looking for Admin?

Related MCP Connectors

Related MCP Servers

Latest Blog Posts

MCP directory API

2. ROOT CLI (`root-cli`)