neuer start semantic chunker

This commit is contained in:
Lars committed 2025-12-12 11:40:38 +01:00
1 parent ecc2b60427
commit df971f9c56
4 files changed
+321 -373

No files matched your search

+52 -93
View File
@@ -1,131 +1,90 @@
"""
app/services/semantic_analyzer.py — Edge Validation & Filtering
Version: Final (Nutzt Prompts.yaml Template)
app/services/semantic_analyzer.py
Zweck: Asynchroner Service zur Zuweisung von Kanten zu Text-Chunks mittels LLM.
Nutzt Templates aus prompts.yaml.
"""
import json
import logging
from typing import List, Dict, Any, Optional
from typing import List, Optional
from dataclasses import dataclass
# Import der benötigten Services (Annahme: llm_service und discovery sind verfügbar.)
# Importe
from app.services.llm_service import LLMService
from app.services.discovery import DiscoveryService
logger = logging.getLogger(__name__)
@dataclass
class SemanticChunkResult:
content: str
suggested_edges: List[str] # Format: "kind:Target"
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: 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]:
async def assign_edges_to_chunk(self, chunk_text: str, all_edges: List[str], note_type: str) -> List[str]:
"""
[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.
Sendet einen Chunk und eine Liste potenzieller Kanten an das LLM.
Das LLM filtert heraus, welche Kanten für diesen Chunk relevant sind.
"""
if not self.edge_template:
logger.error("SemanticAnalyzer: 'edge_allocation_template' fehlt in prompts.yaml!")
return [SemanticChunkResult(content=text, suggested_edges=[])]
if not all_edges:
return []
# Standard-Resolver verwenden, wenn keiner übergeben wird
if target_type_resolver is None:
target_type_resolver = self._default_target_type_resolver
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
# 1. Prompt laden
prompt_template = self.llm.prompts.get("edge_allocation_template")
if not prompt_template:
logger.error("Prompt 'edge_allocation_template' in prompts.yaml nicht gefunden.")
return []
# 2. Kandidaten-Liste formatieren
# Wir übergeben die Kanten als einfache Liste, damit das LLM sie auswählen kann.
edges_str = "\n".join([f"- {e}" for e in all_edges])
# 3. Prompt füllen
final_prompt = prompt_template.format(
chunk_text=chunk_text[:3000], # Truncate safety
edge_list=edges_str
)
# 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)
# 4. LLM Call mit JSON Erzwingung
response_json = await self.llm.generate_raw_response(
final_prompt,
system=None, # System-Rolle ist im Template enthalten
prompt=final_prompt,
force_json=True
)
# 5. Parsing
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.")
# 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:
# Fallback für leere Antworten
if not clean_json:
return []
filtered_edges = []
for item in data:
# 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.
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
# 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)]
data = json.loads(clean_json)
# 6. Validierung: Wir erwarten eine Liste von Strings
if isinstance(data, list):
# Filtern: Nur Strings zurückgeben, die auch in der Input-Liste waren (Sicherheit)
# oder zumindest das korrekte Format haben.
valid_edges = [str(e) for e in data if isinstance(e, str) and ":" in e]
return valid_edges
elif isinstance(data, dict):
# Manchmal packt das LLM es in {"edges": [...]}
for key, val in data.items():
if isinstance(val, list):
return [str(e) for e in val if isinstance(e, str)]
except json.JSONDecodeError:
logger.error("SemanticAnalyzer: LLM lieferte KEIN valides JSON. Fallback auf Raw Text.")
return [SemanticChunkResult(content=text, suggested_edges=[])]
except Exception as e:
logger.error(f"SemanticAnalyzer Unbehandelter Fehler: {e}")
return [SemanticChunkResult(content=text, suggested_edges=[])]
logger.warning(f"SemanticAnalyzer: Unerwartetes JSON Format: {str(data)[:100]}")
return []
# NEU: Abstrakter Fallback-Resolver
def _default_target_type_resolver(self, title: str) -> str:
"""Standard-Fallback, wenn kein Resolver übergeben wird (immer 'concept')."""
return "concept"
except json.JSONDecodeError:
logger.warning("SemanticAnalyzer: LLM lieferte kein valides JSON. Keine Kanten zugewiesen.")
return []
except Exception as e:
logger.error(f"SemanticAnalyzer Error: {e}")
return []
async def close(self):
if self.llm:
await self.llm.close()
# Export des Singleton-Helpers
# Singleton Helper
_analyzer_instance = None
def get_semantic_analyzer():
global _analyzer_instance