Startseite / Artikel / Praktische Hinweise: Aufbau einer modernen ISR-Pipeline für die Code-Modellierung in großen Projekten

agents llm architecture typescript python rag

Praktische Hinweise: Aufbau einer modernen ISR-Pipeline für die Code-Modellierung in großen Projekten

Schrittweise Anleitung zu den Praktischen Hinweisen: Aufbau einer modernen ISR-Pipeline für die Code-Modellierung in großen Projekten – Verträge, Überprüfungen sowie Code-Slots für Teams, die dieses Muster einsetzen.

4540 Wörter

Die folgenden Notizen skizzieren einen praktischen Ansatz zu „Der Aufbau einer modernen ISR-Pipeline für die Code-Verarbeitung in großskaligen Agentenframeworks“. Der Schwerpunkt liegt auf Verträgen, Überprüfungen sowie Ersatzcode-Platzhaltern statt auf motivierenden Erläuterungen. Während der Überblicksphase sollten zunächst die Anforderungen festgehalten werden: erforderliche Eingaben, Erfolgsindikatoren sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Dokumentieren Sie sowohl den erfolgreichen Ablauf als auch den Fehlerbehebungsprozess gemeinsam. Wiederholte Versuche, menschliche Überprüfungen sowie die Handhabung von Fehlern gehören zum Produkt selbst und nicht zu späteren Optimierungen.

Das Problem, das niemand wirklich gelöst hat

Das Problem „Nobody Really“ funktioniert am besten, wenn es als messbare Struktur behandelt wird. Erfassen Sie ein gelungenes Beispiel, einen Fehlerfall sowie die Notizen zum Rollback, bevor Sie den Umfang erweitern. Ziehen Sie kleine, testbare Einheiten vor großen Skripten vor. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortung verweisen und nicht auf einen verworrenen Ablauf. Stellen Sie Tools mit eng definierten Schemata sowie klaren Kennzeichnungen für Nebeneffekte bereit. Die Hosts müssen wissen, welche Aufrufe den Zustand verändern, bevor sie automatisch zustimmen.

Phase 1: Eingabe – Aufbau der drei Säulen

Die Phase 1 Ingestion Building-Phase funktioniert am besten, wenn sie als messbare Ebene betrachtet wird. Erfassen Sie ein „goldenes“ Transkript, einen Fehlerfall sowie die Rollback-Anmerkung, bevor Sie den Umfang erweitern. Betrachten Sie diese Phase als Vertrag zwischen Eingaben und validierten Ausgaben. Benennen Sie die Artefakte, definieren Sie Erfolgskontrollen und lehnen Sie stille, teilweise abgeschlossene Arbeiten ab. Stellen Sie Tools mit engen Schemata sowie expliziten Kennzeichnungen für Nebeneffekte bereit. Die Hosts müssen wissen, welche Aufrufe den Zustand verändern, bevor sie automatisch zustimmen.

Schritt 1: Klonen und Vorbereiten des Repositoriums

Die Klonierung in Schritt 1 sowie die jeweiligen Phasen funktionieren am besten, wenn sie als messbare Größen betrachtet werden. Erfassen Sie vor Erweiterung des Umfangs ein „goldenes Transkript“, einen Fehlerfall sowie eine Notiz zur Rücksetzung. Notieren Sie die Laufzeiten sowie die Kosten für Token oder Abfragen neben den funktionalen Ergebnissen. Eine frühzeitige Sichtbarkeit der Kosten verhindert überraschende Rechnungen, wenn der Prozess von einer Demo in gemeinsam genutzte Umgebungen übergeht. Stellen Sie Tools mit engen Schemata sowie klaren Kennzeichnungen für Nebeneffekte bereit. Die Betreiber müssen wissen, welche Aufrufe den Zustand verändern, bevor sie automatisch zustimmen.

git.Repo.clone_from(
    f"https://{token}@github.com/{owner}/{repo}",
    target_dir=f"~/.isr/repos/{owner}/{repo}",
    depth=None  # Full history — crucial for incremental updates
)

Schritt 2: Datei-Enumerierung und Spracherkennung

Zur Phase der Datei-Enumerierung in Schritt 2 sollten die Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Ändern des Codes definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckten Zuständen schließen zu müssen. Vorzuziehen sind kleine, testbare Einheiten statt umfangreicher Skripte. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortung verweisen und nicht auf ein verworrenes Ablaufschema. Authentifizieren Sie sich am Gateway und erteilen Sie erneut Berechtigungen auf der Datenebene. Ein alleiniges Trägertoken stellt keine Trennlinie zwischen verschiedenen Nutzern dar.

Schritt 3: AST-Zerlegung – Das schwierigste Problem

In der Phase des AST-Chunkings in Schritt 3 sollten die Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Ändern des Codes definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Betrachten Sie diese Phase als Vertrag zwischen den Eingaben und den validierten Ausgaben. Benennen Sie die Artefakte, definieren Sie Erfolgskontrollen und lehnen Sie stille, unvollständige Abschlüsse ab. Authentifizieren Sie sich am Gateway und erteilen Sie erneut Berechtigungen auf der Datenebene. Ein alleiniges Trägertoken stellt keine Trennlinie zwischen Berechtigungsgebieten dar.

