bug fixing

This commit is contained in:
Lars committed 2025-12-12 10:25:01 +01:00
1 parent cd28a9d35c
commit 135c02bc9a
2 files changed
+452 -132

No files matched your search

+102 -49
View File
@@ -1,87 +1,140 @@
"""
app/services/semantic_analyzer.py — Edge Validation & Filtering
Der Service ist nun primär dafür zuständig, Kanten aus einer Liste dem gegebenen Chunk zuzuordnen.
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 ist verfügbar.)
# 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__)
# Ein Singleton-Muster für den Analyzer (wie zuvor)
_analyzer_instance: Optional['SemanticAnalyzer'] = None
@dataclass
class SemanticChunkResult:
content: str
suggested_edges: List[str] # Format: "kind:Target"
def get_semantic_analyzer():
global _analyzer_instance
if _analyzer_instance is None:
_analyzer_instance = SemanticAnalyzer()
return _analyzer_instance
# 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):
# Der DiscoveryService wird hier nicht mehr direkt benötigt.
self.llm = LLMService()
self.discovery = DiscoveryService()
self.MAX_CONTEXT_TOKENS = 3000
async def filter_edges_for_chunk(self, chunk_text: str, all_note_edges: List[str], note_type: str) -> List[str]:
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]:
"""
[Schritt 4 des Workflows] Sendet Chunk und alle Kanten an LLM, um die relevanten Kanten für diesen Chunk zu filtern.
:param chunk_text: Der Text des Chunks zur Analyse.
:param all_note_edges: Alle für die gesamte Notiz gefundenen Kanten (Format: "kind:Target").
:param note_type: Der Typ der Notiz.
:return: Liste der relevanten Kanten für diesen Chunk.
Zerlegt Text mittels LLM in semantische Abschnitte und extrahiert Kanten.
"""
if not all_note_edges:
return []
edge_list_str = "\n".join([f"- {e}" for e in all_note_edges])
system_prompt = (
"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.\n"
"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.\n"
"Format: [\"kind:Target\", \"kind:Target\", ...]\n"
"Wähle nur Kanten, die der Chunk *aktiv* benötigt oder referenziert."
)
# Standard-Resolver verwenden, wenn keiner übergeben wird
if target_type_resolver is None:
target_type_resolver = self._default_target_type_resolver
user_prompt = (
f"Notiz-Typ: {note_type}\n"
f"Textausschnitt:\n---\n{chunk_text}\n---\n\n"
f"Gesamte Kanten der Notiz (AUSWAHL):\n{edge_list_str}\n\n"
"Welche der oben genannten Kanten sind für diesen Textabschnitt relevant? Liste sie im JSON-Array auf."
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:
# 1. LLM Call
response_json = await self.llm.generate_raw_response(
user_prompt,
system=system_prompt,
force_json=True
)
# 2. Robustes JSON Parsing
clean_json = response_json.replace("```json", "").replace("```", "").strip()
data = json.loads(clean_json)
if isinstance(data, list):
# Filtere nach Strings, die den Doppelpunkt enthalten, um das Format "kind:Target" zu garantieren.
return [s for s in data if isinstance(s, str) and ":" in s]
logger.warning(f"SemanticAnalyzer: LLM lieferte non-list beim Edge-Filtern: {data}")
return []
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.")
except json.JSONDecodeError as e:
logger.error(f"SemanticAnalyzer: LLM lieferte KEIN valides JSON beim Edge-Filtern: {e}")
return []
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 beim Edge-Filtern: {e}")
return []
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):
# Stellt sicher, dass der AsyncClient geschlossen wird (gute Praxis)
if self.llm:
await self.llm.close()
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