integration prompts.yaml
This commit is contained in:
parent
2826cbadbc
commit
ecc2b60427
|
|
@ -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,100 +19,95 @@ 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 = (
|
||||
"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."
|
||||
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
|
||||
)
|
||||
|
||||
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,
|
||||
system=system_prompt,
|
||||
final_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):
|
||||
logger.warning(f"SemanticAnalyzer: Ungültiges Chunk-Element ignoriert: {item}")
|
||||
continue
|
||||
# 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.
|
||||
|
||||
content = item.get("content", "").strip()
|
||||
if not content: continue
|
||||
target = item.split(":", 1)[1].strip()
|
||||
target_entity_type = target_type_resolver(target)
|
||||
|
||||
raw_rels = item.get("relations", [])
|
||||
refined_edges = []
|
||||
# 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
|
||||
|
||||
for rel in raw_rels:
|
||||
if not isinstance(rel, dict):
|
||||
logger.warning(f"SemanticAnalyzer: Ignoriere ungültige Relation: {rel}")
|
||||
continue
|
||||
# Wenn das LLM fälschlicherweise das alte Format {content:..., relations:[...]} liefert,
|
||||
# ignorieren wir dies, da das edge_allocation_template ein Array von Strings erwartet.
|
||||
|
||||
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
|
||||
# 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.")
|
||||
|
|
@ -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"
|
||||
|
|
|
|||
|
|
@ -138,3 +138,28 @@ interview_template: |
|
|||
|
||||
## Erstes Schema Feld
|
||||
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", ...]
|
||||
Loading…
Reference in New Issue
Block a user