Agenter Coding

Agenter Coding geht über Chat und Inline-Vorschläge hinaus.
Diese Werkzeuge nutzen die Fähigkeit des Modells, mehrstufige Aufgaben autonom abzuschließen.
Das Modell kann Ihre Codebasis lesen, Dateien bearbeiten und Terminalbefehle ausführen.

Inhaltsverzeichnis

• Modellauswahl
• Continue
• OpenCode
• Claude Code (Sichere Einrichtung)
• Cline

Modellauswahl

Für agente Coding-Aufgaben empfehlen wir, mit Modellen zu beginnen, die agente Fähigkeiten besitzen. Sie können aus der vollständigen Liste der verfügbaren Modelle auswählen.

Suchen Sie nach Modellen, die für folgendes optimiert sind:

• Agenter Coding: Mehrdatei-Bearbeitung, Codebasis-Exploration
• Werkzeugnutzung: Terminalbefehle, Web-Browsing, API-Interaktionen
• Schlussfolgerung: Komplexes Problemlösen und Planung

Beim Auswahl eines Modells prüfen Sie, ob es in den Vorteilen oder der Beschreibung auf agente Aufgaben oder allgemeine Leistung verweist.
Für komplexe agente Workflows empfehlen wir Modelle mit größeren Kontextfenstern (200K+ Tokens), um umfangreiche Codebasen und längere Prompts effektiv verarbeiten zu können.

Continue (Agentenmodus)

Continue ist primär ein Werkzeug zur Code-Vervollständigung und zum Chat – siehe den Abschnitt Code-Vervollständigung für die vollständige Einrichtung und Installation.
Zusätzlich zu der Code-Vervollständigung unterstützt Continue auch agente Workflows über seinen integrierten Agentenmodus, in dem das Modell autonom Dateien lesen, Änderungen vornehmen und mehrstufige Aufgaben abschließen kann.

Um Continue für agente Aufgaben zu nutzen:

1. Öffnen Sie das Continue-Fenster in VS Code
2. Wechseln Sie im Continue-Fenster den Modus-Dropdown von Chat auf Agent
3. Senden Sie eine Aufgabe, z. B. bitten Sie es, eine Funktion zu refaktorisieren oder Fehlerbehandlung hinzuzufügen.
   Continue schlägt die Änderungen vor und bittet Sie, sie zu akzeptieren oder abzulehnen.

OpenCode

OpenCode ist ein Open-Source, terminal-first AI-Code-Agent, der Entwicklern ermöglicht, Code zu generieren, Dateien zu bearbeiten, Befehle auszuführen und Entwicklungsprozesse direkt aus dem Terminal zu automatisieren.
OpenCode unterstützt sowohl selbstgehostete als auch kommerzielle KI-Modelle über Provider-API-Schlüssel und ist daher für Teams und Entwickler geeignet, die state-of-the-art-Modelle nutzen möchten, während sie einen terminalzentrierten Workflow beibehalten.
Sein Design ist besonders gut für SSH-Sitzungen, entfernte HPC-Umgebungen, CI/CD-Pipelines und tastaturbasierte Entwicklungsumgebungen geeignet.
Dieser Abschnitt erklärt, wie Sie OpenCode mit Ihrem SAIA-API-Schlüssel konfigurieren.
Für kommerzielle Modelle siehe die Anleitung für kommerzielle Modelle.

Installation

# npm
npm install -g opencode-ai

# oder mit curl
curl -fsSL https://opencode.ai/install | bash

Nach der Installation fügen Sie OpenCode zu Ihrem PATH hinzu:

echo 'export PATH="$HOME/.opencode/bin:$PATH"' >> ~/.bashrc

Öffnen Sie ein neues Terminal und überprüfen Sie die Installation:

opencode --version

Setzen Sie Ihren API-Schlüssel

Legen Sie Ihren SAIA-API-Schlüssel als Umgebungsvariable fest:

echo 'export SAIA_API_KEY="ihr-saia-api-schlüssel"' >> ~/.bashrc