assert "".join(chunk.raw_text for chunk in chunks) == file.content

Schritt 4: Symbolextraktion – Aufbau des Aufrufgraphen

Zur Phase der Symbolextraktion in Schritt 4 sollten die Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Codeändern definiert werden. Die Betreiber sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Erhalten Sie neben den funktionalen Ergebnissen auch Aufzeichnungen der Laufzeiten sowie der Kosten für Tokens oder Abfragen. Eine frühzeitige Sichtbarkeit der Kosten verhindert überraschende Rechnungen, wenn der Prozess von Demonstrationsumgebungen in gemeinsam genutzte Umgebungen übergeht. Authentifizieren Sie sich am Gateway und erteilen Sie erneut Berechtigungen auf der Datenebene. Ein alleiniger Tragertoken stellt keine Trennlinie zwischen verschiedenen Nutzergruppen dar. Zur Phase der Symbolextraktion in Schritt 4 sollten die Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Codeändern definiert werden. Die Betreiber sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Dokumentieren Sie sowohl den erfolgreichen Ablauf als auch den Notfallweg gemeinsam. Wiederholungsversuche, menschliche Kontrollen sowie die Handhabung von Fehlern gehören zum Produkt selbst und nicht zu späteren Optimierungen.

class_pattern = r'class\s+(\w+)'
func_pattern_python = r'def (\w+)\('
func_pattern_go = r'func.*\('

Schritt 5: Erstellung des Headers – Hinzufügen von Metadatenkontext

Während der Phase der Header-Erstellung im Schritt 5 sollten Sie zunächst den Vertrag aufschreiben: erforderliche Eingaben, Erfolgsindikatoren sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Ziehen Sie kleine, testbare Einheiten vor großen Skripten. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortung verweisen und nicht auf ein verworrenes Ablaufschema. Protokollieren Sie für jeden Aufruf den Namen des Tools, den Hash der Argumente, die Latenzzeit sowie das Ergebnis. Ohne diese Aufzeichnungen verschwenden Sie bei der Fehlersuche Stunden.

# File: decode.go
# Class/Module: decoder
# Function: unmarshal(n *Node, out reflect.Value) (good bool)
# Description: Handles type dispatch for YAML → Go struct conversion

Schritt 6: Erstellung des Kontexts (optional) – Bereicherung durch LLM

Während der Phase „Kontextgenerierung“ im Schritt 6 sollten Sie zunächst den Vertrag aufschreiben: erforderliche Eingaben, Erfolgsindikatoren sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Betrachten Sie diese Phase als Vertrag zwischen Eingaben und validierten Ausgaben. Benennen Sie die Erzeugnisse, definieren Sie Erfolgskontrollen und lehnen Sie stille, teilweise abgeschlossene Abläufe ab. Cachen Sie stabile Systemanweisungen sowie Tool-Schemata. Das erneute Senden identischer Vorlagen ist eine häufige Ursache für Ressourcenverschwendung.

INPUT: [large function body]
OUTPUT: "Handles type dispatch for YAML to Go struct conversion.
         Routes based on the target type reflection and handles nil values."

embedding_input = contextual_text + raw_text

Schritt 7: Code-Embedding – Umwandlung von Code in Vektoren

Beim Bearbeiten der Phase „Code Embedding“ in Schritt 7 sollten Sie zunächst den Vertrag aufschreiben: erforderliche Eingaben, Erfolgsignal sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Notieren Sie die Laufzeiten sowie die Kosten für Token oder Abfragen neben den funktionalen Ergebnissen. Eine frühzeitige Sichtbarkeit der Kosten verhindert überraschende Rechnungen, wenn der Weg von einer Demo-Umgebung in gemeinsam genutzte Umgebungen wechselt. Messen Sie die Trefferquote anhand eines festgelegten Fragebogens, bevor Sie die Anfragenanweisungen anpassen. Häufige Änderungen der Anfragenanweisungen beheben selten ein schwaches Suchsystem. Beim Bearbeiten der Phase „Code Embedding“ in Schritt 7 sollten Sie zunächst den Vertrag aufschreiben: erforderliche Eingaben, Erfolgssignal sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Dokumentieren Sie sowohl den erfolgreichen Ablauf als auch den Notfallweg gemeinsam. Wiederholte Versuche, menschliche Überprüfungen sowie die Handhabung von Fehlern gehören zum Produkt selbst und nicht zu späteren Optimierungen.

Schritt 8: Das Drei-Speicher-System – Der Kern des hybriden Ansatzes

