Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 14: Code-LLM – Autocomplete und Chat in VS Code

Ziel: Ein Code-Modell auf rke2-gpu-1 liefert über den LiteLLM-Alias code Autocomplete und Chat in VS Code – gemessen, mit eigenem Virtual Key und ohne dass Code das Netz verlässt. · Dauer: ca. 150 min · Voraussetzung: Tag 13

Briefing

  • FIM (Fill-in-the-Middle): Der Editor schickt Code vor und nach dem Cursor in einem Rohprompt mit Spezial-Tokens an /v1/completions. Ziel: < 500 ms bis zum Vorschlag, sonst tippt der Mensch schneller.
  • Chat/Edit: normale Chat-Requests an /v1/chat/completions, Sekunden sind okay.
  • vLLM unterstützt den OpenAI-Parameter suffix nicht. Den FIM-Prompt baut deshalb der Client (Continue, Tabby) – mit den Tokens des Modells.
  • Modell: Qwen/Qwen2.5-Coder-7B-Instruct-AWQ – Apache-2.0, ca. 5,6 GB, kann FIM und Chat.
VS Code (Continue) --HTTPS--> llm.lab.internal (Traefik) --> LiteLLM "code"
  FIM:  POST /v1/completions        <|fim_prefix|>…<|fim_suffix|>…<|fim_middle|>
  Chat: POST /v1/chat/completions             --> vllm-code.ki-models:8000

Drill 1: Modell wählen – Lizenz und VRAM

Modell Lizenz (Stand 10/2026) Gewichte Passt auf L4 24 GB?
Qwen2.5-Coder-7B-Instruct-AWQ Apache-2.0 ca. 5,6 GB ja, neben Chat und Embed
Qwen2.5-Coder-1.5B (Base) Apache-2.0 ca. 3 GB (BF16) ja, reines FIM, sehr schnell
Qwen2.5-Coder-3B Qwen Research License ca. 6 GB nur nicht-kommerziell
Codestral 22B Mistral Non-Production License ca. 44 GB (BF16) nein; Produktion nur mit Kauflizenz
Devstral Small (24B) Apache-2.0 ca. 47 GB (BF16) nur quantisiert und allein; für Agenten statt FIM

Achtung: Lizenzen ändern sich. Prüfe vor dem Einsatz die Model Card auf Hugging Face – „open weights” heißt nicht automatisch „kommerziell nutzbar”.

Rechne das GPU-Budget nach (Qwen2.5-7B: 28 Layer, 4 KV-Heads, Head-Dim 128):

python3 -c '
gpu=24*0.33; w=5.6; ovh=1.0
kv=2*28*4*128*2
tok=(gpu-w-ovh)*1024**3/kv
print(f"KV pro Token: {kv/1024:.0f} KiB, KV-Budget: {gpu-w-ovh:.1f} GB, "
      f"Tokens: {tok:,.0f}")
print(f"parallel bei 8192: {tok/8192:.1f}, bei 1500 (Autocomplete): {tok/1500:.0f}")'

Erwartet:

KV pro Token: 56 KiB, KV-Budget: 1.3 GB, Tokens: 24,716
parallel bei 8192: 3.0, bei 1500 (Autocomplete): 16

Warum? Mit 33 % der L4 reicht der KV-Cache für etwa 16 gleichzeitige Autocomplete-Requests – genug für ein kleines Team. Mehr Entwickler brauchen eine eigene GPU für code.

Fortschritt speichern? Kostenlos registrieren

Drill 2: GPU umverteilen und vllm-code starten

Chat 0.80 + Embed 0.12 (Tag 13) lassen keinen Platz. Neues Budget: Chat 0.50, Embed 0.12, Code 0.33.

mkdir -p ~/ki-lab/tag14 && cd ~/ki-lab/tag14
export KUBECONFIG=~/ki-lab/rke2.yaml
kubectl -n ki-models get deploy vllm-chat \
  -o jsonpath='{.spec.template.spec.containers[0].args[3]}{"\n"}'
