From ecc2b60427794d77d7a35b63cd66360cd519fe37 Mon Sep 17 00:00:00 2001 From: Lars Date: Fri, 12 Dec 2025 10:39:40 +0100 Subject: [PATCH] integration prompts.yaml --- app/services/semantic_analyzer.py | 112 ++++++++++++++---------------- config/prompts.yaml | 27 ++++++- 2 files changed, 79 insertions(+), 60 deletions(-) diff --git a/app/services/semantic_analyzer.py b/app/services/semantic_analyzer.py index 1cf7cda..b159ed7 100644 --- a/app/services/semantic_analyzer.py +++ b/app/services/semantic_analyzer.py @@ -1,6 +1,6 @@ """ app/services/semantic_analyzer.py — Edge Validation & Filtering -Version: Final (Entkoppelt von internen Typ-Simulationen) +Version: Final (Nutzt Prompts.yaml Template) """ import json @@ -10,7 +10,6 @@ from dataclasses import dataclass # Import der benötigten Services (Annahme: llm_service und discovery sind verfügbar.) from app.services.llm_service import LLMService -# ANNAHME: DiscoveryService ist für die Matrix-Logik verfügbar. from app.services.discovery import DiscoveryService logger = logging.getLogger(__name__) @@ -20,101 +19,96 @@ class SemanticChunkResult: content: str suggested_edges: List[str] # Format: "kind:Target" -# Die Klasse muss den TargetTypeResolver als DI-Abhängigkeit erhalten, um flexibel zu sein. -# Da dies aber im Mindnet-System noch nicht etabliert ist, muss der Aufrufer den Resolver bereitstellen. - class SemanticAnalyzer: def __init__(self): self.llm = LLMService() self.discovery = DiscoveryService() self.MAX_CONTEXT_TOKENS = 3000 + # NEU: Prompts aus dem LLMService laden + self.edge_template = self.llm.prompts.get("edge_allocation_template", "") async def analyze_and_chunk( self, text: str, source_type: str, - # NEU: Erfordert die Auflösungsfunktion als Eingabe (DI-Prinzip) + # NEU: all_note_edges ist jetzt ein zwingendes Argument für diesen Workflow + all_note_edges: List[str], target_type_resolver: Optional[callable] = None ) -> List[SemanticChunkResult]: """ - Zerlegt Text mittels LLM in semantische Abschnitte und extrahiert Kanten. + [WP-15] Führt die semantische Analyse durch (Zerlegung ODER Kantenfilterung). + Da wir nur den 5-Schritte-Workflow nutzen, wird dies primär als Kantenfilter genutzt. """ + if not self.edge_template: + logger.error("SemanticAnalyzer: 'edge_allocation_template' fehlt in prompts.yaml!") + return [SemanticChunkResult(content=text, suggested_edges=[])] + # Standard-Resolver verwenden, wenn keiner übergeben wird if target_type_resolver is None: target_type_resolver = self._default_target_type_resolver - - system_prompt = ( - "Du bist ein Knowledge Graph Experte. Deine Aufgabe ist es, Rohtext in " - "thematisch geschlossene Abschnitte (Chunks) zu zerlegen.\n" - "Analysiere jeden Abschnitt auf Beziehungen zu anderen Konzepten (Entitäten, Personen, etc.).\n" - "Antworte AUSSCHLIESSLICH mit validem JSON in diesem Format:\n" - "[\n" - " {\n" - " \"content\": \"Der Text des Abschnitts...\",\n" - " \"relations\": [{\"target\": \"Entität X\", \"type\": \"related_to\"}]\n" - " }\n" - "]\n" - "Halte die Chunks mittellang (ca. 100-300 Wörter). Verändere den Inhalt nicht, nur die Struktur." + + edge_list_str = "\n".join([f"- {e}" for e in all_note_edges]) + + # 1. Prompt mit Template füllen + # Wir nutzen den ersten Teil des Templates als System/Rolle und den Rest als User-Prompt + + # NOTE: Da wir das Template direkt aus prompts.yaml laden, enthält es die SYSTEM/ROLLE direkt + final_prompt = self.edge_template.format( + note_type=source_type, + chunk_text=text, + edge_list_str=edge_list_str ) - user_prompt = f"Dokument-Typ: {source_type}\n\nTEXT:\n{text}" + # Wir trennen den System-Teil (bis zur ANWEISUNG) nicht mehr manuell, + # sondern übergeben den gesamten Prompt und lassen das LLM die Rolle verstehen. try: + # 2. LLM Call (Async) response_json = await self.llm.generate_raw_response( - user_prompt, - system=system_prompt, + final_prompt, + system=None, # System-Rolle ist im Template enthalten force_json=True ) clean_json = response_json.replace("```json", "").replace("```", "").strip() data = json.loads(clean_json) + # --- Robuste Parsing-Logik (wie in den Korrekturen etabliert) --- if isinstance(data, dict): data = [data] elif not isinstance(data, list): logger.error("SemanticAnalyzer: JSON root ist weder Array noch Objekt. Fehlerhafte LLM-Antwort.") raise ValueError("Root element is not a list or dictionary.") - results = [] + # Da wir im 5-Schritte-Workflow nur ein Array von Kanten-Strings erwarten: + # Wir behandeln das Resultat (data) als die gefilterte Kantenliste + + if not data: + return [] + + filtered_edges = [] for item in data: - if not isinstance(item, dict): - logger.warning(f"SemanticAnalyzer: Ungültiges Chunk-Element ignoriert: {item}") - continue - - content = item.get("content", "").strip() - if not content: continue - - raw_rels = item.get("relations", []) - refined_edges = [] - - for rel in raw_rels: - if not isinstance(rel, dict): - logger.warning(f"SemanticAnalyzer: Ignoriere ungültige Relation: {rel}") - continue - - target = rel.get("target") - raw_type = rel.get("type", "related_to") + # WENN data ein Array von Strings ist (wie im edge_allocation_template): + if isinstance(item, str) and ":" in item: + # Um die Matrix-Logik zu aktivieren, muss jedes Item einmal durch die Matrix. + # Dies ist komplex, da wir den Typ der ZIEL-Entität benötigen. - if target: - # 1. Typ-Auflösung über die injizierte Funktion - target_entity_type = target_type_resolver(target) # <--- NUTZT DEN INJIZIERTEN RESOLVER - - # 2. Matrix-Logik anwenden: - final_kind = self.discovery._resolve_edge_type(source_type, target_entity_type) - - # 3. Priorisierung: Wählt den Matrix-Vorschlag, wenn er spezifischer ist. - if final_kind not in ["related_to", "references"] and target_entity_type != "concept": - edge_str = f"{final_kind}:{target}" - else: - edge_str = f"{raw_type}:{target}" - - refined_edges.append(edge_str) + target = item.split(":", 1)[1].strip() + target_entity_type = target_type_resolver(target) + + # Hier MUSS der Edge-String manuell korrigiert werden, da der LLM-Output + # die Matrix-Logik ignoriert. Wir simulieren die Korrektur hier nicht mehr, + # sondern vertrauen dem LLM-Output (item) und überlassen die Matrix-Anwendung + # dem derive_edges.py (wo sie hingehört). + filtered_edges.append(item) # Füge den LLM-generierten String hinzu - results.append(SemanticChunkResult(content=content, suggested_edges=refined_edges)) - - return results + # Wenn das LLM fälschlicherweise das alte Format {content:..., relations:[...]} liefert, + # ignorieren wir dies, da das edge_allocation_template ein Array von Strings erwartet. + # Das LLM hat nun die Kanten für den Chunk gefiltert. + return [SemanticChunkResult(content=text, suggested_edges=filtered_edges)] + except json.JSONDecodeError: logger.error("SemanticAnalyzer: LLM lieferte KEIN valides JSON. Fallback auf Raw Text.") return [SemanticChunkResult(content=text, suggested_edges=[])] @@ -122,7 +116,7 @@ class SemanticAnalyzer: logger.error(f"SemanticAnalyzer Unbehandelter Fehler: {e}") return [SemanticChunkResult(content=text, suggested_edges=[])] - # NEU: Abstrakter Fallback-Resolver (muss außerhalb des Kernmoduls verbleiben) + # NEU: Abstrakter Fallback-Resolver def _default_target_type_resolver(self, title: str) -> str: """Standard-Fallback, wenn kein Resolver übergeben wird (immer 'concept').""" return "concept" diff --git a/config/prompts.yaml b/config/prompts.yaml index f192109..a8b5904 100644 --- a/config/prompts.yaml +++ b/config/prompts.yaml @@ -137,4 +137,29 @@ interview_template: | # Titel der Notiz ## Erstes Schema Feld - Der Inhalt hier... \ No newline at end of file + Der Inhalt hier... + + +# --------------------------------------------------------- +# 6. EDGE_ALLOCATION: Kantenfilter (Intent: OFFLINE_FILTER) +# --------------------------------------------------------- +edge_allocation_template: | + SYSTEM ROLLE: Du bist ein Edge Filter Agent. Deine Aufgabe ist es, aus einer gegebenen Liste von potentiellen + Knowledge Graph Kanten (Edges) jene auszuwählen, die *semantisch relevant* für den vorliegenden + Textausschnitt sind. Alle Kanten beziehen sich auf die Hauptnotiz. + + EINGABE: + - Notiz-Typ: {note_type} + - Textausschnitt: + --- + {chunk_text} + --- + - Gesamte Kanten der Notiz (AUSWAHL): + {edge_list_str} + + ANWEISUNG: + Antworte AUSSCHLIESSLICH mit einer validen JSON-Liste von Kanten-Strings, die im Text direkt erwähnt oder + klar impliziert werden. Es ist KEIN Array von Objekten, sondern ein Array von Strings. Wähle nur Kanten, + die der Chunk *aktiv* benötigt oder referenziert. + + OUTPUT FORMAT: ["kind:Target", "kind:Target", ...] \ No newline at end of file