Coding-Agenten mit lokaler KI

Was dieser Artikel über Coding-Agenten behandelt

• Was Coding-Agenten sind und wie sie einfache Entwicklungsaufgaben übernehmen.
• Wie Tool-Calling Code ausführen, Dateien lesen und Tests starten lässt.
• Welche Frameworks wie LangChain, CrewAI und Autogen helfen.
• Wie man Workflows für Refactoring, Dokumentation und Tests baut.
• Sicherheit, Kosten und typische Stolpersteine.

Einleitung: Coding-Agenten mit lokaler KI

Coding-Agenten gehen einen Schritt weiter als reine Code-Vervollständigung. Sie können mehrere Dateien lesen, Befehle ausführen, Ergebnisse interpretieren und selbstständig Schritte planen. So lassen sich Aufgaben wie Refactoring, Dokumentation, Tests oder kleine Features automatisieren. Wer sie lokal betreibt, behält sensible Codebasen im eigenen Netzwerk.

Ein Coding-Agent braucht mehr als nur ein Sprachmodell. Er braucht Werkzeuge: Dateisystemzugriff, Shell, Git, Test-Runner, Linter. Er braucht ein Gedächtnis für den aktuellen Plan und eine Feedback-Schleife, um Ergebnisse zu prüfen. Das nennt man Agentensystem oder Tool-Calling.

Warum brauche ich Coding-Agenten?

Codierung besteht zu einem großen Teil aus wiederkehrenden Aufgaben:

• Refactoring alter Code-Teile,
• Erstellen von Tests,
• Schreiben von Dokumentation,
• Suchen nach veralteten Mustern,
• Einfache Bugfixes,
• Kleinere Features implementieren.

Ein Agent kann diese Aufgaben vorbereiten oder ganz ausführen. Der Entwickler prüft und übernimmt. Das spart Zeit und reduziert monotone Arbeit.

Coding-Agenten kurz erklärt

Ein Agent besteht aus mehreren Teilen:

• Sprachmodell: Plant Schritte und generiert Code.
• Tools: Führen Aktionen aus wie Dateien lesen, Befehle ausführen.
• Gedächtnis: Merkt sich den bisherigen Verlauf.
• Planung: Bricht Aufgaben in einzelne Schritte.
• Reflexion: Prüft Ergebnisse und korrigiert sich.

Wichtige Begriffe:

• Tool-Calling: Modell ruft definierte Funktionen auf.
• ReAct: Reasoning and Acting, ein Muster für Agenten.
• Observability: Nachvollziehbarkeit, was der Agent gemacht hat.
• Sandbox: Abgeschirmte Umgebung für unsichere Operationen.
• MCP: Model Context Protocol für Werkzeuganbindung.

Für wen sind Coding-Agenten gedacht?

• Für Entwickler, die monotone Aufgaben automatisieren wollen.
• Für Teams mit großen, gut strukturierten Codebasen.
• Für Tech-Leads, die Code-Qualität und Dokumentation verbessern wollen.
• Für Alle, die Tool-Calling lokal testen wollen.

Wichtige Begriffe rund um Coding-Agenten

• LangChain: Framework für Agenten und Workflows.
• LangGraph: Erweiterung für komplexe Agentenabläufe.
• CrewAI: Multi-Agenten-Framework mit Rollen.
• Autogen: Microsoft-Framework für Gespräche zwischen Agenten.
• OpenAI Functions: Vorbild für Tool-Calling.
• MCP-Server: Standardisierte Werkzeuganbindung.

Aufbau eines lokalen Coding-Agenten

1. Werkzeuge definieren

Der Agent braucht klar definierte Funktionen:

• read_file(path)
• write_file(path, content)
• run_command(command)
• run_tests()
• search_files(query)

2. Prompt strukturieren

Du bist ein Coding-Assistent. Lies die Datei main.py.
Identifiziere Code-Duplikate. Refactore sie in eine Hilfsfunktion.
Schreibe Tests für die neue Funktion.
Führe die Tests aus.

3. Agenten-Schleife

1. Modell bekommt Aufgabe und verfügbare Tools.
2. Modell entscheidet, welches Tool es aufrufen möchte.
3. Tool wird ausgeführt.
4. Ergebnis zurück an Modell.
5. Schritte wiederholen, bis Aufgabe erledigt.

