Qwen Code

Qwen Code je AI asistent na programovanie, ktorý sa spúšťa v termináli. Číta a upravuje súbory, vykonáva príkazy a odpovedá na otázky týkajúce sa zdrojového kódu.

V infraštruktúre SAV sa spúšťa v kontajneri Singularity na prihlasovacom uzle a pripája sa k modelu, ktorý si sami prevádzkujete na GPU uzle. Najskôr pripravte server podľa dokumentu Spúšťanie LLM pomocou vLLM.

Rýchly štart

cd ~/llm 
sbatch submit_llm.sh                    # start the model server
bash agent.sh <workspace>               # pick a session, then work

agent.sh sa opýta, ktorú reláciu chcete použiť, nájde bežiacu úlohu servera, zistí pridelený uzol a port, otvorí SSH tunel, počká na načítanie modelu a spustí agenta. Po ukončení agenta sa tunel zatvorí.

Qwen Code session:

  1) Continue last session
  2) Start new session
  3) Select previous session
  4) List sessions
  5) Exit

Select [1]:

Po skončení práce uvoľnite GPU:

scancel JOB_ID

---

Nastavenie

Najskôr musíte dokončiť nastavenie servera: potrebujete ~/llm/config.env, API kľúč v ~/.llm_api_key a možnosť spustiť server. Potom pripravte ďalšie dva súbory:

chmod +x ~/llm/agent.sh

Skontrolujte, či premenná QWEN_SIF_X86 v súbore config.env odkazuje na globálny obraz alebo na vlastný obraz uložený v projektovom adresári.

Následne vytvorte dva súbory používateľského účtu, ktoré kontajner potrebuje. Základný obraz neobsahuje záznam o vašom UID a príkazy SLURM v kontajneri sa nebudú vedieť autentifikovať, kým kontajner nedokáže identifikovať používateľa a jeho skupinu:

getent passwd root "$USER"      > ~/llm/.container_passwd
getent group  root "$(id -gn)"  > ~/llm/.container_group

Ak sa údaje vášho účtu zmenia, vytvorte ich znova. V kontajneri sa nimi prekryjú súbory /etc/passwd a /etc/group — pozrite časť Pripojené adresáre a súbory.

---

Používanie

agent.sh [WORKSPACE] [MODE] [-j JOBID] [-- ARGS...]

  WORKSPACE   directory to work in (default: current directory)
  MODE        --continue, --new, --resume or --list
              With no MODE, an interactive menu is shown.
  -j JOBID    vLLM job to connect to (default: the only running one)
  -- ARGS     everything after -- is passed to qwen verbatim

~/llm/agent.sh                      # menu, current directory
~/llm/agent.sh --continue           # straight back into the last session
~/llm/agent.sh ~/my-project --new   # new session, in that workspace
~/llm/agent.sh --list               # list sessions; no GPU needed
~/llm/agent.sh -j 123456 --resume   # pick which server to use
~/llm/agent.sh -- --help            # arguments passed through to qwen

Režimy relácií

Režim	Funkcia
--continue	Pokračuje v najnovšej relácii pre tento pracovný adresár.
--new	Spustí úplne novú reláciu.
--resume	Otvorí vlastný výber relácie v Qwen Code.
--list	Zobrazí uložené relácie a ukončí program.
(bez režimu)	Zobrazí interaktívne menu; kláves Enter vyberie Pokračovať.

Stav relácie sa ukladá do pracovného adresára, ktorý agent.sh pripája do kontajnera. Relácie preto zostávajú zachované medzi jednotlivými spusteniami aj medzi rôznymi úlohami servera. Ak úloha servera dosiahne časový limit, spustite novú úlohu a pomocou --continue pokračujte tam, kde ste skončili.

--list nevyžaduje GPU

Zobrazenie relácií nepoužíva model, preto agent.sh úplne preskočí výber úlohy, vytvorenie tunela aj čakanie na pripravenosť servera. Zoznam sa zobrazí okamžite, aj keď nebeží žiadna úloha vLLM.

---

Priebeh spúšťacieho skriptu

Skript agent.sh vykonáva tieto kroky:

1. Parses the command line — workspace, session mode, job ID, and anything after -- to pass through verbatim.
2. Resolves the session mode, showing the menu if none was given. This happens before anything connects, so the menu appears at once rather than after the model has loaded.
3. Picks the server job — unless the mode needs no server. With no job ID it looks for exactly one running job named vllm; if there are several it prints them and stops rather than guessing, because connecting to the wrong model is confusing and silent.
4. Reads the metadata for that job to learn the node and port, and verifies the job is still running before trusting it, so a stale file produces a clear error instead of a hanging tunnel.
5. Allocates a local port the same way the server does, so several agent sessions can run side by side on one login node.
6. Otvorí tunel na pozadí a nastaví obsluhu ukončenia, ktorá ho zatvorí.
7. Waits for readiness by polling /v1/models until the model has finished loading — up to five minutes — while checking the tunnel is still alive.
8. Launches Qwen Code in the chosen workspace, with the cluster bind mounts that give it access to SLURM.

Metadáta sa parsujú, nikdy sa nenačítavajú pomocou source

Pomocná funkcia field() získava hodnoty pomocou sed a názov uzla aj port pred použitím overuje. Súbor vytvorený úlohou v runtime adresári tak nemôže spustiť kód s oprávneniami používateľa.

~/llm/agent.sh

#!/bin/bash
# Open a tunnel to a running vLLM job and start Qwen Code against it.
#
#   ./agent.sh                      # menu, current directory
#   ./agent.sh --continue           # resume the most recent session
#   ./agent.sh ~/proj --new         # new session in ~/proj
#   ./agent.sh --list               # list sessions; no server needed
#   ./agent.sh -j 123456 --resume   # choose the server job
#   ./agent.sh -- --help            # pass arguments to qwen
set -euo pipefail

source "${LLM_HOME:-$HOME/llm}/config.env"
: "${KEY:?No API key. Create ~/.llm_api_key -- see config.env.}"

usage() {
    cat <<EOF
Usage: ${0##*/} [WORKSPACE] [MODE] [-j JOBID] [-- ARGS...]

  WORKSPACE   directory to work in (default: current directory)
  MODE        --continue, --new, --resume or --list
              With no MODE, an interactive menu is shown.
  -j JOBID    vLLM job to connect to (default: the only running one)
  -- ARGS     everything after -- is passed to qwen verbatim
EOF
}

# ---- Command line ------------------------------------------------------
JOB_ID=""
WORKSPACE=""
MODE=""
PASSTHRU=()

while [[ $# -gt 0 ]]; do
    case "$1" in
        -j) JOB_ID="${2:?-j needs a job ID}"; shift 2 ;;
        -h|--help) usage; exit 0 ;;
        --) shift; PASSTHRU=("$@"); break ;;
        --*) MODE="$1"; shift ;;
        *)  if [[ -n "$WORKSPACE" ]]; then
                echo "Unexpected argument: $1" >&2; usage >&2; exit 1
            fi
            WORKSPACE="$1"; shift ;;
    esac
done

WS="${WORKSPACE:-$PWD}"
if [[ ! -d "$WS" ]]; then
    echo "No such directory: $WS" >&2
    exit 1
fi
WORKSPACE="$(cd "$WS" && pwd)"

# -----------------------------------------------------------------------
# Select Qwen session mode
#
#   --continue   Resume the most recent session for this workspace.
#   --new        Start a completely new session.
#   --resume     Open Qwen's session selector.
#   --list       List available sessions.
#
# With no option, present an interactive menu.
#
# Resolved before anything connects, so the menu appears immediately
# rather than after the model has finished loading.
# -----------------------------------------------------------------------
NEEDS_SERVER=1

case "$MODE" in

    --continue)
        QWEN_ARGS=(--continue)
        ;;

    --new)
        QWEN_ARGS=()
        ;;

    --resume)
        QWEN_ARGS=(--resume)
        ;;

    --list)
        # Listing sessions needs no model, so skip the tunnel.
        QWEN_ARGS=(sessions list)
        NEEDS_SERVER=0
        ;;

    "")
        if [[ ! -t 0 ]]; then
            echo "Not a terminal. Pass --continue, --new," >&2
            echo "--resume or --list explicitly." >&2
            exit 1
        fi

        echo
        echo "Qwen session:"
        echo
        echo "  1) Continue last session"
        echo "  2) Start new session"
        echo "  3) Select previous session"
        echo "  4) List sessions"
        echo "  5) Exit"
        echo
        read -r -p "Select [1]: " CHOICE || CHOICE=1

        # Pressing Enter selects the default.
        CHOICE=${CHOICE:-1}

        case "$CHOICE" in
            1)
                QWEN_ARGS=(--continue)
                ;;
            2)
                QWEN_ARGS=()
                ;;
            3)
                QWEN_ARGS=(--resume)
                ;;
            4)
                QWEN_ARGS=(sessions list)
                NEEDS_SERVER=0
                ;;
            5)
                exit 0
                ;;
            *)
                echo "Invalid selection." >&2
                exit 1
                ;;
        esac
        ;;

    *)
        echo "Unknown option: $MODE" >&2
        echo
        usage >&2
        exit 1
        ;;
