Compare commits

...
Author SHA1 Message Date
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
11 changed files with 1081 additions and 235 deletions

No files matched your search

+164 -114
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 = "/"
@@ -123,13 +137,7 @@ 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)
chunks = [] # ==========================================
current_chunk_blocks = [] # 4. ROBUST EDGE PARSING & PROPAGATION (NEU)
# ==========================================
context_prefix = f"# {doc_title}" 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()
def has_content(blk_list): # A. Inline [[rel:type|target]] (Standard)
return any(b.kind != "heading" for b in blk_list) 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}")
def flush_current_chunk(): # B. Multiline Callouts Parsing (Der Fix für dein Problem)
nonlocal current_chunk_blocks lines = text.split('\n')
if not current_chunk_blocks: current_edge_type = None
return
text_body = "\n\n".join([b.text for b in current_chunk_blocks]) for line in lines:
win_body = f"{context_prefix}\n{text_body}".strip() stripped = line.strip()
first_b = current_chunk_blocks[0] # 1. Start Blockquote: > [!edge] type
sec = first_b.section_title # (Erlaubt optionalen Doppelpunkt)
path = first_b.section_path callout_match = re.match(r'>\s*\[!edge\]\s*([^:\s]+)', stripped)
if callout_match:
current_edge_type = callout_match.group(1).strip()
_create_chunk_obj(chunks, note_id, text_body, win_body, sec, path) # Check: Sind Links noch in der GLEICHEN Zeile?
current_chunk_blocks = [] links = re.findall(r'\[\[([^\]]+)\]\]', stripped)
for l in links:
if "rel:" not in l:
found_edges.add(f"{current_edge_type}:{l}")
continue
def get_current_size(): # 2. Continuation Line: > [[Target]]
txt = "\n\n".join([b.text for b in current_chunk_blocks]) # Wenn wir noch im 'edge mode' sind und die Zeile ein Zitat ist
return estimate_tokens(txt) if current_edge_type and stripped.startswith('>'):
links = re.findall(r'\[\[([^\]]+)\]\]', stripped)
for l in links:
if "rel:" not in l:
found_edges.add(f"{current_edge_type}:{l}")
for b in blocks: # 3. End of Blockquote (kein '>') -> Reset Type
# 1. Header Logic (Struktur-Trigger) elif not stripped.startswith('>'):
is_splitter = (b.kind == "heading" and b.level is not None and b.level <= split_level) current_edge_type = None
if is_splitter: return found_edges
is_higher_hierarchy = (b.level < split_level)
if strict_mode: def _propagate_section_edges(chunks: List[Chunk]) -> List[Chunk]:
# STRICT: """
# Wir splitten immer, außer der Vor-Chunk ist leer. NEU: Verteilt Kanten innerhalb einer Sektion.
if current_chunk_blocks and has_content(current_chunk_blocks): Löst das Problem: Callout steht oben im Kapitel, gilt aber für alle Chunks darunter.
flush_current_chunk() """
current_chunk_blocks.append(b) # Step 1: Sammeln pro Sektion
else: section_map = {} # path -> set(kind:target)
# 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): for ch in chunks:
# NOTBREMSE: Chunk wird zu groß. # Root-Level "/" ignorieren wir meist, da zu global
# Wir splitten hier, auch wenn kein Header da ist. if not ch.section_path or ch.section_path == "/": continue
# Der Kontext (Section Title) bleibt erhalten, da er aus `current_h2` kommt (siehe parse_blocks).
flush_current_chunk()
current_chunk_blocks.append(b)
else:
current_chunk_blocks.append(b)
# Letzten Rest flushen edges = _parse_edges_robust(ch.text)
flush_current_chunk() 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,6 +400,10 @@ 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,
@@ -373,6 +411,7 @@ def _extract_all_edges_from_md(md_text: str, note_id: str, note_type: str) -> Li
"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])
+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))