4. Sicherheit

• Dateizugriff einschränken.
• Befehle in Sandbox ausführen.
• Keine kritischen Operationen ohne Freigabe.
• Änderungen reviewen, bevor sie übernommen werden.

Praxisbeispiel: Refactoring mit Python

import ollama

tools = [
    {
        'type': 'function',
        'function': {
            'name': 'read_file',
            'description': 'Liest eine Datei',
            'parameters': {
                'type': 'object',
                'properties': {
                    'path': {'type': 'string'}
                },
                'required': ['path']
            }
        }
    }
]

antwort = ollama.chat(
    model='llama3.1:8b',
    messages=[{
        'role': 'user',
        'content': 'Lies main.py und fasse die Struktur zusammen.'
    }],
    tools=tools
)

Wichtig: Nicht alle lokalen Modelle unterstützen Tool-Calling gut. Qwen und einige Llama-Varianten funktionieren besser als andere.

Frameworks im Vergleich

LangChain + LangGraph

Sehr flexibel. Viele Beispiele und Integrationen. Etwas Overhead. Gut für komplexe, mehrstufige Workflows.

CrewAI

Einfacher Einstieg. Agenten bekommen Rollen und Aufgaben. Gut für klar strukturierte Teamszenarien.

Autogen

Gesprächsorientiert. Agenten reden miteinander, bis ein Ergebnis entsteht. Für spezielle Workflows interessant, aber aufwendig.

Sicherheit bei Coding-Agenten

• Sandbox: Führe alle Befehle in einer isolierten Umgebung aus.
• Read-only zuerst: Erlaube zuerst nur Lesen.
• Menschliche Freigabe: Schreiboperationen müssen bestätigt werden.
• Keine Secrets im Prompt: Schlüssel und Passwörter herausfiltern.
• Auditing: Protokolliere alle Aktionen.

Typische Stolpersteine bei Coding-Agenten

• Schlechte Tool-Calling-Fähigkeit: Nicht jedes Modell beherrscht Tools gut.
• Zu viele Rechte: Agent löscht oder überschreibt Dateien.
• Halluzinationen: Erfindet Dateien oder APIs.
• Endlosschleifen: Agent wiederholt sich ohne Fortschritt.
• Zu großer Kontext: Große Codebasen passen nicht ins Kontextfenster.
• Keine Tests: Ergebnisse werden nicht geprüft.

Weiterführende Links und Infos

• BotServ.de Lokale Coding-Modelle
• BotServ.de KI-Agenten
• BotServ.de MCP Grundlagen
• LangChain
• CrewAI

FAQ: Coding-Agenten

Kann ein Coding-Agent mein ganzes Projekt übernehmen? Nein. Er hilft bei Teilaufgaben, menschliche Prüfung bleibt nötig.

Welches Modell eignet sich für Tool-Calling? Qwen, Llama 3.1 und einige feinabgestimmte Modelle.

Sind Coding-Agenten sicher? Nur in Sandboxes und mit eingeschränkten Berechtigungen.

Kann ich meine eigene Codebase feinabstimmen? Ja, mit Training oder RAG über eigene Dateien.

Brauche ich ein Framework? Für einfache Agenten reicht Python mit Ollama. Für komplexe Workflows helfen Frameworks.

Quellen und weiterführende Literatur

• LangChain: https://www.langchain.com/
• LangGraph: https://www.langchain.com/langgraph
• CrewAI: https://www.crewai.com/
• Autogen: https://microsoft.github.io/autogen/

Zusammenfassung: Coding-Agenten mit lokaler KI

Coding-Agenten können Dateien lesen, Befehle ausführen und eigenständig kleine Entwicklungsaufgaben bearbeiten. Sie basieren auf Tool-Calling, Planung und Feedback. Lokaler Betrieb schützt sensible Codebasen. Wichtig sind gute Werkzeuge, Sandbox-Sicherheit, menschliche Freigabe und die richtige Modellwahl. Frameworks wie LangChain, CrewAI und Autogen erleichtern komplexe Workflows, sind aber nicht zwingend nötig.