Schritt 8, die Phase des Drei-Speicher-Systems, funktioniert am besten, wenn er als messbare Ebene betrachtet wird. Erfassen Sie vor der Erweiterung des Umfangs eine „goldene“ Transkription, einen Fehlerfall sowie die Rollback-Anmerkung. Ziehen Sie kleine, testbare Einheiten vor umfangreichen Skripten vor. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortung verweisen und nicht auf ein verworrenes Ablaufverfahren. Stellen Sie Tools mit engen Schemata sowie klaren Kennzeichnungen für Nebeneffekte bereit. Die Hosts müssen wissen, welche Aufrufe den Zustand verändern, bevor sie automatisch zustimmen.

Speicher 1: Qdrant – Vektor + Volltext

Die Qdrant Vector-Phase von Store 1 funktioniert am besten, wenn sie als messbare Oberfläche betrachtet wird. Erfassen Sie ein erfolgreiches Beispiel, einen Fehlerfall sowie die Notizen zum Rollback, bevor Sie den Umfang erweitern. Betrachten Sie diese Phase als Vertrag zwischen Eingaben und validierten Ausgaben. Benennen Sie die Artefakte, definieren Sie Erfolgskontrollen und lehnen Sie stille, unvollständige Abschlüsse ab. Stellen Sie Tools mit engen Schemata sowie klaren Kennzeichnungen für Nebeneffekte bereit. Die Hosts müssen wissen, welche Aufrufe den Zustand verändern, bevor sie automatisch zustimmen.

{
  "chunk_id": "a1b2c3d4e5f6:1",
  "repo_name": "go-yaml/yaml",
  "rel_path": "decode.go",
  "language": "go",
  "raw_text": "func (d *decoder) unmarshal(...) { ... }",
  "contextual_text": "Handles type dispatch for YAML...",
  "header": "# File: decode.go\n# Function: unmarshal...",
  "start_line": 340,
  "end_line": 390
}

point_id = uuid.uuid5(NAMESPACE_DNS, chunk_id).int % (2**63)

Store 2: BM25 – Reine Schlüsselwort-Rangliste

The Store 2 BM25 Pure-Phase funktioniert am besten, wenn sie als messbare Oberfläche betrachtet wird. Erfassen Sie vor Erweiterung des Umfangs ein „goldenes Transkript“, einen Fehlerfall sowie eine Notiz zur Rücksetzung. Erfassen Sie außerdem die Laufzeiten sowie die Kosten für Tokens oder Abfragen zusammen mit den funktionalen Ergebnissen. Eine frühzeitige Sichtbarkeit der Kosten verhindert überraschende Rechnungen, wenn sich der Ablauf von einer Demo in gemeinsame Umgebungen verschiebt. Stellen Sie Tools mit engen Schemata sowie expliziten Kennzeichnungen für Nebeneffekte bereit. Die Hosts müssen wissen, welche Aufrufe den Zustand verändern, bevor sie automatisch zustimmen. Die Store 2 BM25 Pure-Phase funktioniert am besten, wenn sie als messbare Oberfläche betrachtet wird. Erfassen Sie vor Erweiterung des Umfangs ein „goldenes Transkript“, einen Fehlerfall sowie eine Notiz zur Rücksetzung. Dokumentieren Sie den erfolgreichen Ablauf genauso wie den Wiederherstellungsprozess gemeinsam. Wiederholversuche, menschliche Überprüfungen sowie die Handhabung von Fehlern gehören zum Produkt selbst und nicht zu späteren Optimierungen.

# Build the BM25 index with full text
corpus = [chunk.get_text_for_embedding() for chunk in all_chunks]
bm25.fit(corpus)

# Store only the chunk IDs in the doc store
doc_store = [chunk.chunk_id for chunk in all_chunks]# Save both
pickle.dump(bm25, "index.pkl")
pickle.dump(doc_store, "doc_store.pkl")

Store 3: KùzuDB – Der Eigenschaftsgraph

Für die Store 3 K zuDB-Phase sollten Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Codeändern definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Man sollte kleine, testbare Einheiten vor umfangreichen Skripten bevorzugen. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortung verweisen und nicht auf ein verworrenes Pipeline-System. Authentifizieren Sie sich am Gateway und erteilen Sie erneut Berechtigungen auf der Datenebene. Ein alleinigesBearer-Token stellt keine Trennlinie zwischen verschiedenen Nutzern dar.

CREATE NODE TABLE Symbol (
  fqn STRING PRIMARY KEY,
  file STRING,
  language STRING,
  kind STRING
)

CREATE REL TABLE Calls (FROM Symbol TO Symbol, confidence FLOAT)
CREATE REL TABLE Imports (FROM Symbol TO Symbol, confidence FLOAT)
CREATE REL TABLE Inherits (FROM Symbol TO Symbol, confidence FLOAT)

MATCH (seed:Symbol WHERE seed.fqn IN [list_of_fqns])
      -[*1..hops]->(reachable:Symbol)
RETURN DISTINCT reachable.fqn

Store 4: Hash Tracker – Unterstützung der schrittweisen Eingabe