Führen Sie source ~/.bashrc aus oder öffnen Sie ein neues Terminal, damit die Änderungen wirksam werden.

Erstellen der Projekt-Konfiguration

Erstellen Sie opencode.json im Projektverzeichnis:

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "saia": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "SAIA",
      "options": {
        "baseURL": "https://chat-ai.academiccloud.de/v1",
        "apiKey": "{env:SAIA_API_KEY}"
      },
      "models": {
        "qwen3-coder-30b-a3b-instruct": {
          "name": "Qwen3 Coder 30B (SAIA)"
        },
        "devstral-2-123b-instruct-2512": {
          "name": "Devstral 2 123B (SAIA)"
        }
      }
    }
  }
}

Sie können opencode.json anpassen, um ein beliebiges Modell Ihrer Wahl auszuwählen, und sicherstellen, dass die Modell-ID genau mit den verfügbaren SAIA-Modellen übereinstimmt.

Starten

# Interaktives TUI
opencode

# Einmalige Aufgabe
opencode run "Schreibe Einheitstests für alle Funktionen in src/utils.py"

Modelle

Modi

• Plan-Modus: Erstellen strukturierter Pläne für komplexe mehrstufige Aufgaben, Überprüfen und Anpassen der Schritte vor der Ausführung
• Build-Modus: Ausführen genehmigter Pläne, Ausführen von Automatisierungen und Erstellen von Workflows

Grundbefehle

Hinzufügen von Kontext

Während einer Aufgabe

Weitere Informationen finden Sie in der offiziellen Dokumentation.

OpenCode in VS Code

Wenn Sie lieber in Ihrem Editor bleiben möchten, läuft die OpenCode-Extension den gleichen OpenCode-Agenten.
Sie verwendet dieselbe opencode.json und SAIA-Konfiguration wie oben beschrieben, sodass keine zusätzliche Einrichtung erforderlich ist.

1. Öffnen Sie die Extensions-Ansicht ( Strg + Shift + X unter Linux, Cmd + Shift + X unter macOS).
2. Suchen Sie nach OpenCode und installieren Sie es.
3. Starten Sie VS Code neu. OpenCode öffnet sich in einem Panel neben Ihrem Editor, wo Sie Aufgaben genauso wie im Terminal ausführen können.

Optional: SAIA-Modell-Plugin

Anstatt Modelle manuell in opencode.json aufzulisten, können Sie ein Plugin installieren, das Ihre SAIA-Modellliste automatisch aktuell hält.
Beim Start von OpenCode holt es im Hintergrund die aktuelle Modellliste von der SAIA-API und fügt sie Ihrer globalen Konfiguration hinzu, sodass neue Modelle ohne manuelle Bearbeitung erscheinen.

Es ist hier verfügbar: opencode-saia-plugin.

Stellen Sie sicher, dass SAIA_API_KEY gesetzt ist (siehe Setzen Sie Ihren API-Schlüssel), und folgen Sie den Einrichtungsschritten im Repository. Es holt die aktuelle Modellliste von der SAIA-API und generiert eine opencode.json mit allen verfügbaren Modellen, kategorisiert (Schlussfolgerung, Code, Vision, agente usw.).

OpenCode in einem gesicherten Container (empfohlen)

Für die lokale Entwicklung empfehlen wir, OpenCode in einem Container auszuführen.
Der Container mountet nur Ihr aktuelles Projektverzeichnis, sodass der Agent Ihre Projektdateien lesen und bearbeiten kann, aber keine Befehle ausführen kann, die Dateien außerhalb Ihres Systems beeinflussen.
Dies ist die empfohlene, sichere Methode, um OpenCode lokal zu nutzen.

Sie erstellen das Image einmal und verwenden es dann in jedem Projekt.
Das Image ist generisch und nicht an ein bestimmtes Projekt gebunden und stört kein vorhandenes Dockerfile Ihres Projekts.

Voraussetzungen: Docker oder Podman auf Ihrem System installiert.

Einmalige Einrichtung

Sie führen diese vier Schritte nur einmal aus.