esac

# ---- Image -------------------------------------------------------------
# The Qwen Code image is built for x86_64 only, which is what the login
# and CPU nodes are. Fail here rather than inside singularity.
if [[ "$(uname -m)" != "x86_64" ]]; then
    echo "This node is $(uname -m); the Qwen Code image is x86_64 only." >&2
    echo "Run agent.sh from a login node." >&2
    exit 1
fi
QWEN_SIF="${QWEN_SIF_X86:?QWEN_SIF_X86 is not set}"

if [[ "$NEEDS_SERVER" == "1" ]]; then

    # ---- Pick the job --------------------------------------------------
    # $USER is not exported in every environment, and set -u would abort.
    ME="${USER:-$(id -un)}"

    if [[ -z "$JOB_ID" ]]; then
        mapfile -t jobs < <(squeue -u "$ME" -n vllm -h -t RUNNING -o '%i')

        case ${#jobs[@]} in

            0)  echo "No running vLLM job. Start one: sbatch submit_llm.sh" >&2
                exit 1 ;;
            1)  JOB_ID="${jobs[0]}" ;;
            *)  echo "Several vLLM jobs are running. Pass -j JOBID:" >&2
                squeue -u "$ME" -n vllm -t RUNNING -o '%.10i %.9T %.14R %.11L' >&2
                exit 1 ;;
        esac
    fi

    # ---- Read its metadata ---------------------------------------------
    META="$LLM_RUNTIME/$JOB_ID.job"
    if [[ ! -r "$META" ]]; then
        echo "No metadata for job $JOB_ID. It may still be starting up." >&2
        echo "Watch it with: tail -f $LLM_LOGS/vllm-$JOB_ID.log" >&2
        exit 1
    fi

    # Parsed, never sourced: this file should not be able to run code.
    field() { sed -n "s/^$1=//p" "$META" | head -n1; }
    NODE=$(field NODE)
    SERVER_PORT=$(field SERVER_PORT)
    SERVED_MODEL=$(field SERVED_MODEL)

    if ! squeue -h -j "$JOB_ID" -t RUNNING -o '%i' | grep -qx "$JOB_ID"; then
        echo "Job $JOB_ID is no longer running; metadata is stale." >&2
        exit 1
    fi
    if [[ ! "$NODE" =~ ^[A-Za-z0-9._-]+$ || ! "$SERVER_PORT" =~ ^[0-9]+$ ]]; then
        echo "Malformed metadata in $META" >&2
        exit 1
    fi

    # ---- Tunnel --------------------------------------------------------
    LOCAL_PORT=$(python3 -c 'import socket; s=socket.socket(); s.bind(("127.0.0.1", 0)); print(s.getsockname()[1]); s.close()')

    ssh -o ExitOnForwardFailure=yes -o BatchMode=yes -N \
        -L "127.0.0.1:$LOCAL_PORT:127.0.0.1:$SERVER_PORT" "$NODE" &
    SSH_PID=$!
    cleanup() {
        kill "$SSH_PID" 2>/dev/null || true
        wait "$SSH_PID" 2>/dev/null || true
    }
    trap cleanup EXIT INT TERM

    # ---- Wait for the model to finish loading --------------------------
    BASE="http://127.0.0.1:$LOCAL_PORT"
    ready=0
    for _ in $(seq 150); do
        if ! kill -0 "$SSH_PID" 2>/dev/null; then
            echo "SSH tunnel to $NODE died." >&2
            exit 1
        fi
        if curl -fsS -m 2 -H "Authorization: Bearer $KEY" \
                "$BASE/v1/models" >/dev/null 2>&1; then
            ready=1; break
        fi
        sleep 2
    done
    if [[ $ready -ne 1 ]]; then
        echo "Server did not answer within 5 minutes." >&2
        echo "Check the log: tail -f $LLM_LOGS/vllm-$JOB_ID.log" >&2
        exit 1
    fi
    echo "Connected to '$SERVED_MODEL' on $NODE:$SERVER_PORT"

    export OPENAI_BASE_URL="$BASE/v1"
    export OPENAI_API_KEY="$KEY"
    export OPENAI_MODEL="$SERVED_MODEL"