Für die Phase „Store 4 Hash Tracker“ sollten vor der Codeänderung Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Betrachten Sie diese Phase als Vertrag zwischen den Eingaben und den validierten Ausgaben. Benennen Sie die Artefakte, definieren Sie Erfolgskontrollen und lehnen Sie stille, unvollständige Abschlüsse ab. Authentifizieren Sie sich am Gateway und erteilen Sie erneut Berechtigungen auf der Datenebene. Ein alleinigesBearer-Token stellt keine Trennlinie zwischen Bereichen dar.

CREATE TABLE chunks (
  chunk_id TEXT PRIMARY KEY,
  repo_name TEXT,
  rel_path TEXT,
  content_sha256 TEXT,
  ingested_at TIMESTAMP
);

CREATE TABLE repos (
  repo_name TEXT PRIMARY KEY,
  last_sha TEXT,
  last_ingested TIMESTAMP
);

Schritt 9: Orchestrierung – Alles zusammenbringen

Zur Orchestrierungsphase Schritt 9 „Bringing“ sollten die Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Codeändern definiert werden. Die Betreiber sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Erhalten Sie neben den funktionalen Ergebnissen auch Aufzeichnungen der Laufzeiten sowie der Kosten für Token oder Abfragen. Eine frühzeitige Sichtbarkeit der Kosten verhindert überraschende Rechnungen, wenn der Ablauf von einer Demo-Umgebung in eine gemeinsam genutzte Umgebung wechselt. Authentifizieren Sie sich am Gateway und erteilen Sie erneut Berechtigungen auf der Datenebene. Ein alleiniges Trägertoken stellt keine Trennlinie zwischen verschiedenen Nutzergruppen dar. Zur Orchestrierungsphase Schritt 9 „Bringing“ sollten die Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Codeändern definiert werden. Die Betreiber sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Dokumentieren Sie sowohl den erfolgreichen Ablauf als auch den Notfallablauf gemeinsam. Wiederholungsversuche, menschliche Kontrollen sowie die Handhabung von Fehlern gehören zum Produkt selbst und nicht zu späteren Optimierungen.

Phase 2: Suche – Drei Signale, eine sortierte Liste

Während der dritten Phase der Suche in Phase 2 sollten Sie zunächst den Vertrag aufschreiben: erforderliche Eingaben, Erfolgsignal sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Ziehen Sie kleine, testbare Einheiten vor großen Skripten. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortung verweisen und nicht auf ein verworrenes Ablaufschema. Protokollieren Sie für jeden Aufruf den Namen des Tools, den Hash der Argumente, die Latenzzeit sowie das Ergebnis. Ohne diese Aufzeichnungen verschwenden Sie Stunden beim Debuggen von Schleifen.

Der Abfragerouter – Kostengünstige Klassifizierung

Beim Arbeiten in der Phase „The Query Router Zero-Cost“ sollten Sie zunächst den Vertrag aufschreiben: erforderliche Eingaben, Erfolgsignal sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Betrachten Sie diese Phase als Vertrag zwischen Eingaben und validierten Ausgaben. Benennen Sie die Ergebnisdokumente, definieren Sie Erfolgskontrollen und lehnen Sie stille, teilweise abgeschlossene Abläufe ab. Protokollieren Sie für jeden Aufruf den Namen des Tools, den Hash der Argumente, die Latenz sowie das Ergebnis. Ohne diese Aufzeichnungen verschwenden Debugging-Agenten Stunden mit sinnlosem Herumprobieren.

"how does ...", "explain how ...", "walk me through ...",
"trace ...", "step by step", "what happens when ..."

"what calls ...", "who calls ...", "callers of ...",
"what imports ...", "subclasses of ...", "where is X used ..."

camelCase like "parseTimestamp" or "NewDecoder"
snake_case like "parse_yaml"
quoted strings like "permission denied"
function calls like "handleErr()"

Der EXACT_FIRST-Schaltweg – Grep

Beim Arbeiten an der The EXACTFIRST Short-Circuit Grep-Ebene sollten Sie zunächst den Vertrag aufschreiben: erforderliche Eingaben, Erfolgsignal sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Notieren Sie die Laufzeiten sowie die Kosten für Token oder Abfragen neben den funktionalen Ergebnissen. Eine frühzeitige Sichtbarkeit der Kosten verhindert überraschende Rechnungen, wenn der Weg von einer Demo in gemeinsame Umgebungen wechselt. Protokollieren Sie für jeden Aufruf den Namen der Tool, den Hash der Argumente, die Latenzzeit sowie das Ergebnis. Ohne diese Aufzeichnungen verschwenden Debugging-Agenten Stunden damit, im Kreis zu laufen. Beim Arbeiten an der The EXACTFIRST Short-Circuit Grep-Ebene sollten Sie zunächst den Vertrag aufschreiben: erforderliche Eingaben, Erfolgssignal sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Dokumentieren Sie gemeinsam den erfolgreichen Ablauf sowie den Notfallweg. Wiederholte Versuche, menschliche Kontrollen und die Handhabung von Fehlern gehören zum Produkt selbst, nicht zu späteren Optimierungen.

