Das Kontextfenster-Problem: Skalierung von Agenten über Token-Grenzen hinaus

In der heutigen Softwareentwicklung sind große Sprachmodelle (LLMs) ein unverzichtbares Werkzeug. Doch trotz ihrer beeindruckenden Fähigkeiten stoßen sie an Grenzen, insbesondere wenn es um die Verarbeitung von Kontextinformationen geht. Aktuelle LLMs haben Kontextfenster von etwa 1 Million Tokens, was für die meisten Unternehmenscodebasen, die Millionen von Tokens umfassen können, unzureichend ist. Dieser Artikel beleuchtet das Kontextfenster-Problem und präsentiert Lösungen, die von der Firma Factory entwickelt wurden, um die Effizienz von LLMs in der Softwareentwicklung zu steigern.

Das Kontextfenster-Problem

Die begrenzte Größe der Kontextfenster in LLMs stellt ein erhebliches Hindernis dar, wenn es darum geht, agentische Workflows in großem Maßstab zu implementieren. Ein typisches Unternehmensmonorepo kann Tausende von Dateien und mehrere Millionen Tokens umfassen. Darüber hinaus gibt es Millionen von Tokens an Informationen, die für eine Ingenieurorganisation relevant sind und außerhalb des Codebases existieren. Diese Diskrepanz zwischen dem, was LLMs verarbeiten können, und dem, was für die Arbeit mit realen Systemen erforderlich ist, ist ein zentrales Problem.

Kritischer Kontext für effektive Agenten

Menschen schreiben Code nicht isoliert. Sie benötigen viele Kontextquellen, um Software zu erstellen, die mit bestehenden Systemen integriert ist. Zu den entscheidenden Kontextarten gehören:

• Aufgabenbeschreibungen: Was erreicht werden muss, wie „implementiere einen neuen API-Endpunkt“ oder „behebe Fehler #123“.
• Werkzeuge: Informationen über die Ressourcen und Systeme, die dem Entwickler oder Agenten zur Verfügung stehen.
• Entwickler-Persona: Informationen über den Entwickler, einschließlich ihrer Umgebung und Rolle.
• Code: Die Dateien und Funktionen, die derzeit geändert werden, bilden die Grundlage jeder Codeänderung.
• Semantische Struktur: Höhere Muster und Einschränkungen, die dem Code Bedeutung verleihen.
• Historischer Kontext: Frühere Refactoring-Bemühungen und Designentscheidungen, die wichtige Einblicke in die Codeentwicklung bieten.
• Kollaborativer Kontext: Soziale und organisatorische Dimensionen der Softwareentwicklung, einschließlich Codierungsstandards und Teamkonventionen.

Fehlt es an einem dieser kritischen Kontexte, leidet die Qualität des Outputs. Dies gilt auch für LLMs, die ohne ausreichenden Kontext nicht die gewünschten Ergebnisse liefern können.

Warum bestehende Ansätze scheitern

Ein häufiger Ansatz zur Bewältigung des Kontextfenster-Problems ist die naive Vektorrückgewinnung. Dabei werden Code-Dateien in Abschnitte unterteilt, die in Vektoren eingebettet werden. Obwohl dies für viele Benutzeranfragen funktioniert, hat es erhebliche Mängel:

• Mangel an struktureller Kodierung: Code ist kein bloßer Text, sondern ein Netz von Abhängigkeiten und Mustern.
• Fehler bei mehrstufigem Denken: Wenn ein Agent verstehen muss, wie verschiedene Teile eines Systems interagieren, führt die Vektorrückgewinnung oft zu isolierten Fragmenten.
• Abnahme der Denkfähigkeit: Die Rückgewinnung irrelevanter Dateien kann die Leistungsfähigkeit des Modells beeinträchtigen.

Diese Probleme zeigen, dass die Vektorrückgewinnung nicht als spezialisiertes Werkzeug zur Navigation durch die strukturierte Natur von Software konzipiert wurde.

Wird eine größere Fenstergröße das Problem lösen?

In letzter Zeit haben LLMs größere Kontextfenster eingeführt, die es ermöglichen, mehr Dateien zu verarbeiten. Doch auch dies hat seine Grenzen:

• Nicht groß genug: Aktuelle Modelle bieten Fenster von 1-2 Millionen Tokens, was immer noch weniger ist als die meisten Produktionscodebasen.
• Qualitätsverschlechterung: Die Aufmerksamkeit des Modells ist nicht gleichmäßig über lange Eingabesequenzen verteilt.
• Monetäre Kosten: Die Verarbeitung zusätzlicher Tokens verursacht direkte Kosten, die für Unternehmen mit großen Ingenieurteams untragbar werden können.

Größere Fenster beseitigen nicht die Notwendigkeit für ein diszipliniertes Kontextmanagement.

Die Kontext-Stack-Lösung von Factory

Factory hat eine Lösung entwickelt, die als Kontext-Stack bezeichnet wird. Dieser Stack ermöglicht es Droids, ihren Kontext dynamisch zu verwalten:

• Repository-Übersichten: Factory generiert eine Zusammenfassung jedes Repositories, die dem Benutzer zur Verfügung steht.
• Semantische Suche: Eine Suche, die auf codebezogene Aufgaben abgestimmt ist, liefert relevante Dateien und Ordnersummen.
• Dateisystembefehle: Droids können gezielt Dateien, Zeilen oder Protokolle abrufen, ohne das Kontextbudget zu überschreiten.
• Integrationen mit Unternehmenskontext: Droids können kritisches Wissen aus anderen Quellen wie Sentry oder Notion nutzen.
• Hierarchisches Gedächtnis: Dieses Gedächtnis sorgt dafür, dass Droids über individuelle und organisatorische Informationen verfügen, die die Konsistenz und Effizienz erhöhen.

Durch die Verwendung dieses Kontext-Stacks können Droids zuverlässig und effizient arbeiten, was zu einer höheren Akzeptanz von Codeänderungen und einer verbesserten Zufriedenheit führt.

Zukünftige Entwicklungen

Wir erwarten bedeutende Fortschritte in den Fähigkeiten von Modellen, insbesondere in den Bereichen:

• Größere Kontextfenster
• Bessere In-Window-Denkfähigkeiten
• Intelligentere Agenten
• Langfristige Aufgabenausführung

Dennoch werden bestimmte Einschränkungen bestehen bleiben, und die Notwendigkeit für diszipliniertes Kontextmanagement wird weiterhin von entscheidender Bedeutung sein.

Quellenliste:

• Quelle: The Context Window Problem: Scaling Agents Beyond Token Limits
• Chroma’s Research Report on Context Rot