AI tools for USATLAS analysis

US ATLAS maintains a marketplace of plugins for AI coding assistants. The plugins load ATLAS-specific context into Claude Code, Cursor, and Codex: what tools exist, how they fit together, and when to use each one. In practice this means the assistant already knows that ATLAS NTuples use MeV, how to write a pyhf workspace, and how to find datasets on the grid, so you spend less time correcting it.

Installation

/plugins marketplace add usatlas/marketplace

git clone https://github.com/usatlas/marketplace.git ~/usatlas-marketplace
mkdir -p ~/.agents/skills
ln -s ~/usatlas-marketplace/plugins/atlas/skills ~/.agents/skills/atlas
ln -s ~/usatlas-marketplace/plugins/analysis-facilities/skills \
      ~/.agents/skills/analysis-facilities
ln -s ~/usatlas-marketplace/plugins/hep-python-tools/skills \
      ~/.agents/skills/hep-python-tools

Plugins

analysis-facilities

Skills for working at each USATLAS Analysis Facility.

BNL and SLAC facility skills are in progress.

atlas

The main ATLAS analysis plugin. Five subagents and 25 skills, covering everything from dataset discovery to publication-ready statistical fits.

The subagents activate when their domain comes up, or you can invoke them directly:

Skills by category:

hep-python-tools

Two skills for writing self-contained Python scripts and CLIs.

MCP servers: letting your assistant act on live systems

Everything above (the plugins) teaches your assistant how ATLAS analysis works. MCP (Model Context Protocol) goes a step further: it lets the assistant actually run things on real, live systems on your behalf, in the same conversation, instead of just describing commands for you to copy and run yourself.

For example, without MCP, you'd ask the assistant "where can I find dataset X?", it would tell you to run rucio list-file-replicas ..., and you'd copy that command, run it in a terminal, then paste the output back so it could continue. With MCP connected, the assistant runs that Rucio lookup itself and uses the real result directly — one less round trip, and no need for you to already know the right command.

AF MCP Platform (UChicago)

UChicago AF runs one such MCP server: the AF MCP Platform. It gives a connected assistant secure, on-your-behalf access to Rucio (find/download datasets), AMI (dataset metadata), HTCondor (check or submit batch jobs), your running JupyterLab notebook, and the AF filesystem — without you having to run any commands yourself.

To use it:

1. Install the af-uchicago plugin in Claude Code (see Installation above) — it already comes configured with this server, so there is nothing else to set up. (Using Cursor, Codex, or another tool, or want to connect without installing the plugin? Point it at https://mcp.af.uchicago.edu/mcp directly — see your tool's docs for how to add an MCP server by URL.) The first time it's actually used, most tools will pop open a browser window asking you to log in with your usual AF credentials — that's it, no passwords or tokens to copy anywhere.
2. Link your identity. This tells the platform which ATLAS/CERN account to act as when it talks to Rucio, AMI, or HTCondor for you. Skip this step and the connection still works, but grid-dependent tools (Rucio, AMI, HTCondor) will fail with an authentication error until you link your identity — link it before relying on those.

If your AI tool can't open a browser to log in (for example, it's running on a remote server with no display), generate a long-lived access token instead at https://mcp-portal.af.uchicago.edu/tokens/ and use it in place of the browser login. The same portal is also where you can review and manage your connection.

Jupyter (your running notebook at UChicago)

If you have a JupyterLab session running at af.uchicago.edu, your MCP client can drive it directly — listing cells, executing code, reading kernel output. The server runs inside your singleuser pod, so authentication reuses your existing notebook credential (JupyterHub API token with the access:servers scope for jupyterhub.af.uchicago.edu, or the per-pod URL token for the af.uchicago.edu/jupyterlab portal).

See Connecting an MCP client to your notebook for the full setup, including the difference in token lifetime between the two launch surfaces.

Example: Claude Code with NRP models + Jupyter MCP

Claude Code does not have to talk to Anthropic's API. You can point it at the National Research Platform (NRP) LLM endpoint to run open-weight models such as qwen3, and — in the same session — attach the Jupyter MCP server so the model can drive a live notebook. This walkthrough wires both together against a BinderHub-launched notebook.

You need three things:

1. Claude Code, configured to use NRP's LLM endpoint
2. An NRP account with an LLM API token
3. A BinderHub repo with jupyter-server-proxy and jupyter-server-mcp installed (the MCP server exposes the notebook on port 3001)

Step 1 — get an NRP LLM token

Create an account at nrp.ai, then mint an LLM token at https://nrp.ai/llmtoken/. This token is your ANTHROPIC_AUTH_TOKEN in the steps below.

Step 2 — configure Claude Code

Edit your Claude Code config (~/.claude.json or equivalent) to route requests to NRP and register the Jupyter MCP server:

{
    "env": {
        "ANTHROPIC_BASE_URL": "https://ellm.nrp-nautilus.io/anthropic",
        "ANTHROPIC_API_KEY": "YOUR_NRP_TOKEN_HERE",
        "ANTHROPIC_DEFAULT_OPUS_MODEL": "qwen3",
        "ANTHROPIC_DEFAULT_SONNET_MODEL": "qwen3",
        "ANTHROPIC_DEFAULT_HAIKU_MODEL": "qwen3",
        "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1",
        "CLAUDE_CODE_DISABLE_FEEDBACK_SURVEY": "1",
        "CLAUDE_CODE_ENABLE_TELEMETRY": "0",
        "API_TIMEOUT_MS": "3000000",
        "DISABLE_TELEMETRY": "1"
    },
    "mcpServers": {
        "jupyter": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://<YOUR_JUPYTERHUB_URL>/user/<your-username>/<your-servername>/proxy/3001/mcp?token=<YOUR_JUPYTER_TOKEN>",
                "--transport",
                "http-only"
            ]
        }
    }
}

The three model slots all map to qwen3 so every Claude Code model tier is served by the same NRP model.

Step 3 — launch a BinderHub notebook

Launch your Binder at https://binderhub.ssl-hep.org/, wait for the server to start, and note the server name from the launch URL. Once it is running, construct the MCP URL:

https://<jupyterhub-host>/user/<your-username>/<server-name>/proxy/3001/mcp?token=<token>

• The server name comes from your BinderHub launch URL.
• The token is a JupyterHub API token from https://<jupyterhub-host>/hub/token.

Plug this URL into the jupyter MCP entry from Step 2.

Step 4 — start Claude Code

Launch without triggering the Anthropic login flow:

export ANTHROPIC_AUTH_TOKEN="YOUR_NRP_TOKEN_HERE"
export ANTHROPIC_BASE_URL="https://ellm.nrp-nautilus.io/anthropic"
unset ANTHROPIC_API_KEY
claude

Reference