Compare commits

...
Author SHA1 Message Date
Lars c68c7404cf Merge pull request 'WP22_Korrektur' (#13) from WP22_Korrektur into main
Deploy mindnet to llm-node / deploy (push) Successful in 4s
Reviewed-on: #13
2025-12-23 12:26:43 +01:00
Lars f8ed7bb62e debug mit print 2025-12-23 11:40:48 +01:00
Lars 81d005d969 pfad Auflösung 2025-12-23 11:34:55 +01:00
Lars 99482ad65a neue parser logik 2025-12-23 07:31:33 +01:00
Lars 2d43e0596c Test der neuen mehrzeiligen Edge-Parser
Deploy mindnet to llm-node / deploy (push) Successful in 4s
2025-12-22 06:08:48 +01:00
Lars 74cac7e16c debug
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-12-22 05:56:36 +01:00
Lars 0c2dc61cb5 types and edge types
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-12-21 17:20:33 +01:00
Lars 97c3461685 doku
Deploy mindnet to llm-node / deploy (push) Successful in 4s
2025-12-20 19:08:17 +01:00
Lars 41e7a49d52 01_authoring_guidelines
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-12-20 16:47:43 +01:00
Lars 725dc6bda4 notiz typen und doku
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-12-20 16:45:25 +01:00
Lars 5da8eb6543 aliasses ergänzung
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-12-19 20:16:55 +01:00
Lars 4f2296b9b0 update um status
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-12-19 20:09:59 +01:00
Lars cb9addb1b6 update implizite bidirektionale Kanten
Deploy mindnet to llm-node / deploy (push) Successful in 4s
2025-12-19 18:50:08 +01:00
Lars c5198a80d8 update 01_knowledge_design zu biddirektionale Kanten
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-12-19 18:42:27 +01:00
Lars 0df266b2e9 ergänzungen aufgrund refacturing vault
Deploy mindnet to llm-node / deploy (push) Successful in 4s
2025-12-19 18:17:23 +01:00
Lars 444f64e94c types.yaml um weitere Typen ergänzt
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-12-19 17:37:30 +01:00
14 changed files with 1220 additions and 289 deletions

No files matched your search

+175 -125
View File
@@ -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
View File
@@ -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)
+17
View File
@@ -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
+72 -30
View File
@@ -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
+1
View File
@@ -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
View File
@@ -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
View File
@@ -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:
+1
View File
@@ -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
+154 -41
View File
@@ -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).*
+48
View File
@@ -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
+69
View File
@@ -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))