fi

# ---- Launch ------------------------------------------------------------
LAUNCH=()

if [[ ${#QWEN_ARGS[@]} -gt 0 ]]; then LAUNCH+=("${QWEN_ARGS[@]}"); fi
if [[ ${#PASSTHRU[@]}  -gt 0 ]]; then LAUNCH+=("${PASSTHRU[@]}");  fi


# The last four binds and the PATH are what let the agent use SLURM from
# inside the container -- see "Bind mounts". Without them sbatch, srun
# and squeue fail to authenticate.
#
# No 'exec': the EXIT trap must still run to close the tunnel.
# ${LAUNCH[@]+...} guards against older bash treating an empty array as
# unset under set -u.

ml singularity

singularity exec \
    --bind "$WORKSPACE:$WORKSPACE" \
    --bind "$HOME:$HOME" \
    --bind "$LLM_PROJECT:$LLM_PROJECT" \
    --bind /run/munge:/run/munge \
    --bind /var/spool/slurmd/conf-cache:/etc/slurm \
    --bind "$LLM_HOME/.container_passwd:/etc/passwd" \
    --bind "$LLM_HOME/.container_group:/etc/group" \
    --pwd "$WORKSPACE" \
    --env "PATH=/usr/local/bin:/opt/agent_env/bin:/opt/slurm/bin:/opt/slurm/sbin:/usr/bin:/bin" \
    "$QWEN_SIF" qwen ${LAUNCH[@]+"${LAUNCH[@]}"}

Pripojenie SLURM na clustri Devana

Na clustri Devana je potrebné pripojiť SLURM nasledovne -- bind /etc/slurm:/etc/slurm & --env "PATH=/usr/local/bin:/opt/agent_env/bin:$HOME/.local/bin:/usr/bin:/bin"

---

Zodpovedné používanie agentov

Programovací agent vykonáva príkazy. V prostredí clustra to má dva dôležité dôsledky:

Beží na prihlasovacom uzle, ale má prístup k SLURM. Keďže agent.sh pripája do kontajnera socket Munge a konfiguráciu SLURM, agent môže sám spúšťať príkazy sbatch, srun, squeue a scancel. Požiadajte ho, aby úlohu odoslal do SLURM namiesto priameho spustenia zostavenia. Náročné výpočty tak prebehnú na výpočtových uzloch, nie na zdieľanom prihlasovacom uzle.

> compile this and run the test suite -- submit it with sbatch to the
> cpu partition under account number <project_ID>, then check the job's output

Všetky príkazy, ktoré agent vykoná priamo, sa stále spúšťajú na prihlasovacom uzle. Dlhšiu interaktívnu reláciu preto môžete spustiť aj v rámci úlohy:

srun --account=<project_ID> --partition=cpu --time=1:00:00 --pty bash
~/llm/agent.sh

Agent môže odosielať úlohy na účet vašej alokácie

Výpočtové zdroje vášho účtu môže čerpať bez ďalšieho potvrdenia. V zadaniach presne určujte partition a časové limity. Ak si nie ste istí, aké úlohy spustil, skontrolujte ich príkazom squeue -u "$USER".

Agent skutočne upravuje súbory

Zadajte mu pracovný adresár alebo ho spustite v projektovom adresári, nie v $HOME. Projekt spravujte pomocou systému na správu verzií, aby ste mohli vykonané zmeny skontrolovať a vrátiť späť. Opatrne používajte režimy s automatickým schvaľovaním akcií — agent pracuje podľa vášho zadania, stále však ide o model.

---

Pripojené adresáre a súbory

Singularity nesprístupňuje automaticky všetky cesty hostiteľského systému. Skript agent.sh pripája sedem ciest; posledné štyri umožňujú agentovi odosielať a monitorovať vlastné SLURM úlohy:

Pripojenie	Dôvod
$WORKSPACE	Adresár, v ktorom agent pracuje
$HOME	Konfigurácia agenta a uložený stav relácií
$LLM_PROJECT	Zdieľané kontajnery a vyrovnávacia pamäť modelov
/run/munge	Autentifikačný socket Munge. Bez neho každý príkaz SLURM v kontajneri zlyhá s chybou prihlasovacích údajov
/var/spool/slurmd/conf-cache → /etc/slurm	Konfigurácia clustra Perun, aby klienti SLURM vedeli, s ktorým riadiacim uzlom komunikovať
/etc/slurm → /etc/slurm	Konfigurácia clustra Devana, aby klienti SLURM vedeli, s ktorým riadiacim uzlom komunikovať
.container_passwd → /etc/passwd	Základný obraz neobsahuje záznam o vašom UID; Munge a SLURM potrebujú identifikovať váš účet podľa mena
.container_group → /etc/group	Rovnaký účel pre vašu primárnu skupinu

Parameter --env PATH následne pridá /opt/slurm/bin a /opt/slurm/sbin do vyhľadávacej cesty, aby boli dostupné príkazy sbatch, srun, squeue a scancel, spolu s /opt/agent_env/bin, kde je nainštalovaný Qwen Code.

Najskôr vytvorte súbory passwd a group

Ide o dva malé súbory, ktoré vytvoríte jednorazovo. Ak neexistujú, pripojenie zlyhá. Pozrite časť Nastavenie.

Obraz s rovnakými prístupovými právami možno spustiť aj manuálne:

ml singularity

singularity exec \
    --bind "$PWD:$PWD" \
    --bind "$HOME:$HOME" \
    --bind /project/p2075-26-2:/project/p2075-26-2 \
    --bind /run/munge:/run/munge \
    --bind /var/spool/slurmd/conf-cache:/etc/slurm \
    --bind "$HOME/llm/.container_passwd:/etc/passwd" \
    --bind "$HOME/llm/.container_group:/etc/group" \
    --pwd "$PWD" \
    --env "PATH=/usr/local/bin:/opt/agent_env/bin:/opt/slurm/bin:/opt/slurm/sbin:/usr/bin:/bin" \
    qwen-code.sif qwen

Pripojenie SLURM na clustri Devana

Na clustri Devana je potrebné pripojiť SLURM nasledovne -- bind /etc/slurm:/etc/slurm & --env "PATH=/usr/local/bin:/opt/agent_env/bin:$HOME/.local/bin:/usr/bin:/bin"

API kľúče, SSH kľúče ani tokeny nikdy nevkladajte priamo do obrazu. Každý, kto má prístup k súboru .sif, ich z neho môže získať.

Vytvorenie obrazu agenta

Predpripravené obrazy obsahujú Qwen Code. Vlastný obraz vytvorte, ak potrebujete inú verziu, ďalšie nástroje alebo úplne iného agenta. Obraz obsahuje iba agenta a jeho runtime; váhy modelu zostávajú vo vyrovnávacej pamäti servera.

qwen-code.def

Bootstrap: docker
From: ubuntu:24.04

%labels
    Description Qwen Code client

%environment
    export LANG=C.UTF-8
    export LC_ALL=C.UTF-8

%post
    set -e
    apt-get update
    DEBIAN_FRONTEND=noninteractive apt-get install -y \
        ca-certificates curl git nodejs npm
    npm install --global @qwen-code/qwen-code@0.2.1
    apt-get clean
    rm -rf /var/lib/apt/lists/*

%runscript
    exec qwen "$@"

Použite konkrétnu verziu namiesto označenia latest, aby bolo možné obraz neskôr znovu vytvoriť v rovnakej podobe. Ak je verzia Node.js v distribúcii príliš stará pre požadované vydanie, nainštalujte v sekcii %post konkrétnu verziu Node.js.

Recept na vytvorenie obrazu qwen-code.sif nájdete v adresári /apps/images/vllm/x86_64 na clustri Perun a v /storage-apps na clustri Devana.

Vytvorenie, testovanie a inštalácia

singularity build qwen-code.sif qwen-code.def
singularity exec qwen-code.sif qwen --version

Vytvorenie obrazu vyžaduje zvýšené oprávnenia a prístup k sieti na stiahnutie základného obrazu a balíkov. Obraz preto vytvorte na vlastnom počítači s rovnakou architektúrou a následne ho skopírujte na cluster.

Prihlasovacie a CPU uzly clustra Perun používajú architektúru x86_64, GPU uzly aarch64 (všetky uzly clustra Devana používajú x86_64). Keďže agent beží na prihlasovacom uzle, zvyčajne potrebujete iba obraz x86_64 — agent.sh vyberie zodpovedajúci obraz podľa výstupu uname -m.

Nikdy neprepisujte obraz, ktorý sa práve používa

Bežiaca úloha môže mať obraz otvorený a nemusíte vedieť, ktorej relácie spôsobíte výpadok. Do názvu súboru uveďte verziu a dátum a následne aktualizujte konfiguráciu.

Použitie iného programovacieho agenta

Okrem obrazu, názvu spustiteľného súboru, príznakov relácie a premenných prostredia nie je tento postup špecifický pre Qwen Code. Ak chcete spustiť iného agenta:

1. Vytvorte preň obraz SIF podľa inštalačných pokynov daného agenta. Obraz obsahuje iba konkrétneho agenta; jeden obraz nemôže spustiť iného.
2. Skopírujte agent.sh, napríklad do ~/llm/aider.sh, a upravte štyri časti: premenné s cestami k obrazom, príkaz qwen na konci skriptu, blok case pre režimy relácií a exporty OPENAI_*, ak agent používa iné premenné.
3. Pridajte cesty k jeho obrazom do config.env vedľa premenných Qwen Code.

Pred výberom agenta skontrolujte dve veci:

• Ktoré premenné používa. Nie každý agent využíva OPENAI_BASE_URL. Niektoré používajú premenné ANTHROPIC_*, iné vyžadujú konfiguračný súbor uložený v $HOME.
• Ktoré API vyžaduje. vLLM poskytuje OpenAI API, preto klient, ktorý podporuje iba Anthropic API, potrebuje prekladový proxy server; nestačí zmeniť názvy premenných.

Podpora volania nástrojov, streamovania a štruktúrovaného výstupu sa líši medzi agentmi aj modelmi. Každú novú kombináciu preto pred nasadením dôkladne otestujte.

Keď pribudne ďalší agent

Ak neskôr pribudne tretí agent, bude vhodné presunúť spoločné časti agent.sh do jedného skriptu s konfiguráciou pre jednotlivých agentov. Pri jedinom agentovi by takéto riešenie prinieslo iba zbytočnú zložitosť.

---

Riešenie problémov

Problémy na strane servera — úloha sa nespustí, model sa nenačíta alebo chýba pamäť GPU — sú opísané na stránke vLLM. Najskôr overte samotný server. Ak odpovedá na požiadavky curl, problém sa nachádza v tejto časti.

`Unknown option: --foo`

Zadaný režim relácie skript agent.sh nepodporuje. Dostupné režimy sú --continue, --new, --resume a --list. Argumenty určené priamo pre Qwen Code uveďte až za oddeľovačom --:

~/llm/agent.sh -- --some-qwen-flag

Menu sa nezobrazuje

agent.sh zobrazuje výzvu iba pri spustení v termináli. Pri spustení zo skriptu alebo z rúry vyžaduje explicitné zadanie režimu, aby automatizované spustenie nezostalo čakať na vstup, ktorý nikdy nepríde.

`agent.sh` hlási, že metadáta neexistujú

Úloha servera ešte nedospela do fázy zverejnenia portu alebo počas spúšťania skončila:

squeue -u "$USER"
tail -50 ~/llm/jobs/vllm-JOBID.log

Úloha v stave PD čaká vo fronte; nejde o chybu.

Server sa nepripraví

agent.sh čaká päť minút. Pri veľkom modeli môže načítanie z prázdnej vyrovnávacej pamäte trvať dlhšie. Stiahnite váhy modelu vopred a potom pokus zopakujte.

Agent sa pripojí, ale nedokáže upravovať súbory

Nefunguje volanie nástrojov. Typickým prejavom je, že agent opisuje úpravy textom, ale nevykoná ich. Overte, či model podporuje volanie nástrojov, a následne skontrolujte, či TOOL_PARSER v config.env zodpovedá formátu, ktorý model generuje. Pri chybe parsovania serverový log obsahuje surový záznam volania nástroja.

Príkazy SLURM v kontajneri zlyhávajú

Zistite, ktorá časť chýba, a to priamo v tom istom kontajneri:

singularity exec \
    --bind /run/munge:/run/munge \
    --bind /var/spool/slurmd/conf-cache:/etc/slurm \
    --bind "$HOME/llm/.container_passwd:/etc/passwd" \
    --bind "$HOME/llm/.container_group:/etc/group" \
    --env "PATH=/opt/slurm/bin:/usr/bin:/bin" \
    "$QWEN_SIF_X86" squeue -u "$USER"

Pripojenie SLURM na clustri Devana

Na clustri Devana je potrebné pripojiť SLURM nasledovne -- bind /etc/slurm:/etc/slurm & --env "PATH=/usr/local/bin:/opt/agent_env/bin:$HOME/.local/bin:/usr/bin:/bin"

Prejav	Príčina
squeue: command not found	V PATH chýba /opt/slurm/bin.
Invalid user for ... alebo zlyhá whoami	Súbory passwd a group chýbajú alebo sú zastarané — vytvorte ich znova podľa časti Nastavenie.
Chyby prihlasovacích údajov alebo socketu Munge	/run/munge nie je pripojený alebo Munge na tomto uzle nebeží.
Unable to contact slurm controller	/var/spool/slurmd/conf-cache alebo /etc/slurm (podľa clustra) nie je pripojený na /etc/slurm.

Všetky zdrojové cesty musia existovať na hostiteľskom systéme. Ak niektorá chýba, Singularity zruší celé spustenie kontajnera. Nejasná chyba pri štarte preto často znamená problém s niektorým z týchto pripojení.

Reláciu nemožno obnoviť

Relácie sa ukladajú samostatne pre každý pracovný adresár, takže --continue spustené v inom adresári žiadnu reláciu nenájde. Pomocou --list zobrazíte dostupné relácie alebo pomocou --resume otvoríte ich výber. Skontrolujte aj, či je pripojený váš domovský adresár — stav relácie sa ukladá tam, nie do obrazu.

Agent sa počas relácie zastaví

Úloha servera pravdepodobne dosiahla časový limit:

sacct -j JOBID --format=JobID,State,Elapsed,Timelimit

Odošlite novú úlohu servera a znovu sa pripojte pomocou --continue. Uložené relácie zostávajú zachované, takže môžete pokračovať tam, kde ste skončili.

`This node is aarch64; the Qwen Code image is x86_64 only`

Nachádzate sa na GPU uzle. Agent sa má spúšťať na prihlasovacom uzle a k modelu pristupovať cez tunel; klientsky obraz pre aarch64 nie je k dispozícii. Prihláste sa na prihlasovací uzol a spustite agenta tam.

Ak z iného dôvodu potrebujete spustiť agenta v rámci úlohy, požiadajte o CPU partition namiesto GPU partition — tieto uzly používajú x86_64:

srun --account=p2075-26-2 --partition=cpu --time=1:00:00 --pty bash

Qwen Code v obraze chýba

singularity exec qwen-code.sif which qwen

Ak príkaz nič nevypíše, inštalácia počas vytvárania obrazu zlyhala bez zjavnej chyby alebo je program nainštalovaný mimo PATH, ktorý nastavuje agent.sh.

---

Referenčná príručka

Príkazy

Úloha	Príkaz
Menu	~/llm/agent.sh
Pokračovať v poslednej relácii	~/llm/agent.sh --continue
Nová relácia v pracovnom adresári	~/llm/agent.sh ~/proj --new
Zobraziť relácie (bez GPU)	~/llm/agent.sh --list
Vybrať úlohu servera	~/llm/agent.sh -j JOBID
Odovzdať argumenty programu	~/llm/agent.sh -- --help
Spustiť server	sbatch ~/llm/submit_llm.sh
Zastaviť server	scancel JOBID

Konfigurácia

Nastavuje sa v súbore config.env:

Premenná	Účel
QWEN_SIF_X86	Obraz Qwen Code (x86_64; prihlasovacie a CPU uzly)
LLM_PROJECT	Projektový adresár pripojený do kontajnera
KEY	API kľúč načítaný zo súboru ~/.llm_api_key

Odkazy

• Qwen Code
• documentation
• Apptainer documentation
• Serving LLMs with vLLM

Created by: Marek Štekláč