rg --json --max-filesize 1M --context 5 --smart-case -- <query> <search_root>

Semantische Suche – Vektorähnlichkeit

Die Phase der semantischen Suche mit Vektorähnlichkeit funktioniert am besten, wenn sie als messbare Größe betrachtet wird. Erfassen Sie ein optimales Beispiel, einen Fehlerfall sowie die Notizen zur Rücksetzung, bevor Sie den Umfang erweitern. Ziehen Sie kleine, testbare Einheiten vor großen, komplexen Skripten vor. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortung verweisen und nicht auf einen verworrenen Ablauf. Stellen Sie Tools mit eng definierten Schemata sowie klaren Angaben zu Nebeneffekten bereit. Die Hosts müssen wissen, welche Aufrufe den Zustand verändern, bevor sie automatisch zustimmen.

Schlüsselwortsuche – BM25-Lexikalische Abgleichung

Die Schlüsselwortsuche im BM25-Lexikalischen Stadium funktioniert am besten, wenn sie als messbare Ebene betrachtet wird. Erfassen Sie ein erfolgreiches Beispiel, einen Fehlfall sowie die Notizen zur Rücksetzung, bevor Sie den Umfang erweitern. Betrachten Sie dieses Stadium als Vertrag zwischen Eingaben und validierten Ausgaben. Benennen Sie die Ergebnisse, definieren Sie Erfolgskontrollen und lehnen Sie stille, unvollständige Ergebnisse ab. Stellen Sie Tools mit engen Schemata sowie klaren Angaben zu Nebeneffekten bereit. Die Hosts müssen wissen, welche Aufrufe den Zustand verändern, bevor sie automatisch zustimmen.

Graphenerweiterung – Strukturelle Beziehungen

Die Phase „Graph Expansion Structural Relationships“ funktioniert am besten, wenn sie als messbare Ebene betrachtet wird. Erfassen Sie vor der Erweiterung des Umfangs ein „goldenes Transkript“, einen Fehlerfall sowie eine Notiz zur Rücksetzung. Erfassen Sie außerdem die Laufzeiten sowie die Kosten für Tokens oder Abfragen neben den funktionalen Ergebnissen. Eine frühzeitige Sichtbarkeit der Kosten verhindert überraschende Rechnungen, wenn der Prozess von einer Demo in gemeinsame Umgebungen übergeht. Stellen Sie Tools mit engen Schemata sowie expliziten Kennzeichnungen für Nebeneffekte bereit. Die Betreiber müssen wissen, welche Aufrufe den Zustand verändern, bevor sie automatisch zustimmen. Die Phase „Graph Expansion Structural Relationships“ funktioniert am besten, wenn sie als messbare Ebene betrachtet wird. Erfassen Sie vor der Erweiterung des Umfangs ein „goldenes Transkript“, einen Fehlerfall sowie eine Notiz zur Rücksetzung. Dokumentieren Sie gemeinsam den erfolgreichen Ablauf sowie den Wiederherstellungsprozess. Wiederholversuche, menschliche Überprüfungen sowie die Handhabung von Fehlern gehören zum Produkt selbst und nicht zu späteren Optimierungen.

MATCH (seed:Symbol WHERE seed.fqn IN [{seed_fqns}])
      -[*1..1]->(reachable:Symbol)
RETURN DISTINCT reachable.fqn

def _fqn_lookup_term(fqn: str) -> str:
    parts = fqn.split(".")
    # Use last two segments for specificity
    term = ".".join(parts[-2:])  # "PieceTree.applyDelta", not just "applyDelta"
    return term

RRF Fusion – Signale kombinieren

In der Phase der RRF Fusion zur Kombination von Signalen sollten vor dem Ändern des Codes die Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Es sollten kleine, testbare Einheiten vorzugsweise gegenüber umfangreichen Skripten verwendet werden. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortung verweisen und nicht auf ein verworrenes Pipeline-System. Authentifizieren Sie am Gateway und erteilen Sie erneut Berechtigungen auf der Datenebene. Ein alleiniges Trägertoken stellt keine Trennlinie zwischen verschiedenen Nutzern dar.

score(doc) = Σᵢ  1 / (k + rankᵢ(doc))

1/(60+1) + 1/(60+3) = 0.01639 + 0.01587 = 0.03226

1/(60+1) = 0.01639

Neubewertung – Bewertung mittels tiefem Cross-Encoder

Zur Bewertungsphase des Reranking Deep Cross-Encoders sollten die Eingaben, der Verantwortliche für diesen Schritt sowie die Abbruchkriterien vor dem Ändern des Codes definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Betrachten Sie diese Phase als Vertrag zwischen den Eingaben und den validierten Ausgaben. Benennen Sie die Erzeugnisse, definieren Sie Erfolgskontrollen und lehnen Sie stille, unvollständige Abschlüsse ab. Authentifizieren Sie sich am Gateway und erteilen Sie erneut Berechtigungen auf der Datenebene. Ein alleinigesBearer-Token stellt keine Trennlinie zwischen Berechtigungsgebieten dar.