kubectl -n ki-models patch deploy vllm-chat --type=json -p '[
  {"op": "replace", "path": "/spec/template/spec/containers/0/args/2",
   "value": "--max-model-len=8192"},
  {"op": "replace", "path": "/spec/template/spec/containers/0/args/3",
   "value": "--gpu-memory-utilization=0.50"},
  {"op": "add", "path": "/spec/template/spec/containers/0/args/-",
   "value": "--kv-cache-dtype=fp8"}]'
kubectl -n ki-models rollout status deploy/vllm-chat --timeout=15m
kubectl apply -f ~/ki-lab/code/code-llm/vllm-code.yaml
kubectl -n ki-models rollout status deploy/vllm-code --timeout=15m
kubectl -n ki-models get pods -l 'app in (vllm-chat,vllm-embed,vllm-code)'

Erwartet (gekürzt, kann je nach Version abweichen):

--gpu-memory-utilization=0.80
deployment.apps/vllm-chat patched
deployment "vllm-chat" successfully rolled out
persistentvolumeclaim/vllm-code-cache created
deployment.apps/vllm-code created
service/vllm-code created
deployment "vllm-code" successfully rolled out
NAME                          READY   STATUS    RESTARTS   AGE
vllm-chat-7f9c8d6b4-qx2lm     1/1     Running   0          6m
vllm-code-5b7d9f8c6-h4k2p     1/1     Running   0          4m
vllm-embed-6c8f7d5b9-m3n8r    1/1     Running   0          1d

Warum? Die Reihenfolge zählt: Erst muss vllm-chat Speicher freigeben, dann startet vllm-code. Andersherum bricht vllm-code mit „not enough free memory” ab. Mit nur noch 50 % der L4 passt eine 16k-Sequenz (rund 2,3 GiB KV-Cache) nicht mehr in den Cache – vLLM würde mit „max seq len” abbrechen. Deshalb halbiert der Patch --max-model-len auf 8192 und speichert den KV-Cache in FP8. Trage alle drei Änderungen auch in code/vllm/vllm-chat.yaml ein, sonst setzt der nächste kubectl apply den alten Wert zurück.

Fortschritt speichern? Kostenlos registrieren

Drill 3: FIM direkt am Modell

kubectl -n ki-models port-forward svc/vllm-code 8002:8000 >/dev/null 2>&1 &
sleep 2
jq -n --arg p $'def is_even(n: int) -> bool:\n    return ' --arg s $'\n' '{
  model: "qwen2.5-coder-7b", max_tokens: 16, temperature: 0,
  prompt: ("<|fim_prefix|>" + $p + "<|fim_suffix|>" + $s + "<|fim_middle|>")}' \
  > fim.json
curl -s localhost:8002/v1/completions -H 'Content-Type: application/json' \
  -d @fim.json | jq '{text: .choices[0].text, usage}'
jq '.suffix = "\n" | .prompt = "def is_even(n: int) -> bool:\n    return "' fim.json \
  | curl -s localhost:8002/v1/completions -H 'Content-Type: application/json' \
  -d @- | jq -c '.error // .choices[0].text'

Erwartet (gekürzt, kann je nach Version abweichen):

{
  "text": "n % 2 == 0",
  "usage": {
    "prompt_tokens": 18,
    "total_tokens": 25,
    "completion_tokens": 7
  }
}
{"message":"suffix is not currently supported", ...}

Warum? Der erste Request ist echtes FIM: Das Modell füllt genau die Lücke und hört auf. Der zweite nutzt den OpenAI-Parameter suffix – vLLM lehnt ihn ab. Darum braucht jeder Client ein Prompt-Template mit den FIM-Tokens des Modells.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Alias code und Team-Key

Ergänze in ~/ki-lab/code/litellm-prod/config.yaml die Einträge aus code/code-llm/litellm-models-code.yaml (code; embed hast du an Tag 13 schon) und schalte die Speicherung von Prompts ab:

  - model_name: code
    litellm_params:
      model: hosted_vllm/qwen2.5-coder-7b     # --served-model-name
      api_base: http://vllm-code.ki-models:8000/v1
      timeout: 30
    model_info:
      mode: chat
general_settings:
  store_prompts_in_spend_logs: false   # Default, hier explizit für das Audit
litellm_settings:
  turn_off_message_logging: true       # keine Prompts an Logging-Callbacks
