Tag 14: Code-LLM – Autocomplete und Chat in VS Code
Ziel: Ein Code-Modell auf
rke2-gpu-1liefert über den LiteLLM-AliascodeAutocomplete 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
suffixnicht. 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: chatgeneral_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-Callbackscd ~/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.pyErwartet (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.pyErwartet (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 -8Erwartet (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.internallöst nicht auf10.10.20.100auf.
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 mistralErwartet (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-outputssetzt. - Continue: Telemetrie in den Extension-Einstellungen abschalten.
Tabby:
TABBY_DISABLE_USAGE_COLLECTION=1(steht intabby.yaml). - Secrets im Code:
.continueignorebzw.onlyMyCodebegrenzen 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"}]}'
doneErwartet (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
codeeine 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.