client.rerank(query, documents, model="rerank-english-v3.0", top_n=20)

Der agierende Kreislauf — ORA (Beobachten → Überlegen → Handeln)

Für die The Agentic Loop ORA-Phase sollten vor dem Ändern des Codes die Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien definiert werden. Die Betreiber sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf verborgene Zustände schließen zu müssen. Erhalten Sie Zeitenangaben sowie Kosten für Token oder Abfragen zusammen mit den funktionalen Ergebnissen. Eine frühzeitige Sichtbarkeit der Kosten verhindert überraschende Rechnungen, wenn der Ablauf von einer Demo-Umgebung in eine gemeinsam genutzte Umgebung wechselt. Authentifizieren Sie sich am Gateway und erteilen Sie erneut Berechtigungen auf der Datenebene. Ein alleiniges Trägertoken stellt keine Trennlinie zwischen verschiedenen Nutzern dar. Für die The Agentic Loop ORA-Phase sollten vor dem Ändern des Codes die Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien definiert werden. Die Betreiber sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf verborgene Zustände schließen zu müssen. Dokumentieren Sie sowohl den erfolgreichen Ablauf als auch den Notfallablauf gemeinsam. Wiederholungsversuche, menschliche Überprüfungen sowie die Handhabung von Fehlern gehören zum Produkt selbst und nicht zu späteren Optimierungen.

INPUT: "How does YAML error handling work?"
OUTPUT: "yaml error handling failf TypeError panic propagate"

SearchPipeline – Der Orchestrator

Beim Arbeiten an der Phase „The Orchestrator“ des SearchPipeline sollten Sie zunächst den Vertrag festhalten: erforderliche Eingaben, Erfolgsignal sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Ziehen Sie kleine, testbare Einheiten vor großen Skripten. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortung verweisen und nicht auf ein verworrenes Pipeline-System. Protokollieren Sie für jeden Aufruf den Namen des Tools, den Hash der Argumente, die Latenzzeit sowie das Ergebnis. Ohne diese Aufzeichnungen verschwenden Sie Stunden beim Debuggen von Schleifen.

Phase 3: Abruf – Zusammenstellung des Kontexts und Synthese der Antwort

Während der Phase 3 „Retrieval Context“ sollten Sie zunächst einen Vertrag aufschreiben: erforderliche Eingaben, Erfolgsindikatoren sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Betrachten Sie diese Phase als Vertrag zwischen Eingaben und validierten Ausgaben. Benennen Sie die Ergebnisse, definieren Sie Erfolgskontrollen und lehnen Sie stille, teilweise abgeschlossene Prozesse ab. Messen Sie die Erinnerungsfähigkeit anhand eines festgelegten Fragebogens, bevor Sie die Anfragen anpassen. Häufige Änderungen der Anfragen beheben selten ein schwaches Retrieval-System.

ContextAssembler – Aufbau des Kontextfensters

Beim Arbeiten in der Phase „Context erstellen“ des ContextAssembler schreiben Sie zunächst den Vertrag auf: erforderliche Eingaben, Erfolgsignal sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Notieren Sie neben den funktionalen Ergebnissen auch die Laufzeiten sowie die Kosten für Tokens oder Abfragen. Eine frühzeitige Sichtbarkeit der Kosten verhindert überraschende Rechnungen, wenn der Weg von einer Demo-Umgebung in gemeinsam genutzte Umgebungen wechselt. Protokollieren Sie für jeden Aufruf den Namen der Tool, den Hash der Argumente, die Latenzzeit sowie das Ergebnis. Ohne diese Aufzeichnungen verschwenden Debugging-Agenten Stunden damit, im Kreis zu laufen. Beim Arbeiten in der Phase „Context erstellen“ des ContextAssembler schreiben Sie zunächst den Vertrag auf: erforderliche Eingaben, Erfolgssignal sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Dokumentieren Sie gemeinsam den erfolgreichen Ablauf sowie den Notfallweg. Wiederholte Versuche, menschliche Überprüfungen und die Handhabung von Fehlern gehören zum Produkt selbst, nicht zu späteren Optimierungen.

<context id="1" file="decode.go" lines="340-390"
         repo="go-yaml/yaml" source="qdrant" expansion="function">
func newDecoder() *decoder {
    ...
}
</context>

AnswerSynthesizer – LLM-Generierung mit Zitaten

Die AnswerSynthesizer-LLM-Generierung mit Phasen funktioniert am besten, wenn sie als messbarer Prozess betrachtet wird. Erfassen Sie ein gelungenes Beispiel, einen Fehlerfall sowie die Notizen zum Rollback, bevor Sie den Umfang erweitern. Ziehen Sie kleine, testbare Einheiten vor großen, komplexen Skripten. Wenn eine Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortung verweisen und nicht auf einen verworrenen Ablauf. Legen Sie Budgets für Tokens pro Schritt und pro Sitzung fest. Agentenbasierte Tools erweitern den Kontext stark; feste Obergrenzen verhindern, dass Demonstrationen zu unerwarteten Rechnungen werden.

