neue chunker strategie mit smart chunking

This commit is contained in:
Lars committed 2025-12-12 10:10:05 +01:00
1 parent 49cdc9a13f
commit cd28a9d35c
4 files changed
+329 -487

No files matched your search

+53 -102
View File
@@ -1,136 +1,87 @@
"""
app/services/semantic_analyzer.py
Kapselt die LLM-Strategie für Chunking und Kanten-Extraktion.
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.
"""
import json
import logging
import re
from typing import List, Dict, Any, Optional
from dataclasses import dataclass
# Import der benötigten Services (Annahme: llm_service und discovery sind verfügbar.)
# Import der benötigten Services (Annahme: llm_service ist verfügbar.)
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"
# Ein Singleton-Muster für den Analyzer (wie zuvor)
_analyzer_instance: Optional['SemanticAnalyzer'] = None
def get_semantic_analyzer():
global _analyzer_instance
if _analyzer_instance is None:
_analyzer_instance = SemanticAnalyzer()
return _analyzer_instance
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 analyze_and_chunk(self, text: str, source_type: str) -> List[SemanticChunkResult]:
async def filter_edges_for_chunk(self, chunk_text: str, all_note_edges: List[str], note_type: str) -> List[str]:
"""
Zerlegt Text mittels LLM in semantische Abschnitte und extrahiert Kanten.
[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.
"""
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."
)
if not all_note_edges:
return []
edge_list_str = "\n".join([f"- {e}" for e in all_note_edges])
user_prompt = f"Dokument-Typ: {source_type}\n\nTEXT:\n{text}"
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."
)
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."
)
try:
# 2. LLM Call (Async)
# 1. LLM Call
response_json = await self.llm.generate_raw_response(
user_prompt,
system=system_prompt,
force_json=True
)
# 3. JSON Parsing & Validierung
# 2. Robustes JSON Parsing
clean_json = response_json.replace("```json", "").replace("```", "").strip()
data = json.loads(clean_json)
# FIX: Typsicherheit auf der Wurzel
if isinstance(data, dict):
# LLM hat ein Einzelobjekt geliefert -> wandle es in ein Array
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:
# Typsicherheit auf Item-Ebene
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:
# Typsicherheit auf Relation-Ebene
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 (für Matrix)
target_entity_type = self._get_target_type_from_title(target)
# 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: Helper zur Abfrage des Typs (muss die bestehenden Funktionen nutzen)
def _get_target_type_from_title(self, title: str) -> str:
"""Simuliert den Abruf des Notiztyps basierend auf dem Titel aus dem Index (für Matrix-Logik)."""
title_lower = title.lower()
if "leitbild-werte" in title_lower or "integrität" in title_lower:
return "value"
if "leitbild-prinzipien" in title_lower:
return "principle"
if "leitbild-rollen" in title_lower:
return "profile"
if "leitbild-rituale-system" in title_lower:
return "concept"
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]
return "concept"
logger.warning(f"SemanticAnalyzer: LLM lieferte non-list beim Edge-Filtern: {data}")
return []
except json.JSONDecodeError as e:
logger.error(f"SemanticAnalyzer: LLM lieferte KEIN valides JSON beim Edge-Filtern: {e}")
return []
except Exception as e:
logger.error(f"SemanticAnalyzer Unbehandelter Fehler beim Edge-Filtern: {e}")
return []
async def close(self):
# Stellt sicher, dass der AsyncClient geschlossen wird (gute Praxis)
if self.llm:
await self.llm.close()