Skip to main content
Glama

dtu-hpc

Let your coding agent run your DTU HPC jobs — without ever giving it a shell.

dtu-hpc connects MCP-capable agents (Claude Code, Codex, and others) to the DTU Computing Center cluster through a small, audited set of operations. You authenticate once a day; your agent submits, monitors, chains, and diagnoses LSF jobs while you direct the research. No SSH terminal, no Cisco VPN in your daily loop, and no interactive shell on the login node — every action the agent can take is a named, argument-validated operation under limits it cannot raise.

Why not just give the agent SSH?

Because your student account is personally accountable for everything that happens on a shared, rationed cluster — and agents are already being used over raw SSH today, with no guardrails at all. This tool is the safer path for something that is happening anyway:

  • No shell on the login node. Agents choose from named operations (submit job, check queue, fetch logs). Every argument is validated. There is no "run this command", and agents never supply script text — they send a spec, and the trusted daemon writes the job script itself.

  • Jailed writes. Agents can only touch approved project folders, with paths re-checked after the server resolves them, so a planted symlink can't escape. Your dotfiles and SSH keys are structurally out of reach.

  • Hard limits the agent cannot raise. GPUs, cores, memory, walltime, chain length, concurrent jobs, and submissions per hour, enforced inside the credentialed daemon from a file outside your project. Raising one takes a human edit plus a restart.

  • Audit trail. Every action — including every denied one — is logged locally. You can always answer "what did my agent do on the cluster?"

  • One kill switch. All access flows through one daemon on your laptop. Stop it and every agent loses cluster access instantly. (Jobs already queued keep running on DTU — dtu-hpc down tells you which, so you can cancel them first if that's what you meant.)

  • Nothing installed on the cluster. DCC sees ordinary SSH sessions and ordinary, well-formed job submissions. No daemons on login nodes.

  • No telemetry. This tool never phones home. Your usage data is yours.

Related MCP server: omp-worker-mcp

What your agent gets good at

DCC runs LSF, which most tutorials (and most LLMs) get wrong — they emit SLURM syntax the cluster rejects, or omit the flags that silently kill jobs at 15 minutes and 1 GB of RAM. The templates here encode the cluster's real rules, including the one that matters most for ML work:

GPU jobs die at 24 hours. dtu-hpc treats longer runs as first-class: hpc_submit_chain splits a 72-hour training run into three checkpointed, dependency-linked segments that resume from each other, with LSF signalling your trainer ten minutes before each kill so it can flush a checkpoint.

Architecture

Claude Code / Codex        agents: disposable, hold no secrets
        │  stdio (MCP)
   dtu-hpc MCP server      stateless adapter
        │  loopback + per-run token
      dtuhpcd              you type your password HERE, once — nowhere else
        │  one persistent SSH session
 login.hpc.dtu.dk → LSF    cluster sees a normal user session

Setup (once)

# Not on PyPI yet — install from source:
git clone https://github.com/PV-Bhat/dtu-hpc-mcp && cd dtu-hpc-mcp
python -m venv .venv && .venv/Scripts/activate     # Linux/macOS: source .venv/bin/activate
pip install -e .
dtu-hpc init               # key setup + cluster install + agent config snippets

init walks you through installing an SSH key on the cluster (you type your DTU password into OpenSSH's own prompt — this tool never sees it). After that, the VPN is no longer needed for cluster work.

Daily use

dtu-hpc up                 # start the control plane, authenticate once
dtu-hpc status             # check it
dtu-hpc audit              # see everything your agents did
dtu-hpc down               # revoke all agent access

Then talk to your agent:

"Run the GRPO config on 2 A100s with a 4-hour budget, and chase it — if it OOMs, halve the batch size and resubmit."

What this does NOT protect against

Being straight about the boundary, because the audience is students staking a real account: a batch job is arbitrary code running as you on a compute node. That is what a batch job is on every cluster. This tool bounds what gets submitted — resources, destinations, rate — and records all of it. It does not sandbox the code inside your job, and an agent that can submit jobs effectively has your Unix account on the compute nodes. The audit log is a plain file, so it is evidence against a confused agent, not a hostile one. Run this with agents you'd trust with your cluster account, and read the log.

Safety model in one paragraph

The daemon holds the only credential and the only connection. Agents reach it through a token-gated loopback socket and can only invoke allowlisted operations with regex-validated arguments. Writes are confined to declared project roots, re-validated after the server resolves symlinks. Job scripts are rendered by the daemon from a spec — agents never supply shell — and are checked against ceilings held outside the project tree, so a profile an agent can edit cannot raise them. Every operation, parameter, and denial is appended to a local audit log. Killing one process revokes access.

Status

Early but real: read, sync, submit, and chain paths all work and have been exercised against DCC. Five independent code reviews (2026-07) found and fixed a class of bugs where resource limits were enforced in the wrong process; see DESIGN.md §2 for what changed and why.

Known gaps, honestly: there is no durable run ledger yet, so a run's story lives across a manifest, the scheduler, and logs rather than one place. Human approval above thresholds is currently asserted by the agent rather than confirmed through a trusted channel. Artifact fetch (pulling results back) isn't built. There are no tests yet.

Issues and PRs welcome — especially from other DTU students. If you run a cluster and want a backend for it, lsf.py is the template to copy.

For DCC / HPC support staff

This tool submits standard bsub jobs from a standard SSH session and runs nothing on your infrastructure. It exists to make agent-assisted usage more conservative than manual usage: validated scripts, capped resources, no login-node compute, full local audit. We'd welcome your review of the operation allowlist — open an issue or reach out.

Troubleshooting

Login failing? Read docs/AUTH.md first. The short version: outside the DTU VPN the cluster requires an SSH key and your password, so a missing key looks exactly like a wrong password. Turn on the VPN, start the daemon, press Enter at the passphrase prompt, type your DTU password.

Available Tools

20 tools
hpc_auditB

Recent control-plane actions, newest last.

Args: limit: How many entries to return.

Inputs: limit. Returns: result

hpc_cancelA

Cancel one LSF job. Only cancel jobs this project submitted.

Args: job_id: Numeric LSF job id.

Inputs: job_id (required). Returns: result

hpc_fetch_logA

Read a log or small text file from inside the project jail (tail semantics).

Args: path: Absolute remote path, must be under an allowed project root. max_bytes: How much of the end of the file to return (cap 512KB).

Inputs: path (required), max_bytes. Returns: result

hpc_gpu_entitlementA

Report which GPU queues this account may submit to, and their caps.

Use this before designing any GPU experiment: walltime ceilings and per-user slot limits determine whether a run must be split into a checkpointed chain.

Inputs: no named parameters. Returns: result

hpc_gpu_modelsA

Live GPU models and availability in a queue. Use before A100 jobs: gpua100 mixes 40GB and 80GB nodes and there is NO selector to force 80GB.

Args: queue: GPU queue name (e.g. "gpua100").

Inputs: queue (required). Returns: result

hpc_gpu_nodesB

Current GPU node availability.

Inputs: no named parameters. Returns: result

hpc_job_efficiencyA

CPU and memory efficiency of a job vs. what it requested. Check this after every substantial run and tighten the next request accordingly.

Args: job_id: Numeric LSF job id.

Inputs: job_id (required). Returns: result

hpc_job_historyB

Scheduling history for one job -- why it pended, why it exited.

Args: job_id: Numeric LSF job id.

Inputs: job_id (required). Returns: result

hpc_jobsB

All of this user's LSF jobs, including recently finished ones.

Inputs: no named parameters. Returns: result

hpc_job_statusA

Full detail for one job.

Args: job_id: Numeric LSF job id.

Inputs: job_id (required). Returns: result

hpc_operationsB

List every cluster operation the policy layer permits, with parameters.

Inputs: no named parameters. Returns: result

hpc_pending_reasonA

Why a pending job is pending, in the scheduler's own words.

Args: job_id: Numeric LSF job id.

Inputs: job_id (required). Returns: result

hpc_queuesA

List LSF queues, or show full limits for one queue.

Args: queue: Optional queue name (e.g. "gpua100"). Omit to list all queues.

Inputs: queue. Returns: result

hpc_quotaB

Storage quotas for home and work3.

Inputs: no named parameters. Returns: result

hpc_render_jobA

Render the LSF job script a submission WOULD use, without submitting.

Use this to show the human a script before the first run of a new profile.

Args: profile_path: Path to the local profile YAML. run_id: Short identifier for this run (e.g. "exp03"). resource_overrides: Optional JSON object overriding profile resources, e.g. '{"walltime": "04:00", "gpus": 1}'.

Inputs: run_id (required), profile_path (required), resource_overrides. Returns: result

hpc_statusA

Check whether the DTU control plane is authenticated and connected.

Call this first in any session. If it reports the daemon is unavailable, the user must start and authenticate it themselves -- you cannot do it for them.

Inputs: no named parameters. Returns: result

hpc_submit_chainA

Submit a checkpoint-resume chain of dependent jobs for runs longer than the 24h GPU walltime cap. The training command must support --resume-from and checkpoint on SIGUSR2 -- verify this BEFORE submitting.

Args: profile_path: Path to the local profile YAML. run_id: Short identifier; segments become <run_id>.0, <run_id>.1, ... project_dir: Local project directory for manifests. segments: Number of walltime-sized segments (total = segments x walltime). resource_overrides: Optional JSON object overriding profile resources. confirmed_by_user: Set ONLY after explicit human approval when above the profile's confirmation thresholds. Chains are always above the 12h default threshold in total, so this usually requires asking.

Inputs: run_id (required), segments (required), project_dir (required), profile_path (required), +2 more. Returns: result

hpc_submit_runA

Submit a single job from a profile. Caps are enforced; runs above the profile's confirmation thresholds require an explicit yes from the human.

Args: profile_path: Path to the local profile YAML. run_id: Short identifier for this run. Also names the local manifest. project_dir: Local project directory (manifests land in runs/<run_id>/). resource_overrides: Optional JSON object overriding profile resources. confirmed_by_user: Set ONLY after the human explicitly approved an above-threshold run in conversation.

Inputs: run_id (required), project_dir (required), profile_path (required), confirmed_by_user, +1 more. Returns: result

hpc_sync_projectA

Upload the project's source files to its remote root on the cluster.

Run this BEFORE submitting, whenever local code has changed — the connector does not upload anything automatically, and a job will happily run stale code. Source and configs only: files over 4MB are refused, and datasets or model weights must go via the transfer node or be downloaded by the job.

Args: profile_path: Path to the local profile YAML (its sync_include / sync_exclude patterns decide what is sent). project_dir: Local project directory to upload from. dry_run: List what would be uploaded without sending anything.

Inputs: project_dir (required), profile_path (required), dry_run. Returns: result

hpc_whoamiA

Identity, groups, login node and home directory on the DTU cluster.

Inputs: no named parameters. Returns: result

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4/5.0

    Scored across 20 tools

    Disambiguation5/5

    Each tool has a clearly distinct purpose: audit, cancel, status, fetch_log, operations, whoami, quota, queues, gpu_entitlement, gpu_nodes, jobs, job_status, job_history, sync_project, job_efficiency, gpu_models, pending_reason, render_job, submit_run, submit_chain. Even closely related tools like gpu_entitlement, gpu_nodes, and gpu_models address different aspects (permissions, availability, models).

    Naming Consistency5/5

    All tools follow the consistent pattern 'hpc_<verb>_<noun>' or 'hpc_<noun>_<verb>' in snake_case, with no mixing of conventions. The prefix 'hpc_' unifies the set and each verb clearly indicates the action.

    Tool Count5/5

    20 tools cover the major aspects of HPC cluster interaction (authentication, job submission, monitoring, GPU info, file sync, etc.) without being overwhelming. Each tool serves a unique function and the count is well-scoped for the domain.

    Completeness5/5

    The tool set provides comprehensive coverage for the HPC workflow: authentication, quota, queues, job lifecycle (submit, cancel, monitor, efficiency), GPU management, file synchronization, and audit. There are no obvious gaps for typical cluster operations.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • F
      license
      A
      quality
      C
      maintenance
      An MCP server that enables LLMs to execute Python code on GPU-accelerated compute nodes within SLURM-managed HPC environments. It bridges local clients to remote clusters by launching JupyterLab sessions via SLURM jobs to facilitate high-performance notebook-based computation.
      7
      -
    • F
      license
      Not graded
      quality
      D
      maintenance
      Enables agents to connect to remote MCP servers once, access their tools through a compact MCP endpoint, pair a CLI inside sandboxes, and create watches that turn command or tool output into pollable structured events.
      2
      -
    • A
      license
      Not graded
      quality
      B
      maintenance
      Enables agent clients to safely connect to tools and execution resources through MCP with authorization, approvals, audit, chat-context isolation, SSH/Docker access, and long-running command session tracking.
      MIT