cd ~/ki-lab/code/litellm-prod
kubectl -n ki-gateway create configmap litellm-config --from-file=config.yaml \
  --dry-run=client -o yaml | kubectl apply -f -
kubectl -n ki-gateway rollout restart deploy/litellm
kubectl -n ki-gateway rollout status deploy/litellm
export LITELLM_MASTER_KEY=sk-lab-master-1234          # Lab-Wert
H=(-H "Authorization: Bearer $LITELLM_MASTER_KEY" -H 'Content-Type: application/json')
API=https://llm.lab.internal
TEAM=$(curl -s $API/team/new "${H[@]}" -d '{"team_alias": "team-code",
  "models": ["code", "embed"], "max_budget": 30, "budget_duration": "30d",
  "rpm_limit": 600}' | jq -r .team_id)
CODE_KEY=$(curl -s $API/key/generate "${H[@]}" -d "{\"team_id\": \"$TEAM\",
  \"key_alias\": \"thomas-vscode\", \"models\": [\"code\", \"embed\"]}" \
  | jq -r .key)
echo "${CODE_KEY:0:6}..."
curl -s $API/v1/completions -H "Authorization: Bearer $CODE_KEY" \
  -H 'Content-Type: application/json' -d @<(jq '.model = "code"' fim.json) \
  | jq -r '.model, .choices[0].text'

Erwartet (gekürzt, kann je nach Version abweichen):

configmap/litellm-config configured
deployment "litellm" successfully rolled out
sk-Xa1...
code
n % 2 == 0

Warum? Autocomplete erzeugt pro Entwickler schnell 20–60 Requests pro Minute. Das Team-Limit rpm_limit: 600 schützt die GPU vor einem kaputten Plugin. Für code gibt es bewusst keinen Fallback auf chat-large-eu: Quellcode verlässt das Netz nie.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Latenz messen mit code_eval.py

code/code-llm/code_eval.py schickt drei FIM-Aufgaben (Python, Python, YAML) und zwei Chat-Fragen über LiteLLM, misst Time-to-first-Token (TTFT) und Gesamtzeit und prüft einfache Erwartungen. Zuerst die Gegenprobe auf dem Laptop gegen LiteLLM aus Tag 4, dort zeigt code auf ein Chat-Modell:

source ~/ki-lab/.venv/bin/activate && pip install -q openai
LITELLM_URL=http://127.0.0.1:4000/v1 LITELLM_KEY=sk-lab-master-1234 \
  RUNS=3 FIM_P95_MS=3000 python ~/ki-lab/code/code-llm/code_eval.py

Erwartet (Laptop, Ollama mit ministral-3:3b, Werte schwanken):

Modell: code  FIM-Stil: qwen  Läufe: 3
Art     TTFT p50  TTFT p95  Total p50  Total p95
FIM        579ms     708ms     1836ms     2078ms
Chat       566ms     628ms     2777ms     4610ms
Treffer: 4/11
✔ FIM p95 2078ms (Ziel ≤ 3000ms)

Nur 4 von 11 Treffern: Ein Chat-Modell kennt die FIM-Tokens nicht und plaudert los („Here’s the completed function…“). Mit DEBUG=1 siehst du die Rohantworten. Jetzt gegen das echte Code-Modell:

export SSL_CERT_FILE=~/ki-lab/lab-ca.crt
LITELLM_URL=$API/v1 LITELLM_KEY=$CODE_KEY RUNS=10 \
  python ~/ki-lab/code/code-llm/code_eval.py

Erwartet (L4, gekürzt, kann je nach Version und Last abweichen):

Modell: code  FIM-Stil: qwen  Läufe: 10
Art     TTFT p50  TTFT p95  Total p50  Total p95
FIM         45ms      90ms      160ms      310ms
Chat        60ms     120ms     3900ms     5200ms
Treffer: 30/32
✔ FIM p95 310ms (Ziel ≤ 500ms)
Kennzahl Ziel Autocomplete Stellschraube
TTFT p95 < 150 ms Prefix-Caching, kurzer Prompt (maxPromptTokens)
Total p95 < 500 ms max_tokens 32–64, kleineres Modell (1.5B)
Fehlerquote < 1 % eigene GPU-Slots, rpm_limit pro Team

