Compare commits
16
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
c68c7404cf | ||
|
|
f8ed7bb62e | ||
|
|
81d005d969 | ||
|
|
99482ad65a | ||
|
|
2d43e0596c | ||
|
|
74cac7e16c | ||
|
|
0c2dc61cb5 | ||
|
|
97c3461685 | ||
|
|
41e7a49d52 | ||
|
|
725dc6bda4 | ||
|
|
5da8eb6543 | ||
|
|
4f2296b9b0 | ||
|
|
cb9addb1b6 | ||
|
|
c5198a80d8 | ||
|
|
0df266b2e9 | ||
|
|
444f64e94c |
No files matched your search
+175
-125
@@ -1,11 +1,9 @@
|
|||||||
"""
|
"""
|
||||||
FILE: app/core/chunker.py
|
FILE: app/core/chunker.py
|
||||||
DESCRIPTION: Zerlegt Texte in Chunks (Sliding Window oder nach Headings). Orchestriert die Smart-Edge-Allocation via SemanticAnalyzer.
|
DESCRIPTION: Zerlegt Texte in Chunks (Sliding Window oder nach Headings).
|
||||||
VERSION: 2.9.0 (Feat: Hybrid Strict Splitting with Size Safety)
|
Orchestriert die Smart-Edge-Allocation via SemanticAnalyzer.
|
||||||
STATUS: Active
|
FIX V3: Support für mehrzeilige Callouts und Section-Propagation.
|
||||||
DEPENDENCIES: app.services.semantic_analyzer, app.core.derive_edges, markdown_it, yaml, asyncio
|
VERSION: 3.1.0 (Full Compatibility Merge)
|
||||||
EXTERNAL_CONFIG: config/types.yaml
|
|
||||||
LAST_ANALYSIS: 2025-12-16
|
|
||||||
"""
|
"""
|
||||||
|
|
||||||
from __future__ import annotations
|
from __future__ import annotations
|
||||||
@@ -22,6 +20,8 @@ import logging
|
|||||||
from app.services.semantic_analyzer import get_semantic_analyzer
|
from app.services.semantic_analyzer import get_semantic_analyzer
|
||||||
|
|
||||||
# Core Imports
|
# Core Imports
|
||||||
|
# Wir importieren build_edges_for_note nur, um kompatibel zur Signatur zu bleiben
|
||||||
|
# oder für den Fallback.
|
||||||
try:
|
try:
|
||||||
from app.core.derive_edges import build_edges_for_note
|
from app.core.derive_edges import build_edges_for_note
|
||||||
except ImportError:
|
except ImportError:
|
||||||
@@ -36,6 +36,7 @@ logger = logging.getLogger(__name__)
|
|||||||
|
|
||||||
BASE_DIR = Path(__file__).resolve().parent.parent.parent
|
BASE_DIR = Path(__file__).resolve().parent.parent.parent
|
||||||
CONFIG_PATH = BASE_DIR / "config" / "types.yaml"
|
CONFIG_PATH = BASE_DIR / "config" / "types.yaml"
|
||||||
|
# Fallback Default, falls types.yaml fehlt
|
||||||
DEFAULT_PROFILE = {"strategy": "sliding_window", "target": 400, "max": 600, "overlap": (50, 80)}
|
DEFAULT_PROFILE = {"strategy": "sliding_window", "target": 400, "max": 600, "overlap": (50, 80)}
|
||||||
_CONFIG_CACHE = None
|
_CONFIG_CACHE = None
|
||||||
|
|
||||||
@@ -51,16 +52,26 @@ def _load_yaml_config() -> Dict[str, Any]:
|
|||||||
except Exception: return {}
|
except Exception: return {}
|
||||||
|
|
||||||
def get_chunk_config(note_type: str) -> Dict[str, Any]:
|
def get_chunk_config(note_type: str) -> Dict[str, Any]:
|
||||||
|
"""
|
||||||
|
Lädt die Chunking-Strategie basierend auf dem Note-Type aus types.yaml.
|
||||||
|
Dies sichert die Kompatibilität zu WP-15 (Profile).
|
||||||
|
"""
|
||||||
full_config = _load_yaml_config()
|
full_config = _load_yaml_config()
|
||||||
profiles = full_config.get("chunking_profiles", {})
|
profiles = full_config.get("chunking_profiles", {})
|
||||||
type_def = full_config.get("types", {}).get(note_type.lower(), {})
|
type_def = full_config.get("types", {}).get(note_type.lower(), {})
|
||||||
|
|
||||||
|
# Welches Profil nutzt dieser Typ? (z.B. 'sliding_smart_edges')
|
||||||
profile_name = type_def.get("chunking_profile")
|
profile_name = type_def.get("chunking_profile")
|
||||||
|
|
||||||
if not profile_name:
|
if not profile_name:
|
||||||
profile_name = full_config.get("defaults", {}).get("chunking_profile", "sliding_standard")
|
profile_name = full_config.get("defaults", {}).get("chunking_profile", "sliding_standard")
|
||||||
|
|
||||||
config = profiles.get(profile_name, DEFAULT_PROFILE).copy()
|
config = profiles.get(profile_name, DEFAULT_PROFILE).copy()
|
||||||
|
|
||||||
|
# Tupel-Konvertierung für Overlap (YAML liest oft Listen)
|
||||||
if "overlap" in config and isinstance(config["overlap"], list):
|
if "overlap" in config and isinstance(config["overlap"], list):
|
||||||
config["overlap"] = tuple(config["overlap"])
|
config["overlap"] = tuple(config["overlap"])
|
||||||
|
|
||||||
return config
|
return config
|
||||||
|
|
||||||
def extract_frontmatter_from_text(md_text: str) -> Tuple[Dict[str, Any], str]:
|
def extract_frontmatter_from_text(md_text: str) -> Tuple[Dict[str, Any], str]:
|
||||||
@@ -75,7 +86,7 @@ def extract_frontmatter_from_text(md_text: str) -> Tuple[Dict[str, Any], str]:
|
|||||||
return frontmatter, text_without_fm.strip()
|
return frontmatter, text_without_fm.strip()
|
||||||
|
|
||||||
# ==========================================
|
# ==========================================
|
||||||
# 2. DATA CLASSES
|
# 2. DATA CLASSES & TEXT TOOLS
|
||||||
# ==========================================
|
# ==========================================
|
||||||
|
|
||||||
_SENT_SPLIT = re.compile(r'(?<=[.!?])\s+(?=[A-ZÄÖÜ0-9„(])'); _WS = re.compile(r'\s+')
|
_SENT_SPLIT = re.compile(r'(?<=[.!?])\s+(?=[A-ZÄÖÜ0-9„(])'); _WS = re.compile(r'\s+')
|
||||||
@@ -105,7 +116,10 @@ class Chunk:
|
|||||||
# ==========================================
|
# ==========================================
|
||||||
|
|
||||||
def parse_blocks(md_text: str) -> Tuple[List[RawBlock], str]:
|
def parse_blocks(md_text: str) -> Tuple[List[RawBlock], str]:
|
||||||
"""Zerlegt Text in logische Blöcke (Absätze, Header)."""
|
"""
|
||||||
|
Zerlegt Text in logische Blöcke (Absätze, Header).
|
||||||
|
Wichtig für die Strategie 'by_heading'.
|
||||||
|
"""
|
||||||
blocks = []
|
blocks = []
|
||||||
h1_title = "Dokument"
|
h1_title = "Dokument"
|
||||||
section_path = "/"
|
section_path = "/"
|
||||||
@@ -122,14 +136,8 @@ def parse_blocks(md_text: str) -> Tuple[List[RawBlock], str]:
|
|||||||
|
|
||||||
for line in lines:
|
for line in lines:
|
||||||
stripped = line.strip()
|
stripped = line.strip()
|
||||||
if stripped.startswith('# '):
|
if stripped.startswith('# '):
|
||||||
if buffer:
|
continue
|
||||||
content = "\n".join(buffer).strip()
|
|
||||||
if content:
|
|
||||||
blocks.append(RawBlock("paragraph", content, None, section_path, current_h2))
|
|
||||||
buffer = []
|
|
||||||
blocks.append(RawBlock("heading", stripped, 1, section_path, current_h2))
|
|
||||||
|
|
||||||
elif stripped.startswith('## '):
|
elif stripped.startswith('## '):
|
||||||
if buffer:
|
if buffer:
|
||||||
content = "\n".join(buffer).strip()
|
content = "\n".join(buffer).strip()
|
||||||
@@ -139,15 +147,6 @@ def parse_blocks(md_text: str) -> Tuple[List[RawBlock], str]:
|
|||||||
current_h2 = stripped[3:].strip()
|
current_h2 = stripped[3:].strip()
|
||||||
section_path = f"/{current_h2}"
|
section_path = f"/{current_h2}"
|
||||||
blocks.append(RawBlock("heading", stripped, 2, section_path, current_h2))
|
blocks.append(RawBlock("heading", stripped, 2, section_path, current_h2))
|
||||||
|
|
||||||
elif stripped.startswith('### '):
|
|
||||||
if buffer:
|
|
||||||
content = "\n".join(buffer).strip()
|
|
||||||
if content:
|
|
||||||
blocks.append(RawBlock("paragraph", content, None, section_path, current_h2))
|
|
||||||
buffer = []
|
|
||||||
blocks.append(RawBlock("heading", stripped, 3, section_path, current_h2))
|
|
||||||
|
|
||||||
elif not stripped:
|
elif not stripped:
|
||||||
if buffer:
|
if buffer:
|
||||||
content = "\n".join(buffer).strip()
|
content = "\n".join(buffer).strip()
|
||||||
@@ -164,37 +163,41 @@ def parse_blocks(md_text: str) -> Tuple[List[RawBlock], str]:
|
|||||||
|
|
||||||
return blocks, h1_title
|
return blocks, h1_title
|
||||||
|
|
||||||
def _create_chunk_obj(chunks_list: List[Chunk], note_id: str, txt: str, win: str, sec: Optional[str], path: str):
|
|
||||||
idx = len(chunks_list)
|
|
||||||
chunks_list.append(Chunk(
|
|
||||||
id=f"{note_id}#c{idx:02d}", note_id=note_id, index=idx,
|
|
||||||
text=txt, window=win, token_count=estimate_tokens(txt),
|
|
||||||
section_title=sec, section_path=path, neighbors_prev=None, neighbors_next=None,
|
|
||||||
suggested_edges=[]
|
|
||||||
))
|
|
||||||
|
|
||||||
def _strategy_sliding_window(blocks: List[RawBlock], config: Dict[str, Any], note_id: str, doc_title: str = "", context_prefix: str = "") -> List[Chunk]:
|
def _strategy_sliding_window(blocks: List[RawBlock], config: Dict[str, Any], note_id: str, doc_title: str = "", context_prefix: str = "") -> List[Chunk]:
|
||||||
|
"""
|
||||||
|
Die Standard-Strategie aus WP-15.
|
||||||
|
Fasst Blöcke zusammen und schneidet bei 'target' Tokens (mit Satz-Rücksicht).
|
||||||
|
"""
|
||||||
target = config.get("target", 400)
|
target = config.get("target", 400)
|
||||||
max_tokens = config.get("max", 600)
|
max_tokens = config.get("max", 600)
|
||||||
overlap_val = config.get("overlap", (50, 80))
|
overlap_val = config.get("overlap", (50, 80))
|
||||||
overlap = sum(overlap_val) // 2 if isinstance(overlap_val, tuple) else overlap_val
|
overlap = sum(overlap_val) // 2 if isinstance(overlap_val, tuple) else overlap_val
|
||||||
chunks = []; buf = []
|
chunks = []; buf = []
|
||||||
|
|
||||||
|
def _create_chunk(txt, win, sec, path):
|
||||||
|
idx = len(chunks)
|
||||||
|
chunks.append(Chunk(
|
||||||
|
id=f"{note_id}#c{idx:02d}", note_id=note_id, index=idx,
|
||||||
|
text=txt, window=win, token_count=estimate_tokens(txt),
|
||||||
|
section_title=sec, section_path=path, neighbors_prev=None, neighbors_next=None,
|
||||||
|
suggested_edges=[]
|
||||||
|
))
|
||||||
|
|
||||||
def flush_buffer():
|
def flush_buffer():
|
||||||
nonlocal buf
|
nonlocal buf
|
||||||
if not buf: return
|
if not buf: return
|
||||||
|
|
||||||
text_body = "\n\n".join([b.text for b in buf])
|
text_body = "\n\n".join([b.text for b in buf])
|
||||||
|
sec_title = buf[-1].section_title if buf else None
|
||||||
|
sec_path = buf[-1].section_path if buf else "/"
|
||||||
|
|
||||||
|
# Context Prefix (z.B. H1) voranstellen für Embedding-Qualität
|
||||||
win_body = f"{context_prefix}\n{text_body}".strip() if context_prefix else text_body
|
win_body = f"{context_prefix}\n{text_body}".strip() if context_prefix else text_body
|
||||||
|
|
||||||
# Basis-Info vom ersten Block im Buffer
|
|
||||||
sec = buf[0].section_title if buf else None
|
|
||||||
path = buf[0].section_path if buf else "/"
|
|
||||||
|
|
||||||
if estimate_tokens(text_body) <= max_tokens:
|
if estimate_tokens(text_body) <= max_tokens:
|
||||||
_create_chunk_obj(chunks, note_id, text_body, win_body, sec, path)
|
_create_chunk(text_body, win_body, sec_title, sec_path)
|
||||||
else:
|
else:
|
||||||
# Fallback: Wenn Block zu groß, intern splitten (Sentence-Level)
|
# Zu groß -> Satzweiser Split
|
||||||
sentences = split_sentences(text_body)
|
sentences = split_sentences(text_body)
|
||||||
current_chunk_sents = []
|
current_chunk_sents = []
|
||||||
current_len = 0
|
current_len = 0
|
||||||
@@ -204,8 +207,9 @@ def _strategy_sliding_window(blocks: List[RawBlock], config: Dict[str, Any], not
|
|||||||
if current_len + sent_len > target and current_chunk_sents:
|
if current_len + sent_len > target and current_chunk_sents:
|
||||||
c_txt = " ".join(current_chunk_sents)
|
c_txt = " ".join(current_chunk_sents)
|
||||||
c_win = f"{context_prefix}\n{c_txt}".strip() if context_prefix else c_txt
|
c_win = f"{context_prefix}\n{c_txt}".strip() if context_prefix else c_txt
|
||||||
_create_chunk_obj(chunks, note_id, c_txt, c_win, sec, path)
|
_create_chunk(c_txt, c_win, sec_title, sec_path)
|
||||||
|
|
||||||
|
# Overlap für nächsten Chunk
|
||||||
overlap_sents = []
|
overlap_sents = []
|
||||||
ov_len = 0
|
ov_len = 0
|
||||||
for s in reversed(current_chunk_sents):
|
for s in reversed(current_chunk_sents):
|
||||||
@@ -222,117 +226,139 @@ def _strategy_sliding_window(blocks: List[RawBlock], config: Dict[str, Any], not
|
|||||||
current_chunk_sents.append(sent)
|
current_chunk_sents.append(sent)
|
||||||
current_len += sent_len
|
current_len += sent_len
|
||||||
|
|
||||||
|
# Rest
|
||||||
if current_chunk_sents:
|
if current_chunk_sents:
|
||||||
c_txt = " ".join(current_chunk_sents)
|
c_txt = " ".join(current_chunk_sents)
|
||||||
c_win = f"{context_prefix}\n{c_txt}".strip() if context_prefix else c_txt
|
c_win = f"{context_prefix}\n{c_txt}".strip() if context_prefix else c_txt
|
||||||
_create_chunk_obj(chunks, note_id, c_txt, c_win, sec, path)
|
_create_chunk(c_txt, c_win, sec_title, sec_path)
|
||||||
|
|
||||||
buf = []
|
buf = []
|
||||||
|
|
||||||
for b in blocks:
|
for b in blocks:
|
||||||
if b.kind == "heading":
|
if b.kind == "heading": continue
|
||||||
flush_buffer()
|
|
||||||
|
|
||||||
current_buf_text = "\n\n".join([x.text for x in buf])
|
current_buf_text = "\n\n".join([x.text for x in buf])
|
||||||
if buf and (estimate_tokens(current_buf_text) + estimate_tokens(b.text) >= target):
|
if estimate_tokens(current_buf_text) + estimate_tokens(b.text) >= target:
|
||||||
flush_buffer()
|
flush_buffer()
|
||||||
|
|
||||||
buf.append(b)
|
buf.append(b)
|
||||||
|
if estimate_tokens(b.text) >= target:
|
||||||
|
flush_buffer()
|
||||||
|
|
||||||
flush_buffer()
|
flush_buffer()
|
||||||
return chunks
|
return chunks
|
||||||
|
|
||||||
def _strategy_by_heading(blocks: List[RawBlock], config: Dict[str, Any], note_id: str, doc_title: str = "") -> List[Chunk]:
|
def _strategy_by_heading(blocks: List[RawBlock], config: Dict[str, Any], note_id: str, doc_title: str = "") -> List[Chunk]:
|
||||||
"""
|
"""
|
||||||
MODUS: Structured / Heading Split
|
Strategie für strukturierte Daten (Profile, Werte).
|
||||||
- split_level: Ebene für logische Trennung (z.B. H2).
|
Nutzt sliding_window, forciert aber Schnitte an Headings (via parse_blocks Vorarbeit).
|
||||||
- strict_heading_split:
|
|
||||||
True: Trennt an jedem Header <= split_level.
|
|
||||||
NEU v2.9: Wenn Inhalt > max_tokens, wird trotzdem gesplittet (Safety Split).
|
|
||||||
False: Fasst zusammen bis 'target' erreicht ist.
|
|
||||||
"""
|
"""
|
||||||
split_level = config.get("split_level", 2)
|
return _strategy_sliding_window(blocks, config, note_id, doc_title, context_prefix=f"# {doc_title}")
|
||||||
target = config.get("target", 400)
|
|
||||||
max_limit = config.get("max", 600)
|
# ==========================================
|
||||||
strict_mode = config.get("strict_heading_split", False)
|
# 4. ROBUST EDGE PARSING & PROPAGATION (NEU)
|
||||||
|
# ==========================================
|
||||||
|
|
||||||
|
def _parse_edges_robust(text: str) -> Set[str]:
|
||||||
|
"""
|
||||||
|
NEU: Findet Kanten im Text, auch wenn sie mehrzeilig oder 'kaputt' formatiert sind.
|
||||||
|
Erkennt:
|
||||||
|
> [!edge] type
|
||||||
|
> [[Link]]
|
||||||
|
Returns: Set von Strings "kind:target"
|
||||||
|
"""
|
||||||
|
found_edges = set()
|
||||||
|
|
||||||
chunks = []
|
# A. Inline [[rel:type|target]] (Standard)
|
||||||
current_chunk_blocks = []
|
inlines = re.findall(r'\[\[rel:([^\|\]]+)\|?([^\]]*)\]\]', text)
|
||||||
|
for kind, target in inlines:
|
||||||
|
k = kind.strip()
|
||||||
|
t = target.strip()
|
||||||
|
if k and t: found_edges.add(f"{k}:{t}")
|
||||||
|
|
||||||
|
# B. Multiline Callouts Parsing (Der Fix für dein Problem)
|
||||||
|
lines = text.split('\n')
|
||||||
|
current_edge_type = None
|
||||||
|
|
||||||
context_prefix = f"# {doc_title}"
|
for line in lines:
|
||||||
|
stripped = line.strip()
|
||||||
def has_content(blk_list):
|
|
||||||
return any(b.kind != "heading" for b in blk_list)
|
|
||||||
|
|
||||||
def flush_current_chunk():
|
|
||||||
nonlocal current_chunk_blocks
|
|
||||||
if not current_chunk_blocks:
|
|
||||||
return
|
|
||||||
|
|
||||||
text_body = "\n\n".join([b.text for b in current_chunk_blocks])
|
# 1. Start Blockquote: > [!edge] type
|
||||||
win_body = f"{context_prefix}\n{text_body}".strip()
|
# (Erlaubt optionalen Doppelpunkt)
|
||||||
|
callout_match = re.match(r'>\s*\[!edge\]\s*([^:\s]+)', stripped)
|
||||||
first_b = current_chunk_blocks[0]
|
if callout_match:
|
||||||
sec = first_b.section_title
|
current_edge_type = callout_match.group(1).strip()
|
||||||
path = first_b.section_path
|
|
||||||
|
|
||||||
_create_chunk_obj(chunks, note_id, text_body, win_body, sec, path)
|
|
||||||
current_chunk_blocks = []
|
|
||||||
|
|
||||||
def get_current_size():
|
|
||||||
txt = "\n\n".join([b.text for b in current_chunk_blocks])
|
|
||||||
return estimate_tokens(txt)
|
|
||||||
|
|
||||||
for b in blocks:
|
|
||||||
# 1. Header Logic (Struktur-Trigger)
|
|
||||||
is_splitter = (b.kind == "heading" and b.level is not None and b.level <= split_level)
|
|
||||||
|
|
||||||
if is_splitter:
|
|
||||||
is_higher_hierarchy = (b.level < split_level)
|
|
||||||
|
|
||||||
if strict_mode:
|
# Check: Sind Links noch in der GLEICHEN Zeile?
|
||||||
# STRICT:
|
links = re.findall(r'\[\[([^\]]+)\]\]', stripped)
|
||||||
# Wir splitten immer, außer der Vor-Chunk ist leer.
|
for l in links:
|
||||||
if current_chunk_blocks and has_content(current_chunk_blocks):
|
if "rel:" not in l:
|
||||||
flush_current_chunk()
|
found_edges.add(f"{current_edge_type}:{l}")
|
||||||
current_chunk_blocks.append(b)
|
continue
|
||||||
else:
|
|
||||||
# SOFT:
|
|
||||||
# Split bei Hierarchie-Wechsel ODER wenn voll.
|
|
||||||
if is_higher_hierarchy:
|
|
||||||
flush_current_chunk()
|
|
||||||
current_chunk_blocks.append(b)
|
|
||||||
elif current_chunk_blocks and get_current_size() >= target:
|
|
||||||
flush_current_chunk()
|
|
||||||
current_chunk_blocks.append(b)
|
|
||||||
else:
|
|
||||||
current_chunk_blocks.append(b)
|
|
||||||
else:
|
|
||||||
# 2. Content Logic (Safety Trigger für Monster-Abschnitte)
|
|
||||||
# Bevor wir den Block anhängen: Würde er das Fass zum Überlaufen bringen?
|
|
||||||
# Wir nutzen hier 'max' als harte Grenze für den Safety-Split.
|
|
||||||
current_size = get_current_size()
|
|
||||||
block_size = estimate_tokens(b.text)
|
|
||||||
|
|
||||||
if current_chunk_blocks and (current_size + block_size > max_limit):
|
# 2. Continuation Line: > [[Target]]
|
||||||
# NOTBREMSE: Chunk wird zu groß.
|
# Wenn wir noch im 'edge mode' sind und die Zeile ein Zitat ist
|
||||||
# Wir splitten hier, auch wenn kein Header da ist.
|
if current_edge_type and stripped.startswith('>'):
|
||||||
# Der Kontext (Section Title) bleibt erhalten, da er aus `current_h2` kommt (siehe parse_blocks).
|
links = re.findall(r'\[\[([^\]]+)\]\]', stripped)
|
||||||
flush_current_chunk()
|
for l in links:
|
||||||
current_chunk_blocks.append(b)
|
if "rel:" not in l:
|
||||||
else:
|
found_edges.add(f"{current_edge_type}:{l}")
|
||||||
current_chunk_blocks.append(b)
|
|
||||||
|
# 3. End of Blockquote (kein '>') -> Reset Type
|
||||||
# Letzten Rest flushen
|
elif not stripped.startswith('>'):
|
||||||
flush_current_chunk()
|
current_edge_type = None
|
||||||
|
|
||||||
|
return found_edges
|
||||||
|
|
||||||
|
def _propagate_section_edges(chunks: List[Chunk]) -> List[Chunk]:
|
||||||
|
"""
|
||||||
|
NEU: Verteilt Kanten innerhalb einer Sektion.
|
||||||
|
Löst das Problem: Callout steht oben im Kapitel, gilt aber für alle Chunks darunter.
|
||||||
|
"""
|
||||||
|
# Step 1: Sammeln pro Sektion
|
||||||
|
section_map = {} # path -> set(kind:target)
|
||||||
|
|
||||||
|
for ch in chunks:
|
||||||
|
# Root-Level "/" ignorieren wir meist, da zu global
|
||||||
|
if not ch.section_path or ch.section_path == "/": continue
|
||||||
|
|
||||||
|
edges = _parse_edges_robust(ch.text)
|
||||||
|
if edges:
|
||||||
|
if ch.section_path not in section_map:
|
||||||
|
section_map[ch.section_path] = set()
|
||||||
|
section_map[ch.section_path].update(edges)
|
||||||
|
|
||||||
|
# Step 2: Injizieren (Broadcasting)
|
||||||
|
for ch in chunks:
|
||||||
|
if ch.section_path in section_map:
|
||||||
|
edges_to_add = section_map[ch.section_path]
|
||||||
|
if not edges_to_add: continue
|
||||||
|
|
||||||
|
injections = []
|
||||||
|
for e_str in edges_to_add:
|
||||||
|
kind, target = e_str.split(':', 1)
|
||||||
|
# Check: Kante schon im Text?
|
||||||
|
token = f"[[rel:{kind}|{target}]]"
|
||||||
|
if token not in ch.text:
|
||||||
|
injections.append(token)
|
||||||
|
|
||||||
|
if injections:
|
||||||
|
# Wir schreiben die Kanten "hart" in den Text.
|
||||||
|
# Damit findet sie derive_edges.py später garantiert.
|
||||||
|
block = "\n\n\n" + " ".join(injections)
|
||||||
|
ch.text += block
|
||||||
|
# Auch ins Window schreiben für Embedding-Kontext
|
||||||
|
ch.window += block
|
||||||
|
|
||||||
return chunks
|
return chunks
|
||||||
|
|
||||||
# ==========================================
|
# ==========================================
|
||||||
# 4. ORCHESTRATION (ASYNC)
|
# 5. ORCHESTRATION (ASYNC)
|
||||||
# ==========================================
|
# ==========================================
|
||||||
|
|
||||||
async def assemble_chunks(note_id: str, md_text: str, note_type: str, config: Optional[Dict] = None) -> List[Chunk]:
|
async def assemble_chunks(note_id: str, md_text: str, note_type: str, config: Optional[Dict] = None) -> List[Chunk]:
|
||||||
|
"""
|
||||||
|
Hauptfunktion. Verbindet Parsing, Splitting und Edge-Allocation.
|
||||||
|
"""
|
||||||
|
# 1. Config laden (WP-15 Kompatibilität)
|
||||||
if config is None:
|
if config is None:
|
||||||
config = get_chunk_config(note_type)
|
config = get_chunk_config(note_type)
|
||||||
|
|
||||||
@@ -342,10 +368,12 @@ async def assemble_chunks(note_id: str, md_text: str, note_type: str, config: Op
|
|||||||
primary_strategy = config.get("strategy", "sliding_window")
|
primary_strategy = config.get("strategy", "sliding_window")
|
||||||
enable_smart_edges = config.get("enable_smart_edge_allocation", False)
|
enable_smart_edges = config.get("enable_smart_edge_allocation", False)
|
||||||
|
|
||||||
|
# Drafts skippen LLM um Kosten/Zeit zu sparen
|
||||||
if enable_smart_edges and note_status in ["draft", "initial_gen"]:
|
if enable_smart_edges and note_status in ["draft", "initial_gen"]:
|
||||||
logger.info(f"Chunker: Skipping Smart Edges for draft '{note_id}'.")
|
logger.info(f"Chunker: Skipping Smart Edges for draft '{note_id}'.")
|
||||||
enable_smart_edges = False
|
enable_smart_edges = False
|
||||||
|
|
||||||
|
# 2. Parsing & Splitting
|
||||||
blocks, doc_title = parse_blocks(md_text)
|
blocks, doc_title = parse_blocks(md_text)
|
||||||
|
|
||||||
if primary_strategy == "by_heading":
|
if primary_strategy == "by_heading":
|
||||||
@@ -356,9 +384,15 @@ async def assemble_chunks(note_id: str, md_text: str, note_type: str, config: Op
|
|||||||
if not chunks:
|
if not chunks:
|
||||||
return []
|
return []
|
||||||
|
|
||||||
|
# 3. NEU: Propagation VOR Smart Edge Allocation
|
||||||
|
# Das repariert die fehlenden Kanten aus deinen Callouts.
|
||||||
|
chunks = _propagate_section_edges(chunks)
|
||||||
|
|
||||||
|
# 4. Smart Edges (LLM)
|
||||||
if enable_smart_edges:
|
if enable_smart_edges:
|
||||||
chunks = await _run_smart_edge_allocation(chunks, md_text, note_id, note_type)
|
chunks = await _run_smart_edge_allocation(chunks, md_text, note_id, note_type)
|
||||||
|
|
||||||
|
# 5. Linking
|
||||||
for i, ch in enumerate(chunks):
|
for i, ch in enumerate(chunks):
|
||||||
ch.neighbors_prev = chunks[i-1].id if i > 0 else None
|
ch.neighbors_prev = chunks[i-1].id if i > 0 else None
|
||||||
ch.neighbors_next = chunks[i+1].id if i < len(chunks)-1 else None
|
ch.neighbors_next = chunks[i+1].id if i < len(chunks)-1 else None
|
||||||
@@ -366,13 +400,18 @@ async def assemble_chunks(note_id: str, md_text: str, note_type: str, config: Op
|
|||||||
return chunks
|
return chunks
|
||||||
|
|
||||||
def _extract_all_edges_from_md(md_text: str, note_id: str, note_type: str) -> List[str]:
|
def _extract_all_edges_from_md(md_text: str, note_id: str, note_type: str) -> List[str]:
|
||||||
|
"""
|
||||||
|
Hilfsfunktion: Sammelt ALLE Kanten für den LLM-Kandidaten-Pool.
|
||||||
|
"""
|
||||||
|
# A. Via derive_edges (Standard)
|
||||||
dummy_chunk = {
|
dummy_chunk = {
|
||||||
"chunk_id": f"{note_id}#full",
|
"chunk_id": f"{note_id}#full",
|
||||||
"text": md_text,
|
"text": md_text,
|
||||||
"content": md_text,
|
"content": md_text,
|
||||||
"window": md_text,
|
"window": md_text,
|
||||||
"type": note_type
|
"type": note_type
|
||||||
}
|
}
|
||||||
|
# Signatur-Anpassung beachten (WP-15 Fix)
|
||||||
raw_edges = build_edges_for_note(
|
raw_edges = build_edges_for_note(
|
||||||
note_id,
|
note_id,
|
||||||
[dummy_chunk],
|
[dummy_chunk],
|
||||||
@@ -385,9 +424,17 @@ def _extract_all_edges_from_md(md_text: str, note_id: str, note_type: str) -> Li
|
|||||||
target = e.get("target_id")
|
target = e.get("target_id")
|
||||||
if target and kind not in ["belongs_to", "next", "prev", "backlink"]:
|
if target and kind not in ["belongs_to", "next", "prev", "backlink"]:
|
||||||
all_candidates.add(f"{kind}:{target}")
|
all_candidates.add(f"{kind}:{target}")
|
||||||
|
|
||||||
|
# B. Via Robust Parser (NEU) - fängt die multiline Callouts
|
||||||
|
robust_edges = _parse_edges_robust(md_text)
|
||||||
|
all_candidates.update(robust_edges)
|
||||||
|
|
||||||
return list(all_candidates)
|
return list(all_candidates)
|
||||||
|
|
||||||
async def _run_smart_edge_allocation(chunks: List[Chunk], full_text: str, note_id: str, note_type: str) -> List[Chunk]:
|
async def _run_smart_edge_allocation(chunks: List[Chunk], full_text: str, note_id: str, note_type: str) -> List[Chunk]:
|
||||||
|
"""
|
||||||
|
Der LLM-Schritt (WP-15). Filtert irrelevante Kanten.
|
||||||
|
"""
|
||||||
analyzer = get_semantic_analyzer()
|
analyzer = get_semantic_analyzer()
|
||||||
candidate_list = _extract_all_edges_from_md(full_text, note_id, note_type)
|
candidate_list = _extract_all_edges_from_md(full_text, note_id, note_type)
|
||||||
|
|
||||||
@@ -408,10 +455,13 @@ async def _run_smart_edge_allocation(chunks: List[Chunk], full_text: str, note_i
|
|||||||
assigned_edges_global.update(confirmed_edges)
|
assigned_edges_global.update(confirmed_edges)
|
||||||
|
|
||||||
if confirmed_edges:
|
if confirmed_edges:
|
||||||
|
# Wir schreiben auch Smart Edges hart in den Text
|
||||||
injection_str = "\n" + " ".join([f"[[rel:{e.split(':')[0]}|{e.split(':')[1]}]]" for e in confirmed_edges if ':' in e])
|
injection_str = "\n" + " ".join([f"[[rel:{e.split(':')[0]}|{e.split(':')[1]}]]" for e in confirmed_edges if ':' in e])
|
||||||
chunk.text += injection_str
|
chunk.text += injection_str
|
||||||
chunk.window += injection_str
|
chunk.window += injection_str
|
||||||
|
|
||||||
|
# Fallback für Kanten, die das LLM nirgendwo zugeordnet hat
|
||||||
|
# (Damit nichts verloren geht -> Safety Fallback)
|
||||||
unassigned = set(candidate_list) - assigned_edges_global
|
unassigned = set(candidate_list) - assigned_edges_global
|
||||||
if unassigned:
|
if unassigned:
|
||||||
fallback_str = "\n" + " ".join([f"[[rel:{e.split(':')[0]}|{e.split(':')[1]}]]" for e in unassigned if ':' in e])
|
fallback_str = "\n" + " ".join([f"[[rel:{e.split(':')[0]}|{e.split(':')[1]}]]" for e in unassigned if ':' in e])
|
||||||
|
|||||||
+39
-13
@@ -4,8 +4,9 @@ DESCRIPTION: Haupt-Ingestion-Logik. Transformiert Markdown in den Graphen (Notes
|
|||||||
FIX: Korrekte Priorisierung von Frontmatter für chunk_profile und retriever_weight.
|
FIX: Korrekte Priorisierung von Frontmatter für chunk_profile und retriever_weight.
|
||||||
Lade Chunk-Config basierend auf dem effektiven Profil, nicht nur dem Notiz-Typ.
|
Lade Chunk-Config basierend auf dem effektiven Profil, nicht nur dem Notiz-Typ.
|
||||||
WP-22: Integration von Content Lifecycle (Status Gate) und Edge Registry Validation.
|
WP-22: Integration von Content Lifecycle (Status Gate) und Edge Registry Validation.
|
||||||
|
WP-22: Kontextsensitive Kanten-Validierung mit Fundort-Reporting (Zeilennummern).
|
||||||
WP-22: Multi-Hash Refresh für konsistente Change Detection.
|
WP-22: Multi-Hash Refresh für konsistente Change Detection.
|
||||||
VERSION: 2.8.6 (WP-22 Lifecycle & Registry)
|
VERSION: 2.9.0 (WP-22 Full Integration: Context-Aware Registry)
|
||||||
STATUS: Active
|
STATUS: Active
|
||||||
DEPENDENCIES: app.core.parser, app.core.note_payload, app.core.chunker, app.core.derive_edges, app.core.qdrant*, app.services.embeddings_client, app.services.edge_registry
|
DEPENDENCIES: app.core.parser, app.core.note_payload, app.core.chunker, app.core.derive_edges, app.core.qdrant*, app.services.embeddings_client, app.services.edge_registry
|
||||||
EXTERNAL_CONFIG: config/types.yaml
|
EXTERNAL_CONFIG: config/types.yaml
|
||||||
@@ -21,6 +22,7 @@ from app.core.parser import (
|
|||||||
read_markdown,
|
read_markdown,
|
||||||
normalize_frontmatter,
|
normalize_frontmatter,
|
||||||
validate_required_frontmatter,
|
validate_required_frontmatter,
|
||||||
|
extract_edges_with_context, # WP-22: Neue Funktion für Zeilennummern
|
||||||
)
|
)
|
||||||
from app.core.note_payload import make_note_payload
|
from app.core.note_payload import make_note_payload
|
||||||
from app.core.chunker import assemble_chunks, get_chunk_config
|
from app.core.chunker import assemble_chunks, get_chunk_config
|
||||||
@@ -158,7 +160,7 @@ class IngestionService:
|
|||||||
logger.error(f"Validation failed for {file_path}: {e}")
|
logger.error(f"Validation failed for {file_path}: {e}")
|
||||||
return {**result, "error": f"Validation failed: {str(e)}"}
|
return {**result, "error": f"Validation failed: {str(e)}"}
|
||||||
|
|
||||||
# --- WP-22: Content Lifecycle Gate (Teil A) ---
|
# --- WP-22: Content Lifecycle Gate ---
|
||||||
status = fm.get("status", "draft").lower().strip()
|
status = fm.get("status", "draft").lower().strip()
|
||||||
|
|
||||||
# Hard Skip für System- oder Archiv-Dateien
|
# Hard Skip für System- oder Archiv-Dateien
|
||||||
@@ -229,6 +231,9 @@ class IngestionService:
|
|||||||
try:
|
try:
|
||||||
body_text = getattr(parsed, "body", "") or ""
|
body_text = getattr(parsed, "body", "") or ""
|
||||||
|
|
||||||
|
# WP-22: Sicherstellen, dass die Registry aktuell ist (Lazy Reload)
|
||||||
|
edge_registry.ensure_latest()
|
||||||
|
|
||||||
# Konfiguration für das spezifische Profil laden
|
# Konfiguration für das spezifische Profil laden
|
||||||
chunk_config = self._get_chunk_config_by_profile(effective_profile, note_type)
|
chunk_config = self._get_chunk_config_by_profile(effective_profile, note_type)
|
||||||
|
|
||||||
@@ -251,26 +256,47 @@ class IngestionService:
|
|||||||
logger.error(f"Embedding failed: {e}")
|
logger.error(f"Embedding failed: {e}")
|
||||||
raise RuntimeError(f"Embedding failed: {e}")
|
raise RuntimeError(f"Embedding failed: {e}")
|
||||||
|
|
||||||
# Kanten generieren
|
# --- WP-22: Kanten-Extraktion & Validierung ---
|
||||||
|
# A. Explizite User-Kanten mit Zeilennummern extrahieren
|
||||||
|
explicit_edges = extract_edges_with_context(parsed)
|
||||||
|
|
||||||
|
# B. System-Kanten generieren (Struktur: belongs_to, next, prev)
|
||||||
try:
|
try:
|
||||||
raw_edges = build_edges_for_note(
|
raw_system_edges = build_edges_for_note(
|
||||||
note_id,
|
note_id,
|
||||||
chunk_pls,
|
chunk_pls,
|
||||||
note_level_references=note_pl.get("references", []),
|
note_level_references=note_pl.get("references", []),
|
||||||
include_note_scope_refs=note_scope_refs
|
include_note_scope_refs=note_scope_refs
|
||||||
)
|
)
|
||||||
except TypeError:
|
except TypeError:
|
||||||
raw_edges = build_edges_for_note(note_id, chunk_pls)
|
raw_system_edges = build_edges_for_note(note_id, chunk_pls)
|
||||||
|
|
||||||
# --- WP-22: Edge Registry Validation (Teil B) ---
|
# C. Alle Kanten validieren und über die Registry mappen
|
||||||
edges = []
|
edges = []
|
||||||
if raw_edges:
|
context = {"file": file_path, "note_id": note_id}
|
||||||
for edge in raw_edges:
|
|
||||||
original_kind = edge.get("kind", "related_to")
|
# Zuerst User-Kanten (provenance="explicit")
|
||||||
# Normalisierung über die Registry (Alias-Auflösung)
|
for e in explicit_edges:
|
||||||
canonical_kind = edge_registry.resolve(original_kind)
|
valid_kind = edge_registry.resolve(
|
||||||
edge["kind"] = canonical_kind
|
edge_type=e["kind"],
|
||||||
edges.append(edge)
|
provenance="explicit",
|
||||||
|
context={**context, "line": e.get("line")}
|
||||||
|
)
|
||||||
|
e["kind"] = valid_kind
|
||||||
|
edges.append(e)
|
||||||
|
|
||||||
|
# Dann System-Kanten (provenance="structure")
|
||||||
|
for e in raw_system_edges:
|
||||||
|
# Sicherstellen, dass System-Kanten korrekt markiert sind
|
||||||
|
valid_kind = edge_registry.resolve(
|
||||||
|
edge_type=e.get("kind", "belongs_to"),
|
||||||
|
provenance="structure",
|
||||||
|
context={**context, "line": "system"}
|
||||||
|
)
|
||||||
|
e["kind"] = valid_kind
|
||||||
|
# Nur hinzufügen, wenn die Registry einen validen Typ zurückgibt
|
||||||
|
if valid_kind:
|
||||||
|
edges.append(e)
|
||||||
|
|
||||||
except Exception as e:
|
except Exception as e:
|
||||||
logger.error(f"Processing failed: {e}", exc_info=True)
|
logger.error(f"Processing failed: {e}", exc_info=True)
|
||||||
|
|||||||
@@ -231,3 +231,20 @@ def extract_wikilinks(text: str) -> List[str]:
|
|||||||
if raw:
|
if raw:
|
||||||
out.append(raw)
|
out.append(raw)
|
||||||
return out
|
return out
|
||||||
|
|
||||||
|
def extract_edges_with_context(note: ParsedNote) -> List[Dict[str, Any]]:
|
||||||
|
"""Extrahiert Kanten-Typen, Ziele und Zeilennummern."""
|
||||||
|
edges = []
|
||||||
|
lines = note.body.splitlines()
|
||||||
|
# Erkennt [[rel:typ Ziel]]
|
||||||
|
rel_pattern = re.compile(r"\[\[rel:([a-zA-Z0-9_-]+)\s+([^\]|#]+)\]\]")
|
||||||
|
|
||||||
|
for i, line in enumerate(lines):
|
||||||
|
for match in rel_pattern.finditer(line):
|
||||||
|
edges.append({
|
||||||
|
"kind": match.group(1).strip(),
|
||||||
|
"target": match.group(2).strip(),
|
||||||
|
"line": i + 1,
|
||||||
|
"provenance": "explicit"
|
||||||
|
})
|
||||||
|
return edges
|
||||||
@@ -1,16 +1,15 @@
|
|||||||
"""
|
"""
|
||||||
FILE: app/services/edge_registry.py
|
FILE: app/services/edge_registry.py
|
||||||
DESCRIPTION: Single Source of Truth für Kanten-Typen.
|
DESCRIPTION: Single Source of Truth für Kanten-Typen mit dynamischem Reload.
|
||||||
FIX: Regex angepasst auf Format **`canonical`** (Bold + Backticks).
|
WP-22: Transparente Status-Meldungen für Dev-Umgebungen.
|
||||||
VERSION: 0.6.10 (Regex Precision Update)
|
VERSION: 0.7.2 (Fix: Restore Console Visibility & Entry Counts)
|
||||||
"""
|
"""
|
||||||
import re
|
import re
|
||||||
import os
|
import os
|
||||||
import json
|
import json
|
||||||
import logging
|
import logging
|
||||||
from typing import Dict, Optional, Set
|
import time
|
||||||
|
from typing import Dict, Optional, Set, Tuple
|
||||||
print(">>> MODULE_LOAD: edge_registry.py initialized <<<", flush=True)
|
|
||||||
|
|
||||||
from app.config import get_settings
|
from app.config import get_settings
|
||||||
|
|
||||||
@@ -18,6 +17,8 @@ logger = logging.getLogger(__name__)
|
|||||||
|
|
||||||
class EdgeRegistry:
|
class EdgeRegistry:
|
||||||
_instance = None
|
_instance = None
|
||||||
|
# System-Kanten, die NIEMALS manuell im Markdown stehen dürfen
|
||||||
|
FORBIDDEN_SYSTEM_EDGES = {"next", "prev", "belongs_to"}
|
||||||
|
|
||||||
def __new__(cls, *args, **kwargs):
|
def __new__(cls, *args, **kwargs):
|
||||||
if cls._instance is None:
|
if cls._instance is None:
|
||||||
@@ -33,31 +34,50 @@ class EdgeRegistry:
|
|||||||
env_vocab_path = os.getenv("MINDNET_VOCAB_PATH")
|
env_vocab_path = os.getenv("MINDNET_VOCAB_PATH")
|
||||||
env_vault_root = os.getenv("MINDNET_VAULT_ROOT") or getattr(settings, "MINDNET_VAULT_ROOT", "./vault")
|
env_vault_root = os.getenv("MINDNET_VAULT_ROOT") or getattr(settings, "MINDNET_VAULT_ROOT", "./vault")
|
||||||
|
|
||||||
|
# Pfad-Priorität: 1. ENV -> 2. _system/dictionary -> 3. 01_User_Manual
|
||||||
if env_vocab_path:
|
if env_vocab_path:
|
||||||
self.full_vocab_path = os.path.abspath(env_vocab_path)
|
self.full_vocab_path = os.path.abspath(env_vocab_path)
|
||||||
else:
|
else:
|
||||||
self.full_vocab_path = os.path.abspath(
|
possible_paths = [
|
||||||
|
os.path.join(env_vault_root, "_system", "dictionary", "edge_vocabulary.md"),
|
||||||
os.path.join(env_vault_root, "01_User_Manual", "01_edge_vocabulary.md")
|
os.path.join(env_vault_root, "01_User_Manual", "01_edge_vocabulary.md")
|
||||||
)
|
]
|
||||||
|
self.full_vocab_path = None
|
||||||
|
for p in possible_paths:
|
||||||
|
if os.path.exists(p):
|
||||||
|
self.full_vocab_path = os.path.abspath(p)
|
||||||
|
break
|
||||||
|
|
||||||
|
if not self.full_vocab_path:
|
||||||
|
self.full_vocab_path = os.path.abspath(possible_paths[0])
|
||||||
|
|
||||||
self.unknown_log_path = "data/logs/unknown_edges.jsonl"
|
self.unknown_log_path = "data/logs/unknown_edges.jsonl"
|
||||||
self.canonical_map: Dict[str, str] = {}
|
self.canonical_map: Dict[str, str] = {}
|
||||||
self.valid_types: Set[str] = set()
|
self.valid_types: Set[str] = set()
|
||||||
|
self._last_mtime = 0.0
|
||||||
|
|
||||||
self._load_vocabulary()
|
# Initialer Lade-Versuch mit Konsolen-Feedback
|
||||||
|
print(f"\n>>> [EDGE-REGISTRY] Initializing with Path: {self.full_vocab_path}", flush=True)
|
||||||
|
self.ensure_latest()
|
||||||
self.initialized = True
|
self.initialized = True
|
||||||
|
|
||||||
def _load_vocabulary(self):
|
def ensure_latest(self):
|
||||||
"""Parst die Markdown-Tabelle im Vault."""
|
"""Prüft den Zeitstempel und lädt bei Bedarf neu."""
|
||||||
print(f">>> CHECK: Loading Vocabulary from {self.full_vocab_path}", flush=True)
|
|
||||||
|
|
||||||
if not os.path.exists(self.full_vocab_path):
|
if not os.path.exists(self.full_vocab_path):
|
||||||
print(f"!!! [DICT-ERROR] File not found: {self.full_vocab_path} !!!", flush=True)
|
print(f"!!! [EDGE-REGISTRY ERROR] File not found: {self.full_vocab_path} !!!", flush=True)
|
||||||
return
|
return
|
||||||
|
|
||||||
# WP-22 Precision Regex:
|
current_mtime = os.path.getmtime(self.full_vocab_path)
|
||||||
# Sucht nach | **`typ`** | oder | **typ** |
|
if current_mtime > self._last_mtime:
|
||||||
# Die Backticks `? sind jetzt optional enthalten.
|
self._load_vocabulary()
|
||||||
|
self._last_mtime = current_mtime
|
||||||
|
|
||||||
|
def _load_vocabulary(self):
|
||||||
|
"""Parst das Wörterbuch und meldet die Anzahl der gelesenen Einträge."""
|
||||||
|
self.canonical_map.clear()
|
||||||
|
self.valid_types.clear()
|
||||||
|
|
||||||
|
# Regex deckt | **canonical** | Aliase | ab
|
||||||
pattern = re.compile(r"\|\s*\*\*`?([a-zA-Z0-9_-]+)`?\*\*\s*\|\s*([^|]+)\|")
|
pattern = re.compile(r"\|\s*\*\*`?([a-zA-Z0-9_-]+)`?\*\*\s*\|\s*([^|]+)\|")
|
||||||
|
|
||||||
try:
|
try:
|
||||||
@@ -74,36 +94,58 @@ class EdgeRegistry:
|
|||||||
c_types += 1
|
c_types += 1
|
||||||
|
|
||||||
if aliases_str and "Kein Alias" not in aliases_str:
|
if aliases_str and "Kein Alias" not in aliases_str:
|
||||||
# Aliase säubern (entfernt Backticks auch hier)
|
|
||||||
aliases = [a.strip() for a in aliases_str.split(",") if a.strip()]
|
aliases = [a.strip() for a in aliases_str.split(",") if a.strip()]
|
||||||
for alias in aliases:
|
for alias in aliases:
|
||||||
|
# Normalisierung: Kleinschreibung und Unterstriche
|
||||||
clean_alias = alias.replace("`", "").lower().strip().replace(" ", "_")
|
clean_alias = alias.replace("`", "").lower().strip().replace(" ", "_")
|
||||||
self.canonical_map[clean_alias] = canonical
|
self.canonical_map[clean_alias] = canonical
|
||||||
c_aliases += 1
|
c_aliases += 1
|
||||||
|
|
||||||
if c_types == 0:
|
# Erfolgskontrolle für das Dev-Terminal
|
||||||
print("!!! [DICT-WARN] Pattern mismatch! Ensure types are **`canonical`** or **canonical**. !!!", flush=True)
|
print(f"=== [EDGE-REGISTRY SUCCESS] Loaded {c_types} Canonical Types and {c_aliases} Aliases ===", flush=True)
|
||||||
else:
|
logger.info(f"Registry reloaded from {self.full_vocab_path}")
|
||||||
print(f"=== [DICT-SUCCESS] Registered {c_types} Canonical Types and {c_aliases} Aliases ===", flush=True)
|
|
||||||
|
|
||||||
except Exception as e:
|
except Exception as e:
|
||||||
print(f"!!! [DICT-FATAL] Error reading file: {e} !!!", flush=True)
|
print(f"!!! [EDGE-REGISTRY FATAL] Error reading file: {e} !!!", flush=True)
|
||||||
|
logger.error(f"Error reading vocabulary: {e}")
|
||||||
|
|
||||||
def resolve(self, edge_type: str) -> str:
|
def resolve(self, edge_type: str, provenance: str = "explicit", context: dict = None) -> str:
|
||||||
"""Normalisiert Kanten-Typen via Registry oder loggt Unbekannte."""
|
"""Validierung mit Fundort-Logging."""
|
||||||
|
self.ensure_latest()
|
||||||
if not edge_type: return "related_to"
|
if not edge_type: return "related_to"
|
||||||
clean_type = edge_type.lower().strip().replace(" ", "_").replace("-", "_")
|
|
||||||
|
|
||||||
|
clean_type = edge_type.lower().strip().replace(" ", "_").replace("-", "_")
|
||||||
|
ctx = context or {}
|
||||||
|
|
||||||
|
# 1. Schutz der Systemkanten (Verbot für manuelle Nutzung)
|
||||||
|
if provenance == "explicit" and clean_type in self.FORBIDDEN_SYSTEM_EDGES:
|
||||||
|
self._log_issue(clean_type, "forbidden_system_usage", ctx)
|
||||||
|
return "related_to"
|
||||||
|
|
||||||
|
# 2. Akzeptanz interner Strukturkanten
|
||||||
|
if provenance == "structure" and clean_type in self.FORBIDDEN_SYSTEM_EDGES:
|
||||||
|
return clean_type
|
||||||
|
|
||||||
|
# 3. Mapping via Wörterbuch
|
||||||
if clean_type in self.canonical_map:
|
if clean_type in self.canonical_map:
|
||||||
return self.canonical_map[clean_type]
|
return self.canonical_map[clean_type]
|
||||||
|
|
||||||
self._log_unknown(clean_type)
|
# 4. Unbekannte Kante
|
||||||
|
self._log_issue(clean_type, "unknown_type", ctx)
|
||||||
return clean_type
|
return clean_type
|
||||||
|
|
||||||
def _log_unknown(self, edge_type: str):
|
def _log_issue(self, edge_type: str, error_kind: str, ctx: dict):
|
||||||
|
"""Detailliertes JSONL-Logging für Debugging."""
|
||||||
try:
|
try:
|
||||||
os.makedirs(os.path.dirname(self.unknown_log_path), exist_ok=True)
|
os.makedirs(os.path.dirname(self.unknown_log_path), exist_ok=True)
|
||||||
entry = {"unknown_type": edge_type, "status": "new"}
|
entry = {
|
||||||
|
"timestamp": time.strftime("%Y-%m-%d %H:%M:%S"),
|
||||||
|
"edge_type": edge_type,
|
||||||
|
"error": error_kind,
|
||||||
|
"file": ctx.get("file", "unknown"),
|
||||||
|
"line": ctx.get("line", "unknown"),
|
||||||
|
"note_id": ctx.get("note_id", "unknown")
|
||||||
|
}
|
||||||
with open(self.unknown_log_path, "a", encoding="utf-8") as f:
|
with open(self.unknown_log_path, "a", encoding="utf-8") as f:
|
||||||
f.write(json.dumps(entry) + "\n")
|
f.write(json.dumps(entry) + "\n")
|
||||||
except Exception: pass
|
except Exception: pass
|
||||||
|
|||||||
@@ -65,6 +65,7 @@ strategies:
|
|||||||
solves: 2.0
|
solves: 2.0
|
||||||
depends_on: 1.5
|
depends_on: 1.5
|
||||||
risk_of: 2.5
|
risk_of: 2.5
|
||||||
|
impacts: 2.0 # NEU: Zeige mir alles, was von dieser Entscheidung betroffen ist!
|
||||||
prompt_template: "decision_template"
|
prompt_template: "decision_template"
|
||||||
prepend_instruction: |
|
prepend_instruction: |
|
||||||
!!! ENTSCHEIDUNGS-MODUS !!!
|
!!! ENTSCHEIDUNGS-MODUS !!!
|
||||||
|
|||||||
+44
-10
@@ -1,4 +1,4 @@
|
|||||||
version: 1.0
|
version: 1.2
|
||||||
|
|
||||||
scoring:
|
scoring:
|
||||||
# W_sem: skaliert den Term (semantic_score * retriever_weight)
|
# W_sem: skaliert den Term (semantic_score * retriever_weight)
|
||||||
@@ -6,20 +6,54 @@ scoring:
|
|||||||
semantic_weight: 1.0
|
semantic_weight: 1.0
|
||||||
|
|
||||||
# W_edge: skaliert edge_bonus aus dem Subgraph
|
# W_edge: skaliert edge_bonus aus dem Subgraph
|
||||||
# Empfehlung: 0.7 → Graph ist deutlich spürbar, aber überstimmt Semantik nicht komplett
|
# Empfehlung: 0.8 → Graph ist deutlich spürbar, aber überstimmt Semantik nicht komplett
|
||||||
edge_weight: 0.7
|
edge_weight: 0.8
|
||||||
|
|
||||||
# W_cent: skaliert centrality_bonus (Knoten-Zentralität im Subgraph)
|
# W_cent: skaliert centrality_bonus (Knoten-Zentralität im Subgraph)
|
||||||
# Empfehlung: 0.5 → zentrale Knoten werden bevorzugt, aber moderat
|
# Empfehlung: 0.5 → zentrale Knoten werden bevorzugt, aber moderat
|
||||||
centrality_weight: 0.5
|
centrality_weight: 0.5
|
||||||
|
|
||||||
|
# WP-22 Stellschraube: Lifecycle (Status-basiertes Scoring)
|
||||||
|
# Bonus für verifiziertes Wissen, Malus für Entwürfe
|
||||||
|
lifecycle_weights:
|
||||||
|
stable: 1.2 # +20% Bonus
|
||||||
|
active: 1.0 # Standardwert
|
||||||
|
draft: 0.5 # -50% Malus
|
||||||
|
system: 0.0 # Hard Skip via Ingestion
|
||||||
|
|
||||||
# Die nachfolgenden Werte überschreiben die Defaults aus app/core/retriever_config.
|
# Die nachfolgenden Werte überschreiben die Defaults aus app/core/retriever_config.
|
||||||
# Wenn neue Kantentypen, z.B. durch Referenzierung innerhalb einer md-Datei im vault anders gewichtet werden sollen, dann muss hier die Konfiguration erfolgen
|
# Wenn neue Kantentypen, z.B. durch Referenzierung innerhalb einer md-Datei im vault anders gewichtet werden sollen, dann muss hier die Konfiguration erfolgen
|
||||||
edge_types:
|
edge_types:
|
||||||
references: 0.20
|
# --- KATEGORIE 1: LOGIK-BOOSTS (Relevanz-Treiber) ---
|
||||||
depends_on: 0.18
|
# Diese Kanten haben die Kraft, das semantische Ranking aktiv umzugestalten.
|
||||||
related_to: 0.15
|
blocks: 1.6 # Kritisch: Risiken/Blocker müssen sofort sichtbar sein.
|
||||||
similar_to: 0.12
|
solves: 1.5 # Zielführend: Lösungen sind primäre Suchziele.
|
||||||
belongs_to: 0.10
|
depends_on: 1.4 # Logisch: Harte fachliche Abhängigkeit.
|
||||||
next: 0.06
|
resulted_in: 1.4 # Kausal: Ergebnisse und unmittelbare Konsequenzen.
|
||||||
prev: 0.06
|
followed_by: 1.3 # Sequenziell (User): Bewusst gesteuerte Wissenspfade.
|
||||||
|
caused_by: 1.2 # Kausal: Ursachen-Bezug (Basis für Intent-Boost).
|
||||||
|
preceded_by: 1.1 # Sequenziell (User): Rückwärts-Bezug in Logik-Ketten.
|
||||||
|
impacts: 1.2 # Langfristige Auswirkung/Einfluss
|
||||||
|
|
||||||
|
# --- KATEGORIE 2: QUALITATIVER KONTEXT (Stabilitäts-Stützen) ---
|
||||||
|
# Diese Kanten liefern wichtigen Kontext, ohne das Ergebnis zu verfälschen.
|
||||||
|
guides: 1.1 # Qualitativ: Prinzipien oder Werte leiten das Thema.
|
||||||
|
part_of: 1.1 # Strukturell: Zieht übergeordnete Kontexte (Parents) mit hoch.
|
||||||
|
based_on: 0.8 # Fundament: Bezug auf Basis-Werte (kalibriert auf Safe-Retrieval).
|
||||||
|
derived_from: 0.6 # Historisch: Dokumentiert die Herkunft von Wissen.
|
||||||
|
uses: 0.6 # Instrumentell: Genutzte Werkzeuge, Methoden oder Ressourcen.
|
||||||
|
|
||||||
|
# --- KATEGORIE 3: THEMATISCHE NÄHE (Ähnlichkeits-Signal) ---
|
||||||
|
# Diese Werte verhindern den "Drift" in fachfremde Bereiche.
|
||||||
|
similar_to: 0.4 # Analytisch: Thematische Nähe (oft KI-generiert).
|
||||||
|
|
||||||
|
# --- KATEGORIE 4: SYSTEM-NUDGES (Technische Struktur) ---
|
||||||
|
# Reine Orientierungshilfen für das System; fast kein Einfluss auf das Ranking.
|
||||||
|
belongs_to: 0.2 # System: Verknüpft Chunks mit der Note (Metadaten-Träger).
|
||||||
|
next: 0.1 # System: Technische Lesereihenfolge der Absätze.
|
||||||
|
prev: 0.1 # System: Technische Lesereihenfolge der Absätze.
|
||||||
|
|
||||||
|
# --- KATEGORIE 5: WEICHE ASSOZIATIONEN (Rausch-Unterdrückung) ---
|
||||||
|
# Verhindert, dass lose Verknüpfungen das Ergebnis "verwässern".
|
||||||
|
references: 0.1 # Assoziativ: Einfacher Querverweis oder Erwähnung.
|
||||||
|
related_to: 0.05 # Minimal: Schwächste thematische Verbindung.
|
||||||
+126
-16
@@ -81,35 +81,43 @@ defaults:
|
|||||||
|
|
||||||
types:
|
types:
|
||||||
|
|
||||||
# --- KERNTYPEN ---
|
|
||||||
|
|
||||||
experience:
|
experience:
|
||||||
chunking_profile: sliding_smart_edges
|
chunking_profile: sliding_smart_edges
|
||||||
retriever_weight: 0.90
|
retriever_weight: 1.10 # Erhöht für biografische Relevanz
|
||||||
edge_defaults: ["derived_from", "references"]
|
edge_defaults: ["derived_from", "references"]
|
||||||
detection_keywords: ["passiert", "erlebt", "gefühl", "situation", "reaktion"]
|
detection_keywords: ["erleben", "reagieren", "handeln", "prägen", "reflektieren"]
|
||||||
schema:
|
schema:
|
||||||
- "Situation (Was ist passiert?)"
|
- "Situation (Was ist passiert?)"
|
||||||
- "Meine Reaktion (Was habe ich getan?)"
|
- "Meine Reaktion (Was habe ich getan?)"
|
||||||
- "Ergebnis & Auswirkung"
|
- "Ergebnis & Auswirkung"
|
||||||
- "Reflexion & Learning (Was lerne ich daraus?)"
|
- "Reflexion & Learning (Was lerne ich daraus?)"
|
||||||
|
|
||||||
|
insight:
|
||||||
|
chunking_profile: sliding_smart_edges
|
||||||
|
retriever_weight: 1.20 # Hoch gewichtet für aktuelle Steuerung
|
||||||
|
edge_defaults: ["references", "based_on"]
|
||||||
|
detection_keywords: ["beobachten", "erkennen", "verstehen", "analysieren", "schlussfolgern"]
|
||||||
|
schema:
|
||||||
|
- "Beobachtung (Was sehe ich?)"
|
||||||
|
- "Interpretation (Was bedeutet das?)"
|
||||||
|
- "Bedürfnis (Was steckt dahinter?)"
|
||||||
|
- "Handlungsempfehlung"
|
||||||
|
|
||||||
project:
|
project:
|
||||||
chunking_profile: sliding_smart_edges
|
chunking_profile: sliding_smart_edges
|
||||||
retriever_weight: 0.97
|
retriever_weight: 0.97
|
||||||
edge_defaults: ["references", "depends_on"]
|
edge_defaults: ["references", "depends_on"]
|
||||||
detection_keywords: ["projekt", "vorhaben", "ziel ist", "planen", "starten"]
|
detection_keywords: ["umsetzen", "planen", "starten", "bauen", "abschließen"]
|
||||||
schema:
|
schema:
|
||||||
- "Mission & Zielsetzung"
|
- "Mission & Zielsetzung"
|
||||||
- "Aktueller Status & Blockaden"
|
- "Aktueller Status & Blockaden"
|
||||||
- "Nächste konkrete Schritte"
|
- "Nächste konkrete Schritte"
|
||||||
|
|
||||||
decision:
|
decision:
|
||||||
# Strict, damit jede Entscheidung atomar bleibt
|
|
||||||
chunking_profile: structured_smart_edges_strict
|
chunking_profile: structured_smart_edges_strict
|
||||||
retriever_weight: 1.00
|
retriever_weight: 1.00
|
||||||
edge_defaults: ["caused_by", "references"]
|
edge_defaults: ["caused_by", "references"]
|
||||||
detection_keywords: ["entschieden", "wahl", "optionen", "alternativen", "adr"]
|
detection_keywords: ["entscheiden", "wählen", "abwägen", "priorisieren", "festlegen"]
|
||||||
schema:
|
schema:
|
||||||
- "Kontext & Problemstellung"
|
- "Kontext & Problemstellung"
|
||||||
- "Betrachtete Optionen"
|
- "Betrachtete Optionen"
|
||||||
@@ -119,34 +127,136 @@ types:
|
|||||||
# --- PERSÖNLICHKEIT & IDENTITÄT ---
|
# --- PERSÖNLICHKEIT & IDENTITÄT ---
|
||||||
|
|
||||||
value:
|
value:
|
||||||
# Strict, damit Werte nicht verschwimmen
|
|
||||||
chunking_profile: structured_smart_edges_strict
|
chunking_profile: structured_smart_edges_strict
|
||||||
retriever_weight: 1.00
|
retriever_weight: 1.00
|
||||||
edge_defaults: ["related_to"]
|
edge_defaults: ["related_to"]
|
||||||
detection_keywords: ["wert", "wichtig ist", "moral", "ethik"]
|
detection_keywords: ["werten", "achten", "verpflichten", "bedeuten"]
|
||||||
schema: ["Definition", "Warum mir das wichtig ist", "Leitsätze"]
|
schema:
|
||||||
|
- "Definition"
|
||||||
|
- "Warum mir das wichtig ist"
|
||||||
|
- "Leitsätze"
|
||||||
|
|
||||||
principle:
|
principle:
|
||||||
# L3 Strict für P3/P3a und Tier2/MP1 Logik
|
|
||||||
chunking_profile: structured_smart_edges_strict_L3
|
chunking_profile: structured_smart_edges_strict_L3
|
||||||
retriever_weight: 0.95
|
retriever_weight: 0.95
|
||||||
edge_defaults: ["derived_from", "references"]
|
edge_defaults: ["derived_from", "references"]
|
||||||
detection_keywords: ["prinzip", "regel", "grundsatz", "leitlinie"]
|
detection_keywords: ["leiten", "steuern", "ausrichten", "handhaben"]
|
||||||
schema: ["Das Prinzip", "Anwendung & Beispiele"]
|
schema:
|
||||||
|
- "Das Prinzip"
|
||||||
|
- "Anwendung & Beispiele"
|
||||||
|
|
||||||
|
trait:
|
||||||
|
chunking_profile: structured_smart_edges_strict
|
||||||
|
retriever_weight: 1.10
|
||||||
|
edge_defaults: ["related_to"]
|
||||||
|
detection_keywords: ["begeistern", "können", "auszeichnen", "befähigen", "stärken"]
|
||||||
|
schema:
|
||||||
|
- "Eigenschaft / Talent"
|
||||||
|
- "Beispiele aus der Praxis"
|
||||||
|
- "Potenzial für die Zukunft"
|
||||||
|
|
||||||
|
obstacle:
|
||||||
|
chunking_profile: structured_smart_edges_strict
|
||||||
|
retriever_weight: 1.00
|
||||||
|
edge_defaults: ["blocks", "related_to"]
|
||||||
|
detection_keywords: ["blockieren", "fürchten", "vermeiden", "hindern", "zweifeln"]
|
||||||
|
schema:
|
||||||
|
- "Beschreibung der Hürde"
|
||||||
|
- "Ursprung / Auslöser"
|
||||||
|
- "Auswirkung auf Ziele"
|
||||||
|
- "Gegenstrategie"
|
||||||
|
|
||||||
belief:
|
belief:
|
||||||
chunking_profile: sliding_short
|
chunking_profile: sliding_short
|
||||||
retriever_weight: 0.90
|
retriever_weight: 0.90
|
||||||
edge_defaults: ["related_to"]
|
edge_defaults: ["related_to"]
|
||||||
schema: ["Der Glaubenssatz", "Ursprung & Reflexion"]
|
detection_keywords: ["glauben", "meinen", "annehmen", "überzeugen"]
|
||||||
|
schema:
|
||||||
|
- "Der Glaubenssatz"
|
||||||
|
- "Ursprung & Reflexion"
|
||||||
|
|
||||||
profile:
|
profile:
|
||||||
# Strict: Jede Rolle (H2) muss ein eigener Chunk sein
|
|
||||||
chunking_profile: structured_smart_edges_strict
|
chunking_profile: structured_smart_edges_strict
|
||||||
retriever_weight: 0.70
|
retriever_weight: 0.70
|
||||||
edge_defaults: ["references", "related_to"]
|
edge_defaults: ["references", "related_to"]
|
||||||
schema: ["Rolle / Identität", "Fakten & Daten", "Historie"]
|
detection_keywords: ["verkörpern", "verantworten", "agieren", "repräsentieren"]
|
||||||
|
schema:
|
||||||
|
- "Rolle / Identität"
|
||||||
|
- "Fakten & Daten"
|
||||||
|
- "Historie"
|
||||||
|
|
||||||
|
|
||||||
|
idea:
|
||||||
|
chunking_profile: sliding_short
|
||||||
|
retriever_weight: 0.70
|
||||||
|
edge_defaults: ["leads_to", "references"]
|
||||||
|
detection_keywords: ["einfall", "gedanke", "potenzial", "möglichkeit"]
|
||||||
|
schema:
|
||||||
|
- "Der Kerngedanke"
|
||||||
|
- "Potenzial & Auswirkung"
|
||||||
|
- "Nächste Schritte"
|
||||||
|
|
||||||
|
skill:
|
||||||
|
chunking_profile: sliding_smart_edges
|
||||||
|
retriever_weight: 0.90
|
||||||
|
edge_defaults: ["references", "related_to"]
|
||||||
|
detection_keywords: ["lernen", "beherrschen", "üben", "fertigkeit", "kompetenz"]
|
||||||
|
schema:
|
||||||
|
- "Definition der Fähigkeit"
|
||||||
|
- "Aktueller Stand & Lernpfad"
|
||||||
|
- "Evidenz (Proof of Work)"
|
||||||
|
|
||||||
|
habit:
|
||||||
|
chunking_profile: sliding_short
|
||||||
|
retriever_weight: 0.85
|
||||||
|
edge_defaults: ["related_to", "triggered_by"]
|
||||||
|
detection_keywords: ["gewohnheit", "routine", "automatismus", "immer wenn"]
|
||||||
|
schema:
|
||||||
|
- "Auslöser (Trigger)"
|
||||||
|
- "Routine (Handlung)"
|
||||||
|
- "Belohnung (Reward)"
|
||||||
|
- "Strategie"
|
||||||
|
|
||||||
|
need:
|
||||||
|
chunking_profile: sliding_smart_edges
|
||||||
|
retriever_weight: 1.05
|
||||||
|
edge_defaults: ["related_to", "impacts"]
|
||||||
|
detection_keywords: ["bedürfnis", "brauchen", "mangel", "erfüllung"]
|
||||||
|
schema:
|
||||||
|
- "Das Bedürfnis"
|
||||||
|
- "Zustand (Mangel vs. Erfüllung)"
|
||||||
|
- "Bezug zu Werten"
|
||||||
|
|
||||||
|
motivation:
|
||||||
|
chunking_profile: sliding_smart_edges
|
||||||
|
retriever_weight: 0.95
|
||||||
|
edge_defaults: ["drives", "references"]
|
||||||
|
detection_keywords: ["motivation", "antrieb", "warum", "energie"]
|
||||||
|
schema:
|
||||||
|
- "Der Antrieb"
|
||||||
|
- "Zielbezug"
|
||||||
|
- "Energiequelle"
|
||||||
|
|
||||||
|
bias:
|
||||||
|
chunking_profile: sliding_short
|
||||||
|
retriever_weight: 0.80
|
||||||
|
edge_defaults: ["affects", "related_to"]
|
||||||
|
detection_keywords: ["denkfehler", "verzerrung", "vorurteil", "falle"]
|
||||||
|
schema: ["Beschreibung der Verzerrung", "Typische Situationen", "Gegenstrategie"]
|
||||||
|
|
||||||
|
state:
|
||||||
|
chunking_profile: sliding_short
|
||||||
|
retriever_weight: 0.60
|
||||||
|
edge_defaults: ["impacts"]
|
||||||
|
detection_keywords: ["stimmung", "energie", "gefühl", "verfassung"]
|
||||||
|
schema: ["Aktueller Zustand", "Auslöser", "Auswirkung auf den Tag"]
|
||||||
|
|
||||||
|
boundary:
|
||||||
|
chunking_profile: sliding_smart_edges
|
||||||
|
retriever_weight: 0.90
|
||||||
|
edge_defaults: ["protects", "related_to"]
|
||||||
|
detection_keywords: ["grenze", "nein sagen", "limit", "schutz"]
|
||||||
|
schema: ["Die Grenze", "Warum sie wichtig ist", "Konsequenz bei Verletzung"]
|
||||||
# --- STRATEGIE & RISIKO ---
|
# --- STRATEGIE & RISIKO ---
|
||||||
|
|
||||||
goal:
|
goal:
|
||||||
|
|||||||
@@ -28,6 +28,7 @@ Das Repository ist in **logische Domänen** unterteilt.
|
|||||||
| :--- | :--- |
|
| :--- | :--- |
|
||||||
| `01_chat_usage_guide.md` | **Bedienung.** Wie steuere ich die Personas (Berater, Spiegel)? Wie nutze ich das Feedback? |
|
| `01_chat_usage_guide.md` | **Bedienung.** Wie steuere ich die Personas (Berater, Spiegel)? Wie nutze ich das Feedback? |
|
||||||
| `01_knowledge_design.md` | **Content-Regeln.** Die "Bibel" für den Vault. Erklärt Note-Typen, Matrix-Logik und Markdown-Syntax. |
|
| `01_knowledge_design.md` | **Content-Regeln.** Die "Bibel" für den Vault. Erklärt Note-Typen, Matrix-Logik und Markdown-Syntax. |
|
||||||
|
| `01-authoring-guidelines` | **Content strukturieren-.** primäres Werkzeug, um Wissen so zu strukturieren, so dass Mindnet die Persönlichkeit spiegelt, empathisch reagiert und strategisch berät |
|
||||||
|
|
||||||
### 📂 02_Concepts (Fachliche Logik)
|
### 📂 02_Concepts (Fachliche Logik)
|
||||||
*Zielgruppe: Architekten, Product Owner*
|
*Zielgruppe: Architekten, Product Owner*
|
||||||
|
|||||||
@@ -0,0 +1,189 @@
|
|||||||
|
---
|
||||||
|
id: 01-authoring-guidelines
|
||||||
|
title: Authoring Guidelines – Handbuch für den Digitalen Zwilling
|
||||||
|
type: principle
|
||||||
|
status: stable
|
||||||
|
version: 1.1.0
|
||||||
|
area: system_documentation
|
||||||
|
tags: [handbuch, authoring, methodik, obsidian, mindnet, best-practice]
|
||||||
|
retriever_weight: 2.0
|
||||||
|
---
|
||||||
|
|
||||||
|
# Authoring Guidelines: Dein Werkzeug für den Digitalen Zwilling
|
||||||
|
|
||||||
|
|
||||||
|
Dieses Handbuch ist dein primäres Werkzeug, um Wissen so zu strukturieren, dass Mindnet deine Persönlichkeit spiegelt, empathisch reagiert und dich strategisch berät.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## ⚡ Die 6 Goldenen Regeln des Knowledge Designs
|
||||||
|
|
||||||
|
1. **Atomare Gedanken:** Eine Notiz = Ein Thema. Trenne z. B. „Meditation“ von „Mobility“, auch wenn beides Ich-Pflege ist.
|
||||||
|
2. **Explizite Typen:** Nutze den `type`, um der KI zu sagen, wie sie den Text verarbeiten soll (z. B. `insight` für Beobachtungen, `experience` für Erlebnisse).
|
||||||
|
3. **Semantische Links:** Verknüpfe aktiv mit `[[rel:depends_on ...]]` oder `[[rel:based_on ...]]`. Sag dem System, *warum* Dinge zusammenhängen.
|
||||||
|
4. **Werte & Ziele definieren:** Erstelle für jeden Nordstern und jeden Kernwert eine eigene Notiz. Ohne Maßstäbe kann der „Berater“ nicht entscheiden.
|
||||||
|
5. **Emotionales Bridging:** Nutze Begriffe wie „Druck“, „Stolz“, „Euphorie“ oder „Hilflosigkeit“, um die Empathie-Ebene der KI zu aktivieren.
|
||||||
|
6. **Narrative Tiefe (Fleisch am Knochen):** Dokumentiere das „Warum“ hinter einer Entscheidung. Fakten informieren, aber Erzählungen prägen den Charakter.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 1. Strategische Steuerung (Status & Gewicht)
|
||||||
|
|
||||||
|
Du entscheidest über das Frontmatter, wie präsent eine Information im „Gedächtnis“ ist.
|
||||||
|
|
||||||
|
### 1.1 Status-Logik
|
||||||
|
* **`stable`**: Gold-Standard. Für finale Leitbild-Texte und Nordsterne. Erhält +20% Relevanz-Bonus.
|
||||||
|
* **`active`**: Standard für laufende Projekte und aktuelle Beobachtungen.
|
||||||
|
* **`draft`**: Brainstorming oder rohe Tages-Logs. Die KI nutzt diese nur nachrangig (50% Malus), um Rauschen zu vermeiden.
|
||||||
|
* **`system`**: Rein technische Dateien (Templates, Guides). Werden im Chat ignoriert.
|
||||||
|
|
||||||
|
### 1.2 Manuelle Gewichtung (`retriever_weight`)
|
||||||
|
* **Boost (1.20):** Für hochrelevante Erkenntnisse. **Beispiel:** Beobachtungen zum Verhalten von Rohan werden als `insight` mit `1.20` markiert, damit sie bei Erziehungsfragen sofort präsent sind.
|
||||||
|
* **Deboost (0.50 - 0.80):** Für tägliche Routine-Einträge („Heute 10 Min. meditiert“). Sie dienen der Chronik, sollen aber keine tiefen Analysen verfälschen.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 2. Das Kochbuch: Praktische Use-Cases
|
||||||
|
|
||||||
|
### 2.1 Ein Erlebnis aufschreiben (`type: experience`)
|
||||||
|
**Ziel:** Den „Spiegel“ (Empathy) mit deiner Biografie kalibrieren.
|
||||||
|
|
||||||
|
**Struktur & Leitfragen:**
|
||||||
|
- **Kontext:** Was ist passiert? (Sachlich kurz).
|
||||||
|
- **Emotions-Check:** Wie habe ich mich in der Situation gefühlt? (Wichtig für Regel 5).
|
||||||
|
- **Die Lektion:** Was habe ich über mich gelernt? (z. B. „Ich reagiere allergisch auf Ungerechtigkeit“).
|
||||||
|
- **Deep-Edge:** Mit welcher Rolle ist das verknüpft? `[[rel:supports Meine Rollenlandkarte 2025#Vater]]`.
|
||||||
|
|
||||||
|
### 2.2 Eine Beobachtung festhalten (`type: insight`)
|
||||||
|
**Ziel:** Den „Berater“ (Decision) mit Mustern versorgen.
|
||||||
|
|
||||||
|
**Beispiel Rohan-Beobachtung:**
|
||||||
|
- **Beobachtung:** Rohan reagiert positiv auf „leise“ Impulse und 90/10 Coaching.
|
||||||
|
- **Interpretation:** Direkte Konfrontation erzeugt Gegendruck; Fragen erzeugen Ownership.
|
||||||
|
- **Konsequenz:** Prinzip P3a (Familienregeln) muss immer einen Bedürfnischeck vorausschicken.
|
||||||
|
|
||||||
|
### 2.3 Ein Review durchführen (`type: journal` / `insight`)
|
||||||
|
**Ziel:** Den Fortschritt steuern.
|
||||||
|
- **Daily:** Rohes Log (Status `draft`).
|
||||||
|
- **Weekly/Monthly:** Verdichtung der Erkenntnisse in eine `stable` Notiz. Frage: „Was war der größte Hebel diese Woche?“.
|
||||||
|
|
||||||
|
### 2.4 Das Handlungsprinzip (`type: principle`)
|
||||||
|
**Ziel:** Testbare Regeln für schwierige Entscheidungssituationen.
|
||||||
|
|
||||||
|
**Struktur-Vorgabe:**---
|
||||||
|
id: 01-authoring-guidelines
|
||||||
|
title: Authoring Guidelines – Das Handbuch für den Digitalen Zwilling
|
||||||
|
type: principle
|
||||||
|
status: stable
|
||||||
|
version: 1.2.0
|
||||||
|
area: system_documentation
|
||||||
|
tags: [handbuch, authoring, methodik, obsidian, mindnet, best-practice]
|
||||||
|
retriever_weight: 2.0
|
||||||
|
---
|
||||||
|
|
||||||
|
## 🕸️ Teil 3: Netzdesign (Hubs, Edges & Lücken)
|
||||||
|
|
||||||
|
Ein intelligentes Netz wächst durch strategische Verknüpfungen, nicht durch Textmenge.
|
||||||
|
|
||||||
|
### 3.1 Wissens-Hubs (Zentralnotizen)
|
||||||
|
Hubs fungieren als Verteilerzentren im Graphen.
|
||||||
|
* **Struktur:** Nutze Überschriften (H2, H3) und verlinke von dort auf Detailnotizen.
|
||||||
|
* **Deep-Edges:** Verlinke präzise Abschnitte: `[[Rollenlandkarte#Vater]]`. Dies ermöglicht der KI, nur den relevanten Kontext zu laden.
|
||||||
|
|
||||||
|
### 3.2 Forward-Mapping (Strategische Lücken)
|
||||||
|
Setze bewusst Links auf Dateien, die noch nicht existieren (z. B. `[[Die beste Version meiner selbst]]`).
|
||||||
|
* **Zweck:** Du signalisierst dem System: „Hier entsteht ein wichtiges Konzept“.
|
||||||
|
* **Effekt:** Die KI erkennt diese Lücken und kann im Chat proaktiv Fragen stellen, um diese Felder mit dir gemeinsam zu füllen.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 4. Obsidian Usability & Automatisierung
|
||||||
|
|
||||||
|
### 4.1 Templater-Integration
|
||||||
|
Nutze Vorlagen, die bereits die **Leitfragen** und das richtige **Retriever-Weight** enthalten. Ein Klick auf „Neues Erlebnis“ sollte automatisch das Frontmatter mit `type: experience` und `weight: 1.1` füllen.
|
||||||
|
|
||||||
|
### 4.2 Meta Bind Dashboards
|
||||||
|
Nutze **Meta Bind**, um Felder wie `status` oder `retriever_weight` über Schieberegler direkt in der Notiz zu steuern. Das macht die Gewichtung deines Wissens intuitiv und spielerisch.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 5. Vernetzung für die Mindnet-Personas
|
||||||
|
|
||||||
|
| Persona | Notiz-Fokus | Effekt im Dialog |
|
||||||
|
| :--- | :--- | :--- |
|
||||||
|
| **🪞 Spiegel (Empathy)** | Gefühle & Biografisches | „Ich verstehe deinen Frust, das war bei Projekt X ähnlich...“. |
|
||||||
|
| **⚖️ Berater (Decision)** | Werte & Wächterfragen | „Option A ist nicht ratsam, da sie gegen dein Prinzip der Integrität verstößt“. |
|
||||||
|
| **📚 Bibliothekar (Facts)** | Struktur & Definitionen | „Deine Mission als Vater ist es, verlässliche Präsenz zu zeigen...“. |
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
> [!abstract] Fazit für den Autor
|
||||||
|
> Mindnet ist ein **Persönlichkeitsspiegel**. Dokumentiere weniger „Technik“ und mehr „Mensch“. Jede Notiz sollte die Frage beantworten: „Was sagt das über mich und meine Werte aus?“.
|
||||||
|
- **3 Signale:** Woran merke ich im Alltag, dass ich das Prinzip lebe?.
|
||||||
|
- **Wächterfrage:** Welche Frage stelle ich mir im Moment der Entscheidung?.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 6. Obsidian Workflow-Hacks
|
||||||
|
|
||||||
|
### 6.1 Templater & Meta Bind
|
||||||
|
- **Automatisierung:** Nutze das **Templater-Plugin**, um beim Erstellen einer Notiz sofort die passenden Leitfragen und das richtige `retriever_weight` einzufügen.
|
||||||
|
- **Interaktive Steuerung:** Nutze **Meta Bind**, um Felder wie `status` oder `retriever_weight` über Buttons oder Slider direkt im Lesemodus zu ändern, ohne im YAML-Code zu tippen.
|
||||||
|
|
||||||
|
### 6.2 Deep-Edges & Verknüpfung
|
||||||
|
- Verknüpfe Erlebnisse immer mit der entsprechenden Rolle: `[[rel:supports Meine Rollenlandkarte 2025#Vater]]`.
|
||||||
|
- Nutze `derived_from`, um Prinzipien an ihre Ursprungs-Session zu binden.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 7. Vernetzung für Mindnet Personas
|
||||||
|
|
||||||
|
| Persona | Notiz-Fokus | Beispiel |
|
||||||
|
| :--- | :--- | :--- |
|
||||||
|
| **🪞 Spiegel (Empathy)** | Emotionen & Prägungen | „Ich fühlte mich hilflos, als...“. |
|
||||||
|
| **⚖️ Berater (Decision)** | Kriterien & Abwägungen | „Option A verletzt Wert X, weil...“. |
|
||||||
|
| **📚 Bibliothekar (Facts)** | Struktur & Definition | „Rollenmission Vater bedeutet...“. |
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
> [!tip] Best Practice
|
||||||
|
> Wenn du merkst, dass eine Notiz zu technisch wird: Halte inne und frage dich: „Was macht das mit mir als Mensch?“ Schreibe *das* auf. Das ist die Essenz für deinen KI-Zwilling.
|
||||||
|
|
||||||
|
## 8. Verbindungen von Notiztypen
|
||||||
|
|
||||||
|
```mermaid
|
||||||
|
graph TD
|
||||||
|
%% Identity Stream
|
||||||
|
V[Value] -- definieren --> N[Need]
|
||||||
|
N -- erzeugen --> M[Motivation]
|
||||||
|
B[Belief] -- prägen --> M
|
||||||
|
T[Trait] -- unterstützen --> M
|
||||||
|
|
||||||
|
%% Action Stream
|
||||||
|
M -- treiben --> G[Goal]
|
||||||
|
G -- konkretisiert in --> P[Project]
|
||||||
|
P -- unterteilt in --> TA[Task]
|
||||||
|
D[Decision] -- steuert --> P
|
||||||
|
PR[Principle] -- leitet --> D
|
||||||
|
|
||||||
|
%% History Stream
|
||||||
|
TA -- führt zu --> E[Event]
|
||||||
|
E -- generiert --> EX[Experience]
|
||||||
|
PE[Person] -- beteiligt an --> E
|
||||||
|
|
||||||
|
%% Feedback Loop
|
||||||
|
EX -- liefert --> I[Insight]
|
||||||
|
I -- kalibrieren --> V
|
||||||
|
I -- verfeinern --> PR
|
||||||
|
I -- validieren --> B
|
||||||
|
|
||||||
|
%% Constraints
|
||||||
|
RI[Risk] -- gefährdet --> G
|
||||||
|
O[Obstacle] -- blockiert --> TA
|
||||||
|
BI[Bias] -- verzerrt --> D
|
||||||
|
S[State] -- beeinflusst --> EX
|
||||||
|
|
||||||
|
style V fill:#f9f,stroke:#333,stroke-width:2px
|
||||||
|
style EX fill:#bbf,stroke:#333,stroke-width:2px
|
||||||
|
style P fill:#bfb,stroke:#333,stroke-width:2px
|
||||||
|
|
||||||
@@ -3,7 +3,7 @@ doc_type: user_manual
|
|||||||
audience: user, author
|
audience: user, author
|
||||||
scope: vault, markdown, schema
|
scope: vault, markdown, schema
|
||||||
status: active
|
status: active
|
||||||
version: 2.7.0
|
version: 2.8.0
|
||||||
context: "Regelwerk für das Erstellen von Notizen im Vault. Die 'Source of Truth' für Autoren."
|
context: "Regelwerk für das Erstellen von Notizen im Vault. Die 'Source of Truth' für Autoren."
|
||||||
---
|
---
|
||||||
|
|
||||||
@@ -11,16 +11,14 @@ context: "Regelwerk für das Erstellen von Notizen im Vault. Die 'Source of Trut
|
|||||||
|
|
||||||
**Quellen:** `knowledge_design.md`, `types.yaml`
|
**Quellen:** `knowledge_design.md`, `types.yaml`
|
||||||
|
|
||||||
## ⚡ Die 5 Goldenen Regeln (TL;DR)
|
## ⚡ Die 6 Goldenen Regeln (TL;DR)
|
||||||
|
|
||||||
Damit Mindnet als dein Digitaler Zwilling funktioniert, beachte beim Schreiben diese Grundsätze:
|
|
||||||
|
|
||||||
1. **Atomare Gedanken:** Eine Notiz = Ein Thema. Wenn du über zwei Projekte schreibst, mach zwei Notizen draus.
|
|
||||||
2. **Explizite Typen:** Setze immer den `type` im Frontmatter. Mindnet behandelt eine `decision` ("Wir machen X") völlig anders als ein `concept` ("Was ist X").
|
|
||||||
3. **Semantische Links:** Schreibe nicht nur `[[Link]]`, sondern `[[rel:depends_on Link]]`. Sag dem System *wie* Dinge zusammenhängen.
|
|
||||||
4. **Werte & Ziele definieren:** Damit die **Decision Engine** dich beraten kann, musst du deine Kriterien (`type: value`, `type: goal`) explizit als Notizen anlegen.
|
|
||||||
5. **Emotionales Bridging:** Damit die **Empathie** funktioniert, nutze in Erfahrungsberichten (`type: experience`) emotionale Schlüsselwörter ("Krise", "Freude", "Angst").
|
|
||||||
|
|
||||||
|
1. **Atomare Gedanken:** Eine Notiz = Ein Thema. Vermischung führt zu "Context-Pollution", wodurch die KI unpräzise berät.
|
||||||
|
2. **Explizite Typen:** Der `type` im Frontmatter ist der wichtigste Hebel. Er entscheidet über die mathematische Gewichtung im System.
|
||||||
|
3. **Semantische Links:** Nutze das Vokabular aus der `01_edge_vocabulary.md`. Ersetze einfache Verweise durch funktionale Beziehungen wie `caused_by` oder `based_on`.
|
||||||
|
4. **Werte & Ziele definieren:** Ohne explizite Kriterien (`type: value`) fehlt dem System der Maßstab für eine Bewertung.
|
||||||
|
5. **Emotionales Bridging:** Dokumentiere deine Gefühle. Begriffe wie „Druck“ oder „Euphorie“ sind die Schnittstelle für die Empathie-Logik.
|
||||||
|
6. **Narrative Tiefe (Fleisch am Knochen):** Ein „Was“ ohne „Warum“ ist für die KI nur ein Fakt, für dich als Mensch aber bedeutungslos. Dokumentiere die Intention hinter deinen Taten.
|
||||||
---
|
---
|
||||||
|
|
||||||
## 1. Zweck & Scope
|
## 1. Zweck & Scope
|
||||||
@@ -43,10 +41,17 @@ type: project # Steuert Chunking & Wichtigkeit
|
|||||||
status: active # active, archived, draft
|
status: active # active, archived, draft
|
||||||
created: 2025-12-12 # ISO 8601
|
created: 2025-12-12 # ISO 8601
|
||||||
tags: [ki, entwicklung] # Taxonomie
|
tags: [ki, entwicklung] # Taxonomie
|
||||||
|
aliases: [KI Projekt, Codename Quickhack]
|
||||||
---
|
---
|
||||||
```
|
```
|
||||||
|
|
||||||
### 2.1 Advanced Overrides: Die KI-Steuerung übernehmen
|
### **2.1 [NEU] Naming Convention: Intuitiv vs. Technisch**
|
||||||
|
Für die Benutzerfreundlichkeit und die intuitive Navigation in Obsidian wird die Nutzung von **menschenlesbaren Titeln** bevorzugt (z. B. `Mein Persönliches Leitbild 2025` statt `leitbild_identity`).
|
||||||
|
- Die technische Eindeutigkeit wird primär über die `id` im Frontmatter sichergestellt.
|
||||||
|
- Die KI nutzt die Semantik des Dateinamens als zusätzlichen Kontext-Vektor.
|
||||||
|
|
||||||
|
### 2.2 Advanced Overrides: Die KI-Steuerung übernehmen
|
||||||
|
|
||||||
|
|
||||||
In 95% der Fälle setzt der `type` (z.B. "concept") automatisch die richtigen Einstellungen. In Spezialfällen kannst du diese manuell im Frontmatter überschreiben, um das Verhalten der KI zu erzwingen.
|
In 95% der Fälle setzt der `type` (z.B. "concept") automatisch die richtigen Einstellungen. In Spezialfällen kannst du diese manuell im Frontmatter überschreiben, um das Verhalten der KI zu erzwingen.
|
||||||
|
|
||||||
@@ -86,23 +91,110 @@ retriever_weight: 1.5
|
|||||||
```
|
```
|
||||||
|
|
||||||
---
|
---
|
||||||
|
## 3. Frontmatter Felder und ihre Bedeutung
|
||||||
|
### 3.1 Typ-Referenz & Stream-Logik
|
||||||
|
|
||||||
## 3. Typ-Referenz & Verhalten
|
Das System euriert Informationen in funktionalen Streams. Wähle den Typ danach aus, in welchem "Gedächtnis-Bereich" die Information landen soll.
|
||||||
|
|
||||||
Wähle den Typ, der die **Rolle** der Notiz am besten beschreibt. Der Typ setzt die Defaults für die oben genannten Parameter.
|
### 3.1 Identity Stream (Der Kern / Das „Warum“)
|
||||||
|
Dieser Stream definiert deine stabilen Merkmale und inneren Kompasse.
|
||||||
|
|
||||||
| Typ | Default Profil | Default Gewicht | Einsatzzweck |
|
| Typ | Gewicht | Chunking Profil | Zweck & Inhalt |
|
||||||
| :--- | :--- | :--- | :--- |
|
| :--- | :--- | :--- | :--- |
|
||||||
| **`concept`** | `sliding_smart_edges` | 0.60 | Fachbegriffe, Theorien. Zeitloses Wissen. |
|
| **`value`** | 1.00 | `structured_strict` | Fundamentale Werte und moralische Maßstäbe. |
|
||||||
| **`project`** | `sliding_smart_edges` | 0.97 | Aktive Vorhaben mit Ziel und Status. |
|
| **`principle`** | 0.95 | `structured_strict_L3` | Handlungsleitlinien mit tiefer Hierarchie (H3-Split). |
|
||||||
| **`experience`**| `sliding_smart_edges` | 0.90 | Persönliche Lektionen (für Empathie). |
|
| **`trait`** | 1.10 | `structured_strict` | Charakterliche Stärken und Talente. |
|
||||||
| **`decision`** | **`structured_..._strict`** | **1.00** | Entscheidungen. Muss atomar getrennt sein (Optionen vs. Ergebnis). |
|
| **`belief`** | 0.90 | `sliding_short` | Tiefe Überzeugungen über dich und die Gesellschaft. |
|
||||||
| **`value`** | **`structured_..._strict`** | **1.00** | Werte/Prinzipien. |
|
| **`profile`** | 0.70 | `structured_strict` | Rollenidentitäten (z. B. Vater, Mentor, Unternehmer). |
|
||||||
| **`principle`**| `structured_..._strict_L3`| 0.95 | Handlungsleitlinien (Trennt bis Ebene H3). |
|
| **`need`** | 1.05 | `sliding_smart_edges` | Psychologische Grundbedürfnisse (z. B. Autonomie, Bindung). |
|
||||||
| **`goal`** | `sliding_smart_edges` | 0.95 | Strategische Ziele. |
|
| **`motivation`**| 0.95 | `sliding_smart_edges` | Innere Antreiber und Quellen deiner Energie. |
|
||||||
| **`risk`** | `sliding_short` | 0.85 | Risiken (kurz und prägnant). |
|
| **`boundary`** | 0.90 | `sliding_smart_edges` | Deine persönlichen Grenzen und Integritäts-Leitplanken. |
|
||||||
| **`journal`** | `sliding_standard` | 0.80 | Zeitbezogene Logs. |
|
| **`bias`** | 0.80 | `sliding_short` | Bekannte kognitive Verzerrungen und Denkfallen. |
|
||||||
| **`source`** | `sliding_standard` | 0.50 | Externe Quellen (niedrig gewichtet). |
|
|
||||||
|
### 3.1.2 Action Stream (Die Dynamik / Das „Was“)
|
||||||
|
Dieser Stream umfasst alles, was auf Umsetzung, Planung und aktuelle Zustände zielt.
|
||||||
|
|
||||||
|
| Typ | Gewicht | Chunking Profil | Zweck & Inhalt |
|
||||||
|
| :--- | :--- | :--- | :--- |
|
||||||
|
| **`project`** | 0.97 | `sliding_smart_edges` | Aktive Vorhaben mit Mission und Zielsetzung. |
|
||||||
|
| **`goal`** | 0.95 | `sliding_smart_edges` | Strategische Nordsterne und Zielzustände. |
|
||||||
|
| **`decision`** | 1.00 | `structured_strict` | Getroffene Entscheidungen (ADR-Logik). |
|
||||||
|
| **`risk`** | 0.85 | `sliding_short` | Potenzielle Gefahren und Bedrohungsszenarien. |
|
||||||
|
| **`obstacle`** | 1.00 | `structured_strict` | Aktuelle Hürden, Ängste und Blockaden. |
|
||||||
|
| **`task`** | 0.80 | `sliding_short` | Operative Aufgaben und Definition of Done. |
|
||||||
|
| **`skill`** | 0.90 | `sliding_smart_edges` | Fertigkeiten, Lernpfade und Meisterschaft. |
|
||||||
|
| **`habit`** | 0.85 | `sliding_short` | Routinen, Automatismen und Verhaltensmuster. |
|
||||||
|
| **`idea`** | 0.70 | `sliding_short` | Flüchtige Einfälle und Rohmaterial für Projekte. |
|
||||||
|
| **`state`** | 0.60 | `sliding_short` | Momentane Verfassung, Stimmung und Energielevel. |
|
||||||
|
|
||||||
|
### 3.1.3 History & Basis Stream (Die Evidenz / Das „Wann“)
|
||||||
|
Dieser Stream speichert deine Erlebnisse, Fakten und externes Wissen als Belege.
|
||||||
|
|
||||||
|
| Typ | Gewicht | Chunking Profil | Zweck & Inhalt |
|
||||||
|
| :--- | :--- | :--- | :--- |
|
||||||
|
| **`insight`** | 1.20 | `sliding_smart_edges` | Hochrelevante Erkenntnisse und Verhaltensmuster. |
|
||||||
|
| **`experience`**| 1.10 | `sliding_smart_edges` | Biografische Lektionen und prägende Erlebnisse. |
|
||||||
|
| **`event`** | 0.60 | `sliding_standard` | Chronologische Protokolle und Ereignisse. |
|
||||||
|
| **`journal`** | 0.80 | `sliding_standard` | Tägliche Logs und ungefilterte Gedanken. |
|
||||||
|
| **`person`** | 0.50 | `sliding_standard` | Kontaktprofile und soziale Vernetzung. |
|
||||||
|
| **`source`** | 0.50 | `sliding_standard` | Externe Quellen wie Bücher, Videos oder Artikel. |
|
||||||
|
| **`concept`** | 0.60 | `sliding_smart_edges` | Fachbegriffe, Theorien und zeitloses Wissen. |
|
||||||
|
| **`glossary`** | 0.40 | `sliding_short` | Kurze Begriffsdefinitionen. |
|
||||||
|
| **`default`** | 1.00 | `sliding_standard` | Fallback für alle nicht klassifizierten Notizen. |
|
||||||
|
|
||||||
|
### 3.2 Status und Bedeutung
|
||||||
|
|
||||||
|
| Status | Bedeutung | Auswirkung auf die KI |
|
||||||
|
| :--- | :--- | :--- |
|
||||||
|
| **`stable`** | **Geprüftes Wissen.** Die Notiz ist inhaltlich korrekt, finalisiert und verlässlich (Gold-Standard). | **🚀 Bevorzugt (Bonus):** Die KI vertraut diesen Inhalten mehr (+20% Relevanz-Score). Bei widersprüchlichen Infos gewinnt `stable`. |
|
||||||
|
| **`active`** | **Standard.** Aktuelle Arbeitsnotizen, Projekte oder Dokumentationen (Default, wenn leer). | **🔵 Neutral:** Standard-Gewichtung (Faktor 1.0). |
|
||||||
|
| **`draft`** | **Entwurf.** Brainstorming, unstrukturierte Mitschriften oder rohe Ideen. | **🔻 Gedämpft (Malus):** Die KI nutzt diese Infos nur, wenn es keine besseren Treffer gibt (Relevanz auf 50% reduziert). Reduziert "Rauschen" in den Antworten. |
|
||||||
|
| **`system`** | **Intern.** Konfigurationsdateien, technische Logs oder Admin-Skripte. | **❌ Ignoriert (Hard Skip):** Die Datei wird **nicht** in den Suchindex aufgenommen und ist für den Chat unsichtbar. |
|
||||||
|
| **`template`**| **Vorlage.** Leere Gerüste für neue Notizen (z.B. für Obsidian). | **❌ Ignoriert (Hard Skip):** Verhindert, dass leere Vorlagen als Suchergebnisse auftauchen. |
|
||||||
|
|
||||||
|
### Wann nutze ich welchen Status?
|
||||||
|
|
||||||
|
1. **Ideenfindung:** Setzen Sie neue Ideen immer auf **`draft`**. So können Sie frei schreiben, ohne dass die KI sofort "Halbwissen" als Fakten verkauft.
|
||||||
|
2. **Finalisierung:** Sobald eine Entscheidung getroffen oder ein Konzept fertig ist, ändern Sie den Status auf **`stable`**.
|
||||||
|
3. **Konfiguration:** Nutzen Sie **`system`** für Dateien wie die `01_edge_vocabulary.md`, damit die KI nicht die Definition der Kanten zitiert, wenn Sie eigentlich nach Inhalten suchen.
|
||||||
|
|
||||||
|
### 3.3 Aliases (Synonyme & Verlinkung)
|
||||||
|
|
||||||
|
Nutze `aliases: [Synonym]` für:
|
||||||
|
1. **Flüssiges Schreiben:** `[[RAG]]` statt `[[Retrieval Augmented Generation]]`.
|
||||||
|
2. **Semantische Anker:** Der Chat findet die Notiz auch über den Alias-Begriff.
|
||||||
|
|
||||||
|
|
||||||
|
Das optionale Feld `aliases` erlaubt es dir, einer Notiz alternative Titel oder Synonyme zu geben. Dies ist ein mächtiges Werkzeug für die Usability und die Suche.
|
||||||
|
|
||||||
|
```yaml
|
||||||
|
---
|
||||||
|
title: Leitbild – Handlungsprinzipien
|
||||||
|
aliases: [Prinzipien, Handlungsleitlinien, Entscheidungsprinzipien]
|
||||||
|
---
|
||||||
|
|
||||||
|
**Best Practices für Aliases**
|
||||||
|
|
||||||
|
Damit dein System sauber bleibt, beachte diese Regeln:
|
||||||
|
|
||||||
|
* ✅ **Akronyme & Abkürzungen:**
|
||||||
|
Nutze Aliases für technische Kürzel.
|
||||||
|
* *Note:* `Retrieval Augmented Generation`
|
||||||
|
* *Alias:* `[RAG, RAG-Architektur]`
|
||||||
|
* *Vorteil:* Du tippst im Fließtext nur `[[RAG]]` und bist fertig.
|
||||||
|
|
||||||
|
* ✅ **Projekt-Codenamen:**
|
||||||
|
Verbinde den offiziellen Titel mit dem Flur-Namen.
|
||||||
|
* *Note:* `Projekt Phoenix – Cloud Migration`
|
||||||
|
* *Alias:* `[Phoenix, Cloud-Projekt]`
|
||||||
|
|
||||||
|
* ❌ **Vermeide generische Begriffe (Namespace Pollution):**
|
||||||
|
Gib einer spezifischen Notiz niemals einen Alias, der ein allgemeines Wort ist.
|
||||||
|
* *Schlecht:* Alias `[Meeting]` für `2025-10-JourFixe`.
|
||||||
|
* *Folge:* Jedes Mal, wenn du das Wort "Meeting" tippst, schlägt Obsidian dir diesen einen alten Jour Fixe vor. Das zerstört den Schreibfluss.
|
||||||
|
|
||||||
|
* ❌ **Keine Plural-Wahn:**
|
||||||
|
Mindnet und Obsidian finden meist auch den Plural (Fuzzy Search). Du musst nicht `[Prinzip, Prinzipien, Prinzips]` anlegen. Ein Stammbegriff reicht oft.
|
||||||
|
|
||||||
---
|
---
|
||||||
|
|
||||||
@@ -123,33 +215,41 @@ Dies ist die **mächtigste** Methode. Du sagst dem System explizit, **wie** Ding
|
|||||||
* `similar_to`: Ähnelt / Ist vergleichbar mit.
|
* `similar_to`: Ähnelt / Ist vergleichbar mit.
|
||||||
* `solves`: Löst (Problem).
|
* `solves`: Löst (Problem).
|
||||||
* `based_on`: Basiert auf (Fundament).
|
* `based_on`: Basiert auf (Fundament).
|
||||||
|
* **`prev` / `next` [NEU]**: Markiert chronologische oder evolutionäre Abfolgen (z.B. Leitbild-Evolution).
|
||||||
|
|
||||||
### 4.2 Callout-Edges
|
### 4.2 Callout-Edges (empfohlen)
|
||||||
Für Zusammenfassungen am Ende einer Notiz:
|
Für Zusammenfassungen am Ende einer Notiz, oder eines Absatzes:
|
||||||
|
|
||||||
```markdown
|
```markdown
|
||||||
> [!edge] related_to: [[Vector Embeddings]] [[AI Agents]]
|
> [!edge] related_to
|
||||||
|
> [[Vector Embeddings]]
|
||||||
|
> [[AI Agents]]
|
||||||
```
|
```
|
||||||
|
|
||||||
|
### 4.3 Implizite Bidirektionalität (Edger-Logik) [NEU] [PRÜFEN!]
|
||||||
|
In Mindnet musst du Kanten **nicht** manuell in beide Richtungen pflegen. Der **Edger** übernimmt die Paarbildung automatisch im Hintergrund.
|
||||||
|
|
||||||
|
**Deine Aufgabe:** Setze die Kante in der Datei, die du gerade bearbeitest, so wie es der **logische Fluss** vorgibt.
|
||||||
|
|
||||||
|
* **Blick zurück (Rückwärtslink):** Wenn du ein Ergebnis dokumentierst, nutze `derived_from`, `based_on` oder `prev`.
|
||||||
|
* **Blick nach vorn (Vorwärtslink):** Wenn du einen Plan oder ein Protokoll schreibst, nutze `resulted_in`, `supports` oder `next`.
|
||||||
|
|
||||||
|
**System-Logik (Beispiele):**
|
||||||
|
- Schreibst du in Note A: `next: [[B]]`, weiß das System automatisch: `B prev A`.
|
||||||
|
- Schreibst du in Note B: `derived_from: [[A]]`, weiß das System automatisch: `A resulted_in B`.
|
||||||
|
|
||||||
|
**Vorteil:** Keine redundante Datenpflege, kein "Link-Nightmare", volle Konsistenz im Graphen.
|
||||||
|
|
||||||
---
|
---
|
||||||
|
|
||||||
## 5. Schreiben für den KI-Zwilling (Szenarien)
|
## 5. Schreiben für den KI-Zwilling (Szenarien)
|
||||||
|
|
||||||
Damit der **RAG-Chat** dich berät, musst du "Futter" für die Decision Engine liefern.
|
Damit der **RAG-Chat** dich berät, musst du "Futter" für die Decision Engine liefern.
|
||||||
|
|
||||||
### Szenario A: Decision Engine (`DECISION`)
|
### 5.1 Szenario A: Decision Engine (`DECISION`)
|
||||||
* **Ziel:** Das System soll abwägen: "Passt Tool X zu mir?"
|
* **Ziel:** Das System soll abwägen: "Passt Tool X zu mir?"
|
||||||
* **Vorgehen:** Erstelle Notizen mit `type: value` oder `type: goal`.
|
* **Vorgehen:** Erstelle Notizen mit `type: value` oder `type: goal`.
|
||||||
|
|
||||||
**Beispiel Notiz:**
|
|
||||||
```yaml
|
|
||||||
---
|
|
||||||
type: value
|
|
||||||
title: Prinzip: Datensparsamkeit
|
|
||||||
---
|
|
||||||
Wir speichern nur das Minimum an Daten. Cloud-Uploads persönlicher Daten sind verboten, es sei denn, sie sind E2E-verschlüsselt.
|
|
||||||
```
|
|
||||||
|
|
||||||
* **Effekt:** Wenn du fragst "Soll ich Notion nutzen?", lädt die Engine diese Notiz und antwortet: *"Nein, Notion ist SaaS ohne E2E. Das verletzt dein Prinzip der Datensparsamkeit."*
|
* **Effekt:** Wenn du fragst "Soll ich Notion nutzen?", lädt die Engine diese Notiz und antwortet: *"Nein, Notion ist SaaS ohne E2E. Das verletzt dein Prinzip der Datensparsamkeit."*
|
||||||
|
|
||||||
### Szenario B: Empathie (`EMPATHY`)
|
### Szenario B: Empathie (`EMPATHY`)
|
||||||
@@ -168,6 +268,22 @@ Ich habe gelernt: Das ist oft das Zeichen kurz vor dem Durchbruch.
|
|||||||
```
|
```
|
||||||
* **Effekt:** Bei "Alles ist grau" findet das System diese Notiz und spiegelt die Lektion zurück.
|
* **Effekt:** Bei "Alles ist grau" findet das System diese Notiz und spiegelt die Lektion zurück.
|
||||||
|
|
||||||
|
### 5.2 **Szenario C: Forward-Mapping (Lücken-Analyse) [NEU]**
|
||||||
|
* **Ziel:** Strategische Wissenslücken füllen.
|
||||||
|
* **Vorgehen:** Erstelle Hub-Notizen mit Forward-Links auf noch nicht existierende Dateien (z. B. `[[Besten Version meiner Selbst]]`).
|
||||||
|
* **Effekt:** Das System erkennt die semantische Bedeutung des geplanten Wissens und kann proaktiv Fragen stellen, um diese Lücken zu schließen.
|
||||||
|
|
||||||
|
### 5.3 **Szenario D: Narratives Gedächtnis (Intention) [NEU]**
|
||||||
|
* **Ziel:** Das System soll verstehen, *warum* eine Entscheidung getroffen wurde, um in ähnlichen künftigen Situationen konsistent zu beraten.
|
||||||
|
* **Vorgehen:** Nutze in `journal`- oder `experience`-Notizen Abschnitte für "Hintergrund" und "Interpretation".
|
||||||
|
* **Beispiel:** Statt "Wert: Disziplin" schreibe "Ich wähle Disziplin, weil ich in meiner Kindheit erlebt habe, wie Willkür schadet."
|
||||||
|
* **Effekt:** Die KI spiegelt nicht nur die Regel, sondern die Überzeugung dahinter.
|
||||||
|
|
||||||
|
### 5.4 Szenario C: Forward-Mapping (Lücken-Analyse)
|
||||||
|
Setze bewusst Links auf Dateien, die noch nicht existieren (z.B. `[[Die beste Version meiner selbst]]`). Die KI erkennt diese semantischen Lücken und stellt im Chat proaktive Fragen, um diese Felder mit dir zu füllen.
|
||||||
|
|
||||||
|
### 5.5 Szenario D: Narratives Gedächtnis
|
||||||
|
Dokumentiere das "Warum" (Fleisch am Knochen). Wenn du schreibst: *"Ich wähle Disziplin, weil ich Willkür als Kind schmerzhaft erlebt habe"*, versteht die KI die emotionale Kausalität und kann dich in Krisen an diesen Ursprung erinnern.
|
||||||
---
|
---
|
||||||
|
|
||||||
## 6. Best Practices & Beispiele
|
## 6. Best Practices & Beispiele
|
||||||
@@ -204,9 +320,6 @@ title: ADR: Wahl von Qdrant
|
|||||||
type: decision
|
type: decision
|
||||||
status: final
|
status: final
|
||||||
tags: [architektur, db]
|
tags: [architektur, db]
|
||||||
# OVERRIDES: Wir wollen diese Notiz extrem wichtig machen und strikt trennen.
|
|
||||||
# Da "strict" genutzt wird, landet "Alternativen" in einem eigenen Chunk
|
|
||||||
# und vermischt sich nicht mit der Entscheidung selbst.
|
|
||||||
chunking_profile: structured_smart_edges_strict
|
chunking_profile: structured_smart_edges_strict
|
||||||
retriever_weight: 1.5
|
retriever_weight: 1.5
|
||||||
---
|
---
|
||||||
@@ -224,4 +337,4 @@ Wir haben auch [[rel:similar_to Pinecone]] und [[rel:similar_to Weaviate]] betra
|
|||||||
## 7. Virtual Schema Layer
|
## 7. Virtual Schema Layer
|
||||||
|
|
||||||
Grundsätzlich gilt das Prinzip des **Virtual Schema Layers**. Die Logik (wie `chunk_size`) wird zentral in der `types.yaml` verwaltet.
|
Grundsätzlich gilt das Prinzip des **Virtual Schema Layers**. Die Logik (wie `chunk_size`) wird zentral in der `types.yaml` verwaltet.
|
||||||
**Aber:** Als Power-User hast du über die oben genannten Overrides (`chunking_profile`) jederzeit die Möglichkeit, aus diesem Standard auszubrechen, wenn eine spezifische Notiz eine Sonderbehandlung benötigt.
|
**Aber:** Als Power-User hast du über die Overrides jederzeit die Möglichkeit, aus diesem Standard auszubrechen.
|
||||||
@@ -0,0 +1,72 @@
|
|||||||
|
---
|
||||||
|
doc_type: technical_reference
|
||||||
|
audience: developer, power_user
|
||||||
|
scope: obsidian, scripts, workflow
|
||||||
|
status: active
|
||||||
|
version: 1.0.0
|
||||||
|
context: "Setup und Dokumentation der Obsidian-Integration für Mindnet v2.9."
|
||||||
|
---
|
||||||
|
|
||||||
|
# Obsidian Integration Guide
|
||||||
|
|
||||||
|
Dieses Dokument beschreibt die technische Implementierung der Mindnet-Logik innerhalb von Obsidian mittels Templater-Skripten.
|
||||||
|
|
||||||
|
## 1. Voraussetzungen
|
||||||
|
|
||||||
|
Um die volle Funktionalität des Mindnet-Workflows zu nutzen, sind folgende Obsidian-Plugins zwingend erforderlich:
|
||||||
|
* **Templater:** Für die Ausführung der JavaScript-Logik beim Erstellen von Notizen und Kanten.
|
||||||
|
* **Meta Bind (Optional):** Zur intuitiven Steuerung von Frontmatter-Feldern wie `retriever_weight`.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 2. Kern-Komponenten
|
||||||
|
|
||||||
|
### 2.1 Mindnet Universal Creator (`mindnetCreate.js`)
|
||||||
|
Das zentrale Skript zur Erstellung neuer Notizen. Es stellt sicher, dass jede Datei im korrekten Ordner landet und das notwendige Frontmatter für das Mindnet-Backend erhält.
|
||||||
|
|
||||||
|
**Kern-Funktionen:**
|
||||||
|
* Automatische Typ-Auswahl basierend auf den Vorlagen in `_system/templates/creation`.
|
||||||
|
* Validierung und Erzwingung der ID-Syntax (`YYYYMMDDHHmm-slug`).
|
||||||
|
* Pfad-Erzwingung bei Verlinkungen, um die Konsistenz des Graphen zu wahren.
|
||||||
|
|
||||||
|
### 2.2 Edge Callout Selector Skript
|
||||||
|
Dieses Skript ermöglicht das Einfügen von semantischen Kanten (`[!edge]`) durch Auswahl aus dem zentralen Wörterbuch.
|
||||||
|
|
||||||
|
**Features:**
|
||||||
|
* **Kategorisierte Auswahl:** Gruppierung der Kanten nach Themenbereichen (H3-Ebene der Vokabel-Datei).
|
||||||
|
* **Alias-Support:** Ermöglicht die Wahl zwischen technischem System-Namen (Canonical) und benutzerfreundlichen Aliasen.
|
||||||
|
* **Automatisches Callout-Formatting:** Transformiert markierte Wikilinks direkt in einen validen Edge-Block.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 3. Konfiguration & Speicherorte
|
||||||
|
|
||||||
|
Damit die Skripte funktionieren, müssen folgende Pfade im Vault existieren:
|
||||||
|
|
||||||
|
| Pfad | Inhalt / Zweck |
|
||||||
|
| :--- | :--- |
|
||||||
|
| `_system/scripts/` | Speicherort für die `.js` Module (z.B. `mindnetCreate.js`). |
|
||||||
|
| `_system/templates/` | Ablage für die Templater-Trigger-Dateien. |
|
||||||
|
| `_system/templates/creation/` | Enthält die Typ-spezifischen Vorlagen (z.B. `template-insight.md`). |
|
||||||
|
| `_system/dictionary/edge_vocabulary.md` | Single Source of Truth für alle erlaubten Kanten-Typen. |
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 4. Workflow-Integration
|
||||||
|
|
||||||
|
### 4.1 Notiz-Erstellung
|
||||||
|
1. Verwenden des Hotkeys für den `Mindnet Creator`.
|
||||||
|
2. Auswahl des gewünschten Typs (z. B. `EXPERIENCE`).
|
||||||
|
3. Das Skript erstellt die Datei im Zielordner und öffnet sie mit den passenden Leitfragen.
|
||||||
|
|
||||||
|
### 4.2 Kanten-Management
|
||||||
|
1. Markieren eines oder mehrerer Wikilinks im Text.
|
||||||
|
2. Starten des `Insert Edge Callout` Skripts.
|
||||||
|
3. Auswahl des Kanten-Typs (z. B. `caused_by`) und der gewünschten Bezeichnung.
|
||||||
|
4. Das Skript fügt den Block automatisch unter der Markierung ein.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 5. Wartung & Updates
|
||||||
|
|
||||||
|
Bei Änderungen an den Notiz-Typen in der `types.yaml` müssen die entsprechenden Markdown-Vorlagen im Ordner `creation` manuell synchronisiert werden, um die Konsistenz zwischen Obsidian und dem Backend zu wahren.
|
||||||
@@ -47,23 +47,56 @@ Seit Version 2.7.0 gilt für `chunking_profile` und `retriever_weight` folgende
|
|||||||
2. **Type Config:** Der Standardwert für den `type` aus `types.yaml`.
|
2. **Type Config:** Der Standardwert für den `type` aus `types.yaml`.
|
||||||
3. **Global Default:** Fallback aus `defaults` in `types.yaml`.
|
3. **Global Default:** Fallback aus `defaults` in `types.yaml`.
|
||||||
|
|
||||||
### 2.2 Typ-Referenztabelle (Vollständig)
|
|
||||||
|
|
||||||
| Typ (`type`) | Chunk Profile (Standard) | Retriever Weight ($W_{type}$) | Smart Edges? | Beschreibung |
|
## 2.2 Typ-Referenz & Stream-Logik (Vollständige Liste: 28 Typen)
|
||||||
| :--- | :--- | :--- | :--- | :--- |
|
|
||||||
| **decision** | `structured_strict` | 1.00 | Ja | Entscheidungen. Atomar. |
|
Das System euriert Informationen in drei funktionalen Streams. Wähle den Typ danach aus, in welchem Bereich deines „Digitalen Zwillings“ die Information wirken soll.
|
||||||
| **value** | `structured_strict` | 1.00 | Ja | Werte/Prinzipien. Atomar. |
|
|
||||||
| **project** | `sliding_smart` | 0.97 | Ja | Aktive Vorhaben. |
|
### 2.2.1 Identity Stream (Der Kern / Das „Warum“)
|
||||||
| **experience** | `sliding_smart` | 0.90 | Ja | Persönliche Learnings. |
|
Dieser Stream definiert deine stabilen Merkmale und inneren Kompasse.
|
||||||
| **concept** | `sliding_smart` | 0.60 | Ja | Abstrakte Begriffe. |
|
|
||||||
| **principle** | `structured_L3` | 0.95 | Nein | Prinzipien (Tiefer Split). |
|
| Typ | Gewicht | Chunking Profil | Zweck & Inhalt |
|
||||||
| **belief** | `sliding_short` | 0.90 | Nein | Glaubenssätze. |
|
| :--- | :--- | :--- | :--- |
|
||||||
| **risk** | `sliding_short` | 0.90 | Nein | Risiken. |
|
| **`value`** | 1.00 | `structured_strict` | Fundamentale Werte und moralische Maßstäbe. |
|
||||||
| **journal** | `sliding_standard` | 0.80 | Nein | Logs / Dailies. |
|
| **`principle`** | 0.95 | `structured_strict_L3` | Handlungsleitlinien mit tiefer Hierarchie (H3-Split). |
|
||||||
| **person** | `sliding_standard` | 0.50 | Nein | Profile. |
|
| **`trait`** | 1.10 | `structured_strict` | Charakterliche Stärken und Talente. |
|
||||||
| **source** | `sliding_standard` | 0.50 | Nein | Externe Quellen. |
|
| **`belief`** | 0.90 | `sliding_short` | Tiefe Überzeugungen über dich und die Gesellschaft. |
|
||||||
| **glossary** | `sliding_short` | 0.40 | Nein | Begriffsdefinitionen. |
|
| **`profile`** | 0.70 | `structured_strict` | Rollenidentitäten (z. B. Vater, Mentor, Unternehmer). |
|
||||||
| **default** | `sliding_standard` | 1.00 | Nein | Fallback für alle anderen. |
|
| **`need`** | 1.05 | `sliding_smart_edges` | Psychologische Grundbedürfnisse (z. B. Autonomie, Bindung). |
|
||||||
|
| **`motivation`**| 0.95 | `sliding_smart_edges` | Innere Antreiber und Quellen deiner Energie. |
|
||||||
|
| **`boundary`** | 0.90 | `sliding_smart_edges` | Deine persönlichen Grenzen und Integritäts-Leitplanken. |
|
||||||
|
| **`bias`** | 0.80 | `sliding_short` | Bekannte kognitive Verzerrungen und Denkfallen. |
|
||||||
|
|
||||||
|
### 2.2.2 Action Stream (Die Dynamik / Das „Was“)
|
||||||
|
Dieser Stream umfasst alles, was auf Umsetzung, Planung und aktuelle Zustände zielt.
|
||||||
|
|
||||||
|
| Typ | Gewicht | Chunking Profil | Zweck & Inhalt |
|
||||||
|
| :--- | :--- | :--- | :--- |
|
||||||
|
| **`project`** | 0.97 | `sliding_smart_edges` | Aktive Vorhaben mit Mission und Zielsetzung. |
|
||||||
|
| **`goal`** | 0.95 | `sliding_smart_edges` | Strategische Nordsterne und Zielzustände. |
|
||||||
|
| **`decision`** | 1.00 | `structured_strict` | Getroffene Entscheidungen (ADR-Logik). |
|
||||||
|
| **`risk`** | 0.85 | `sliding_short` | Potenzielle Gefahren und Bedrohungsszenarien. |
|
||||||
|
| **`obstacle`** | 1.00 | `structured_strict` | Aktuelle Hürden, Ängste und Blockaden. |
|
||||||
|
| **`task`** | 0.80 | `sliding_short` | Operative Aufgaben und Definition of Done. |
|
||||||
|
| **`skill`** | 0.90 | `sliding_smart_edges` | Fertigkeiten, Lernpfade und Meisterschaft. |
|
||||||
|
| **`habit`** | 0.85 | `sliding_short` | Routinen, Automatismen und Verhaltensmuster. |
|
||||||
|
| **`idea`** | 0.70 | `sliding_short` | Flüchtige Einfälle und Rohmaterial für Projekte. |
|
||||||
|
| **`state`** | 0.60 | `sliding_short` | Momentane Verfassung, Stimmung und Energielevel. |
|
||||||
|
|
||||||
|
### 2.2.3 History & Basis Stream (Die Evidenz / Das „Wann“)
|
||||||
|
Dieser Stream speichert deine Erlebnisse, Fakten und externes Wissen als Belege.
|
||||||
|
|
||||||
|
| Typ | Gewicht | Chunking Profil | Zweck & Inhalt |
|
||||||
|
| :--- | :--- | :--- | :--- |
|
||||||
|
| **`insight`** | 1.20 | `sliding_smart_edges` | Hochrelevante Erkenntnisse und Verhaltensmuster. |
|
||||||
|
| **`experience`**| 1.10 | `sliding_smart_edges` | Biografische Lektionen und prägende Erlebnisse. |
|
||||||
|
| **`event`** | 0.60 | `sliding_standard` | Chronologische Protokolle und Ereignisse. |
|
||||||
|
| **`journal`** | 0.80 | `sliding_standard` | Tägliche Logs und ungefilterte Gedanken. |
|
||||||
|
| **`person`** | 0.50 | `sliding_standard` | Kontaktprofile und soziale Vernetzung. |
|
||||||
|
| **`source`** | 0.50 | `sliding_standard` | Externe Quellen wie Bücher, Videos oder Artikel. |
|
||||||
|
| **`concept`** | 0.60 | `sliding_smart_edges` | Fachbegriffe, Theorien und zeitloses Wissen. |
|
||||||
|
| **`glossary`** | 0.40 | `sliding_short` | Kurze Begriffsdefinitionen. |
|
||||||
|
| **`default`** | 1.00 | `sliding_standard` | Fallback für alle nicht klassifizierten Notizen. |
|
||||||
|
|
||||||
*Richtwert für $W_{type}$: 0.1 (minimale Relevanz/Filter) bis 1.0 (maximale Relevanz).*
|
*Richtwert für $W_{type}$: 0.1 (minimale Relevanz/Filter) bis 1.0 (maximale Relevanz).*
|
||||||
|
|
||||||
@@ -74,27 +107,67 @@ Seit Version 2.7.0 gilt für `chunking_profile` und `retriever_weight` folgende
|
|||||||
Steuert die Gewichtung der Scoring-Formel und die neuen Lifecycle-Modifier.
|
Steuert die Gewichtung der Scoring-Formel und die neuen Lifecycle-Modifier.
|
||||||
|
|
||||||
```yaml
|
```yaml
|
||||||
|
version: 1.2
|
||||||
|
|
||||||
scoring:
|
scoring:
|
||||||
semantic_weight: 1.0 # Basis-Relevanz (Cosine Similarity)
|
# W_sem: skaliert den Term (semantic_score * retriever_weight)
|
||||||
edge_weight: 0.7 # Einfluss des Graphen (Bonus)
|
# Empfehlung Startwert: 1.0 → Semantik bleibt Hauptsignal
|
||||||
centrality_weight: 0.5 # Einfluss von Hubs (Zentralität)
|
semantic_weight: 1.0
|
||||||
|
|
||||||
# WP-22 Lifecycle Modifier (Multiplikativ auf Semantik)
|
# W_edge: skaliert edge_bonus aus dem Subgraph
|
||||||
|
# Empfehlung: 0.8 → Graph ist deutlich spürbar, aber überstimmt Semantik nicht komplett
|
||||||
|
edge_weight: 0.8
|
||||||
|
|
||||||
|
# W_cent: skaliert centrality_bonus (Knoten-Zentralität im Subgraph)
|
||||||
|
# Empfehlung: 0.5 → zentrale Knoten werden bevorzugt, aber moderat
|
||||||
|
centrality_weight: 0.5
|
||||||
|
|
||||||
|
# WP-22 Stellschraube: Lifecycle (Status-basiertes Scoring)
|
||||||
|
# Bonus für verifiziertes Wissen, Malus für Entwürfe
|
||||||
lifecycle_weights:
|
lifecycle_weights:
|
||||||
stable: 1.2 # Bonus: Geprüftes Wissen wird 20% höher gewichtet
|
stable: 1.2 # +20% Bonus
|
||||||
draft: 0.5 # Malus: Entwürfe werden auf 50% gedämpft
|
active: 1.0 # Standardwert
|
||||||
system: 0.0 # Ausschluss aus dem Index
|
draft: 0.5 # -50% Malus
|
||||||
|
system: 0.0 # Hard Skip via Ingestion
|
||||||
|
|
||||||
# Kanten-spezifische Basis-Gewichtung (Ohne Intent-Boost)
|
# Die nachfolgenden Werte überschreiben die Defaults aus app/core/retriever_config.
|
||||||
edge_weights:
|
# Wenn neue Kantentypen, z.B. durch Referenzierung innerhalb einer md-Datei im vault anders gewichtet werden sollen, dann muss hier die Konfiguration erfolgen
|
||||||
depends_on: 1.5 # Harte Abhängigkeiten stark gewichten
|
edge_types:
|
||||||
blocks: 1.5 # Blocker/Risiken stark gewichten
|
# --- KATEGORIE 1: LOGIK-BOOSTS (Relevanz-Treiber) ---
|
||||||
caused_by: 1.2 # Kausalitäten moderat stärken
|
# Diese Kanten haben die Kraft, das semantische Ranking aktiv umzugestalten.
|
||||||
based_on: 1.3 # Werte-Bezug stärken
|
blocks: 1.6 # Kritisch: Risiken/Blocker müssen sofort sichtbar sein.
|
||||||
related_to: 0.5 # Weiche Assoziation schwächen
|
solves: 1.5 # Zielführend: Lösungen sind primäre Suchziele.
|
||||||
references: 0.8 # Standard-Referenzen
|
depends_on: 1.4 # Logisch: Harte fachliche Abhängigkeit.
|
||||||
|
resulted_in: 1.4 # Kausal: Ergebnisse und unmittelbare Konsequenzen.
|
||||||
|
followed_by: 1.3 # Sequenziell (User): Bewusst gesteuerte Wissenspfade.
|
||||||
|
caused_by: 1.2 # Kausal: Ursachen-Bezug (Basis für Intent-Boost).
|
||||||
|
preceded_by: 1.1 # Sequenziell (User): Rückwärts-Bezug in Logik-Ketten.
|
||||||
|
|
||||||
|
# --- KATEGORIE 2: QUALITATIVER KONTEXT (Stabilitäts-Stützen) ---
|
||||||
|
# Diese Kanten liefern wichtigen Kontext, ohne das Ergebnis zu verfälschen.
|
||||||
|
guides: 1.1 # Qualitativ: Prinzipien oder Werte leiten das Thema.
|
||||||
|
part_of: 1.1 # Strukturell: Zieht übergeordnete Kontexte (Parents) mit hoch.
|
||||||
|
based_on: 0.8 # Fundament: Bezug auf Basis-Werte (kalibriert auf Safe-Retrieval).
|
||||||
|
derived_from: 0.6 # Historisch: Dokumentiert die Herkunft von Wissen.
|
||||||
|
uses: 0.6 # Instrumentell: Genutzte Werkzeuge, Methoden oder Ressourcen.
|
||||||
|
|
||||||
|
# --- KATEGORIE 3: THEMATISCHE NÄHE (Ähnlichkeits-Signal) ---
|
||||||
|
# Diese Werte verhindern den "Drift" in fachfremde Bereiche.
|
||||||
|
similar_to: 0.4 # Analytisch: Thematische Nähe (oft KI-generiert).
|
||||||
|
|
||||||
|
# --- KATEGORIE 4: SYSTEM-NUDGES (Technische Struktur) ---
|
||||||
|
# Reine Orientierungshilfen für das System; fast kein Einfluss auf das Ranking.
|
||||||
|
belongs_to: 0.2 # System: Verknüpft Chunks mit der Note (Metadaten-Träger).
|
||||||
|
next: 0.1 # System: Technische Lesereihenfolge der Absätze.
|
||||||
|
prev: 0.1 # System: Technische Lesereihenfolge der Absätze.
|
||||||
|
|
||||||
|
# --- KATEGORIE 5: WEICHE ASSOZIATIONEN (Rausch-Unterdrückung) ---
|
||||||
|
# Verhindert, dass lose Verknüpfungen das Ergebnis "verwässern".
|
||||||
|
references: 0.1 # Assoziativ: Einfacher Querverweis oder Erwähnung.
|
||||||
|
related_to: 0.05 # Minimal: Schwächste thematische Verbindung.
|
||||||
```
|
```
|
||||||
|
|
||||||
|
|
||||||
---
|
---
|
||||||
|
|
||||||
## 4. Edge Typen & Registry Referenz
|
## 4. Edge Typen & Registry Referenz
|
||||||
@@ -124,38 +197,124 @@ Die Datei muss eine Markdown-Tabelle enthalten, die vom Regex-Parser gelesen wir
|
|||||||
|
|
||||||
### 4.3 Verfügbare Kanten-Typen (System-Standard)
|
### 4.3 Verfügbare Kanten-Typen (System-Standard)
|
||||||
|
|
||||||
| Kind (Canonical) | Symmetrisch? | Herkunft | Bedeutung |
|
| System-Typ (Canonical) | Erlaubte Aliasse (User) | Beschreibung |
|
||||||
| :--- | :--- | :--- | :--- |
|
| :--------------------- | :--------------------------------------------------- | :-------------------------------------- |
|
||||||
| `references` | Nein | Wikilink | Standard-Verweis ("Erwähnt X"). |
|
| **`caused_by`** | `ausgelöst_durch`, `wegen`, `ursache_ist` | Kausalität: A löst B aus. |
|
||||||
| `belongs_to` | Nein | Struktur | Chunk gehört zu Note. |
|
| **`derived_from`** | `abgeleitet_von`, `quelle`, `inspiriert_durch` | Herkunft: A stammt von B. |
|
||||||
| `caused_by` | Nein | Inline | Kausalität: A löst B aus. |
|
| **`based_on`** | `basiert_auf`, `fundament`, `grundlage` | Fundament: B baut auf A auf. |
|
||||||
| `based_on` | Nein | Matrix | Fundament: A fußt auf B. |
|
| **`solves`** | `löst`, `beantwortet`, `fix_für` | Lösung: A ist Lösung für Problem B. |
|
||||||
| `blocks` | Nein | Inline | Blocker: A verhindert B. |
|
| **`part_of`** | `teil_von`, `gehört_zu`, `cluster` | Hierarchie: Kind -> Eltern. |
|
||||||
| `solves` | Nein | Inline | Lösung: A ist Lösung für Problem B. |
|
| **`depends_on`** | `hängt_ab_von`, `braucht`, `requires`, `enforced_by` | Abhängigkeit: A braucht B. |
|
||||||
| `next` / `prev` | Ja | Struktur | Sequenzielle Lesereihenfolge. |
|
| **`blocks`** | `blockiert`, `verhindert`, `risiko_für` | Blocker: A verhindert B. |
|
||||||
|
| **`uses`** | `nutzt`, `verwendet`, `tool` | Werkzeug: A nutzt B. |
|
||||||
|
| **`guides`** | `steuert`, `leitet`, `orientierung` | Soft-Dependency: A gibt Richtung für B. |
|
||||||
|
| **`followed_by`** | `danach`, `folgt`, `nachfolger`, `followed_by` | Prozess: A -> B. |
|
||||||
|
| **`preceeded_by`** | `davor`, `vorgänger`, `preceded_by` | Prozess: B <- A. |
|
||||||
|
| **`related_to`** | `siehe_auch`, `kontext`, `thematisch` | Lose Assoziation. |
|
||||||
|
| **`similar_to`** | `ähnlich_wie`, `vergleichbar` | Synonym / Ähnlichkeit. |
|
||||||
|
| **`references`** | *(Kein Alias)* | Standard-Verweis (Fallback). |
|
||||||
|
| **`resulted_in`** | `ergebnis`, `resultat`, `erzeugt` | Herkunft: A erzeugt Ergebnis B |
|
||||||
|
|
||||||
|
**ACHTUNG!** Die Kantentypen
|
||||||
|
**belongs_to**, **next** und **prev** dürfen nicht vom Nutzer gesetzt werden
|
||||||
|
|
||||||
---
|
---
|
||||||
|
|
||||||
|
|
||||||
## 5. Decision Engine (`decision_engine.yaml`)
|
## 5. Decision Engine (`decision_engine.yaml`)
|
||||||
|
|
||||||
Steuert den Hybrid Router und das dynamische Intent-Boosting (WP-22).
|
Die Decision Engine fungiert als zentraler Orchestrator für die Intent-Erkennung und das dynamische Retrieval-Routing. Sie bestimmt, wie das System auf eine Nutzeranfrage reagiert, welche Informationstypen bevorzugt werden und wie der Wissensgraph für die spezifische Situation verformt wird.
|
||||||
|
|
||||||
**Beispielauszug für Intent-Boosting:**
|
### 5.1 Intent Recognition: Dual-Path Routing
|
||||||
|
Das System nutzt ein zweistufiges Verfahren, um die Absicht des Nutzers zu identifizieren:
|
||||||
|
|
||||||
|
1. **Fast Path (Keyword Trigger):** Das System scannt die Anfrage nach definierten `trigger_keywords`. Wird ein Treffer gefunden, wird die entsprechende Strategie sofort ohne LLM-Einsatz gewählt.
|
||||||
|
2. **Slow Path (LLM Router):** Wenn kein Keyword matcht und `llm_fallback_enabled: true` gesetzt ist, analysiert ein LLM die Nachricht mittels Few-Shot Prompting.
|
||||||
|
|
||||||
|
#### LLM Router Konfiguration
|
||||||
|
Der Router nutzt den `llm_router_prompt`, um Anfragen in eine der fünf Kern-Strategien (`FACT`, `DECISION`, `EMPATHY`, `CODING`, `INTERVIEW`) zu klassifizieren.
|
||||||
|
|
||||||
|
| Einstellung | Wert | Beschreibung |
|
||||||
|
| :--- | :--- | :--- |
|
||||||
|
| `llm_fallback_enabled` | `true` | Aktiviert die KI-basierte Klassifizierung, falls Keywords fehlen. |
|
||||||
|
| `llm_router_prompt` | *(Template)* | Enthält die Strategie-Definitionen und Few-Shot Beispiele für den LLM-Entscheidungsweg. |
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
### 5.2 Strategie-Mechaniken (Graph Shaping)
|
||||||
|
Jede Strategie definiert drei Hebel, um das Ergebnis des Retrievers zu beeinflussen:
|
||||||
|
|
||||||
|
* **`inject_types`:** Erzwingt die Einbindung bestimmter Notiz-Typen (z. B. `value` bei Entscheidungen), auch wenn diese semantisch eine geringere Ähnlichkeit aufweisen.
|
||||||
|
* **`edge_boosts`:** Erhöht die Gewichtung spezifischer Kanten-Typen in der Scoring-Formel. Dies ermöglicht es dem Graphen, die Textsuche situativ zu "überstimmen".
|
||||||
|
* **`prepend_instruction`:** Injiziert eine spezifische Systemanweisung in das LLM-Prompt, um den Antwortstil anzupassen (z. B. "Wäge Fakten gegen Werte ab").
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
### 5.3 Übersicht der Strategien
|
||||||
|
|
||||||
|
| Strategie | Fokus | Bevorzugte Kanten (`edge_boosts`) | Injektionstypen |
|
||||||
|
| :--- | :--- | :--- | :--- |
|
||||||
|
| **FACT** | Wissensabfrage & Definitionen | `part_of` (2.0), `composed_of` (2.0), `similar_to` (1.5) | *(Keine)* |
|
||||||
|
| **DECISION** | Rat, Strategie & Abwägung | `blocks` (2.5), `solves` (2.0), `risk_of` (2.5) | `value`, `principle`, `goal`, `risk` |
|
||||||
|
| **EMPATHY** | Emotionale Resonanz | `based_on` (2.0), `experienced_in` (2.5), `related_to` (2.0) | `experience`, `belief`, `profile` |
|
||||||
|
| **CODING** | Programmierung & Syntax | `implemented_in` (3.0), `uses` (2.5), `depends_on` (2.0) | `snippet`, `reference`, `source` |
|
||||||
|
| **INTERVIEW** | Erfassung neuer Daten | *(Keine)* | *(Keine)* |
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
### 5.4 Der Interview-Modus & Schemas
|
||||||
|
Die Strategie `INTERVIEW` dient der strukturierten Datenerfassung.
|
||||||
|
|
||||||
|
* **Trigger:** Aktiviert durch Phrasen wie "neue notiz", "festhalten" oder "dokumentieren".
|
||||||
|
* **Schema-Logik:** Nutzt das `default`-Schema mit den Feldern `Titel`, `Thema/Inhalt` und `Tags`, sofern kein spezifisches Typ-Schema aus der `types.yaml` greift.
|
||||||
|
* **Dynamik:** In diesem Modus wird der Fokus vom Retrieval (Wissen finden) auf die Extraktion (Wissen speichern) verschoben.
|
||||||
|
|
||||||
|
> **Hinweis:** Da spezifische Schemas für Projekte oder Erfahrungen direkt in der `types.yaml` definiert werden, dient die `decision_engine.yaml` hier primär als Fallback für generische Datenaufnahmen.
|
||||||
|
|
||||||
|
|
||||||
|
Auszug aus der decision_engine.yaml
|
||||||
```yaml
|
```yaml
|
||||||
intents:
|
strategies:
|
||||||
EMPATHY:
|
# 1. Fakten-Abfrage (Fallback & Default)
|
||||||
description: "Emotionaler Support / Werte-Fokus"
|
FACT:
|
||||||
boost_edges:
|
description: "Reine Wissensabfrage."
|
||||||
based_on: 2.0 # Verdoppelt den Einfluss von Werte-Kanten
|
trigger_keywords: []
|
||||||
related_to: 1.5 # Stärkt assoziative Bezüge
|
inject_types: []
|
||||||
inject_types: ["experience", "belief"]
|
# WP-22: Definitionen & Hierarchien bevorzugen
|
||||||
|
edge_boosts:
|
||||||
|
part_of: 2.0
|
||||||
|
composed_of: 2.0
|
||||||
|
similar_to: 1.5
|
||||||
|
caused_by: 0.5
|
||||||
|
prompt_template: "rag_template"
|
||||||
|
prepend_instruction: null
|
||||||
|
|
||||||
|
# 2. Entscheidungs-Frage
|
||||||
|
DECISION:
|
||||||
|
description: "Der User sucht Rat, Strategie oder Abwägung."
|
||||||
|
trigger_keywords:
|
||||||
|
- "soll ich"
|
||||||
|
- "meinung"
|
||||||
|
- "besser"
|
||||||
|
- "empfehlung"
|
||||||
|
- "strategie"
|
||||||
|
- "entscheidung"
|
||||||
|
- "abwägung"
|
||||||
|
- "vergleich"
|
||||||
|
inject_types: ["value", "principle", "goal", "risk"]
|
||||||
|
# WP-22: Risiken und Konsequenzen hervorheben
|
||||||
|
edge_boosts:
|
||||||
|
blocks: 2.5
|
||||||
|
solves: 2.0
|
||||||
|
depends_on: 1.5
|
||||||
|
risk_of: 2.5
|
||||||
|
prompt_template: "decision_template"
|
||||||
|
prepend_instruction: |
|
||||||
|
!!! ENTSCHEIDUNGS-MODUS !!!
|
||||||
|
BITTE WÄGE FAKTEN GEGEN FOLGENDE WERTE, PRINZIPIEN UND ZIELE AB:
|
||||||
|
|
||||||
|
# 3. Empathie / "Ich"-Modus
|
||||||
|
|
||||||
WHY:
|
|
||||||
description: "Ursachenanalyse (Kausalität)"
|
|
||||||
boost_edges:
|
|
||||||
caused_by: 2.5 # Massiver Boost für Kausalitätsketten
|
|
||||||
derived_from: 1.8 # Fokus auf die Herkunft
|
|
||||||
```
|
```
|
||||||
|
|
||||||
*Richtwert für Kanten-Boosts: 0.1 (Abwertung) bis 3.0+ (Dominanz gegenüber Text-Match).*
|
*Richtwert für Kanten-Boosts: 0.1 (Abwertung) bis 3.0+ (Dominanz gegenüber Text-Match).*
|
||||||
@@ -167,7 +167,55 @@ Diese Features stehen als nächstes an oder befinden sich in der Umsetzung.
|
|||||||
2. **Single Source of Truth (SSOT):** Die Registry nutzt `01_edge_vocabulary.md` als führende Konfiguration.
|
2. **Single Source of Truth (SSOT):** Die Registry nutzt `01_edge_vocabulary.md` als führende Konfiguration.
|
||||||
3. **Self-Learning Loop:** Protokollierung unbekannter Kanten in `unknown_edges.jsonl`.
|
3. **Self-Learning Loop:** Protokollierung unbekannter Kanten in `unknown_edges.jsonl`.
|
||||||
|
|
||||||
|
## 23: Agentic Multi-Stream Reasoning (Mindnet 2025)
|
||||||
|
|
||||||
|
### 1. Zielsetzung & Problemstellung
|
||||||
|
Das bisherige System basiert auf einem globalen Scoring-Modell, bei dem Notizen unterschiedlicher Typen (z. B. `insight` vs. `belief`) in einem einzigen Retrieval-Topf konkurrieren. Dies führt dazu, dass leiser gewichtete, aber fundamentale Identitätsmerkmale oft durch hochgewichtete aktuelle Erkenntnisse verdrängt werden. Ziel dieses Pakets ist die Einführung einer parallelen **Stream-Architektur**, um die Vielschichtigkeit menschlicher Entscheidungsprozesse (Werte + Erfahrung + Absicht) im LLM-Kontext zu garantieren.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
### 2. Funktionsbeschreibung: Die Streams
|
||||||
|
Die Daten aus der `types.yaml` werden in drei logische Verarbeitungseinheiten unterteilt:
|
||||||
|
|
||||||
|
#### A. Identity Stream (Die Wahrheitsebene)
|
||||||
|
* **Inhalt:** `value`, `belief`, `trait`, `principle`, `need`, `boundary`, `bias`.
|
||||||
|
* **Zweck:** Definition des moralischen Kompasses, der psychologischen Grundbedürfnisse und kognitiven Muster.
|
||||||
|
* **Wirkung:** Liefert das "Warum" hinter jeder Handlung.
|
||||||
|
|
||||||
|
#### B. History Stream (Die Evidenzebene)
|
||||||
|
* **Inhalt:** `experience`, `event`, `source`, `journal`, `person`.
|
||||||
|
* **Zweck:** Bereitstellung empirischer Belege aus der Vergangenheit und sozialer Kontexte.
|
||||||
|
* **Wirkung:** Verankert die Antwort in real erlebten Mustern und Fakten.
|
||||||
|
|
||||||
|
#### C. Action Stream (Die Dynamikebene)
|
||||||
|
* **Inhalt:** `project`, `decision`, `goal`, `task`, `risk`, `motivation`, `habit`, `state`.
|
||||||
|
* **Zweck:** Analyse der aktuellen Richtung, geplanter Vorhaben und des gegenwärtigen Zustands.
|
||||||
|
* **Wirkung:** Liefert den Kontext für die Umsetzung und zukünftige Ziele.
|
||||||
|
|
||||||
|
|
||||||
|
### 3. Technische Wirkungsweise (Solution Sketch)
|
||||||
|
|
||||||
|
#### Schritt 1: Query-Decomposition
|
||||||
|
Ein initialer Klassifizierungs-Agent analysiert die Nutzeranfrage und bestimmt, welcher Stream primär angesprochen werden muss (z. B. "Wie soll ich mich entscheiden?" boostet den Identity Stream).
|
||||||
|
|
||||||
|
#### Schritt 2: Parallel Stream Retrieval
|
||||||
|
Anstelle einer Suche werden drei unabhängige Vektor-Suchen mit Typ-Filtern durchgeführt:
|
||||||
|
* **Search_A (Identity):** Top-5 Ergebnisse aus Identitäts-Notizen.
|
||||||
|
* **Search_B (History):** Top-5 Ergebnisse aus biografischen/externen Notizen.
|
||||||
|
* **Search_C (Action):** Top-5 Ergebnisse aus operativen/strategischen Notizen.
|
||||||
|
|
||||||
|
#### Schritt 3: Agentic Synthesis (The Reasoning)
|
||||||
|
Ein Synthese-Agent (LLM) erhält die aggregierten Ergebnisse in getrennten Sektionen. Die Anweisung lautet:
|
||||||
|
1. **Prüfung:** Steht das aktuelle Vorhaben (Action) im Einklang mit den Werten (Identity)?
|
||||||
|
2. **Abgleich:** Welche vergangenen Erfahrungen (History) stützen oder widersprechen diesem Weg?
|
||||||
|
3. **Korrektur:** Identifiziere mögliche Biases oder Grenzüberschreitungen (Boundary).
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
### 4. Erwartete Ergebnisse
|
||||||
|
* **Höhere Resonanz:** Antworten wirken authentischer, da sie explizit auf das Wertesystem des Nutzers Bezug nehmen.
|
||||||
|
* **Widerspruchs-Erkennung:** Das System kann den Nutzer aktiv warnen, wenn ein Projekt gegen seine `principles` oder `needs` verstößt.
|
||||||
|
* **Robustes Retrieval:** Wichtige Identitäts-Informationen gehen nicht mehr im "Rauschen" von hunderten Journal-Einträgen verloren.
|
||||||
---
|
---
|
||||||
|
|
||||||
## 4. Abhängigkeiten & Release-Plan
|
## 4. Abhängigkeiten & Release-Plan
|
||||||
|
|||||||
@@ -0,0 +1,69 @@
|
|||||||
|
import asyncio
|
||||||
|
import os
|
||||||
|
import sys
|
||||||
|
from pathlib import Path
|
||||||
|
|
||||||
|
# Pfad-Setup
|
||||||
|
sys.path.insert(0, os.path.abspath("."))
|
||||||
|
|
||||||
|
from app.core.chunker import assemble_chunks, _extract_all_edges_from_md
|
||||||
|
from app.core.derive_edges import build_edges_for_note
|
||||||
|
|
||||||
|
# Mock für Settings, falls nötig
|
||||||
|
os.environ["MINDNET_LLM_MODEL"] = "phi3:mini"
|
||||||
|
|
||||||
|
async def analyze_file(file_path: str):
|
||||||
|
print(f"\n=== ANALYSE: {file_path} ===")
|
||||||
|
|
||||||
|
with open(file_path, "r", encoding="utf-8") as f:
|
||||||
|
text = f.read()
|
||||||
|
|
||||||
|
# 1. Globale Kandidaten (Was sieht der Pre-Scan?)
|
||||||
|
# Wir simulieren den Aufruf, den der Chunker macht
|
||||||
|
note_id = Path(file_path).stem
|
||||||
|
candidates = _extract_all_edges_from_md(text, note_id, "concept")
|
||||||
|
print(f"\n[1] Globale Kandidaten (Pre-Scan):")
|
||||||
|
for c in candidates:
|
||||||
|
print(f" - {c}")
|
||||||
|
|
||||||
|
# 2. Chunking (Ohne Smart Edges erstmal, um die physische Integrität zu prüfen)
|
||||||
|
# Wir nutzen ein Profil, das dem User-Setup entspricht
|
||||||
|
config = {
|
||||||
|
"strategy": "sliding_window",
|
||||||
|
"target": 400,
|
||||||
|
"max": 600,
|
||||||
|
"overlap": 50,
|
||||||
|
"enable_smart_edge_allocation": False # Erstmal aus
|
||||||
|
}
|
||||||
|
|
||||||
|
chunks = await assemble_chunks(note_id, text, "concept", config=config)
|
||||||
|
|
||||||
|
print(f"\n[2] Chunk-Struktur & Physische Kanten:")
|
||||||
|
for i, chunk in enumerate(chunks):
|
||||||
|
print(f"\n--- Chunk {i} (Section: {chunk.section_path}) ---")
|
||||||
|
print(f"Snippet: {chunk.text[:50]}...")
|
||||||
|
|
||||||
|
# Was findet derive_edges in diesem rohen Chunk?
|
||||||
|
# Wir simulieren das Payload-Dict, das derive_edges erwartet
|
||||||
|
chunk_pl = {"text": chunk.text, "window": chunk.window, "chunk_id": chunk.id}
|
||||||
|
edges = build_edges_for_note(note_id, [chunk_pl])
|
||||||
|
|
||||||
|
found_explicitly = [f"{e['kind']}:{e.get('target_id')}" for e in edges if e['rule_id'] in ['callout:edge', 'inline:rel']]
|
||||||
|
|
||||||
|
if found_explicitly:
|
||||||
|
print(f" ✅ Gefundene Explizite Kanten: {found_explicitly}")
|
||||||
|
else:
|
||||||
|
print(f" ❌ Keine expliziten Kanten gefunden (trotz Callout im Text?)")
|
||||||
|
|
||||||
|
# Check auf Callout im Text
|
||||||
|
if "> [!edge]" in chunk.text:
|
||||||
|
print(" ℹ️ HINWEIS: '> [!edge]' String ist im Text vorhanden!")
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
# Pfad zu deiner problematischen Datei hier anpassen!
|
||||||
|
target_file = "./vault_master/Dein_Problematisches_File.md"
|
||||||
|
|
||||||
|
if len(sys.argv) > 1:
|
||||||
|
target_file = sys.argv[1]
|
||||||
|
|
||||||
|
asyncio.run(analyze_file(target_file))
|
||||||
Reference in new issue
Block a user