140 lines
5.7 KiB
Python
140 lines
5.7 KiB
Python
"""
|
|
app/services/semantic_analyzer.py — Edge Validation & Filtering
|
|
Version: Final (Entkoppelt von internen Typ-Simulationen)
|
|
"""
|
|
|
|
import json
|
|
import logging
|
|
from typing import List, Dict, Any, Optional
|
|
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__)
|
|
|
|
@dataclass
|
|
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
|
|
|
|
async def analyze_and_chunk(
|
|
self,
|
|
text: str,
|
|
source_type: str,
|
|
# NEU: Erfordert die Auflösungsfunktion als Eingabe (DI-Prinzip)
|
|
target_type_resolver: Optional[callable] = None
|
|
) -> List[SemanticChunkResult]:
|
|
"""
|
|
Zerlegt Text mittels LLM in semantische Abschnitte und extrahiert Kanten.
|
|
"""
|
|
|
|
# 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."
|
|
)
|
|
|
|
user_prompt = f"Dokument-Typ: {source_type}\n\nTEXT:\n{text}"
|
|
|
|
try:
|
|
response_json = await self.llm.generate_raw_response(
|
|
user_prompt,
|
|
system=system_prompt,
|
|
force_json=True
|
|
)
|
|
|
|
clean_json = response_json.replace("```json", "").replace("```", "").strip()
|
|
data = json.loads(clean_json)
|
|
|
|
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 = []
|
|
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")
|
|
|
|
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)
|
|
|
|
results.append(SemanticChunkResult(content=content, suggested_edges=refined_edges))
|
|
|
|
return results
|
|
|
|
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=[])]
|
|
|
|
# NEU: Abstrakter Fallback-Resolver (muss außerhalb des Kernmoduls verbleiben)
|
|
def _default_target_type_resolver(self, title: str) -> str:
|
|
"""Standard-Fallback, wenn kein Resolver übergeben wird (immer 'concept')."""
|
|
return "concept"
|
|
|
|
async def close(self):
|
|
if self.llm:
|
|
await self.llm.close()
|
|
|
|
# Export des Singleton-Helpers
|
|
_analyzer_instance = None
|
|
def get_semantic_analyzer():
|
|
global _analyzer_instance
|
|
if _analyzer_instance is None:
|
|
_analyzer_instance = SemanticAnalyzer()
|
|
return _analyzer_instance |