Warum? Die Zeit misst das Skript ab dem Absenden des Requests. vLLM schickt die HTTP-Header erst mit dem ersten Token – wer ab der Antwort misst, sieht eine TTFT nahe 0 ms.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Continue in VS Code

Continue liest ~/.continue/config.yaml (Format schema: v1; config.json ist veraltet) und Secrets aus ~/.continue/.env.

mkdir -p ~/.continue
[ -f ~/.continue/config.yaml ] && cp ~/.continue/config.yaml ~/.continue/config.yaml.bak
sed "s|__HOME__|$HOME|g" ~/ki-lab/code/code-llm/continue-config.yaml \
  > ~/.continue/config.yaml
printf 'LITELLM_CODE_KEY=%s\n' "$CODE_KEY" > ~/.continue/.env
chmod 600 ~/.continue/.env
grep -nE 'model:|roles:|- (chat|autocomplete|embed)$|caBundlePath' \
  ~/.continue/config.yaml | head -8

Erwartet (Home-Pfad weicht ab):

10:    model: code
14:      caBundlePath: /Users/thomas/ki-lab/lab-ca.crt
15:    roles:
16:      - chat
24:    model: code
28:      caBundlePath: /Users/thomas/ki-lab/lab-ca.crt
30:    roles:
31:      - autocomplete

Die wichtigen Stellen im Autocomplete-Modell:

Schlüssel Wert Warum
useLegacyCompletionsEndpoint true FIM geht an /v1/completions, nicht an Chat
promptTemplates.autocomplete Qwen-FIM-Tokens Continue erkennt das Modell am Namen – code verrät nichts
requestOptions.caBundlePath ~/ki-lab/lab-ca.crt Lab-CA für llm.lab.internal
autocompleteOptions.debounceDelay 250 ms erst nach einer Tipp-Pause anfragen

Test in VS Code: Extension „Continue” installieren, neue Datei test.py, def fib(n): tippen und kurz warten – ein grauer Vorschlag erscheint, Tab übernimmt ihn. Im Chat-Panel (Cmd+L) Modell „Lab Code (Chat)” wählen. Gleichzeitig im Cluster:

kubectl -n ki-gateway logs deploy/litellm --since=2m | grep -c 'POST /v1/completions'

Erwartet: eine Zahl > 0 (ein Request pro Tipp-Pause).

Tipp: Bleibt Autocomplete stumm, öffne Ausgabe → Continue in VS Code. „fetch failed” heißt fast immer: CA-Pfad falsch oder llm.lab.internal löst nicht auf 10.10.20.100 auf.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Tabby als Alternative

Tabby ist ein eigener Server mit Web-UI, Benutzerverwaltung und Plugins für VS Code und JetBrains. Hier nutzt er keine eigene GPU, sondern dieselben LiteLLM-Aliase.

cd ~/ki-lab/tag14
kubectl create namespace ki-code --dry-run=client -o yaml | kubectl apply -f -
TABBY_KEY=$(curl -s $API/key/generate "${H[@]}" -d "{\"team_id\": \"$TEAM\",
  \"key_alias\": \"tabby\", \"models\": [\"code\", \"embed\"]}" | jq -r .key)
sed "s|__LITELLM_TABBY_KEY__|$TABBY_KEY|" \
  ~/ki-lab/code/code-llm/tabby-config.toml > config.toml
kubectl -n ki-code create secret generic tabby-config --from-file=config.toml
rm config.toml
kubectl apply -f ~/ki-lab/code/code-llm/tabby.yaml
kubectl -n ki-code rollout status deploy/tabby --timeout=5m
curl -s https://code.lab.internal/v1/health | jq '{model, chat_model, version}'

Erwartet (gekürzt, kann je nach Version abweichen):

namespace/ki-code created
secret/tabby-config created
persistentvolumeclaim/tabby-data created
deployment.apps/tabby created
service/tabby created
ingress.networking.k8s.io/tabby created
deployment "tabby" successfully rolled out
{
  "model": "code",
  "chat_model": "code",
  "version": { "git_describe": "v0.32.0", ... }
}