1. Erstellen Sie eine Datei namens Dockerfile (Großbuchstabe D, keine Erweiterung) in einem beliebigen Ordner Ihrer Wahl (erstellen Sie einen mit mkdir opencode-sandbox).
Dies ist der Standardname, den Docker standardmäßig verwendet.
Ein anderer Name wie dockerfile (klein) oder Dockerfile.txt kann dazu führen, dass das Build-Prozess es nicht findet, also bleiben Sie bei Dockerfile.
Fügen Sie den folgenden Code in Ihre Dockerfile ein:

FROM node:20-slim

# Installieren von OpenCode
RUN npm install -g opencode-ai

WORKDIR /workspace
CMD ["opencode"]

Wenn Ihre Projekte eine bestimmte Sprachlaufzeit benötigen (z. B. Python oder Python mit uv), fügen Sie diese hier hinzu, bevor Sie das Image bauen.
Der Container hat nur das, was Sie hier installieren.

2. Erstellen Sie das Image. Gehen Sie in den Ordner, der die Dockerfile enthält, und führen Sie aus:

cd opencode-sandbox      # der Ordner, in dem Sie die Dockerfile gespeichert haben
docker build -t opencode-sandbox .

Das . bedeutet „baue mit der Dockerfile im aktuellen Ordner“, sodass Sie den Pfad nicht eingeben müssen. (Ersetzen Sie docker durch podman, falls Sie Podman verwenden.) Sie wiederholen diesen Schritt nur, wenn Sie die Dockerfile ändern.

Bestätigen Sie, dass das Image erstellt wurde:

docker images | grep opencode-sandbox

3. Fügen Sie das run-opencode-Alias hinzu. Das Alias muss in Ihrer Shell-Konfigurationsdatei geschrieben werden (das Tippen einmal am Prompt dauert nur für dieses Terminal).
Hier ist die einzeilige Version, die alte Aliase entfernt und das saubere Alias in ~/.bashrc hinzufügt:

sed -i '/alias run-opencode=/d' ~/.bashrc && cat >> ~/.bashrc << 'EOF'
alias run-opencode='docker run -it --rm --user "$(id -u):$(id -g)" -e HOME=/tmp -e SAIA_API_KEY="$SAIA_API_KEY" -v "$PWD":/workspace -w /workspace opencode-sandbox'
EOF

4. Laden Sie Ihre Shell neu, damit das Alias verfügbar ist:

source ~/.bashrc      # oder: source ~/.zshrc

Überprüfen Sie, ob das Alias registriert ist:

alias run-opencode

Dies sollte die Alias-Definition zurückgeben. Wenn ja, ist die Einrichtung abgeschlossen.

Verwendung in einem Projekt

Dies ist das, was Sie jedes Mal tun, wenn Sie an einem Projekt arbeiten möchten.
Beachten Sie, dass Sie run-opencode aus dem Projekt heraus ausführen, das Sie bearbeiten möchten, nicht aus dem Sandbox-Ordner, in dem Sie das Image gebaut haben.

1. Stellen Sie sicher, dass Ihr API-Schlüssel in der aktuellen Shell gesetzt ist (siehe Setzen Sie Ihren API-Schlüssel):

echo $SAIA_API_KEY      # sollte Ihren Schlüssel ausgeben, nicht leer sein

2. Gehen Sie in das Projekt, das Sie bearbeiten möchten, und stellen Sie sicher, dass es eine opencode.json enthält (die SAIA-Konfiguration aus Erstellen der Projekt-Konfiguration):

cd ~/pfad/zu/ihrem/projekt

Platzieren Sie opencode.json im Stammverzeichnis des Projekts (dem Ordner, aus dem Sie run-opencode ausführen).
Der Container mountet diesen Ordner als Arbeitsverzeichnis, sodass OpenCode die Konfiguration automatisch erkennt.
Eine globale/Heim-Konfiguration auf Ihrem Host ist im Sandbox nicht sichtbar, daher benötigt jedes Projekt seine eigene.

3. Starten Sie den Sandbox:

run-opencode