You are a code intelligence assistant. Answer questions about source code precisely.

Rules:
- Answer ONLY from the provided code context — never hallucinate code or APIs
- Cite every file you reference using [path/to/file.go:start-end] format
- Show working code examples from the context, not just descriptions
- If context is insufficient, say exactly: "Insufficient context: [what is missing]"

\[([^:\]\s][^:\]]*):(\d+)(?:-(\d+))?\]

RetrievalPipeline – Der endgültige Orchesterer

Die Phase „Final Orchestrator“ von RetrievalPipeline funktioniert am besten, wenn sie als messbarer Ansatz betrachtet wird. Erfassen Sie ein perfektes Transkript, einen Fehlerfall sowie eine Notiz zur Rücksetzung, bevor Sie den Umfang erweitern. Betrachten Sie diese Phase als Vertrag zwischen Eingaben und validierten Ausgaben. Benennen Sie die Ergebnisdokumente, definieren Sie Erfolgskontrollen und lehnen Sie stille, unvollständige Abschlüsse ab. Trennen Sie die Strategie zur Aufteilung in Blöcke von der Strategie zur Datenerfassung. Ein Änderungs an einer sollte nicht dazu führen, dass die andere neu geschrieben werden muss, wenn sich die Qualitätsmetriken ändern.

retrieval = RetrievalPipeline(
    search_pipeline=SearchPipeline(...),
    context_assembler=ContextAssembler(search_pipeline.qdrant),
    answer_synthesizer=AnswerSynthesizer(...),
)

API und CLI

Die API- und CLI-Ebene funktioniert am besten, wenn sie als messbarer Bereich betrachtet wird. Erfassen Sie vor Erweiterung des Umfangs ein optimales Beispiel, einen Fehlerfall sowie eine Notiz zur Rücksetzung. Erfassen Sie außerdem die Laufzeiten sowie die Kosten für Token oder Abfragen zusammen mit den funktionalen Ergebnissen. Eine frühzeitige Sichtbarkeit der Kosten verhindert überraschende Rechnungen, wenn der Einsatzbereich von einer Demo-Umgebung in gemeinsam genutzte Umgebungen wechselt. Stellen Sie Tools mit engen Schemata sowie klaren Kennzeichnungen für Nebeneffekte bereit. Die Betreiber müssen wissen, welche Aufrufe den Zustand verändern, bevor sie diese automatisch freigeben.

HTTP API

Die HTTP-API-Ebene funktioniert am besten, wenn sie als messbarer Bereich betrachtet wird. Erfassen Sie ein „goldenes“ Transkript, einen Fehlerfall sowie eine Notiz zur Rücksetzung, bevor Sie den Umfang erweitern. Bewahren Sie Konfigurationen außerhalb des Anwendungscode auf. Umgebungsdateien, Geheimdatenspeicher und Feature-Flags sollten an einem Ort gesammelt sein, den Betreiber ohne das Durchlesen des gesamten Systems prüfen können. Stellen Sie Tools mit eng definierten Schemata sowie expliziten Kennzeichnungen für Nebeneffekte bereit. Die Hosts müssen wissen, welche Aufrufe den Zustand verändern, bevor sie automatisch zustimmen.

{
  "query": "parseTimestamp",
  "repo_name": "go-yaml/yaml",
  "top_k": 10,
  "use_graph": false,
  "use_rerank": true
}

{
  "question": "how does yaml error handling work?",
  "repo_name": "go-yaml/yaml",
  "mode": "answer",
  "max_context_chunks": 10
}

CLI

Die CLI-Phase funktioniert am besten, wenn sie als messbarer Bereich betrachtet wird. Erfassen Sie ein optimales Transkript, einen Fehlerfall sowie eine Notiz zur Rücksetzung, bevor Sie den Umfang erweitern. Dokumentieren Sie gleichzeitig den erfolgreichen Ablauf sowie den Wiederherstellungsprozess. Wiederholversuche, menschliche Überprüfungen und die Handhabung von Fehlern gehören zum Produkt selbst und nicht zu späteren Optimierungen. Stellen Sie Tools mit eng definierten Schemata sowie klaren Kennzeichnungen für Nebeneffekte bereit. Die Hosts müssen wissen, welche Aufrufe den Zustand verändern, bevor sie automatisch zustimmen.

# Ingest a repository
isr ingest go-yaml/yaml --with-context

# Search
isr search "what calls Unmarshal" --repo go-yaml/yaml# Retrieve with answer
isr retrieve "how does YAML error handling work?" \
  --repo go-yaml/yaml --mode answer --verbose# Start the server
isr server

Konfiguration und Optimierung

