Skip to main content
Glama

Server Configuration

Describes the environment variables required to run the server.

NameRequiredDescriptionDefault

No arguments

Instructions

Guidance the server publishes about itself, which clients place ahead of the tool catalog so the model reads it before choosing anything.

Runs local Python projects as background jobs on Kaggle's free machines. Jobs run on Kaggle, independent of this session: submit_job returns immediately. To be notified when a job finishes, run the shell command kjob wait <job_id> in the background (it polls every 60s and exits when the job is done), then call job_output. Job state is kept locally, so after a session restart list_jobs shows earlier jobs. Runs are capped at 12 h: for longer work the script checkpoints into its cwd, and when job_output reports incomplete, submit the same job again with resume_from=.

Capabilities

Features and capabilities supported by this server

Protocol revision2025-11-25

CapabilityDetails
tools
{
  "listChanged": false
}
prompts
{
  "listChanged": false
}
resources
{
  "subscribe": false,
  "listChanged": false
}

Tools

Functions exposed to the LLM to take actions

NameDescription
submit_jobA

Run a Python project on Kaggle as a private background job; returns immediately.

The project's code (excluding .git, virtualenvs, caches and data_dir) is bundled; on Kaggle
`entry` runs as `__main__` with cwd=/kaggle/working. Files written there become the job's
output (limit ~20 GB). If the project has requirements.txt it is pip-installed first
(needs internet=True). Each run is limited to 12 hours.

Args:
    project_dir: Local project directory.
    entry: Script to run, relative to project_dir (e.g. "train.py").
    data_dir: Optional local directory uploaded as a private dataset for this job only.
        On Kaggle its path is in env var KJOB_DATA_DIR. Subdirectories are uploaded zipped.
    datasets: Existing Kaggle dataset refs ("owner/slug") to attach, mounted under
        /kaggle/input. Use upload_dataset for data shared by many jobs.
    gpu: Request a GPU (counts against the weekly GPU quota).
    internet: Allow network access (pip installs, downloads).
    ephemeral: Delete the job's kernel, outputs and per-job dataset from Kaggle after
        job_output downloads them, so Kaggle storage does not fill up.
    resume_from: job_id of a finished job whose output (e.g. checkpoints) this job continues
        from; on Kaggle its path is in env var KJOB_RESUME_DIR (read-only).
    time_limit_h: Stop the run after this many hours (max 12, Kaggle's cutoff) so its
        output is saved. Env var KJOB_DEADLINE holds the deadline as epoch seconds; the run
        is stopped there if the script has not exited, and job_output reports incomplete.
job_statusB

Current status of a job: queued, running, complete, error or cancel_*.

list_jobsA

All jobs submitted from this machine, newest first. refresh=True asks Kaggle for status.

job_logsB

stdout/stderr of a job's latest run (last tail_chars characters; 0 = all).

Kaggle usually publishes the log only after the run finishes.
job_outputA

Download a finished job's output files (default: <project_dir>/kaggle_out/<job_id>/).

For ephemeral jobs the kernel and its per-job dataset are then deleted from Kaggle, unless
the run stopped at its time limit (incomplete): then it is kept so a new job can resume it.
cleanup_jobA

Delete a finished job's kernel (with its outputs) and per-job dataset from Kaggle.

upload_datasetA

Upload a local directory as a private Kaggle dataset to reuse across jobs.

Pass the returned ref in submit_job(datasets=[...]). Not deleted automatically;
use delete_dataset when done.
list_datasetsB

Datasets uploaded with upload_dataset that still exist.

delete_datasetA

Delete a dataset created by upload_dataset. Refuses if an unfinished job uses it.

Prompts

Interactive templates invoked by user choice

NameDescription

No prompts

Resources

Contextual data attached and managed by the client

NameDescription

No resources

TDQS

A3.7/5.0

Scored across 9 tools

Disambiguation4/5

Each tool maps to a distinct action in the job or dataset lifecycle, and descriptions clarify the boundaries between look-alike pairs (job_status vs list_jobs, job_logs vs job_output). The only mild overlap is cleanup_job, which deletes a kernel plus its per-job dataset, versus delete_dataset for uploaded datasets — but the descriptions make that distinction explicit.

Naming Consistency4/5

Eight of nine names follow a predictable snake_case verb_noun pattern (submit_job, list_jobs, upload_dataset, delete_dataset). The read-side tools (job_status, job_logs, job_output) drop the verb and lead with the noun, a minor but noticeable inconsistency in an otherwise clean scheme.

Tool Count5/5

Nine tools is well scoped: six cover the remote job lifecycle and three cover reusable datasets, with no filler. Nothing looks redundant or missing from a count perspective.

Completeness4/5

The job lifecycle (submit, status, list, logs, output, cleanup) and dataset lifecycle (upload, list, delete) are both well covered. The notable gap is cancellation — job_status reports cancel_* states, yet there is no tool to cancel a running job, forcing reliance on time_limit_h.

Maintenance

ActivityMaintained
ResponsivenessNo recent community issues