integration prompts.yaml

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 = (
+        edge_list_str = "\n".join([f"- {e}" for e in all_note_edges])
-            "Du bist ein Knowledge Graph Experte. Deine Aufgabe ist es, Rohtext in "
+        
-            "thematisch geschlossene Abschnitte (Chunks) zu zerlegen.\n"
+        # 1. Prompt mit Template füllen
-            "Analysiere jeden Abschnitt auf Beziehungen zu anderen Konzepten (Entitäten, Personen, etc.).\n"
+        # Wir nutzen den ersten Teil des Templates als System/Rolle und den Rest als User-Prompt
-            "Antworte AUSSCHLIESSLICH mit validem JSON in diesem Format:\n"
+        
-            "[\n"
+        # NOTE: Da wir das Template direkt aus prompts.yaml laden, enthält es die SYSTEM/ROLLE direkt
-            "  {\n"
+        final_prompt = self.edge_template.format(
-            "    \"content\": \"Der Text des Abschnitts...\",\n"
+            note_type=source_type,
-            "    \"relations\": [{\"target\": \"Entität X\", \"type\": \"related_to\"}]\n"
+            chunk_text=text,
-            "  }\n"
+            edge_list_str=edge_list_str
-            "]\n"
-            "Halte die Chunks mittellang (ca. 100-300 Wörter). Verändere den Inhalt nicht, nur die Struktur."
         )
         
-        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, 
+                final_prompt, 
-                system=system_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):
+                # WENN data ein Array von Strings ist (wie im edge_allocation_template):
-                    logger.warning(f"SemanticAnalyzer: Ungültiges Chunk-Element ignoriert: {item}")
+                if isinstance(item, str) and ":" in item:
-                    continue
+                    # 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.
-                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")
                     
-                    if target:
+                    target = item.split(":", 1)[1].strip()
-                        # 1. Typ-Auflösung über die injizierte Funktion
+                    target_entity_type = target_type_resolver(target)
-                        target_entity_type = target_type_resolver(target) # <--- NUTZT DEN INJIZIERTEN RESOLVER
+                    
-                        
+                    # Hier MUSS der Edge-String manuell korrigiert werden, da der LLM-Output 
-                        # 2. Matrix-Logik anwenden:
+                    # die Matrix-Logik ignoriert. Wir simulieren die Korrektur hier nicht mehr, 
-                        final_kind = self.discovery._resolve_edge_type(source_type, target_entity_type)
+                    # sondern vertrauen dem LLM-Output (item) und überlassen die Matrix-Anwendung
-                        
+                    # dem derive_edges.py (wo sie hingehört).
-                        # 3. Priorisierung: Wählt den Matrix-Vorschlag, wenn er spezifischer ist.
+                    filtered_edges.append(item) # Füge den LLM-generierten String hinzu
-                        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)
                 
-                results.append(SemanticChunkResult(content=content, suggested_edges=refined_edges))
+                # Wenn das LLM fälschlicherweise das alte Format {content:..., relations:[...]} liefert,
-                
+                # ignorieren wir dies, da das edge_allocation_template ein Array von Strings erwartet.
-            return results
 
+            # 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" 

config/prompts.yaml

@@ -137,4 +137,29 @@ interview_template: |
   # Titel der Notiz
   
   ## Erstes Schema Feld
-  Der Inhalt hier...
+  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", ...]