dtu-hpc
The dtu-hpc server provides secure, audited access to the DTU HPC LSF cluster for job submission, monitoring, and management, along with account and file operations. It includes safety features like resource limits, jailed file access, and audit logging.
Connection and account: Check control plane status (
hpc_status), list available operations (hpc_operations), view user identity/group/quotas (hpc_whoami,hpc_quota).Queue and GPU discovery: List queues (
hpc_queues), view GPU entitlements and caps (hpc_gpu_entitlement), check current GPU node availability and models per queue (hpc_gpu_nodes,hpc_gpu_models).Project file management: Upload project files with size limits (
hpc_sync_project) and fetch logs or text files (hpc_fetch_log).Job submission: Render job scripts for preview (
hpc_render_job), submit single jobs (hpc_submit_run) or checkpoint-resumed chains (hpc_submit_chain) with resource caps and user confirmation for high-threshold jobs.Job monitoring and diagnosis: List user's jobs including finished ones (
hpc_jobs), get detailed status/history (hpc_job_status,hpc_job_history), see pending reasons (hpc_pending_reason), and check CPU/memory efficiency (hpc_job_efficiency).Job control and auditing: Cancel jobs (
hpc_cancel) and review an audit log of all actions (hpc_audit).
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@dtu-hpc Submit a training job on 2 A100 GPUs for 4 hours."
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.
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 downtells 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 sessionSetup (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 snippetsinit 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 accessThen 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 toolshpc_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
Scored across 20 tools
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).
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.
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.
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
Related MCP Connectors
MCP gateway and cloud hosting for MCP servers, agents and apps like RAG, managed from your agent.
Hosted MCP server for task-first delegation to remote workstations and workers.
- aXDeprecatedio.github.ax-platform
Agent-native collaboration network: orchestrate a team of long-running agents from any MCP client.
Run and manage H Company's Computer-Use Agents from any MCP client.
Related MCP Servers
- FlicenseAqualityCmaintenanceAn 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-
- AlicenseNot gradedqualityCmaintenanceLets coding agents delegate bounded background tasks to OMP models via an MCP server, with job control, custom roles and agents.74 npmMIT
- FlicenseNot gradedqualityDmaintenanceEnables 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-
- AlicenseNot gradedqualityBmaintenanceEnables 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