Dies startet den Container mit dem aktuellen Ordner als mount und startet OpenCode.
Der Agent kann die Dateien in diesem Ordner lesen und bearbeiten, aber nichts außerhalb davon.

Fehlerbehebung

run-opencode: Befehl nicht gefunden: Das Alias ist nicht in Ihrer Shell geladen. Überprüfen Sie, ob es in Ihrer Konfigurationsdatei steht:

grep -n run-opencode ~/.bashrc      # oder ~/.zshrc

• Wenn nichts ausgegeben wird, wurde das Alias nie in die Datei geschrieben (es wurde nur am Prompt eingegeben). Wiederholen Sie Schritt 3 der einmaligen Einrichtung, dann source die Datei erneut.
• Wenn es das Alias ausgibt, aber der Befehl immer noch nicht gefunden wird, bestätigen Sie, dass Sie die Datei bearbeiten, die Ihre Shell tatsächlich liest: Führen Sie echo $SHELL aus und verwenden Sie ~/.zshrc für zsh oder ~/.bashrc für bash.
  Wenn OpenCode startet, aber kein Modell erreichen kann: dann erreicht der Schlüssel den Container nicht oder das Projekt hat keine gültige Konfiguration. Bestätigen Sie, dass echo $SAIA_API_KEY Ihren Schlüssel ausgibt, und dass das Projektverzeichnis eine gültige opencode.json enthält.

Claude Code (Sichere Einrichtung)

Claude Code ist Anthropics terminal-first Code-Agent, ebenfalls als VS Code-Erweiterung verfügbar.
Diese Einrichtung läuft auf den Modellen in unserem Cluster mit nur einem SAIA-API-Schlüssel, sodass Ihr Code und Ihre Prompts auf der GWDG-Infrastruktur bleiben.

Vor Beginn

Sie benötigen zwei Dinge:

1. Einen SAIA-API-Schlüssel. Falls Sie noch keinen besitzen, fordern Sie ihn hier an.
2. Claude Code installiert. Die Installation ist dieselbe wie bei der kommerziellen Einrichtung, daher folgen Sie den bestehenden Anweisungen: CLI installieren oder VS Code-Erweiterung installieren.

Nur die Konfiguration unterscheidet sich, und das ist, was der nächste Abschnitt behandelt.

Konfiguration

Erstellen oder aktualisieren Sie ~/.claude/settings.json (Windows: %USERPROFILE%\.claude\settings.json), fügen Sie den folgenden Block ein und ersetzen Sie <ihr SAIA-API-Schlüssel> durch Ihren eigenen Schlüssel:

{
  "env": {
    "ANTHROPIC_BASE_URL": "https://chat-ai.academiccloud.de",
    "ANTHROPIC_AUTH_TOKEN": "<ihr SAIA-API-Schlüssel>",
    "ANTHROPIC_MODEL": "qwen3-coder-next",
    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "qwen3.6-27b",
    "ANTHROPIC_DEFAULT_OPUS_MODEL": "qwen3.5-397b-a17b",
    "ANTHROPIC_DEFAULT_SONNET_MODEL": "qwen3-coder-next",
    "CLAUDE_CODE_MAX_CONTEXT_TOKENS": "131072",
    "CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING": "1",
    "CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS": "1",
    "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1",
    "DISABLE_TELEMETRY": "1",
    "DISABLE_ERROR_REPORTING": "1",
    "DISABLE_BUG_COMMAND": "1",
    "DISABLE_AUTOUPDATER": "1"
  },
  "permissions": {
    "deny": [
      "Read(./.env)",
      "Read(./.env.*)",
      "Read(~/.ssh/**)",
      "Read(~/.aws/**)",
      "Bash(git push:*)"
    ]
  }
}

Starten Sie eine Sitzung mit dem claude-Befehl oder öffnen Sie die Claude-Leiste in VS Code.
Da die Einstellungsdatei in Ihrem Benutzerprofil liegt, gelten diese Werte für jede Claude Code-Sitzung unabhängig vom Shell, aus der sie gestartet wird.
Verifizieren Sie die Konfiguration.