Danach https://code.lab.internal öffnen, Admin-Konto anlegen und im VS-Code-Plugin „Tabby” Server-URL und persönliches Token eintragen.

Kriterium Continue Tabby
Betrieb nur Client-Konfiguration Server mit DB, Benutzern, Token
Konfiguration config.yaml pro Entwickler zentral config.toml
Repo-Kontext lokal im Editor Server indiziert Git-Repos
Auswertung über LiteLLM-Keys eigene Nutzungsstatistik plus LiteLLM

Warum? Für ein kleines Team reicht Continue: nichts zu betreiben, Governance über Virtual Keys. Tabby lohnt sich, wenn ihr zentral steuern wollt, wer welche Repos als Kontext bekommt.

Fortschritt speichern? Kostenlos registrieren

Drill 8: Governance – kein Code verlässt das Netz

kubectl apply -f ~/ki-lab/code/code-llm/netpol.yaml
kubectl -n default run np-test --rm -i --restart=Never \
  --image=curlimages/curl:8.16.0 -- curl -s -m 5 -o /dev/null \
  -w '%{http_code}\n' http://vllm-code.ki-models:8000/health || echo "blockiert"
kubectl -n ki-gateway exec deploy/litellm -- python -c "import urllib.request as u
print(u.urlopen('http://vllm-code.ki-models:8000/health').status)"
grep -A5 'model_name: code' ~/ki-lab/code/litellm-prod/config.yaml \
  | grep -c mistral

Erwartet (gekürzt, kann je nach Version abweichen):

networkpolicy.networking.k8s.io/vllm-code-ingress created
networkpolicy.networking.k8s.io/tabby-egress created
000
blockiert
200
0

Warum? Cilium setzt Kubernetes-NetworkPolicies durch: Nur LiteLLM (und Prometheus) erreichen vllm-code. Damit läuft jeder Code-Request über LiteLLM – mit Key, Budget und Audit. grep -c mistral = 0 belegt: Für code gibt es keinen externen Fallback.

Die Logging-Policy fürs Team, kurz und schriftlich:

  • LiteLLM speichert Metadaten (Key, Modell, Tokens, Dauer), keine Prompts: store_prompts_in_spend_logs: false, turn_off_message_logging: true.
  • vLLM loggt keine Prompts, solange niemand --enable-log-requests (plus DEBUG-Level) oder --enable-log-outputs setzt.
  • Continue: Telemetrie in den Extension-Einstellungen abschalten. Tabby: TABBY_DISABLE_USAGE_COLLECTION=1 (steht in tabby.yaml).
  • Secrets im Code: .continueignore bzw. onlyMyCode begrenzen den Kontext, ersetzen aber keinen Secret-Scanner im CI.

Fortschritt speichern? Kostenlos registrieren

Drill 9: Ausblick Agentic Coding mit Leitplanken

Agenten wie Cline (VS-Code-Extension) oder OpenHands (eigener Server mit Sandbox-Containern) lesen Dateien, führen Befehle aus und rufen das Modell in Schleifen auf – 50–200 Requests pro Aufgabe sind normal. Beide sprechen die OpenAI-API, also https://llm.lab.internal/v1 mit einem eigenen Key.

AGENT_KEY=$(curl -s $API/key/generate "${H[@]}" -d "{\"team_id\": \"$TEAM\",
  \"key_alias\": \"agent-thomas\", \"models\": [\"code\"], \"max_budget\": 2,
  \"budget_duration\": \"1d\", \"rpm_limit\": 30, \"max_parallel_requests\": 2,
  \"metadata\": {\"use\": \"agentic\"}}" | jq -r .key)
curl -s "$API/key/info" -H "Authorization: Bearer $AGENT_KEY" \
  | jq -c '.info | {key_alias, max_budget, rpm_limit, max_parallel_requests}'

Erwartet (kann je nach Version abweichen):