Die Phase der Konfiguration und Optimierung funktioniert am besten, wenn sie als messbarer Prozess betrachtet wird. Erfassen Sie ein gelungenes Beispiel, einen Fehlerfall sowie eine Notiz zur Rücksetzung, bevor Sie den Umfang erweitern. Ziehen Sie kleine, testbare Einheiten vor großen Skripten vor. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortung verweisen und nicht auf einen komplizierten Ablauf. Stellen Sie Tools mit eng definierten Schemata sowie klaren Angaben zu Nebeneffekten bereit. Die Hosts müssen wissen, welche Aufrufe den Zustand verändern, bevor sie automatisch zustimmen.

Bewertung und Testing

Die Phase der Bewertung und Tests funktioniert am besten, wenn sie als messbarer Rahmen betrachtet wird. Erfassen Sie vor Erweiterung des Umfangs ein „goldenes“ Transkript, einen Fehlerfall sowie eine Notiz zur Rücksetzung. Behandeln Sie diese Phase als Vertrag zwischen Eingaben und validierten Ausgaben. Benennen Sie die Ergebnisdokumente, definieren Sie Erfolgskontrollen und lehnen Sie stille, unvollständige Abschlüsse ab. Stellen Sie Tools mit engen Schemata sowie klaren Angaben zu Nebeneffekten bereit. Die Hosts müssen wissen, welche Aufrufe den Zustand verändern, bevor sie automatisch zustimmen.

Fazit: Warum das wichtig ist

Die Phase „Fazit: Warum das wichtig ist“ funktioniert am besten, wenn sie als messbarer Bereich betrachtet wird. Erfassen Sie ein „goldenes Transkript“, einen Fehlerfall sowie eine Notiz zur Rücksetzung, bevor Sie den Umfang erweitern. Erfassen Sie außerdem die Laufzeiten sowie die Kosten für Tokens oder Abfragen zusammen mit den funktionalen Ergebnissen. Eine frühzeitige Sichtbarkeit der Kosten verhindert überraschende Rechnungen, wenn der Prozess von einer Demo in gemeinsam genutzte Umgebungen übergeht. Stellen Sie Tools mit engen Schemata sowie klaren Kennzeichnungen für Nebeneffekte bereit. Die Betreiber müssen wissen, welche Aufrufe den Zustand verändern, bevor sie automatisch zustimmen. Die Phase „Fazit: Warum das wichtig ist“ funktioniert am besten, wenn sie als messbarer Bereich betrachtet wird. Erfassen Sie ein „goldenes Transkript“, einen Fehlerfall sowie eine Notiz zur Rücksetzung, bevor Sie den Umfang erweitern. Dokumentieren Sie gemeinsam den erfolgreichen Ablauf sowie den Wiederherstellungsprozess. Wiederholversuche, menschliche Überprüfungen sowie die Handhabung von Fehlern gehören zum Produkt selbst und nicht zu späteren Optimierungen.

Operative Kontrollliste

Zur Phase der Betriebskontrollliste sollten die Eingabedaten, der Verantwortliche für den jeweiligen Schritt sowie die Abbruchkriterien vor dem Ändern des Codes definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen.

Halten Sie die Konfiguration außerhalb des Anwendungscode. Umgebungsdateien, Geheimdatenspeicher und Feature-Flags sollten an einem Ort gesammelt sein, den die Operator überprüfen können, ohne den gesamten Ablauf durchzulesen.

Authentifizieren Sie sich am Gateway und erteilen Sie erneut Berechtigungen auf der Datenebene. Ein alleinigesBearer-Token stellt keine Trennlinie zwischen verschiedenen Nutzungseinheiten dar.

Führen Sie nach aufwändigen Schritten einen Checkpoint durch. Das Wiederaufnehmen des Vorgangs sollte keine erneute Abrechnung für denselben LLM-Aufruf veranlassen, wenn ein Operator einen späteren Knoten erneut ausführt.

Pinnen Sie die Abhängigkeitsversionen und speichern Sie den Image-Digest, mit dem die Demo ausgeführt wurde. Reproduzierbarkeit ist besser als „stammesbezogenes Wissen“.

Betrachten Sie diese Phase als Vertrag zwischen Eingaben und validierten Ausgaben. Benennen Sie die Artefakte, definieren Sie Erfolgskontrollen und lehnen Sie stille, unvollständige Abschlüsse ab.

Vor der Weiterentwicklung des Stack sollten Sie Versionen einfrieren, ein „goldenes“ Protokoll für den kritischen Pfad erstellen und die Rollback-Schritte bestätigen. Gemeinsame Umgebungen benötigen Geschwindigkeitsbeschränkungen, Überprüfungen der Nutzungsrechte sowie einen klaren Verantwortlichen für die Rotation von Geheimnissen. Wählen Sie langweilige Zuverlässigkeit statt cleverer, einmaliger Demonstrationen.

Batch-Hinweis für 2f4a57bf7527: Halten Sie die Provider-Schlüssel außerhalb des Repositories, legen Sie eine Obergrenze für Session-Tokens fest und speichern Sie die Protokolle neben den Evaluierungs-Dateien, damit spätere Modellwechsel vergleichbar bleiben.

Alle Artikel Brief senden