Wenn Sie die VS Code-Erweiterung verwenden, aktivieren Sie zusätzlich die Benutzereinstellung Claude Code: Login-Prompt deaktivieren, damit die Erweiterung nicht nach einem Anthropic-Login fragt.
Sie können sie auch direkt in Ihrer VS Code-Benutzer-settings.json setzen:

{
  "claudeCode.disableLoginPrompt": true
}

Was die Variablen tun

Setzen Sie absichtlich ein kleines Modell für Hintergrundaufgaben.
Dies reduziert den Token-Verbrauch spürbar, ohne die Ergebnisqualität zu beeinträchtigen.
Optional kann CLAUDE_CODE_SUBAGENT_MODEL im gleichen env-Block das Modell für Subagenten festlegen.
Die Einstellung der Schlussfolgerungsebene (“Aufwand”) hat bei den internen Modellen keine Wirkung.

Eine projektbezogene .claude/settings.json im Repository wird zusätzlich angewendet und ist eine bequeme Möglichkeit, eine vorkonfigurierte Einrichtung an ein Team zu übertragen.
Der API-Schlüssel gehört nicht in diese Datei, da er committet wird. Setzen Sie nur die verbleibenden Variablen dort.

Modellwechsel

Es gibt drei Möglichkeiten, ein Modell auszuwählen.
Methode 1 reicht in den meisten Fällen aus.

Methode 1: Modellname direkt eingeben (keine Konfiguration)

Eingegeben in der laufenden Sitzung, nichts wird in eine Datei geschrieben:

/model qwen3.5-397b-a17b

Beim Start entsprechend:

claude --model qwen3.5-397b-a17b

Jedes Modell im Cluster ist auf diese Weise erreichbar, auch wenn es nicht in der Auswahlliste erscheint.
Sie müssen nur den Modellnamen kennen.

Methode 2: Drei Modelle in die Auswahlliste einfügen

Der /model-Befehl öffnet eine Liste mit drei festen Feldern mit den Bezeichnungen „opus“, „sonnet“ und „haiku“.
Diese drei Felder können mit SAIA-Modellen gefüllt werden, indem Sie den folgenden Block in das env-Block in ~/.claude/settings.json hinzufügen:

"ANTHROPIC_DEFAULT_OPUS_MODEL": "qwen3.5-397b-a17b",
"ANTHROPIC_DEFAULT_SONNET_MODEL": "qwen3-coder-next",
"ANTHROPIC_DEFAULT_HAIKU_MODEL": "qwen3.6-27b"

Die Liste bietet dann drei SAIA-Modelle.
Die Bezeichnungen „opus“, „sonnet“ und „haiku“ bleiben unverändert; die hinter ihnen stehenden Modelle sind die, die Sie eingegeben haben.
Diese Methode bietet maximal diese drei Felder.

Methode 3: Alle Modelle in die Auswahlliste einfügen.

Dies ist optional und nicht offiziell unterstützt.
Zwei verschiedene Dateien sind beteiligt:

• Voraussetzung: "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1" im env-Block in ~/.claude/settings.json. Ohne sie überschreibt Claude Code die Modellliste bei jedem Start.
• Modellliste: Auf der obersten Ebene von ~/.claude.json, eine andere Datei. Erweitern Sie sie mit dem Schlüssel unten, während keine Sitzung läuft, ersetzen Sie die Datei nicht:

"additionalModelOptionsCache": [
  {"value":"qwen3-coder-next","label":"Qwen3 Coder Next","description":"Codierung"},
  {"value":"glm-4.7","label":"GLM 4.7","description":"Codierungsalternative"},
  {"value":"qwen3.5-397b-a17b","label":"Qwen3.5 397B A17B","description":"Groß, Vision"},
  {"value":"qwen3.5-122b-a10b","label":"Qwen3.5 122B A10B","description":"Mittelgroß, Vision"},
  {"value":"qwen3.6-35b-a3b","label":"Qwen3.6 35B A3B","description":"Schnell, Vision"},
  {"value":"qwen3.6-27b","label":"Qwen3.6 27B","description":"Klein, Hintergrundaufgaben"},
  {"value":"qwen3-30b-a3b-instruct-2507","label":"Qwen3 30B A3B","description":"Klein, allgemein"},
  {"value":"qwen3-omni-30b-a3b-instruct","label":"Qwen3 Omni 30B A3B","description":"Multimodal"},
  {"value":"deepseek-v4-flash-0731","label":"DeepSeek V4 Flash","description":"Schnell, allgemein"},
  {"value":"openai-gpt-oss-120b","label":"GPT-OSS 120B","description":"Allgemein"},
  {"value":"mistral-medium-3.5-128b","label":"Mistral Medium 3.5","description":"Allgemein, Vision"},
  {"value":"gemma-4-31b-it","label":"Gemma 4 31B IT","description":"Allgemein, Vision"},
  {"value":"apertus-70b-instruct-2509","label":"Apertus 70B","description":"Allgemein"},
  {"value":"meta-llama-3.1-8b-instruct","label":"Llama 3.1 8B","description":"Sehr klein"}
]

value ist die Modell-ID; label und description sind freie Anzeigetexte.
Die eingebauten Einträge (Standard, Opus, Sonnet) bleiben sichtbar, sind aber über SAIA nicht verwendbar.
Die Embedding-Modelle sind absichtlich ausgelassen, ebenso wie devstral-2-123b-instruct-2512, das Anfragen von Claude Code ablehnt.
Das Ausführen von /logout löscht den Eintrag.

Berechtigungen und Sandbox

Claude Code hat Dateizugriff und führt Befehle aus, daher gilt die gleiche Empfehlung wie für OpenCode: Führen Sie es in einem gesicherten Container aus, der nur Ihr aktuelles Projektverzeichnis mountet.
Der Container ist die äußere Sicherheitsgrenze; das Berechtigungssystem ist die zweite Schicht und sollte verwendet werden, anstatt umgangen zu werden.

• Behalten Sie den Berechtigungs-Dialog aktiviert. Vermeiden Sie --dangerously-skip-permissions außerhalb eines Container-Sandboxes, und selbst innerhalb eines solchen macht es nur Sinn für Aufgaben ohne Netzwerk und ohne Zugriff auf Geheimnisse.
• Ausschließen Sie den Zugriff auf Geheimnisse und unzusammenhängende Verzeichnisse mit Verweigerungsregeln.
• Verweigerungsregeln können auch sicherstellen, dass Merge- und Bereitstellungsaufgaben manuell bleiben.

Die Verweigerungsregeln gehen in ~/.claude/settings.json als zweiter Block neben env ein, wie im Konfigurationsabschnitt oben gezeigt.
Dieser Block kann erweitert werden, z. B. um ausgehenden Webzugriff zu blockieren:

{
  "permissions": {
    "deny": [
      "Read(./.env)",
      "Read(./.env.*)",
      "Read(~/.ssh/**)",
      "Read(~/.aws/**)",
      "Bash(git push:*)",
      "WebFetch",
      "WebSearch"
    ]
  }
}

WebFetch und WebSearch können weggelassen werden, wo Ihre Netzwerkregeln bereits ausgehenden Traffic blockieren; die Verweigerungsregeln machen die Einschränkung unabhängig von der Container-Konfiguration wirksam.
Siehe Berechtigungsmodi für das vollständige Berechtigungsmodell.

Verifizieren der Konfiguration

Bevor Sie starten, überprüfen Sie URL und Schlüssel unabhängig vom Tool:

curl -X POST "https://chat-ai.academiccloud.de/v1/messages" \
  -H "Authorization: Bearer <ihr SAIA-API-Schlüssel>" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{"model":"qwen3-coder-next","max_tokens":10,
       "messages":[{"role":"user","content":"Test"}]}'

Eine Antwort mit "type":"message" bestätigt den Zugriff.

Innerhalb der Sitzung führen Sie /status aus und überprüfen zwei Zeilen:

• Anthropic base URL muss https://chat-ai.academiccloud.de anzeigen. Wenn die Zeile fehlt, hat die Variable die Sitzung nicht erreicht und wird weiterhin der Anthropic-API verwendet.
• Auth token muss ANTHROPIC_AUTH_TOKEN nennen. Wenn stattdessen eine Login method-Zeile mit einem persönlichen Konto erscheint, ist der SAIA-Schlüssel nicht aktiv.

Einschränkungen

Claude Code ist für Anthropic-Modelle konzipiert, und der Anbieter unterstützt explizit keine Ausführung mit anderen Modellen.
Bei größeren Aufgaben erwarten Sie schwächere Ergebnisse als mit den nativen Modellen, insbesondere bei Werkzeugnutzung wie Lesen und Bearbeiten von Dateien oder Ausführen von Befehlen.
OpenCode ist von Design her anbieterunabhängig und ist der bessere Ausgangspunkt, wenn Sie solche Probleme haben.

Cline

Cline ist ein Open-Source-Coding-Agent, der große Sprachmodell-Schlussfolgerung mit praktischen Entwickler-Workflows kombiniert.
Dieser Abschnitt beschreibt die Hauptvorteile von Cline, erläutert sein Plan → Handeln-Interface und führt eine Installation durch, die Cline mit SAIA-Modellen verbindet.

Der Plan → Handeln-Loop

• Plan-Modus:
  Sie können ein Ziel beschreiben, z. B. „OAuth2-Login hinzufügen“.
  Cline antwortet mit einem nummerierten Plan, der Dateiänderungen und Befehle aufzählt.

• Überprüfung:
  Bearbeiten Sie die Checkliste oder bitten Sie Cline, sie zu verfeinern.
  Nichts ändert sich im Arbeitsbereich, bis Sie genehmigen.

• Handeln-Modus:
  Cline führt jeden Schritt aus: Bearbeitet Dateien, führt Befehle aus und zeigt Unterschiede an.
  Sie bestätigen oder lehnen Aktionen in Echtzeit ab.

Diese Trennung gibt dem Agenten Autonomie, ohne die menschliche Kontrolle zu entfernen.

Installationsanleitung (VS Code)

Bitte finden Sie die Installationsanweisungen unten:

• Voraussetzungen

  • Visual Studio Code (v1.93 oder neuer)
  • SAIA-API-Schlüssel
  • Node 18+ für optionalen CLI-Gebrauch

• Erweiterung installieren

  • Suchen Sie in VS Code-Markt nach Cline und installieren Sie es.

• Verbindung zu CoCo AI herstellen

  • Öffnen Sie Cline (Befehlspalette → „Cline: In neuem Tab öffnen“).

  • Klicken Sie auf „Mit eigenem API-Schlüssel einrichten“ und wählen Sie „OpenAI-kompatibel“.

  • Füllen Sie die Felder aus:

    Feld	Wert
    Basis-URL	https://chat-ai.academiccloud.de/v1
    API-Schlüssel	Ihr SAIA-API-Schlüssel
    Modell-ID	glm-4.7 (weitere nach Bedarf hinzufügen)

  • Fügen Sie zusätzliche Modelle (z. B. qwen3-30b-a3b-instruct-2507) mit derselben URL und demselben Schlüssel hinzu, falls erforderlich.

  • Weisen Sie Rollen zu (falls Sie ein anderes Modell für Plan und Handeln verwenden möchten): Setzen Sie z. B. glm-4.7 für Handeln; setzen Sie qwen3-30b-a3b-instruct-2507 für Plan.

Täglicher Workflow

Hier ist der tägliche Workflow:

Plan → Plan genehmigen → Handeln → Unterschiede überprüfen → Iterieren

Cline schließt die Lücke zwischen chatbasierten Assistenten und vollständiger IDE-Automatisierung.
Mit einer kurzen Einrichtung, die auf CoCo AI zeigt, wird es ein flexibler Co-Entwickler für komplexe Codebasen, während die Kontrolle des Entwicklers erhalten bleibt.