{"key_alias":"agent-thomas","max_budget":2,"rpm_limit":30,"max_parallel_requests":2}
Leitplanke Umsetzung
Kosten und Last eigener Key: Tagesbudget, rpm_limit, max_parallel_requests
Ausführung Agent nur im Devcontainer bzw. OpenHands-Sandbox, nie auf dem Host mit Produktions-Kubeconfig
Freigaben Cline: „Auto-approve” für Befehle aus; jede Shell-Aktion bestätigen
Schreibrechte eigener Git-Branch, Merge nur per Review; keine Push-Rechte auf main
Modell 7B reicht für Autocomplete, für Agenten eher 24B+ (Devstral) auf eigener GPU

Warum? Ein Agent mit Shell-Zugriff ist ein Benutzer mit deinen Rechten, der schnell tippt. Die Leitplanken gehören in Infrastruktur (Key, Sandbox, Branch-Schutz), nicht in den Prompt.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

#!/usr/bin/env bash
ok() { echo "✔ $1"; }; nok() { echo "✘ $1"; }
kubectl -n ki-models rollout status deploy/vllm-code --timeout=10s >/dev/null 2>&1 \
  && ok "vllm-code läuft" || nok "vllm-code läuft"
curl -s $API/v1/completions -H "Authorization: Bearer $CODE_KEY" \
  -H 'Content-Type: application/json' -d @<(jq '.model = "code"' fim.json) \
  | jq -e '.choices[0].text | test("%")' >/dev/null \
  && ok "FIM über LiteLLM" || nok "FIM über LiteLLM"
LITELLM_URL=$API/v1 LITELLM_KEY=$CODE_KEY RUNS=5 \
  python ~/ki-lab/code/code-llm/code_eval.py >/dev/null \
  && ok "FIM p95 ≤ 500 ms" || nok "FIM p95 ≤ 500 ms"
kubectl -n ki-models get networkpolicy vllm-code-ingress >/dev/null 2>&1 \
  && ok "NetworkPolicy vllm-code" || nok "NetworkPolicy vllm-code"
curl -sf https://code.lab.internal/v1/health >/dev/null \
  && ok "Tabby erreichbar" || nok "Tabby erreichbar"
grep -q 'LITELLM_CODE_KEY=sk-' ~/.continue/.env \
  && ok "Continue-Key gesetzt" || nok "Continue-Key gesetzt"

Challenge

Eine Werkstudentin soll nur Autocomplete bekommen, kein Chat: ein Key, der nur /v1/completions darf, 30 Requests pro Minute, gültig 30 Tage.

Hinweis: /key/generate kennt neben models auch allowed_routes und duration.

Lösung

WS_KEY=$(curl -s $API/key/generate "${H[@]}" -d "{\"team_id\": \"$TEAM\",
  \"key_alias\": \"werkstudentin\", \"models\": [\"code\"], \"rpm_limit\": 30,
  \"duration\": \"30d\", \"allowed_routes\": [\"/v1/completions\",
  \"/completions\"]}" | jq -r .key)
for ep in completions chat/completions; do
  curl -s -o /dev/null -w "$ep: %{http_code}\n" $API/v1/$ep \
    -H "Authorization: Bearer $WS_KEY" -H 'Content-Type: application/json' \
    -d '{"model": "code", "prompt": "x", "max_tokens": 1,
         "messages": [{"role": "user", "content": "x"}]}'
done

Erwartet (doc-geprüft, kann je nach Version abweichen):

completions: 200
chat/completions: 401

In Continue bekommt dieser Key nur das Modell mit roles: [autocomplete].

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Ab etwa 15 aktiven Entwicklern bekommt code eine eigene GPU; Autocomplete und Agenten trennt ihr über zwei Aliase und zwei vLLM-Deployments.
  • Continue-Konfiguration zentral verteilen (MDM, Dotfiles-Repo); Keys pro Person aus dem Self-Service (LiteLLM-UI mit SSO), nie geteilte Team-Keys.
  • Lizenzprüfung als Freigabeprozess: Modell, Version, Lizenztext und Hash der Gewichte im Modellregister ablegen.
  • Betriebsrat und Datenschutz: Metadaten pro Person (wer wie viel) sind Leistungsdaten – Auswertung nur aggregiert pro Team.
  • Agentic Coding nur in Sandboxes ohne Zugriff auf Produktions-Secrets; OpenHands-Runtime-Container mit eigener NetworkPolicy.