> Wie Coding-Agenten Code finden: AST-Chunking mit tree-sitter, Repo-Maps, Merkle-Tree-Sync, Code-Embedding-Modelle 2026 und wann grep einen Index schlägt.
>
> Web page: https://balazscsorba.com/de/blog/code-rag-repository-indexing · Language: Deutsch · Also available in: [English](https://balazscsorba.com/blog/code-rag-repository-indexing.md) · [Magyar](https://balazscsorba.com/hu/blog/code-rag-repository-indexing.md)
> Author: Balázs Csorba · Published: 2026-10-01 · Keywords: RAG over code, AST chunking, tree-sitter code chunking, repository map, code embeddings, semantic code search, codebase indexing, repo map tokens, incremental code index, CoIR benchmark

[Blog](https://balazscsorba.com/de/blog)/Retrieval & Suche

# RAG über Code: AST-Chunking, Repo-Maps und Code-Embeddings für Agenten

Wie Coding-Agenten Code finden: AST-Chunking mit tree-sitter, Repo-Maps, Merkle-Tree-Sync, Code-Embedding-Modelle 2026 und wann grep einen Index schlägt.

[Balázs Csorba](https://balazscsorba.com/de/about)·1\. Oktober 2026·8 Min. Lesezeit

-   RAG
-   Code search
-   Tree-sitter
-   Embeddings
-   Coding agents

![Ein verzweigter Codebaum speist eine Reihe von Karteikarten.](https://balazscsorba.com/images/blog/code-rag-repository-indexing/cover.webp?v=ba771e90f4)

## Das Wichtigste in Kürze

-   Zeilenbasiertes Chunking zerteilt Funktionen und trennt Importe vom Code, der sie braucht; das cAST-Paper maß durch AST-basiertes Chunking +4,3 Recall@5 auf RepoEval und +2,67 Pass@1 auf SWE-bench.
-   Tree-sitter ist der gemeinsame Parser: nach Funktion, Klasse oder Methode chunken, kleine Geschwister zusammenführen, übergroße Knoten teilen und zu jedem Chunk Pfad, Zeilenbereich, Symbolname und Signatur speichern.
-   Eine Repo-Map braucht keine Embeddings: Aider rankt tree-sitter-Symbole über einen Datei-Abhängigkeitsgraphen und passt Signaturen in ein Standardbudget von 1k Tokens ein.
-   Aktualität ist der schwierige Teil: Cursor synchronisiert nur geänderte Zweige eines Merkle-Baums, Kilo Code nutzt Datei-Watcher und Hash-Caches, und CocoIndex bettet nur geänderte Dateien neu ein.
-   Grep und Glob veralten nie und kosten Tokens pro Suche; ein Index kostet Speicher, Embedding-Ausgaben und Pflege. Viele Teams brauchen beides: grep für exakte Namen, einen Index für Bedeutung.

Auf dieser Seite

1.  [Warum zeilenbasiertes Chunking bei Code scheitert](https://balazscsorba.com/#why-line-based-chunking-fails-on-code)
2.  [AST-Chunking mit tree-sitter](https://balazscsorba.com/#ast-chunking-with-tree-sitter)
3.  [Repo-Maps: Symbolkontext ohne Embeddings](https://balazscsorba.com/#repo-maps-symbol-context-without-embeddings)
4.  [Wie kommerzielle Agenten Code indexieren](https://balazscsorba.com/#how-commercial-agents-index-code)
5.  [Code-Embedding-Modelle 2026](https://balazscsorba.com/#code-embedding-models-in-2026)
6.  [Code-Suche messen und aktuell halten](https://balazscsorba.com/#measuring-code-retrieval-and-keeping-it-fresh)
7.  [Wann agentisches grep einen Index schlägt, und eine Checkliste](https://balazscsorba.com/#when-agentic-grep-beats-an-index)
8.  [Quellen](https://balazscsorba.com/#sources)

Diesen Artikel anhören

0:000:00

**RAG über Code** ist Retrieval-augmented Generation mit einem Repository als Korpus, und sie scheitert anders als RAG über Dokumente. Code hat harte Grenzen (Funktionen, Klassen, Importe), exakte Bezeichner, die mehr zählen als Umschreibungen, und einen Aufrufgraphen, der Dateien verbindet. Zerlegt man ihn wie Fließtext, bekommt das Modell eine halbe Funktion ohne Importe; indexiert man ihn einmal und vergisst ihn, liest der Agent selbstbewusst Code, der gestern gelöscht wurde.

Dieser Artikel behandelt strukturelles Chunking mit tree-sitter, Repo-Maps ohne Embeddings, wie Cursor und Kilo Code einen Index aktuell halten, die Code-Embedding-Modelle Stand Oktober 2026, wie man die Suche am eigenen Repository misst und wann grep jeden Index schlägt. Was überhaupt in den Kontext eines Agenten gehört, beschreibt [die Entscheidungsmatrix zu AGENTS.md, Skills, MCP und CLI](https://balazscsorba.com/de/blog/agents-md-skills-mcp-cli-decision-matrix); hier geht es darum, wie der Code gefunden wird.

## Warum zeilenbasiertes Chunking bei Code scheitert

Zeilenbasiertes Chunking scheitert, weil Codegrenzen nicht auf feste Zeilenzahlen fallen. Ein 40-Zeilen-Fenster teilt eine Funktion in der Mitte, lässt einen Decorator in einem Chunk und seine Klasse im nächsten und trennt Importe vom Code, der sie nutzt. Der Retriever rankt dann Fragmente, die allein nichts mehr bedeuten.

Das cAST-Paper hat den Effekt gemessen. Es beschreibt zeilenbasierte Heuristiken als solche, die „oft semantische Strukturen zerbrechen, Funktionen teilen oder Unzusammenhängendes zusammenführen“, und ersetzt sie durch rekursives Chunking entlang des abstrakten Syntaxbaums, wobei kleine Geschwisterknoten bis zu einer Größengrenze zusammengeführt werden. Das verbesserte Recall@5 auf RepoEval um 4,3 Punkte und Pass@1 auf SWE-bench um 2,67 Punkte ([cAST](https://arxiv.org/abs/2506.15655)). Der Gewinn ist absolut bescheiden, kommt aber von einem Parser, nicht von einem größeren Modell.

![Zeilenfenster gegen AST-Chunks Zwei Spalten für dieselbe Quelldatei. Spalte A, feste Zeilenfenster: Fenster 1 enthält die Importe und die erste Hälfte von parse(); Fenster 2 den Rest von parse() und einen von seiner Klasse getrennten Decorator; Fenster 3 den Klassenrumpf ohne seinen Decorator. Spalte B, AST-Knoten: ein Modul-Chunk mit Importen und Konstanten der Datei; ein Funktions-Chunk mit dem ganzen Rumpf von parse() sowie Pfad, Zeilenbereich und Signatur; ein Klassen-Chunk für Order, bei dem der Decorator bleibt. Eine Fußzeile nennt die cAST-Ergebnisse: +4,3 Recall@5 auf RepoEval und +2,67 Pass@1 auf SWE-bench.](https://balazscsorba.com/images/blog/code-rag-repository-indexing/diagram-5.webp?v=d3e781821a)

Feste Zeilenfenster zerschneiden Definitionen; AST-Chunks halten jede Funktion und Klasse ganz und tragen Ort und Signatur mit.

Code-Suche ist noch aus einem zweiten Grund keine Textsuche: Anfragen mischen natürliche Sprache mit exakten Bezeichnern. Eine Frage wie „wo wiederholen wir den ERP-Aufruf“ braucht semantischen Abgleich, „wer ruft `createSalesOrder` auf“ dagegen eine exakte Symbolsuche. Ein gutes Setup bedient beides, deshalb kombinieren die meisten Systeme unten Struktur mit Suche.

## AST-Chunking mit tree-sitter

Tree-sitter ist der gemeinsame Parser dieser Systeme: Er parst eine Datei in einen konkreten Syntaxbaum, und Abfragedateien wie `tags.scm` legen pro Sprache fest, was als Definition oder Referenz zählt ([Aider](https://aider.chat/2023/10/22/repomap.html)). Ein Chunker läuft über die Knoten der obersten Ebene, gibt Funktionen, Klassen und Methoden als Chunks aus, führt kleine Nachbarn zusammen, damit eine Datei mit kurzen Hilfsfunktionen nicht zu fünfzig winzigen Chunks wird, und teilt übergroße Knoten, indem er in ihre Kinder absteigt.

```
# Sketch: AST chunks with sibling merging, the idea behind cAST
from tree_sitter import Language, Parser
import tree_sitter_python as tspython

parser = Parser(Language(tspython.language()))
MAX_CHARS = 1000  # Kilo Code documents 100 to 1,000 characters per block

def chunks(src: bytes, path: str):
    buf = []
    for node in parser.parse(src).root_node.children:
        text = src[node.start_byte:node.end_byte].decode()
        if len(text) > MAX_CHARS and node.child_count:
            yield from split_children(node, src, path)   # oversized: recurse
        elif sum(len(t) for t, _ in buf) + len(text) <= MAX_CHARS:
            buf.append((text, node))                     # merge small siblings
        else:
            yield emit(buf, path)                        # path, lines, symbol, signature
            buf = [(text, node)]
    if buf:
        yield emit(buf, path)
```

Kilo Code aus der Linie von Cline und Roo dokumentiert konkrete Einstellungen dafür: tree-sitter-Parsing in semantische Blöcke von 100 bis 1.000 Zeichen, geteilte große Funktionen und ein zeilenbasierter Fallback für Dateien, die der Parser nicht versteht ([Kilo Code](https://kilo.ai/docs/customize/context/codebase-indexing)). Unabhängig von den Größengrenzen sollten Sie zu jedem Chunk Metadaten speichern: Dateipfad, Zeilenbereich, Symbolname und Signatur. Der Agent braucht Pfad und Zeilen, um die echte Datei zu öffnen, und die Signatur macht den Chunk in einer Ergebnisliste auch ohne Rumpf lesbar.

## Repo-Maps: Symbolkontext ohne Embeddings

Eine Repo-Map gibt dem Modell die Gestalt eines Repositorys ganz ohne Vektorindex. Aider baut sie mit tree-sitter: die wichtigsten Klassen und Funktionen mit Typen und Aufrufsignaturen. Was in ein Token-Budget passt, wählt ein Graph-Ranking-Algorithmus über einen Graphen, in dem jede Datei ein Knoten ist und Abhängigkeiten Kanten sind. Die Einstellung `--map-tokens` steht standardmäßig auf 1k Tokens, und die Map wächst, solange noch keine Dateien im Chat sind ([Aider-Doku](https://aider.chat/docs/repomap.html)).

Die Map enthält Signaturen, keine Rümpfe, deshalb ist sie günstig. Aiders Designnotiz von 2023 erklärt, dass tree-sitter ctags ersetzt hat, weil es vollständige Signaturen direkt aus dem Quelltext zeigt und Sprachunterstützung als installierbare Pakete mitbringt ([Aider-Blog](https://aider.chat/2023/10/22/repomap.html)). Das Suchmuster heißt „erst die Marken“: Das Modell liest die Map, wählt die nötigen Dateien und liest erst dann diese vollständig. Für viele Aufgaben in einem bekannten Repository reicht das, und nichts muss je neu eingebettet werden.

Language Server gehen noch einen Schritt weiter. Serena ist ein MCP-Toolkit für Suche und Bearbeitung auf Symbolebene, dessen Standard-Backend das Language Server Protocol ist und mehr als 40 Sprachen abdeckt ([Serena](https://github.com/oraios/serena)). Statt Text zu durchsuchen, fragt der Agent nach Definition oder Referenzen eines Symbols und bekommt exakte Antworten. Wie viel das in der Praxis spart, steht in [den Token-Spar-Werkzeugen für Coding-Agenten](https://balazscsorba.com/de/blog/token-saving-tools-coding-agents-top-20).

## Wie kommerzielle Agenten Code indexieren

Cursor indexiert mit einem Merkle-Baum. Jede Datei bekommt einen SHA-256-Hash und jeder Ordner einen Hash seiner Kinder, sodass nach einer Änderung nur die geänderten Zweige abweichen und synchronisiert werden müssen. In einem Workspace mit 50.000 Dateien ergeben allein Dateinamen und Hashes rund 3,2 MB. Geänderte Dateien werden in syntaktische Chunks zerlegt, Embeddings nach Chunk-Inhalt gecacht, und ein Ähnlichkeits-Hash findet einen vorhandenen Index zur Wiederverwendung, mit Inhaltsnachweisen, damit ein Client nur Ergebnisse für Dateien bekommt, die er tatsächlich lesen kann ([Cursor](https://cursor.com/blog/secure-codebase-indexing)).

Die Vektorschicht dahinter ist turbopuffer, das Cursors Suche mit mehr als einer Billion Vektoren beschreibt, mit einem Namespace pro Codebasis-Instanz und eingebettet mit Cursors eigenem Modell. Das Kopieren eines vorhandenen Namespace für einen neuen Checkout senkte die mediane Zeit bis zur ersten Abfrage von 7,87 Sekunden auf 525 Millisekunden und das p99 von 4,03 Stunden auf 21 Sekunden ([turbopuffer](https://turbopuffer.com/customers/cursor)). Das ist das Onboarding-Problem jedes Code-Index: Der erste Index eines großen Repositorys ist der langsame Teil.

Kilo Code liefert dasselbe Muster für ein lokales Setup: standardmäßig LanceDB oder Qdrant als externen Store, Embedding-Anbieter einschließlich Ollama für einen vollständig lokalen Stack, Datei-Watcher plus Hash-Caching für inkrementelle Updates und Behandlung von Branch-Wechseln. Zu den Standardwerten gehören ein minimaler Such-Score von 0,4 und bis zu 50 Ergebnisse ([Kilo Code](https://kilo.ai/docs/customize/context/codebase-indexing)). Cline selbst dokumentiert dagegen derzeit eingebaute Werkzeuge wie `read_files` und `search_codebase` und keinen Embedding-Index ([Cline-Doku](https://docs.cline.bot/tools-reference/all-cline-tools.md)).

![Indexierter Suchpfad für Code Fünf Schritte von links nach rechts: das Repository, verfolgt über Merkle-Hashes; tree-sitter macht aus geänderten Dateien AST-Chunks; die Chunks werden eingebettet, mit Cache nach Inhalts-Hash; die Vektoren landen in einem Store mit einem Namespace pro Codebasis; die Suche liefert Chunks, und der Agent liest danach die Dateien.](https://balazscsorba.com/images/blog/code-rag-repository-indexing/diagram-19.webp?v=9eee616d4b)

Der indexierte Pfad zahlt einmal für Struktur und Embeddings; der agentische Pfad (grep, glob, lesen, wiederholen) überspringt jeden Kasten hier und zahlt stattdessen pro Suche in Tokens.

System

Chunking

Such-Primitive

Speicher

Aktualität

Aider-Repo-Map

tree-sitter-Tags, nur Signaturen

Graph-Ranking über Dateiabhängigkeiten

keiner; Map geht in den Prompt

pro Anfrage neu, 1k Tokens Standard

Cursor

syntaktische Chunks

semantische Suche über Embeddings

turbopuffer, Namespace pro Codebasis

Merkle-Baum, nur geänderte Zweige

Kilo Code

tree-sitter-Blöcke, 100–1.000 Zeichen

Vektorsuche, Mindestscore 0,4

LanceDB oder Qdrant

Datei-Watcher plus Hash-Cache

Serena

keins; Symbole aus Language Servern

LSP-Definitionen und -Referenzen

Zustand des Language Servers

live

Claude Code

keins

grep (ripgrep) und glob, just in time

keiner

nie veraltet; Tokens pro Suche

## Code-Embedding-Modelle 2026

Stand Oktober 2026 gibt es drei praktische Wege. Gehostet und codeoptimiert: Voyage führt `voyage-code-4` als aktuelles Code-Modell für $0,12 pro Million Tokens mit 200 Millionen freien Tokens, während `voyage-code-3` für $0,18 zu den älteren Modellen gewandert ist ([Voyage](https://docs.voyageai.com/docs/pricing)). Selbst gehostet: Qwen3-Embedding gibt es in 0.6B, 4B und 8B mit 32k Kontext, Matryoshka-Dimensionen und Unterstützung für mehr als 100 Sprachen einschließlich Programmiersprachen ([Qwen](https://qwenlm.github.io/blog/qwen3-embedding/)).

Der dritte Weg ist ein allgemeines multimodales oder Langkontext-Modell. jina-embeddings-v4 kann entweder einen einzelnen 2048-dimensionalen Vektor oder Token-Vektoren für Late Interaction ausgeben, meldet 71,59 auf dem Code-Benchmark CoIR und steht unter der Qwen Research License, was für kommerzielle Nutzung zählt ([Jina](https://jina.ai/models/jina-embeddings-v4/)). Cohere Embed v4 bietet 128k Kontext und Matryoshka-Ausgabe von 256 bis 1536 Dimensionen für $0,12 pro Million Tokens ([Cohere](https://docs.cohere.com/changelog/embed-multimodal-v4)). Welches Modell man wählt, ist eine allgemeine Frage, behandelt in [der Auswahl von Embedding-Modellen](https://balazscsorba.com/de/blog/embedding-model-selection-2026); bei Code zählt der lange Kontext, weil ganze Dateien und lange Funktionen hineinpassen.

Für ein Repository mit einigen hunderttausend Zeilen ist die Embedding-Rechnung bei diesen Preisen klein; die echten Kosten sind das Neueinbetten nach Änderungen und der Aufwand, den Index korrekt zu halten. Codeoptimierung lohnt sich am meisten, wenn Anfragen in natürlicher Sprache kommen und der Code Fachbegriffe nutzt, die ein allgemeines Modell nie gesehen hat.

## Code-Suche messen und aktuell halten

Messen Sie am eigenen Repository und nutzen Sie öffentliche Benchmarks als Plausibilitätsprüfung. CoIR, veröffentlicht auf der ACL 2025, kombiniert zehn Datensätze über acht Suchaufgaben und sieben Domänen, und die Autoren stellten fest, dass selbst aktuelle Spitzenmodelle bei der Code-Suche erhebliche Schwierigkeiten hatten ([CoIR](https://arxiv.org/abs/2407.02883)). Ihre Anfragen, Bezeichner und Konventionen sind dort nicht enthalten, also bauen Sie ein kleines eigenes Set.

1.  30 bis 50 echte Fragen aus Tickets und Code-Reviews sammeln, jeweils mit der Datei und dem Symbol, das sie beantwortet.
2.  Fragen in natürlicher Sprache mit exakten Namenssuchen mischen, weil sie unterschiedliche Retriever fordern.
3.  Recall bei 5 und 10 je Chunking- und Modellvariante messen und das Set im Repository ablegen.
4.  Nach Modellwechseln und großen Refactorings erneut ausführen, nicht nur einmal.

Aktualität braucht so viel Design wie Qualität. Die bewährten Muster sind Datei-Watcher mit Inhalts-Hash-Caches (Kilo Code), Merkle-Bäume, die nur geänderte Zweige synchronisieren (Cursor), und memoisierte Pipelines: CocoIndex schlüsselt seinen Cache pro Datei und pro Verarbeitungsschritt, sodass ein Commit, der wenige Dateien berührt, nur diese neu einbettet, gelöschte Dateien ihre Zeilen entfernen und der Index entweder als Nachhollauf in der CI oder im Live-Modus mit etwa einer Sekunde Latenz auf dem Arbeitsverzeichnis läuft ([CocoIndex](https://cocoindex.io/blogs/index-codebase-v1)). Löschungen sind der Fall, den die meisten Setups falsch machen, und so zitiert ein Agent entfernten Code. Late Chunking und Contextual Retrieval ergänzen Chunks zusätzlich um Kontext, siehe [Contextual Retrieval und Late Chunking](https://balazscsorba.com/de/blog/contextual-retrieval-late-chunking).

**Ranglisten sind nicht Ihr Repository**

Benchmark-Werte für Code-Embeddings ändern sich von Monat zu Monat, und keiner enthält Ihre Namenskonventionen. Nutzen Sie einen CoIR-Wert als Filter für die Shortlist und lassen Sie Ihr eigenes Frageset entscheiden.

## Wann agentisches grep einen Index schlägt, und eine Checkliste

Grep schlägt einen Index, wenn das Repository klein genug für eine schnelle Suche ist, sich ständig ändert oder die Maschine nicht verlassen darf. Anthropic beschreibt Claude Code als Hybrid: CLAUDE.md wird vorab geladen, und „Primitive wie glob und grep erlauben es, die Umgebung zu navigieren und Dateien just in time abzurufen, wodurch die Probleme veralteter Indizes und komplexer Syntaxbäume umgangen werden“. Derselbe Beitrag hält fest, dass Erkundung zur Laufzeit langsamer ist als vorberechnete Suche ([Anthropic](https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents)). Das Grep-Werkzeug von Claude Code basiert auf ripgrep, ergänzt um Glob ([Claude-Code-Doku](https://code.claude.com/docs/en/tools-reference)).

Ich nutze Claude Code, opencode und Codex nebeneinander, und der Zielkonflikt ist im Alltag sichtbar: Grep-zuerst-Agenten geben in einem unbekannten Bereich Tokens für mehrere Such- und Leserunden aus und liefern nie Code, den es nicht mehr gibt. Die Kosten eines Index sind das Gegenteil: Speicher, Embedding-Ausgaben und die Aktualitätsmechanik von oben, dafür weniger Runden bei Fragen, die nach Bedeutung gestellt werden.

-   **Repository-Größe**: Unterhalb einer Größe, bei der ripgrep sofort antwortet, mit grep und einer Repo-Map beginnen.
-   **Änderungsrate**: Hohe Änderungsraten sprechen für grep oder LSP; ein Index braucht inkrementelle Updates, die Löschungen beherrschen.
-   **Monorepo**: Viele Teams und unbekannte Bereiche sprechen für einen Index, idealerweise geteilt und über Checkouts wiederverwendet.
-   **Compliance**: Darf Code die Maschine nicht verlassen, lokale Embedder und einen lokalen Store nutzen oder auf den Index verzichten.
-   **Hybrid als Standard**: grep für exakte Namen, LSP für Definitionen und Referenzen, ein Index für Bedeutung.

Wenn Sie eine Suche für einen Coding-Agenten oder einen internen Code-Assistenten bauen, deckt meine [KI-Engineering-Arbeit](https://balazscsorba.com/de/expertise/ai-engineer) solche Setups ab, vom Chunking bis zur Evaluierung.

## Quellen

1.  [cAST: AST-based chunking for code RAG (arXiv 2506.15655)](https://arxiv.org/abs/2506.15655)
2.  [Aider docs: repository map](https://aider.chat/docs/repomap.html)
3.  [Aider blog: building a better repository map with tree-sitter (2023)](https://aider.chat/2023/10/22/repomap.html)
4.  [Anthropic Engineering: effective context engineering for AI agents (Sep 2025)](https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents)
5.  [Cursor blog: securely indexing large codebases (Jan 2026)](https://cursor.com/blog/secure-codebase-indexing)
6.  [turbopuffer: Cursor customer story](https://turbopuffer.com/customers/cursor)
7.  [Kilo Code docs: codebase indexing](https://kilo.ai/docs/customize/context/codebase-indexing)
8.  [Serena on GitHub](https://github.com/oraios/serena)
9.  [Voyage AI docs: pricing](https://docs.voyageai.com/docs/pricing)
10.  [Qwen blog: Qwen3-Embedding (Jun 2025)](https://qwenlm.github.io/blog/qwen3-embedding/)
11.  [CoIR: a benchmark for code information retrieval (arXiv 2407.02883)](https://arxiv.org/abs/2407.02883)
12.  [CocoIndex blog: indexing a codebase](https://cocoindex.io/blogs/index-codebase-v1)

## Häufige Fragen

Was ist RAG über Code?

Retrieval-augmented Generation, bei der der Korpus ein Code-Repository ist. Statt Text in Absätze zu teilen, zerlegt das System Code entlang der Syntax, meist in Funktionen und Klassen, indexiert diese Chunks mit Embeddings oder Symbolkarten und gibt dem Modell die relevantesten Teile für eine Aufgabe.

Warum AST-Chunking statt fester Zeilenfenster?

Feste Fenster schneiden Funktionen in der Mitte durch und trennen Decorators und Importe vom zugehörigen Code. Chunking entlang des abstrakten Syntaxbaums hält ganze Definitionen zusammen. Das cAST-Paper berichtet +4,3 Punkte Recall@5 auf RepoEval und +2,67 Punkte Pass@1 auf SWE-bench durch rekursives AST-Chunking mit Zusammenführen von Geschwisterknoten.

Was ist eine Repo-Map?

Eine kompakte Zusammenfassung der Klassen und Funktionen eines Repositorys mit ihren Signaturen, erstellt mit tree-sitter. Aider rankt Symbole über einen Graphen der Dateiabhängigkeiten und nimmt nur auf, was in ein Token-Budget passt, standardmäßig 1k Tokens, sodass das Modell die Struktur ohne Dateiinhalte sieht.

Welches Embedding-Modell eignet sich 2026 für Code?

Stand Oktober 2026 gibt es codeoptimierte Optionen wie voyage-code-4 für $0,12 pro Million Tokens und Qwen3-Embedding in 0.6B, 4B und 8B zum Selbsthosten; jina-embeddings-v4 meldet 71,59 auf CoIR unter einer Forschungslizenz. Bewerten Sie zwei oder drei Kandidaten mit Anfragen aus Ihrem eigenen Repository, bevor Sie wählen.

Brauchen Coding-Agenten überhaupt einen Vektorindex?

Nicht immer. Claude Code navigiert just in time mit grep und glob, was veraltete Indizes und komplexe Syntaxbäume vermeidet, aber langsamer ist als vorberechnete Suche. Ein Index lohnt sich bei großen oder unbekannten Repositorys und bei Fragen, die nach Bedeutung statt nach Namen gestellt werden.

Geschrieben von Balázs Csorba

Senior Fullstack & AI Engineer in der Steiermark – über 10 Jahre Vue, Nuxt, Node.js und PHP, heute baue ich Werkzeuge für KI-Agenten.

[KI-Entwicklung & MCP-Server →](https://balazscsorba.com/de/expertise/ai-engineer)[Über mich →](https://balazscsorba.com/de/about)

## Weitere Artikel

-   [Embedding-Modell wählen 2026: Leaderboards, Kosten und ein Vergleichstest mit eigenen Daten](https://balazscsorba.com/de/blog/embedding-model-selection-2026)
-   [Contextual Retrieval und Late Chunking: RAG-Chunks ihren Kontext zurückgeben](https://balazscsorba.com/de/blog/contextual-retrieval-late-chunking)
-   [Zugriffskontrolle für RAG: berechtigungsbewusstes Retrieval ohne Datenlecks](https://balazscsorba.com/de/blog/rag-access-control-permissions)
-   [RAG über Produktkataloge: aus PIM-Daten Antworten machen, die halten](https://balazscsorba.com/de/blog/rag-product-catalog-pim-data)

## Klingt nach dem, was du suchst?

Erzähl mir von deinem Projekt oder deiner Stelle – ich freue mich, von dir zu hören.

[Kontakt aufnehmen](mailto:contact@balazscsorba.com) [Auf LinkedIn vernetzen](https://www.linkedin.com/in/balazs-csorba)