neue Dokumentationstruktur - (QS geprüft)
Deploy mindnet to llm-node / deploy (push) Successful in 4s
Deploy mindnet to llm-node / deploy (push) Successful in 4s
This commit is contained in:
1 parent
0bb5f57cc6
commit
620858a575
39 files changed
+1840
No files matched your search
@@ -0,0 +1,465 @@
|
||||
# mindnet v2.2 – Dokumentationsrahmenplan
|
||||
**Datei:** `docs/mindnet_docs_master_plan_v2.2.md`
|
||||
**Stand:** 2025-12-06
|
||||
**Bezug:** Programmplan mindnet v2.2 :contentReference[oaicite:0]{index=0}
|
||||
|
||||
---
|
||||
|
||||
## 1. Zweck dieses Rahmenplans
|
||||
|
||||
Dieser Rahmenplan definiert:
|
||||
|
||||
- die **Zieldokumente** der mindnet v2.2 Dokumentation,
|
||||
- deren **Dateinamen, Zielgruppen, Inhalte und Quellen**,
|
||||
- die **Zuordnung** zu Workpackages (WP) und Release-Tags,
|
||||
- die **Regeln zum Informations-Erhalt** (keine inhaltlichen Verluste),
|
||||
- die **empfohlene Bearbeitungsreihenfolge**.
|
||||
|
||||
Alle hier beschriebenen Zieldokumente werden als **eigene Markdown-Dateien** gepflegt und sind Teil von WP-14 _Review / Refactoring / Dokumentation_ (Phase E). :contentReference[oaicite:1]{index=1}
|
||||
|
||||
---
|
||||
|
||||
## 2. Prinzipien zur Sicherung der Informationen
|
||||
|
||||
Um zu verhindern, dass Inhalte oder Ergebnisse verloren gehen, gelten folgende Prinzipien:
|
||||
|
||||
1. **Programmplan v2.2 als Masterreferenz**
|
||||
- Programmauftrag, Vision, Phasenmodell und WP-Status werden **nicht verändert**, sondern nur referenziert.
|
||||
- `Programmplan_V2.2.md` bleibt das führende Dokument für Ziele, WPs, Ampelstatus. :contentReference[oaicite:2]{index=2}
|
||||
|
||||
2. **Keine unkontrollierte Löschung von Inhalten**
|
||||
- Bestehende Dokumente (`knowledge_design.md`, `chunking_strategy.md`, `mindnet_technical_architecture.md`, `Handbuch.md`, `TYPE_REGISTRY_MANUAL.md`, `docs_mindnet_retriever.md`, `wp04_retriever_scoring.md`) werden **nicht gelöscht**, sondern:
|
||||
- vollständig archiviert,
|
||||
- in die neuen Zieldokumente **überführt**,
|
||||
- oder **explizit** in den Anhängen (I) als „legacy / historisch“ verlinkt.
|
||||
|
||||
3. **Explizite Quellenzuordnung („Building Blocks“)**
|
||||
- Für jede Sektion eines Zieldokuments wird angegeben, aus **welchen bestehenden Dateien und Abschnitten** der Inhalt stammt.
|
||||
- Neue Inhalte (z. B. User Guide H) werden klar als „neu, v2.2“ gekennzeichnet.
|
||||
|
||||
4. **Ist-Stand vs. Roadmap trennen**
|
||||
- Implementierter Stand v2.2: WP01–WP04a (🟢) mit Importer, Chunking, Edge-Pipeline, Typ-Registry und hybrider Retriever.
|
||||
- Geplante Features (Self-Healing, Virtual Schema Layer, Explanation Layer, Feedback-Logging, MCP-Agenten) werden als **Roadmap-Funktionen** kenntlich gemacht (Phase B–D, WPs 05–13).
|
||||
|
||||
5. **Versionierbarkeit**
|
||||
- Alle Zieldokumente tragen im Kopf eine **Version** und **Stand-Datum** sowie optional einen Verweis auf den letzten Gitea-Tag (z. B. `mindnet_v2.2_docs_initial`, `WP04a-Retriever_final`). :contentReference[oaicite:6]{index=6}
|
||||
- Änderungen werden im Abschnitt „Changelog“ der jeweiligen Datei notiert.
|
||||
|
||||
6. **Keine funktionalen Annahmen ohne Verifikation**
|
||||
- Wo das Verhalten nicht eindeutig aus Code-/Handbuch-/WP-Dokumenten hervorgeht, wird der Punkt zunächst als _offene Frage_ markiert und nicht als Tatsache dokumentiert.
|
||||
- Verifizierte Funktionen (z. B. `import_markdown`, Edge-Schema, `types.yaml`, `/query`, Scoring-Formel) werden exakt gemäß der bestehenden Dokumente beschrieben.
|
||||
|
||||
---
|
||||
|
||||
## 3. Zieldokumente der mindnet v2.2 Dokumentation
|
||||
|
||||
### 3.1 Übersichtstabelle
|
||||
|
||||
| ID | Zieldatei | Rolle/Zielgruppe | Hauptquellen (Building Blocks) |
|
||||
|----|------------------------------------------|---------------------------------------------|--------------------------------|
|
||||
| A | `mindnet_overview_v2.2.md` | Einstieg für alle Rollen | Programmplan v2.2, Knowledge Design |
|
||||
| B | `mindnet_functional_architecture_v2.2.md`| Architekt:innen, Mindmaster | Knowledge Design, Functional Architecture, Programmplan |
|
||||
| C | `mindnet_technical_architecture_v2.2.md` | Entwickler:innen, Tech-Architekt:innen | mindnet_technical_architecture, chunking_strategy, Handbuch |
|
||||
| D | `mindnet_knowledge_design_manual_v2.2.md`| Vault-Autor:innen, Mindmaster, Analyst:innen| knowledge_design, TYPE_REGISTRY_MANUAL, Functional Architecture |
|
||||
| E | `mindnet_pipeline_playbook_v2.2.md` | Dev/Ops, Tech-Lead | mindnet_v2_implementation_playbook, Handbuch, chunking_strategy, docs_mindnet_retriever, wp04_retriever_scoring |
|
||||
| F | `mindnet_developer_guide_v2.2.md` | Entwickler:innen (Code, API, Tests) | Technical Architecture, Handbuch, docs_mindnet_retriever |
|
||||
| G | `mindnet_admin_guide_v2.2.md` | Admins, Betreiber | Handbuch, Implementation Playbook, Programmplan (Governance) |
|
||||
| H | `mindnet_user_guide_v2.2.md` | Endnutzer:innen, Agent-User | Knowledge Design, Programmplan (Use Cases), spätere MCP-WPs |
|
||||
| I | `mindnet_appendices_v2.2.md` | Alle Rollen (Referenzen, Tabellen) | TYPE_REGISTRY_MANUAL, chunking_strategy, WP-Übersicht, Edge-Referenz |
|
||||
|
||||
---
|
||||
|
||||
## 4. Detailpläne pro Zieldokument (Inhaltsverzeichnis & Building Blocks)
|
||||
|
||||
### A) `mindnet_overview_v2.2.md`
|
||||
|
||||
#### Zweck & Zielgruppe
|
||||
- Einstieg in mindnet für alle Rollen (Owner, Mindmaster, Developer, Admin, Agenten-Entwickler).
|
||||
- Auf 3–5 Seiten: _Was ist mindnet? Wie ist es gedacht? Wie lese ich die Dokumentation?_ :contentReference[oaicite:17]{index=17}
|
||||
|
||||
#### Geplantes Inhaltsverzeichnis
|
||||
|
||||
1. **Einführung**
|
||||
1. Programmauftrag & Vision (v2.2)
|
||||
2. Was mindnet ist – und was nicht
|
||||
2. **Drei Ebenen von mindnet**
|
||||
1. Content-Ebene (Vault, Notes, Chunks)
|
||||
2. Semantische Ebene (Edges, Typen, Retriever)
|
||||
3. Identitäts- / Persönlichkeits-Ebene (Werte, Entscheidungen, Profile – Roadmap)
|
||||
3. **End-to-End-Überblick**
|
||||
1. Datenfluss: Vault → Import → Qdrant → Retriever → Antwort
|
||||
2. WP-Phasenmodell (A–E) und aktueller Stand (WP01–04a grün)
|
||||
4. **Rollen & Perspektiven**
|
||||
1. Mindmaster / Owner
|
||||
2. Autor:in (Vault-Notes)
|
||||
3. Developer / Architect
|
||||
4. Administrator:in
|
||||
5. Agenten & LLMs (MCP-Perspektive)
|
||||
5. **Leserführung durch die Dokumentation**
|
||||
1. Welche Datei für welche Rolle?
|
||||
2. Wie mit Ist-Stand vs. Roadmap umgehen?
|
||||
6. **Glossar zentraler Begriffe**
|
||||
- mindnet, Vault, Note, Chunk, Edge, Type, Identity, Self-Healing, Self-Tuning, Explanation Layer, Virtual Schema Layer, etc.
|
||||
|
||||
#### Building Blocks (Quellen-Mapping)
|
||||
|
||||
- Programmauftrag & Vision → `Programmplan_V2.2.md`, Kapitel 1–2. :contentReference[oaicite:18]{index=18}
|
||||
- Phasenmodell & WPs → `Programmplan_V2.1.md`/v2.2, Kapitel 5–9 (angepasst auf v2.2-Stand).
|
||||
- High-Level-Architektur → `knowledge_design.md`, Kapitel 1–3 (Ziel, Zielarchitektur, Collections). :contentReference[oaicite:20]{index=20}
|
||||
- Rollenmodell → Ableitung aus Knowledge Design + Programmplan (Owner, Agenten, MCP-WPs).
|
||||
|
||||
---
|
||||
|
||||
### B) `mindnet_functional_architecture_v2.2.md`
|
||||
|
||||
#### Zweck & Zielgruppe
|
||||
- Fachliche Architektur von mindnet (Konzeptmodell).
|
||||
- Für Architekt:innen, Mindmaster, Knowledge-Designer.
|
||||
|
||||
#### Geplantes Inhaltsverzeichnis
|
||||
|
||||
1. **Ziel & Einordnung**
|
||||
1. Bezug zu Programmauftrag & WPs (WP01–WP07, WP10–12)
|
||||
2. **Kernkonzepte**
|
||||
1. Notes & Note-Typen (concept, experience, project, decision, value, principle, person, event, …)
|
||||
2. Chunks & Sections
|
||||
3. Edges (Struktur, explizit, inline, Default-Kanten)
|
||||
4. Typen-Registry & Virtual Schema Layer (fachliche Sicht, Roadmap)
|
||||
3. **Graph-Modell**
|
||||
1. Knotenarten (Notes, Chunks, Identity Nodes, People)
|
||||
2. Kantenarten (belongs_to, references, similar_to, depends_on, related_to, next/prev, …)
|
||||
3. Scope & Provenienz (chunk vs. note, rule_id, confidence)
|
||||
4. **End-to-End fachlicher Datenfluss**
|
||||
1. Erfassung von Wissen (Note erstellen)
|
||||
2. Import & Graphaufbau
|
||||
3. Retrieval & Begründungspfade
|
||||
4. Self-Healing & Retroactive Edges (WP06/07 – Roadmap)
|
||||
5. **Szenarien & Use Cases**
|
||||
1. Wissensspeicherung (z. B. Leitbild, Projekt, Erfahrung)
|
||||
2. Entscheidungen & Why-Layer (WP04b – Roadmap)
|
||||
3. Persönlichkeits-/Identitätsmodell (WP10–12 – Roadmap)
|
||||
6. **Rollenmodell (fachliche Sicht)**
|
||||
1. Mindmaster
|
||||
2. Content-Autor:innen
|
||||
3. Analyst:innen (Graph-Leser)
|
||||
7. **Designprinzipien (fachlich)**
|
||||
- Late Binding, Virtual Schema, Self-Healing, Minimalinvasives Schreiben etc.
|
||||
|
||||
#### Building Blocks
|
||||
|
||||
- `knowledge_design.md` – Kapitel 1–4, 6–7 (Ziel, Architektur, Collections, Identitäten, Prinzipien). :contentReference[oaicite:28]{index=28}
|
||||
- `mindnet_functional_architecture.md` – alle Kapitel (Kernkonzepte, Edgetypen, Provenienz, Rollen). :contentReference[oaicite:29]{index=29}
|
||||
- `chunking_strategy.md` – Edges, Datenmodell, Graph-Sicht. :contentReference[oaicite:30]{index=30}
|
||||
- Programmplan – WPs 01–07, 10–12 für Roadmap-Features.
|
||||
|
||||
---
|
||||
|
||||
### C) `mindnet_technical_architecture_v2.2.md`
|
||||
|
||||
#### Zweck & Zielgruppe
|
||||
- Technische Architektur des Systems: Collections, Payload-Felder, Services, Schemata.
|
||||
- Für Entwickler:innen und Tech-Architekt:innen.
|
||||
|
||||
#### Geplantes Inhaltsverzeichnis
|
||||
|
||||
1. **Ziel & Scope**
|
||||
1. Abgrenzung zur funktionalen Architektur
|
||||
2. Bezug zu WPs 02–04a, 05 (Schema, Importer, Retriever)
|
||||
2. **Systemübersicht**
|
||||
1. Komponentenübersicht (Importer, Qdrant, Retriever-API, Embedding-Service, n8n/MCP-Ausblick)
|
||||
2. Ports, Dienste, Hauptverzeichnisse
|
||||
3. **Datenmodell in Qdrant**
|
||||
1. Notes (`mindnet_notes`)
|
||||
2. Chunks (`mindnet_chunks`)
|
||||
3. Edges (`mindnet_edges`)
|
||||
4. Optionale Collections (`mindnet_people`, zukünftige)
|
||||
4. **Typ-Registry & Konfiguration**
|
||||
1. `config/types.yaml` – Aufbau, Defaults, Typauflösung (Ist-Stand: Frontmatter-Overrides deaktiviert)
|
||||
2. `config/retriever.yaml` – Scoringgewichte, Edge-Typ-Gewichte :contentReference[oaicite:35]{index=35}
|
||||
5. **Import-Pipeline (technische Sicht)**
|
||||
1. Discovery & Parsing (`import_markdown.py`)
|
||||
2. Hash-/Idempotenz-Mechanismus (ENV-Variablen, Baseline-Modi)
|
||||
3. Chunking (`chunker.py`, `chunk_payload.py`)
|
||||
4. Edge-Erzeugung (`derive_edges.py`)
|
||||
5. Roundtrip & Tests (Export & Vault-Vergleich)
|
||||
6. **Retriever-Architektur**
|
||||
1. API (FastAPI-Endpunkt `/query`)
|
||||
2. Semantik- und Hybridmodus
|
||||
3. Subgraph & Graph-API (expand)
|
||||
4. Scoring-Formel und Komponenten (semantik, edges, centrality) :contentReference[oaicite:37]{index=37}
|
||||
7. **Offene technische Punkte / Roadmap**
|
||||
1. Explanation Layer (WP04b)
|
||||
2. Feedback-Logging (WP04c)
|
||||
3. Virtual Schema Layer (WP05)
|
||||
4. Self-Healing & Self-Tuning (WP06–08)
|
||||
|
||||
#### Building Blocks
|
||||
|
||||
- `mindnet_technical_architecture.md` – Kerntext. :contentReference[oaicite:39]{index=39}
|
||||
- `chunking_strategy.md` – Datenmodell & Chunk-Details. :contentReference[oaicite:40]{index=40}
|
||||
- `Handbuch.md` – ENV, Skripte, Runbooks. :contentReference[oaicite:41]{index=41}
|
||||
- `wp04_retriever_scoring.md` / `docs_mindnet_retriever.md` – Retriever-Details. :contentReference[oaicite:42]{index=42}
|
||||
|
||||
---
|
||||
|
||||
### D) `mindnet_knowledge_design_manual_v2.2.md`
|
||||
|
||||
#### Zweck & Zielgruppe
|
||||
- Konkrete Anleitung für das Schreiben und Strukturieren von Notes & Chunks im Vault.
|
||||
- Für dich als Owner/Mindmaster und alle, die Notes erstellen.
|
||||
|
||||
#### Geplantes Inhaltsverzeichnis
|
||||
|
||||
1. **Zweck & Scope**
|
||||
1. Rolle des Vaults als „Source of Truth“
|
||||
2. **Note-Struktur & Frontmatter**
|
||||
1. Pflicht- und optionale Felder (id, title, type, tags, status, created/updated, …)
|
||||
2. Empfehlungen für IDs, Pfade und Namenskonventionen
|
||||
3. **Note-Typen & Typ-Registry**
|
||||
1. Übersicht der Typen (concept, project, experience, decision, value, principle, person, event, …)
|
||||
2. Typ-spezifische Einsatzempfehlungen
|
||||
3. Zusammenspiel mit `types.yaml` (retriever_weight, chunk_profile, edge_defaults)
|
||||
4. **Edges & Referenzen in Notes**
|
||||
1. Wikilinks (`[[Note]]`) → `references`
|
||||
2. Inline-Relationen (`[[rel:depends_on XYZ]]`, `similar_to`, `related_to`)
|
||||
3. Callout-Edges (`> [!edge] …`)
|
||||
4. Strukturkanten (Ordner, belongs_to)
|
||||
5. **Best Practices**
|
||||
1. Beispiele für gut modellierte Notes (Projekt, Entscheidung, Erfahrung)
|
||||
2. Typische Anti-Patterns und wie man sie vermeidet
|
||||
6. **Langfristige Stabilität**
|
||||
1. Virtual Schema Layer – was bedeutet das für Note-Autoren? (Wenig Änderungen in bestehenden Notes, Logik in Configs) :contentReference[oaicite:46]{index=46}
|
||||
|
||||
#### Building Blocks
|
||||
|
||||
- `knowledge_design.md` – Kerntext + Beispiele. :contentReference[oaicite:47]{index=47}
|
||||
- `TYPE_REGISTRY_MANUAL.md` – Typ-Registry & Verhalten. :contentReference[oaicite:48]{index=48}
|
||||
- `mindnet_functional_architecture.md` – ergänzende Konzepte & Edges. :contentReference[oaicite:49]{index=49}
|
||||
- `chunking_strategy.md` – Inline-Relationen, Edges, Datenmodell. :contentReference[oaicite:50]{index=50}
|
||||
|
||||
---
|
||||
|
||||
### E) `mindnet_pipeline_playbook_v2.2.md`
|
||||
|
||||
#### Zweck & Zielgruppe
|
||||
- End-to-End-Playbook für die gesamte Pipeline:
|
||||
- Importer,
|
||||
- Chunking,
|
||||
- Edge-Erzeugung,
|
||||
- Retriever & Scoring,
|
||||
- (perspektivisch) Explanation Layer, Self-Healing, Self-Tuning.
|
||||
- Für Dev/Ops und technische Leads.
|
||||
|
||||
#### Geplantes Inhaltsverzeichnis
|
||||
|
||||
1. **Zweck & Einordnung**
|
||||
1. Bezug zu WPs 02–04a (Ist) und 04b–08 (Roadmap)
|
||||
2. **Import-Pipeline (Runbook-Sicht)**
|
||||
1. Inputs (Vault, Config-Files, ENV)
|
||||
2. Standardläufe (Initialimport, inkrementelle Updates, Sync-Deletes)
|
||||
3. Baseline-Builds & Hash-Modi
|
||||
3. **Chunking & Payload-Aufbau**
|
||||
1. Chunk-Profile, Overlaps, Fenster
|
||||
2. Feldbesetzung (`text`, `window`, `section_title`, `neighbors`, …)
|
||||
4. **Edge-Erzeugung**
|
||||
1. Strukturkanten (belongs_to, next, prev)
|
||||
2. Explizite Edges (Wikilinks, Inline-Relationen, Callouts)
|
||||
3. Typ-Default-Kanten aus `types.yaml`
|
||||
5. **Retriever & Scoring**
|
||||
1. Konfiguration (`retriever.yaml`, ENV)
|
||||
2. Scoring-Formel und Parameter
|
||||
3. Semantik- vs. Hybridmodus
|
||||
4. Test- und Smoke-Suites
|
||||
6. **Quality Gates & Tests**
|
||||
1. Roundtrip-Tests (Vault → Qdrant → Export)
|
||||
2. Chunk-Integrität und Fenster-Checks
|
||||
3. Retriever-Regressionstests
|
||||
7. **Ausblick: Self-Healing, Retroactive Edges, Self-Tuning**
|
||||
1. Geplante Batch-Jobs und Feedback-Pipelines (WP06–08)
|
||||
|
||||
#### Building Blocks
|
||||
|
||||
- `mindnet_v2_implementation_playbook.md` – Policies, Teststrategie, KPIs. :contentReference[oaicite:57]{index=57}
|
||||
- `Handbuch.md` – Skripte & Test-Runbooks. :contentReference[oaicite:58]{index=58}
|
||||
- `chunking_strategy.md` – Chunk- & Edge-Strategie. :contentReference[oaicite:59]{index=59}
|
||||
- `docs_mindnet_retriever.md` / `wp04_retriever_scoring.md` – Retriever-Praktiken & Tests. :contentReference[oaicite:60]{index=60}
|
||||
|
||||
---
|
||||
|
||||
### F) `mindnet_developer_guide_v2.2.md`
|
||||
|
||||
#### Zweck & Zielgruppe
|
||||
- Konzentrierte Sicht für Entwickler:innen:
|
||||
- wie das Projekt strukturiert ist,
|
||||
- wie man es lokal aufsetzt,
|
||||
- wie man neue Features implementiert/testet.
|
||||
|
||||
#### Geplantes Inhaltsverzeichnis
|
||||
|
||||
1. **Projektstruktur**
|
||||
1. Verzeichnisbaum (app/, scripts/, tests/, config/, …)
|
||||
2. **Lokale Entwicklungsumgebung**
|
||||
1. Abhängigkeiten, venv, ENV
|
||||
2. Starten von Services (Qdrant, API, ggf. ollama)
|
||||
3. **APIs & Module**
|
||||
1. Importer-Skripte
|
||||
2. Core-Module (Chunker, Edge-Engine, Retriever)
|
||||
3. FastAPI-Endpunkte (`/query`, evtl. Admin-Endpoints)
|
||||
4. **Tests & Debugging**
|
||||
1. pytest-Suites
|
||||
2. Logging & Diagnoseskripte
|
||||
5. **Guidelines für Erweiterungen**
|
||||
1. Neue Typen & Edge-Regeln
|
||||
2. Änderungen am Datenmodell
|
||||
3. Umgang mit Schema-Änderungen (Virtual Schema Layer)
|
||||
|
||||
#### Building Blocks
|
||||
|
||||
- `mindnet_technical_architecture.md` – Modul- & API-Beschreibungen. :contentReference[oaicite:63]{index=63}
|
||||
- `Handbuch.md` – Skripte & Beispiele. :contentReference[oaicite:64]{index=64}
|
||||
- `docs_mindnet_retriever.md` – API-Beispiele für den Retriever. :contentReference[oaicite:65]{index=65}
|
||||
|
||||
---
|
||||
|
||||
### G) `mindnet_admin_guide_v2.2.md`
|
||||
|
||||
#### Zweck & Zielgruppe
|
||||
- Betriebshandbuch für mindnet:
|
||||
- Installation,
|
||||
- Konfiguration,
|
||||
- Backup/Restore,
|
||||
- Monitoring,
|
||||
- Troubleshooting.
|
||||
|
||||
#### Geplantes Inhaltsverzeichnis
|
||||
|
||||
1. **Zielgruppe & Scope**
|
||||
2. **Initial Setup**
|
||||
1. Voraussetzungen (Ubuntu, Docker/Qdrant, Python-Umgebung)
|
||||
2. ENV-Variablen & Config-Files (types.yaml, retriever.yaml)
|
||||
3. **Betrieb im Alltag**
|
||||
1. Regelmäßige Imports
|
||||
2. Umgang mit Fehlermeldungen im Importer
|
||||
3. Health-Checks für Qdrant & API
|
||||
4. **Update-Prozess**
|
||||
1. Vorgehen bei Schema-/Code-Updates
|
||||
2. Umgang mit neuen Typen und Policies
|
||||
5. **Backup & Restore**
|
||||
1. Qdrant-Snapshots
|
||||
2. Vault-Backup (Obsidian)
|
||||
3. Konsistenzprüfungen
|
||||
6. **Monitoring & Logging**
|
||||
1. typische Logquellen (Importer, API, n8n)
|
||||
7. **Governance & Sicherheit**
|
||||
1. Bezug zur Programm-Governance (WP14, MCP-Sicherheit)
|
||||
|
||||
#### Building Blocks
|
||||
|
||||
- `Handbuch.md` – Betriebsskripte & ENV. :contentReference[oaicite:69]{index=69}
|
||||
- `mindnet_v2_implementation_playbook.md` – Policies/Resilienz. :contentReference[oaicite:70]{index=70}
|
||||
- Programmplan – Governance / WP14. :contentReference[oaicite:71]{index=71}
|
||||
|
||||
---
|
||||
|
||||
### H) `mindnet_user_guide_v2.2.md`
|
||||
|
||||
#### Zweck & Zielgruppe
|
||||
- Anleitung für Nutzer:innen (inkl. späterer Chat-Agenten-User):
|
||||
- wie man mindnet im Alltag nutzt,
|
||||
- wie man Fragen stellt,
|
||||
- wie man neue Gedanken einbringt.
|
||||
|
||||
#### Geplantes Inhaltsverzeichnis
|
||||
|
||||
1. **Was mindnet für dich tut**
|
||||
1. Persönliches Gedächtnis
|
||||
2. KI-Zwilling als Gesprächspartner :contentReference[oaicite:72]{index=72}
|
||||
2. **Zugänge zu mindnet**
|
||||
1. Obsidian-Vault
|
||||
2. Chat-Agent (lokal, n8n-Workflows)
|
||||
3. (später) Interview-Assistent, MCP-Tools
|
||||
3. **Gute Fragen an mindnet**
|
||||
1. Beispiel-Queries (Wissensabruf, Entscheidungen, Reflexionen)
|
||||
4. **Neue Inhalte eingeben**
|
||||
1. Notes in Obsidian erstellen
|
||||
2. Typen und Links bewusst setzen (vereinfachte Version aus D)
|
||||
5. **Ergebnisse interpretieren**
|
||||
1. Was bedeutet ein Treffer-Set?
|
||||
2. Wie sind Scores zu lesen? (nur Ist-Stand, Explanation Layer als Ausblick)
|
||||
6. **Feedback & Lernen**
|
||||
1. Manuelles Feedback (gut/schlecht) – Roadmap WP04c/08
|
||||
|
||||
#### Building Blocks
|
||||
|
||||
- Programmplan – Vision & Use-Cases. :contentReference[oaicite:76]{index=76}
|
||||
- Knowledge Design – Autorensicht (stark vereinfacht). :contentReference[oaicite:77]{index=77}
|
||||
- Retriever-Dokumente – Scoring & Interpretation. :contentReference[oaicite:78]{index=78}
|
||||
|
||||
---
|
||||
|
||||
### I) `mindnet_appendices_v2.2.md`
|
||||
|
||||
#### Zweck & Zielgruppe
|
||||
- Referenzen, Tabellen, technische Details, die Hauptdokumente nicht überfrachten sollen.
|
||||
|
||||
#### Geplantes Inhaltsverzeichnis
|
||||
|
||||
1. **Typenreferenz (Auszug aus `types.yaml`)**
|
||||
- Tabellenform: Typ, chunk_profile, edge_defaults, retriever_weight
|
||||
2. **Edge-Typen & Bedeutungen**
|
||||
- belongs_to, references, depends_on, similar_to, related_to, next, prev, …
|
||||
3. **Datenmodelle (JSON-Skizzen)**
|
||||
- Note, Chunk, Edge-Payload (aktuell implementierter Stand)
|
||||
4. **Relevante ENV-Variablen & Konfigurationen**
|
||||
- Hash-Settings, COLLECTION_PREFIX, MINDNET_TYPES_FILE, MINDNET_RETRIEVER_CONFIG etc.
|
||||
5. **WP-Übersicht & Status**
|
||||
- kompakte Tabelle aller WPs mit Status (🟢/🟡) und Verweisen auf relevante Dokumente.
|
||||
6. **Historische Dokumente**
|
||||
- Verweis auf alte Versionen (`mindnet_functional_architecture.md`, ältere Playbooks), falls diese nicht vollständig eingearbeitet werden.
|
||||
|
||||
#### Building Blocks
|
||||
|
||||
- `TYPE_REGISTRY_MANUAL.md` – Typen-Referenz. :contentReference[oaicite:84]{index=84}
|
||||
- `chunking_strategy.md` – JSON-Beispiele. :contentReference[oaicite:85]{index=85}
|
||||
- `mindnet_technical_architecture.md` – Felder & Prioritäten. :contentReference[oaicite:86]{index=86}
|
||||
- Programmplan – WP-Tabellen.
|
||||
|
||||
---
|
||||
|
||||
## 5. Bearbeitungsreihenfolge (Empfehlung)
|
||||
|
||||
Aus Sicht der Informationssicherung und Konsistenz ist folgende Reihenfolge sinnvoll:
|
||||
|
||||
1. **C – `mindnet_technical_architecture_v2.2.md`**
|
||||
- Begründung:
|
||||
- bildet den **aktuellen implementierten Stand** von WP02–WP04a am präzisesten ab,
|
||||
- ist stark an konkrete Felder, Collections und Skripte gebunden (hier ist der Ist-Stand am eindeutigsten belegbar),
|
||||
- ist die Grundlage für Developer Guide, Playbook und Admin Guide.
|
||||
|
||||
2. **E – `mindnet_pipeline_playbook_v2.2.md`**
|
||||
- Konsolidiert Handbuch + Implementation-Playbook + WP04-Dokumente.
|
||||
|
||||
3. **D – `mindnet_knowledge_design_manual_v2.2.md`**
|
||||
- Stellt sicher, dass das Wissensdesign stabil dokumentiert ist, bevor Overview/User Guide entstehen.
|
||||
|
||||
4. **A – `mindnet_overview_v2.2.md`**
|
||||
- Kann sich dann sauber auf die finalisierte fachliche/technische Sicht stützen.
|
||||
|
||||
5. **F, G, H, I**
|
||||
- Developer/Admin/User Guides & Appendices, basierend auf den konsolidierten Kern-Dokumenten.
|
||||
|
||||
---
|
||||
|
||||
## 6. Nächster konkreter Schritt
|
||||
|
||||
Als nächstes finalisieren wir gemäß dieser Reihenfolge das Dokument:
|
||||
|
||||
> **C – `mindnet_technical_architecture_v2.2.md`**
|
||||
|
||||
Dabei gehen wir wie folgt vor:
|
||||
|
||||
1. Bestehendes `mindnet_technical_architecture.md` **vollständig** als Basis übernehmen. :contentReference[oaicite:89]{index=89}
|
||||
2. Fehlende Details aus `chunking_strategy.md`, `Handbuch.md`, `TYPE_REGISTRY_MANUAL.md` und `wp04_retriever_scoring.md` integrieren (ohne Informationsverlust).
|
||||
3. Ist-Stand vs. Roadmap klar kennzeichnen (WP04b–08, WP05–07).
|
||||
|
||||
Dieses Vorgehen hält die technische Wahrheit konsistent und liefert eine stabile Basis für alle nachfolgenden Dokumente.
|
||||
@@ -0,0 +1,705 @@
|
||||
# mindnet v2.4 — Programmplan
|
||||
**Version:** 2.7.0 (Post-WP15: Roadmap Erweiterung für Graph-Health & Visualisierung)
|
||||
**Stand:** 2025-12-12
|
||||
**Status:** Aktiv
|
||||
|
||||
---
|
||||
- [mindnet v2.4 — Programmplan](#mindnet-v24--programmplan)
|
||||
- [1. Programmauftrag](#1-programmauftrag)
|
||||
- [2. Vision](#2-vision)
|
||||
- [3. Programmziele](#3-programmziele)
|
||||
- [3.1 Kurzfristig (Abgeschlossen / Laufend)](#31-kurzfristig-abgeschlossen--laufend)
|
||||
- [3.2 Mittelfristig (Nächste Schritte)](#32-mittelfristig-nächste-schritte)
|
||||
- [3.3 Langfristig](#33-langfristig)
|
||||
- [4. Architekturprinzipien](#4-architekturprinzipien)
|
||||
- [5. Programmstruktur (Phasenmodell)](#5-programmstruktur-phasenmodell)
|
||||
- [6. Workpackages – detaillierte Übersicht](#6-workpackages--detaillierte-übersicht)
|
||||
- [Legende Aufwand / Komplexität](#legende-aufwand--komplexität)
|
||||
- [WP-01 – Wissensdesign (abgeschlossen)](#wp-01--wissensdesign-abgeschlossen)
|
||||
- [WP-02 – Chunking \& Hash-Strategie (abgeschlossen)](#wp-02--chunking--hash-strategie-abgeschlossen)
|
||||
- [WP-03 – Import-Pipeline \& Edge-System v2 (abgeschlossen)](#wp-03--import-pipeline--edge-system-v2-abgeschlossen)
|
||||
- [WP-04a – Retriever \& Graph-Scoring (abgeschlossen)](#wp-04a--retriever--graph-scoring-abgeschlossen)
|
||||
- [WP-04b – Explanation Layer ("Why-Layer") (abgeschlossen)](#wp-04b--explanation-layer-why-layer-abgeschlossen)
|
||||
- [WP-04c – Feedback Logging \& Bewertungsdaten (abgeschlossen)](#wp-04c--feedback-logging--bewertungsdaten-abgeschlossen)
|
||||
- [WP-05 – Persönlichkeitsmodell \& RAG-Chat (abgeschlossen)](#wp-05--persönlichkeitsmodell--rag-chat-abgeschlossen)
|
||||
- [WP-05b – Advanced Chat (Optional)](#wp-05b--advanced-chat-optional)
|
||||
- [WP-06 – Decision Engine \& Hybrid Router (abgeschlossen)](#wp-06--decision-engine--hybrid-router-abgeschlossen)
|
||||
- [WP-07 – Interview-Assistent (abgeschlossen)](#wp-07--interview-assistent-abgeschlossen)
|
||||
- [WP-08 – Self-Tuning v1/v2 (geplant)](#wp-08--self-tuning-v1v2-geplant)
|
||||
- [WP-09 – Vault-Onboarding \& Migration (geplant)](#wp-09--vault-onboarding--migration-geplant)
|
||||
- [WP-10 – Chat-Interface \& Writeback (abgeschlossen)](#wp-10--chat-interface--writeback-abgeschlossen)
|
||||
- [WP-10a – GUI Evolution: Draft Editor (abgeschlossen)](#wp-10a--gui-evolution-draft-editor-abgeschlossen)
|
||||
- [WP-11 – Backend Intelligence \& Persistence (abgeschlossen)](#wp-11--backend-intelligence--persistence-abgeschlossen)
|
||||
- [WP-12 – Knowledge Rewriter (Soft Mode, geplant)](#wp-12--knowledge-rewriter-soft-mode-geplant)
|
||||
- [WP-13 – MCP-Integration \& Agenten-Layer (geplant)](#wp-13--mcp-integration--agenten-layer-geplant)
|
||||
- [WP-14 – Review / Refactoring / Dokumentation (geplant)](#wp-14--review--refactoring--dokumentation-geplant)
|
||||
- [WP-15 – Smart Edge Allocation \& Chunking Strategies (abgeschlossen)](#wp-15--smart-edge-allocation--chunking-strategies-abgeschlossen)
|
||||
- [WP-16 – Auto-Discovery \& Enrichment (geplant)](#wp-16--auto-discovery--enrichment-geplant)
|
||||
- [WP-17 – Conversational Memory (Dialog-Gedächtnis) (geplant)](#wp-17--conversational-memory-dialog-gedächtnis-geplant)
|
||||
- [WP-18 – Graph Health \& Maintenance (NEU, geplant)](#wp-18--graph-health--maintenance-neu-geplant)
|
||||
- [WP-19 – Graph Visualisierung \& Explorer (NEU, geplant)](#wp-19--graph-visualisierung--explorer-neu-geplant)
|
||||
- [WP-20 – Cloud Hybrid Mode (Gemini) (NEU, geplant)](#wp-20--cloud-hybrid-mode-gemini-neu-geplant)
|
||||
- [7. Abhängigkeiten (vereinfacht, aktualisiert)](#7-abhängigkeiten-vereinfacht-aktualisiert)
|
||||
- [8. Laufzeit- \& Komplexitätsindikatoren (aktualisiert)](#8-laufzeit---komplexitätsindikatoren-aktualisiert)
|
||||
- [9. Programmfortschritt (Ampel, aktualisiert)](#9-programmfortschritt-ampel-aktualisiert)
|
||||
- [10. Governance \& Versionierung](#10-governance--versionierung)
|
||||
- [11. Executive Summary](#11-executive-summary)
|
||||
|
||||
---
|
||||
|
||||
## 1. Programmauftrag
|
||||
|
||||
mindnet v2.4 entwickelt ein persönliches, wachsendes KI-Gedächtnis, das:
|
||||
|
||||
- Wissen, Erfahrungen, Werte und Entscheidungen speichert,
|
||||
- diese Informationen semantisch verknüpft und rekonstruierbar macht,
|
||||
- einen KI-Zwilling aufbaut, der ähnlich argumentiert, entscheidet und reflektiert wie du,
|
||||
- über mehrere Kanäle gefüttert wird:
|
||||
- Obsidian-Markdown (primäre Quelle),
|
||||
- Chat-basierter Agent (Decision Engine & RAG-Chat aktiv),
|
||||
- Interview-Assistent (One-Shot Extraction aktiv),
|
||||
- **Draft Editor (Active Intelligence aktiv)**,
|
||||
- automatisch neue Zusammenhänge erkennt und vernetzt (Edges, Typen, Hinweise),
|
||||
- sich durch Rückmeldungen (Feedback) selbst verbessert (Self-Tuning).
|
||||
|
||||
Langfristig soll mindnet als **digitales Gegenüber** funktionieren, das:
|
||||
|
||||
- dich versteht,
|
||||
- deine Denkweise reflektiert,
|
||||
- deine Werte kennt und verwendet,
|
||||
- Entscheidungen begründen kann („Warum?“),
|
||||
- Erinnerungen einordnet,
|
||||
- und für deine Nachkommen als dialogfähiger Gesprächspartner zur Verfügung steht.
|
||||
|
||||
mindnet ist **kein statisches Wissensarchiv**, sondern ein **lebendes, lernendes Gedächtnismodell** mit Fokus auf:
|
||||
|
||||
- persönliche Perspektive,
|
||||
- erklärbare Begründungspfade (Why-Layer),
|
||||
- kontinuierliche Erweiterbarkeit,
|
||||
- robuste technische Basis (lokal, nachvollziehbar, versioniert).
|
||||
|
||||
---
|
||||
|
||||
## 2. Vision
|
||||
|
||||
> „Ein persönliches semantisches Gedächtnis, das mit mir wächst, meine Persönlichkeit spiegelt und mir als intelligenter, erklärbarer, lernender Begleiter dient.“
|
||||
|
||||
Kernprinzipien der Vision:
|
||||
|
||||
- **Erklärbarkeit:**
|
||||
Jede Antwort muss über Edges, Scores, Werte-Bezüge und Herkunftsnotizen begründbar sein. Das System kann Entscheidungen auf zugrundeliegende `[DECISION]`-Notizen zurückführen.
|
||||
|
||||
- **Wachstum:**
|
||||
Das System arbeitet von Anfang an mit unvollständigen Daten, kann aber schrittweise dichter werden, ohne dass alte Notizen massenhaft manuell angepasst werden müssen.
|
||||
|
||||
- **Flexibilität (Late Binding):**
|
||||
Semantik wird überwiegend in Konfiguration (z. B. `types.yaml`, `prompts.yaml`, `decision_engine.yaml`) festgelegt. Die Persönlichkeit entsteht durch das Config-Design, nicht durch Hardcoding.
|
||||
|
||||
- **Autonomie & Self-Healing:**
|
||||
mindnet schlägt fehlende Typen, Relationen und Edges vor (z. B. aus Inline-Relationen, Edge-Defaults, Ähnlichkeitsbeziehungen) und baut damit einen „self-healing graph“ auf.
|
||||
|
||||
- **Lernen & Self-Tuning:**
|
||||
Feedback zu Antworten (gut/schlecht, relevant/nicht relevant) fließt in Score-Gewichte, Policies und ggf. Edge-Struktur ein.
|
||||
|
||||
- **Persönlichkeit:**
|
||||
Entscheidungen werden wert- und erfahrungsbasiert begründet; das System agiert als KI-Zwilling durch Nutzung lokaler LLMs (z.B. Phi-3/Mistral) und eines Intent-Routers.
|
||||
|
||||
- **Incremental Growth:**
|
||||
Das System muss mit wenigen, heterogenen Notizen starten und sich fortlaufend verdichten können – ohne Retro-Massenmigrationen im Vault.
|
||||
|
||||
---
|
||||
|
||||
## 3. Programmziele
|
||||
|
||||
### 3.1 Kurzfristig (Abgeschlossen / Laufend)
|
||||
|
||||
- Automatische Sammlung von Wissen aus Markdown-Vault.
|
||||
- Aufbau eines stabilen Graph-Speichers in Qdrant (`*_notes`, `*_chunks`, `*_edges`).
|
||||
- Semantischer und graphbasierter Retriever (WP-04a abgeschlossen).
|
||||
- **Erklärbarkeit:** Why-Layer liefert Begründungen zu Treffern (WP-04b abgeschlossen).
|
||||
- **Feedback-Loop:** Systematisches Logging von Suche und Bewertung (WP-04c abgeschlossen).
|
||||
- **RAG-Chat:** KI antwortet in natürlicher Sprache auf Basis von Wissen und Persönlichkeit (WP-05 abgeschlossen).
|
||||
- **Decision Engine:** System erkennt Intent (Fakt vs. Entscheidung) und wägt Werte ab (WP-06 abgeschlossen).
|
||||
- **Multi-Persona:** System wechselt den Tonfall (Empathisch vs. Analytisch) situativ (WP-06 abgeschlossen).
|
||||
- **Chat Interface:** Web-basiertes Frontend (Streamlit) für einfache Interaktion und Feedback-Gabe (WP-10 abgeschlossen).
|
||||
- **Interview-Assistent (WP-07):** One-Shot Extraction von Notizen ("Neues Projekt anlegen") ist live.
|
||||
- **Active Intelligence (WP-11):** Automatische Link-Vorschläge (Matrix-Logik) während des Schreibens.
|
||||
- Technische Basis: FastAPI (Async), Qdrant (768 Dim), Ollama (Phi-3/Nomic), Streamlit.
|
||||
- Automatisierte Erkennung von Beziehungen:
|
||||
- Wikilinks, Inline-Relationen, Callout-Edges, Typ-Defaults.
|
||||
- „Mitwachsendes“ Schema ohne Obsidian-Umstrukturierungen:
|
||||
- Neues Wissen kann sofort erfasst werden,
|
||||
- bestehende Notizen bleiben gültig (Virtual Schema Layer).
|
||||
|
||||
### 3.2 Mittelfristig (Nächste Schritte)
|
||||
|
||||
- **Self-Tuning (WP-08):** Optimierung der Gewichte in `retriever.yaml` basierend auf dem gesammelten Feedback.
|
||||
- Agenten können über MCP-Tools (`mindnet_query`, `mindnet_chat`) auf mindnet zugreifen (WP-13).
|
||||
|
||||
### 3.3 Langfristig
|
||||
|
||||
- KI-Zwilling, der deinen Stil, deine Werte und deine typische Denkweise repräsentiert.
|
||||
- Weitgehend autonomes Self-Tuning der Wissensstruktur (auf Basis gespeicherter Feedback-Daten & Policies).
|
||||
- Lebenslanges Gedächtnis, das
|
||||
- konsistent bleibt,
|
||||
- wächst,
|
||||
- sich weiterentwickelt,
|
||||
- und deine Geschichte für deine Nachkommen erzählbar und erlebbar macht.
|
||||
|
||||
---
|
||||
|
||||
## 4. Architekturprinzipien
|
||||
|
||||
Die folgenden Prinzipien steuern alle Workpackages und Entscheidungen:
|
||||
|
||||
1. **Late Binding (späte Semantik)**
|
||||
- Struktur und Interpretation werden in Konfigurationen (z. B. `types.yaml`, `prompts.yaml`, `decision_engine.yaml`) definiert, nicht direkt in den Vault-Dateien.
|
||||
- Die "Persönlichkeit" des Chats ist ein Prompt-Template, kein Code.
|
||||
|
||||
2. **Virtual Schema Layer**
|
||||
- Typen, Regeln, Policies, Edge-Defaults werden im Schema-Layer beschrieben.
|
||||
- Markdown-Dateien benötigen nur minimale, robuste Angaben (Titel, Typ, optionale Properties).
|
||||
|
||||
3. **Self-Healing Graph**
|
||||
- Der Graph wird regelmäßig analysiert (Edges, Centrality, fehlende Links).
|
||||
- Automatisierte Jobs ergänzen fehlende Kanten.
|
||||
|
||||
4. **Deterministische IDs**
|
||||
- Notes, Chunks und Edges erhalten stabile IDs (z. B. UUIDv5).
|
||||
- Der Graph ist jederzeit wiederaufbaubar (Import-Pipeline idempotent).
|
||||
|
||||
5. **Full Explainability & Context Enrichment**
|
||||
- Jeder Score, jede Beziehung muss nachvollziehbar sein.
|
||||
- Dem LLM werden Metadaten (`[DECISION]`, `[PROJECT]`) injiziert, um Halluzinationen zu vermeiden und logische Schlüsse zu ermöglichen.
|
||||
|
||||
6. **Persistence First**
|
||||
- Obsidian bleibt die primäre Quelle der Wahrheit.
|
||||
- mindnet ergänzt, schlägt Änderungen vor, schreibt aber nur kontrolliert.
|
||||
|
||||
7. **Minimalinvasives Schreiben**
|
||||
- Automatische Veränderungen an Markdown-Dateien erfolgen ausschließlich nach expliziter Zustimmung.
|
||||
|
||||
8. **Incremental Growth & Early Value**
|
||||
- Das System muss bereits mit wenigen Notizen und einem kleinen Vault sinnvolle Antworten liefern.
|
||||
- Feedback-Mechanismen werden früh eingeführt.
|
||||
|
||||
9. **Observability & Testbarkeit**
|
||||
- Jeder Importlauf, jede Retriever-Anfrage und jede Policy-Änderung soll prüfbar sein.
|
||||
|
||||
10. **Local First & Privacy**
|
||||
- Nutzung lokaler LLMs (Ollama) für Inference. Keine Daten verlassen den Server.
|
||||
|
||||
---
|
||||
|
||||
## 5. Programmstruktur (Phasenmodell)
|
||||
|
||||
Phase A – Fundament & Import (Fertig)
|
||||
Phase B – Semantik, Graph & Lernen (Fertig)
|
||||
Phase C – Persönlichkeitsmodell & KI-Zwilling (Fertig)
|
||||
Phase D – Agenten, MCP & Interaktion (Aktiv)
|
||||
Phase E – Maintenance, Visualisierung & Scaling (Neu)
|
||||
|
||||
Alle Workpackages sind einer Phase zugeordnet. WP-01 bis WP-07 und WP-10/10a/11 sind erfolgreich abgeschlossen.
|
||||
|
||||
---
|
||||
|
||||
## 6. Workpackages – detaillierte Übersicht
|
||||
|
||||
### Legende Aufwand / Komplexität
|
||||
|
||||
- Aufwand: Niedrig / Mittel / Hoch
|
||||
- Komplexität: Niedrig / Mittel / Hoch
|
||||
|
||||
Die Status-Ampel zeigt den aktuellen Stand gemäß Programmfortschritt.
|
||||
|
||||
---
|
||||
|
||||
### WP-01 – Wissensdesign (abgeschlossen)
|
||||
|
||||
**Phase:** A
|
||||
**Status:** 🟢 abgeschlossen
|
||||
|
||||
**Ziel:**
|
||||
Grundlegendes Schema für mindnet festlegen (`knowledge_design.md`), inkl.:
|
||||
- Note-Typen (z. B. `concept`, `experience`, `project`, `decision`, `value`).
|
||||
- Standard-Properties und Grundstruktur von Edges.
|
||||
- Abbildung zentraler Lebens-Bereiche.
|
||||
|
||||
**Erreichte Ergebnisse:**
|
||||
- `knowledge_design.md` und `types.yaml` definieren die Zielarchitektur.
|
||||
|
||||
---
|
||||
|
||||
### WP-02 – Chunking & Hash-Strategie (abgeschlossen)
|
||||
|
||||
**Phase:** A
|
||||
**Status:** 🟢 abgeschlossen
|
||||
|
||||
**Ziel:**
|
||||
Festlegen und implementieren einer robusten Chunking-Strategie und einer Hash-Logik zur Änderungserkennung.
|
||||
|
||||
**Erreichte Ergebnisse:**
|
||||
- Implementierte Chunker-Logik mit Overlap.
|
||||
- Stabile Hash-Strategie zur sicheren Änderungserkennung.
|
||||
|
||||
---
|
||||
|
||||
### WP-03 – Import-Pipeline & Edge-System v2 (abgeschlossen)
|
||||
|
||||
**Phase:** A/B
|
||||
**Status:** 🟢 abgeschlossen
|
||||
|
||||
**Ziel:**
|
||||
Durchgängige Import-Pipeline von Markdown → Notes/Chunks/Edges in Qdrant mit deterministischen IDs.
|
||||
|
||||
**Erreichte Ergebnisse:**
|
||||
- Vollständige E2E-Import-Pipeline.
|
||||
- Vollständiges Edge-Modell (Strukturkanten, Wikilinks, Inline-Relationen).
|
||||
|
||||
---
|
||||
|
||||
### WP-04a – Retriever & Graph-Scoring (abgeschlossen)
|
||||
|
||||
**Phase:** B
|
||||
**Status:** 🟢 abgeschlossen
|
||||
|
||||
**Ziel:**
|
||||
Aufbau eines hybriden Retrievers, der Semantik, Typwissen und Graph-Informationen kombiniert.
|
||||
|
||||
**Erreichte Ergebnisse:**
|
||||
- Hybrides Scoring-Modell (Semantic + Edge + Centrality).
|
||||
- Konfiguration über `retriever.yaml`.
|
||||
- `/query` Endpoint aktiv.
|
||||
|
||||
---
|
||||
|
||||
### WP-04b – Explanation Layer ("Why-Layer") (abgeschlossen)
|
||||
|
||||
**Phase:** B
|
||||
**Status:** 🟢 abgeschlossen
|
||||
|
||||
**Ziel:**
|
||||
Treffererklärungen liefern, die verständlich machen, warum ein Ergebnis gewählt wurde.
|
||||
|
||||
**Erreichte Ergebnisse:**
|
||||
- **DTO-Erweiterung:** `QueryHit` enthält `explanation`, `breakdown` und `reason`.
|
||||
- **Logic:** Graph-Adapter unterstützt `incoming_edges` (Reverse Lookup) für Authority-Erklärungen.
|
||||
- **Output:** `/query` Endpoint liefert auf Wunsch (`explain: true`) menschenlesbare Begründungen ("Verweist auf...").
|
||||
|
||||
---
|
||||
|
||||
### WP-04c – Feedback Logging & Bewertungsdaten (abgeschlossen)
|
||||
|
||||
**Phase:** B
|
||||
**Status:** 🟢 abgeschlossen
|
||||
|
||||
**Ziel:**
|
||||
Grundlage für Self-Tuning schaffen durch systematisches Logging.
|
||||
|
||||
**Erreichte Ergebnisse:**
|
||||
- **Data Flywheel:** Logging von Queries und User-Feedback in lokalen JSONL-Dateien.
|
||||
- **Search Log:** Speichert Query + Score-Snapshot in `data/logs/search_history.jsonl`.
|
||||
- **Feedback Log:** Speichert User-Ratings in `data/logs/feedback.jsonl`.
|
||||
- **Traceability:** Durchgängige `query_id` von Request bis Feedback.
|
||||
|
||||
---
|
||||
|
||||
### WP-05 – Persönlichkeitsmodell & RAG-Chat (abgeschlossen)
|
||||
|
||||
**Phase:** C
|
||||
**Status:** 🟢 abgeschlossen
|
||||
|
||||
**Ziel:**
|
||||
Aufbau eines RAG-Systems, das in natürlicher Sprache antwortet und Kontext versteht.
|
||||
|
||||
**Erreichte Ergebnisse:**
|
||||
- **Infrastruktur:** Integration von Ollama (Phi-3 Mini) in den Service-Layer.
|
||||
- **Router:** `/chat` Endpoint mit "Hybrid Retrieval Enforcement".
|
||||
- **Context Enrichment:** Injection von Metadaten (`[TYPE]`, `[SCORE]`) in den Prompt, damit kleine Modelle (SLMs) komplexe Zusammenhänge ("Warum?") verstehen.
|
||||
- **Config:** `prompts.yaml` steuert System-Prompt und RAG-Template.
|
||||
|
||||
**Aufwand / Komplexität:**
|
||||
- Aufwand: Mittel
|
||||
- Komplexität: Mittel
|
||||
|
||||
---
|
||||
|
||||
### WP-05b – Advanced Chat (Optional)
|
||||
|
||||
**Phase:** C
|
||||
**Status:** ⚪ optional
|
||||
|
||||
**Ziel:**
|
||||
Erweiterung des Chats um Gedächtnis (History) und einfache Tools.
|
||||
|
||||
**Umfang:**
|
||||
- Implementierung von `ChatHistory` (vergangene Nachrichten in den Kontext).
|
||||
- Einfache Tool-Nutzung (z.B. "Suche in Web").
|
||||
|
||||
---
|
||||
|
||||
### WP-06 – Decision Engine & Hybrid Router (abgeschlossen)
|
||||
|
||||
**Phase:** C
|
||||
**Status:** 🟢 abgeschlossen
|
||||
|
||||
**Ziel:**
|
||||
Transformation vom reinen Wissens-Abrufer zum strategischen Entscheidungspartner durch Intent-Erkennung.
|
||||
|
||||
**Erreichte Ergebnisse:**
|
||||
- **Hybrid Intent Router:** Kombination aus schnellem Keyword-Matching und intelligentem LLM-Fallback zur Erkennung der Absicht (`DECISION`, `EMPATHY`, `FACT`, `CODING`).
|
||||
- **Strategic Retrieval:** Gezieltes Nachladen von Werten (`value`), Zielen (`goal`) oder Erfahrungen (`experience`) basierend auf dem Intent.
|
||||
- **Multi-Persona:** Dynamische Anpassung des Tonfalls (Berater vs. Spiegel vs. Techniker) durch `prompts.yaml`.
|
||||
- **Late Binding:** Vollständige Konfiguration via `decision_engine.yaml`.
|
||||
- **Robustheit:** Konfigurierbare Timeouts für CPU-Inference.
|
||||
|
||||
**Aufwand / Komplexität:**
|
||||
- Aufwand: Mittel
|
||||
- Komplexität: Hoch
|
||||
|
||||
---
|
||||
|
||||
### WP-07 – Interview-Assistent (abgeschlossen)
|
||||
|
||||
**Phase:** C/D
|
||||
**Status:** 🟢 abgeschlossen
|
||||
|
||||
**Ziel:**
|
||||
Dialogbasierter Erfassungs-Assistent, der strukturierte Interviews führt und daraus konsistente Markdown-Notizen generiert.
|
||||
|
||||
**Erreichte Ergebnisse:**
|
||||
- **One-Shot Extractor:** Extrahiert Notiz-Inhalte aus einem Prompt.
|
||||
- **Schema Injection:** Typspezifische Pflichtfelder (Late Binding).
|
||||
- **Draft Generator:** Liefert validen Markdown-Codeblock mit `status: draft`.
|
||||
|
||||
**Aufwand / Komplexität:**
|
||||
- Aufwand: Niedrig/Mittel
|
||||
- Komplexität: Mittel
|
||||
|
||||
---
|
||||
|
||||
### WP-08 – Self-Tuning v1/v2 (geplant)
|
||||
|
||||
**Phase:** B/C
|
||||
**Status:** 🟡 geplant (Nächster Fokus)
|
||||
|
||||
**Ziel:**
|
||||
Aufbau eines Self-Tuning-Mechanismus, der auf Basis von Feedback-Daten (WP-04c) Vorschläge für Retriever- und Policy-Anpassungen macht.
|
||||
|
||||
**Umfang:**
|
||||
- Auswertung der JSONL-Feedback-Daten.
|
||||
- Regel-basierte Anpassungs-Vorschläge für `retriever.yaml` und Typ-Prioritäten.
|
||||
|
||||
**Aufwand / Komplexität:**
|
||||
- Aufwand: Hoch
|
||||
- Komplexität: Hoch
|
||||
|
||||
---
|
||||
|
||||
### WP-09 – Vault-Onboarding & Migration (geplant)
|
||||
|
||||
**Phase:** B
|
||||
**Status:** 🟡 geplant
|
||||
|
||||
**Ziel:**
|
||||
Sicherstellen, dass bestehende und neue Obsidian-Vaults schrittweise in mindnet integriert werden können – ohne Massenumbau.
|
||||
|
||||
**Umfang:**
|
||||
- Tools zur Analyse des Vault-Status.
|
||||
- Empfehlungen für minimale Anpassungen.
|
||||
|
||||
**Aufwand / Komplexität:**
|
||||
- Aufwand: Mittel
|
||||
- Komplexität: Niedrig/Mittel
|
||||
|
||||
---
|
||||
|
||||
### WP-10 – Chat-Interface & Writeback (abgeschlossen)
|
||||
|
||||
**Phase:** D
|
||||
**Status:** 🟢 abgeschlossen
|
||||
|
||||
**Ziel:**
|
||||
Ablösung der Terminal-Interaktion durch ein grafisches Interface.
|
||||
|
||||
**Erreichte Ergebnisse:**
|
||||
- **Tech-Stack:** Streamlit Frontend (`app/frontend/ui.py`).
|
||||
- **Funktionen:** Chat-Verlauf, Visualisierung von Intents und Quellen (Expander).
|
||||
- **Feedback:** Globales Rating (Sterne) und granulare Quellen-Bewertung (Faces).
|
||||
- **Writeback:** Mockup-Interface für neue Einträge (Vorbereitung WP-07).
|
||||
- **Deployment:** Systemd-Services für Prod (8501) und Dev (8502).
|
||||
|
||||
**Aufwand / Komplexität:**
|
||||
- Aufwand: Hoch
|
||||
- Komplexität: Hoch
|
||||
|
||||
---
|
||||
|
||||
### WP-10a – GUI Evolution: Draft Editor (abgeschlossen)
|
||||
|
||||
**Phase:** D
|
||||
**Status:** 🟢 abgeschlossen
|
||||
|
||||
**Ziel:**
|
||||
Anpassung der GUI an komplexe Interaktionsmuster, die durch den Interview-Assistenten und Knowledge-Builder entstehen.
|
||||
|
||||
**Erreichte Ergebnisse:**
|
||||
- **Draft Editor:** Interaktive `st.text_area` für generierte Entwürfe.
|
||||
- **Sanitizer:** `normalize_meta_and_body` zur Korrektur von LLM-Fehlern.
|
||||
- **Download/Copy:** Export-Funktionen für Markdown.
|
||||
|
||||
**Aufwand / Komplexität:**
|
||||
- Aufwand: Mittel
|
||||
- Komplexität: Mittel
|
||||
|
||||
---
|
||||
|
||||
### WP-11 – Backend Intelligence & Persistence (abgeschlossen)
|
||||
|
||||
**Phase:** D
|
||||
**Status:** 🟢 abgeschlossen
|
||||
|
||||
**Ziel:**
|
||||
Ermöglichung von "Active Intelligence" durch asynchrone Verarbeitung und semantische Analyse im Hintergrund.
|
||||
|
||||
**Erreichte Ergebnisse:**
|
||||
- **Async Core:** Umstellung der Pipeline auf `asyncio` und `httpx` (Vermeidung von Blockaden).
|
||||
- **Nomic Embeddings:** Integration von `nomic-embed-text` (768 Dim) für State-of-the-Art Semantik.
|
||||
- **Matrix Logic:** Regelwerk für kontextsensitive Kanten (`experience` + `value` -> `based_on`).
|
||||
- **Sliding Window:** Analyse langer Texte für Link-Vorschläge.
|
||||
- **Persistence API:** Neuer Endpunkt `/ingest/save` für atomares Speichern & Indizieren.
|
||||
|
||||
**Aufwand / Komplexität:**
|
||||
- Aufwand: Hoch
|
||||
- Komplexität: Hoch
|
||||
|
||||
---
|
||||
|
||||
### WP-12 – Knowledge Rewriter (Soft Mode, geplant)
|
||||
|
||||
**Phase:** C/D
|
||||
**Status:** 🟡 geplant
|
||||
|
||||
**Ziel:**
|
||||
Optionaler Assistent, der vorhandene Notes „aufräumt“, zusammenfasst oder reorganisiert – ausschließlich mit expliziter Freigabe.
|
||||
|
||||
**Aufwand / Komplexität:**
|
||||
- Aufwand: Niedrig/Mittel
|
||||
- Komplexität: Mittel
|
||||
|
||||
---
|
||||
|
||||
### WP-13 – MCP-Integration & Agenten-Layer (geplant)
|
||||
|
||||
**Phase:** D
|
||||
**Status:** 🟡 geplant
|
||||
|
||||
**Ziel:**
|
||||
mindnet als MCP-Server bereitstellen, damit Agenten/LLMs standardisierte Tools nutzen können.
|
||||
|
||||
**Umfang:**
|
||||
- MCP-Server mit Tools (`mindnet_query`, `mindnet_explain`, etc.).
|
||||
|
||||
**Aufwand / Komplexität:**
|
||||
- Aufwand: Mittel
|
||||
- Komplexität: Mittel
|
||||
|
||||
---
|
||||
|
||||
### WP-14 – Review / Refactoring / Dokumentation (geplant)
|
||||
|
||||
**Phase:** E
|
||||
**Status:** 🟡 geplant
|
||||
|
||||
**Ziel:**
|
||||
Aufräumen, dokumentieren, stabilisieren – insbesondere für Onboarding Dritter und Langfrist-Betrieb.
|
||||
|
||||
**Aufwand / Komplexität:**
|
||||
- Aufwand: Mittel
|
||||
- Komplexität: Niedrig/Mittel
|
||||
|
||||
---
|
||||
|
||||
### WP-15 – Smart Edge Allocation & Chunking Strategies (abgeschlossen)
|
||||
|
||||
**Phase:** D
|
||||
**Status:** 🟢 abgeschlossen
|
||||
|
||||
**Ziel:**
|
||||
Einführung einer intelligenten Verteilung von Wissenskanten an spezifische Text-Chunks, um die Präzision des Retrievals zu erhöhen, ohne die Stabilität des Systems durch lange LLM-Verarbeitungszeiten zu gefährden.
|
||||
|
||||
**Erreichte Ergebnisse:**
|
||||
- **5-Stufen-Workflow:** Implementierung von "Smart Edge Allocation" (Global Scan -> Deterministic Split -> LLM Filter -> Injection -> Fallback).
|
||||
- **Neue Chunking-Strategien:** Einführung von `by_heading` (für strukturierte Daten) und verbessertem `sliding_window` als deterministische Basis.
|
||||
- **Robustheit:** Trennung von Zerlegung (Code) und Analyse (LLM). Bei LLM-Fehlern oder Timeouts greift ein Fallback-Mechanismus (Datenverlust ausgeschlossen).
|
||||
- **Architektur:** Trennung der Orchestrierung (`chunker.py`) von der KI-Logik (`semantic_analyzer.py`).
|
||||
- **Konfiguration:** Steuerung über `types.yaml` (`enable_smart_edge_allocation`) ermöglicht granulare Anpassung pro Notiztyp.
|
||||
|
||||
**Aufwand / Komplexität:**
|
||||
- Aufwand: Mittel
|
||||
- Komplexität: Hoch
|
||||
|
||||
---
|
||||
|
||||
### WP-16 – Auto-Discovery & Enrichment (geplant)
|
||||
|
||||
**Phase:** D
|
||||
**Status:** 🟡 geplant
|
||||
|
||||
**Ziel:**
|
||||
Automatisches Erkennen und Vorschlagen von fehlenden Kanten in "dummem" Text (ohne explizite Wikilinks) vor der Speicherung. Umwandlung von Text in "smarten Text" durch Nutzung des `DiscoveryService`.
|
||||
|
||||
**Umfang:**
|
||||
- Integration eines "Enrichers" in die Ingestion-Pipeline (Schritt 0).
|
||||
- Unterscheidung zwischen "Hard Candidates" (explizite Links) und "Soft Candidates" (Vektor-basierte Vorschläge).
|
||||
- LLM-basierte Verifikation der Vorschläge zur Vermeidung von Halluzinationen.
|
||||
|
||||
**Aufwand / Komplexität:**
|
||||
- Aufwand: Mittel
|
||||
- Komplexität: Hoch
|
||||
|
||||
---
|
||||
|
||||
### WP-17 – Conversational Memory (Dialog-Gedächtnis) (geplant)
|
||||
|
||||
**Phase:** D
|
||||
**Status:** 🟡 geplant
|
||||
|
||||
**Ziel:**
|
||||
Erweiterung des Chat-Backends von einem statischen Request-Response-Modell zu einem zustandsbehafteten Dialogsystem ("Multi-Turn Conversation"). Das System soll sich an vorherige Aussagen im aktuellen Gesprächsverlauf erinnern, um Rückfragen ("Was meinst du damit?") korrekt zu interpretieren.
|
||||
|
||||
**Umfang:**
|
||||
- **API-Erweiterung:** `ChatRequest` DTO erhält ein `history`-Feld (Liste von Nachrichten).
|
||||
- **Context Management:** Implementierung einer Token-Budget-Logik, die dynamisch zwischen RAG-Kontext (Dokumente) und Dialog-Verlauf (History) balanciert, um das Kontextfenster (8k) optimal zu nutzen.
|
||||
- **Prompt Engineering:** Integration eines `{chat_history}` Platzhalters in den System-Prompt.
|
||||
- **Frontend-Update:** Die `ui.py` muss die letzten N Nachrichtenpaare (User/AI) bei jedem Request mitsenden.
|
||||
|
||||
**Aufwand / Komplexität:**
|
||||
- Aufwand: Mittel
|
||||
- Komplexität: Mittel
|
||||
|
||||
---
|
||||
|
||||
### WP-18 – Graph Health & Maintenance (NEU, geplant)
|
||||
|
||||
**Phase:** E
|
||||
**Status:** 🟡 geplant (Prio 2)
|
||||
|
||||
**Ziel:**
|
||||
Sicherstellung der Konsistenz des Wissensgraphen bei Löschungen oder Umbenennungen von Notizen ("Dangling Edges").
|
||||
|
||||
**Architektur-Idee:**
|
||||
- **Health-Check Script:** Ein Cronjob (`scripts/check_graph_integrity.py`), der alle Kanten prüft, ob ihre `target_id` noch in `mindnet_notes` existiert.
|
||||
- **Report:** Ausgabe von "Broken Links" als Liste für den User.
|
||||
- **Auto-Heal (Optional):** Markieren von defekten Kanten als `broken` statt hartem Löschen.
|
||||
|
||||
**Aufwand / Komplexität:**
|
||||
- Aufwand: Niedrig
|
||||
- Komplexität: Mittel
|
||||
|
||||
---
|
||||
|
||||
### WP-19 – Graph Visualisierung & Explorer (NEU, geplant)
|
||||
|
||||
**Phase:** E
|
||||
**Status:** 🟡 geplant (Prio 1)
|
||||
|
||||
**Ziel:**
|
||||
Schaffung von Vertrauen und Transparenz durch Visualisierung der vom "Smart Chunker" erzeugten Verbindungen.
|
||||
|
||||
**Architektur-Idee:**
|
||||
- **Frontend-Erweiterung:** Neuer Tab "🕸️ Graph" in Streamlit.
|
||||
- **Tech-Stack:** Integration von `streamlit-agraph` oder `pyvis`.
|
||||
- **Feature:** Visualisierung der Nachbarschaft einer Notiz (Ego-Graph) oder eines Suchergebnisses.
|
||||
- **Nutzen:** Schnelle Validierung, ob Smart Edges korrekt gesetzt wurden.
|
||||
|
||||
**Aufwand / Komplexität:**
|
||||
- Aufwand: Mittel
|
||||
- Komplexität: Mittel
|
||||
|
||||
---
|
||||
|
||||
### WP-20 – Cloud Hybrid Mode (Gemini) (NEU, geplant)
|
||||
|
||||
**Phase:** E
|
||||
**Status:** ⚪ optional
|
||||
|
||||
**Ziel:**
|
||||
Optionale Beschleunigung ("Turbo-Modus") für Massen-Imports oder komplexe Analysen durch Nutzung externer High-Performance LLMs (Google Gemini 1.5 Flash), unter Beachtung des Datenschutzes.
|
||||
|
||||
**Architektur-Idee:**
|
||||
- **Provider-Switch:** Erweiterung des `LLMService` um einen Provider-Parameter (`ollama` vs. `gemini`).
|
||||
- **Konfiguration:** `types.yaml` oder `.env` erlaubt Umschalten pro Umgebung (z.B. Dev=Cloud, Prod=Local).
|
||||
- **Privacy:** Warnhinweis im UI, wenn Daten die lokale Umgebung verlassen.
|
||||
|
||||
**Aufwand / Komplexität:**
|
||||
- Aufwand: Mittel
|
||||
- Komplexität: Niedrig
|
||||
|
||||
---
|
||||
|
||||
## 7. Abhängigkeiten (vereinfacht, aktualisiert)
|
||||
|
||||
WP01-03 → WP04-06 (Core)
|
||||
WP11 → WP15 (Smart Edges)
|
||||
WP15 → WP19 (Visualisierung - zur Kontrolle)
|
||||
WP15 → WP16 (Auto-Discovery)
|
||||
WP03 → WP18 (Maintenance)
|
||||
WP10 → WP17 (Memory)
|
||||
WP20 (Cloud) ist unabhängig/optional.
|
||||
|
||||
---
|
||||
|
||||
## 8. Laufzeit- & Komplexitätsindikatoren (aktualisiert)
|
||||
|
||||
| WP | Aufwand | Komplexität |
|
||||
|-------|----------------|------------------|
|
||||
| WP15 | Mittel | Hoch |
|
||||
| WP16 | Mittel | Hoch |
|
||||
| WP17 | Mittel | Mittel |
|
||||
| WP18 | Niedrig | Mittel |
|
||||
| WP19 | Mittel | Mittel |
|
||||
| WP20 | Mittel | Niedrig |
|
||||
|
||||
---
|
||||
|
||||
## 9. Programmfortschritt (Ampel, aktualisiert)
|
||||
|
||||
| WP | Status | Titel |
|
||||
|-------|--------|-------|
|
||||
| WP01-14| 🟢 | (Basis-System) |
|
||||
| WP15 | 🟢 | Smart Edge Allocation |
|
||||
| WP16 | 🟡 | Auto-Discovery |
|
||||
| WP17 | 🟡 | Conversational Memory |
|
||||
| WP18 | 🟡 | Graph Health (Neu) |
|
||||
| WP19 | 🟡 | Visualization (Neu) |
|
||||
| WP20 | ⚪ | Cloud Mode (Neu) |
|
||||
|
||||
---
|
||||
|
||||
## 10. Governance & Versionierung
|
||||
|
||||
- Versionierung über Gitea (Branches, Tags, Releases).
|
||||
- Feature-Branch Workflow mit "Sync First" Strategie.
|
||||
- Jede wesentliche Änderung an Architektur/Schema erhält einen eigenen Commit.
|
||||
- Jedes Workpackage erhält ein eigenes Chat-Fenster mit dediziertem Prompt (WP-Hand-Over).
|
||||
- Programmleitung verantwortet Konsistenz und Priorisierung.
|
||||
- **Modell-Governance:** Das verwendete LLM (z.B. `phi3:mini`) wird in der `.env` und `config.py` festgeschrieben. Updates erfordern Tests gegen die "Why-Layer" Referenzfragen.
|
||||
|
||||
---
|
||||
|
||||
## 11. Executive Summary
|
||||
|
||||
mindnet v2.4 ist so aufgesetzt, dass:
|
||||
|
||||
- du **schrittweise** Wissen erfassen kannst (Obsidian + Chat + Interview-Drafts),
|
||||
- die Struktur **mitwächst**, ohne Retro-Massenarbeit im Vault,
|
||||
- ein **hybrider Retriever** qualitativ hochwertige, erklärbare Antworten liefert,
|
||||
- ein **Self-Healing- und Self-Tuning-Mechanismus** vorbereitet ist (durch WP-04c Feedback-Daten),
|
||||
- ein **Persönlichkeitsmodell** (Decision Engine, Empathie) existiert und den Tonfall situativ anpasst,
|
||||
- eine **grafische Oberfläche** (WP-10/10a) existiert, die komplexe Zusammenhänge visualisiert und Co-Creation ermöglicht,
|
||||
- **Active Intelligence** (WP-11) dich beim Schreiben unterstützt, indem es automatisch Verknüpfungen vorschlägt,
|
||||
- langfristig ein **KI-Zwilling** aufgebaut wird, der deine Werte, Erfahrungen und Denkweise spiegelt,
|
||||
- die technische Architektur (AsyncIO, Qdrant 768d, YAML-Policies) lokal, nachvollziehbar und performant bleibt.
|
||||
|
||||
Dieser Programmplan bildet die konsolidierte Grundlage (v2.4.0) für alle weiteren Arbeiten.
|
||||
@@ -0,0 +1,292 @@
|
||||
# mindnet v2.4 – Knowledge Design Manual
|
||||
**Datei:** `docs/mindnet_knowledge_design_manual_v2.6.md`
|
||||
**Stand:** 2025-12-12
|
||||
**Status:** **FINAL** (Integrierter Stand WP01–WP15)
|
||||
**Quellen:** `knowledge_design.md`, `TYPE_REGISTRY_MANUAL.md`, `chunking_strategy.md`, `mindnet_functional_architecture.md`.
|
||||
|
||||
---
|
||||
|
||||
## ⚡ Die 5 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"), damit der Vektor-Retriever sie bei Gefühls-Anfragen findet.
|
||||
|
||||
---
|
||||
|
||||
## 1. Zweck & Scope
|
||||
|
||||
Dieses Handbuch ist die **primäre Arbeitsanweisung** für dich als Mindmaster (Owner) und alle Autoren, die Inhalte im mindnet-Vault erstellen.
|
||||
|
||||
### 1.1 Zielsetzung
|
||||
Mindnet ist mehr als eine Dokumentablage. Es ist ein vernetztes System, das deine Persönlichkeit, Entscheidungen und Erfahrungen abbildet.
|
||||
Seit Version 2.6 verfügt Mindnet über:
|
||||
* **Hybrid Router:** Das System erkennt, ob du Fakten, Entscheidungen oder Empathie brauchst.
|
||||
* **Smart Edge Allocation:** Das System prüft deine Links intelligent und bindet sie nur an die Textabschnitte (Chunks), wo sie wirklich relevant sind.
|
||||
* **Web UI (WP10):** Du kannst direkt sehen, welche Quellen genutzt wurden.
|
||||
* **Active Intelligence (WP11):** Das System hilft dir beim Schreiben und Vernetzen (Link-Vorschläge).
|
||||
|
||||
### 1.2 Der Vault als „Source of Truth“
|
||||
Die Markdown-Dateien in deinem Vault sind die **einzige Quelle der Wahrheit**.
|
||||
* Mindnet importiert diesen Zustand deterministisch in die Datenbank (Qdrant).
|
||||
* Änderungen an IDs, Typen oder Inhalten müssen **immer** im Markdown erfolgen, niemals direkt in der Datenbank.
|
||||
* Was nicht im Markdown steht (z. B. implizites Wissen im Kopf), existiert für das System nicht.
|
||||
|
||||
---
|
||||
|
||||
## 2. Note-Struktur & Frontmatter
|
||||
|
||||
Jede Notiz benötigt einen YAML-Header (Frontmatter) am Dateianfang. Dieser Block macht die Notiz maschinenlesbar.
|
||||
|
||||
### 2.1 Pflichtfelder
|
||||
Jede Datei muss mindestens folgende Felder enthalten, um korrekt verarbeitet zu werden:
|
||||
|
||||
---
|
||||
id: 20251110-projekt-alpha-8a9b2c # Eindeutige Kennung (YYYYMMDD-slug)
|
||||
title: Projekt Alpha # Sprechender Titel (wird in Suchergebnissen angezeigt)
|
||||
type: project # Steuert Verarbeitung & Vernetzung (siehe Kap. 3)
|
||||
status: active # active, archived oder 'draft' (für generierte Notes)
|
||||
created: 2025-11-10 # Erstellungsdatum (ISO 8601 oder YYYY-MM-DD)
|
||||
updated: 2025-12-07 # Letzte Änderung
|
||||
tags: [ki, entwicklung] # Taxonomie für Filterung
|
||||
---
|
||||
|
||||
### 2.2 Optionale Felder
|
||||
Diese Felder sind technisch nicht zwingend, aber für bestimmte Typen sinnvoll:
|
||||
|
||||
lang: de # Sprache (Default: de)
|
||||
aliases: [Alpha Projekt, Project A] # Synonyme (WICHTIG für Exact Match in Intelligence)
|
||||
visibility: internal # internal (default), public, private
|
||||
|
||||
> **Hinweis:** Felder wie `retriever_weight` oder `chunk_profile` sollten **nicht** mehr manuell im Frontmatter gesetzt werden. Diese werden zentral über den `type` gesteuert (siehe Kap. 3), um die Wartbarkeit zu sichern.
|
||||
|
||||
### 2.3 Empfehlungen für IDs und Pfade
|
||||
|
||||
**Die ID (Identifikator):**
|
||||
* Muss global eindeutig und **stabil** sein.
|
||||
* Darf sich nicht ändern, wenn die Datei umbenannt oder verschoben wird.
|
||||
* **Empfehlung:** `YYYYMMDD-slug` (z. B. `20231027-vektor-db`). Dies garantiert Eindeutigkeit und Chronologie.
|
||||
|
||||
**Dateinamen & Pfade:**
|
||||
* Pfade dienen der menschlichen Ordnung (Ordnerstruktur), sind für Mindnet aber sekundär.
|
||||
* Dateinamen sollten dem Titel entsprechen (`Projekt Alpha.md`) oder dem Slug (`projekt-alpha.md`).
|
||||
* Sonderzeichen vermeiden (außer Bindestrich und Unterstrich).
|
||||
|
||||
---
|
||||
|
||||
## 3. Note-Typen & Typ-Registry
|
||||
|
||||
Der `type` ist der wichtigste Hebel im Knowledge Design. Er steuert nicht nur das Gewicht bei der Suche, sondern seit WP-06 auch, **wann** eine Notiz aktiv in den Chat geholt wird ("Strategic Retrieval") und seit WP-15, **ob Smart Edges aktiviert sind**.
|
||||
|
||||
### 3.1 Übersicht der Kern-Typen
|
||||
|
||||
Mindnet unterscheidet verschiedene Wissensarten. Wähle den Typ, der die **Rolle** der Notiz am besten beschreibt:
|
||||
|
||||
| Typ | Beschreibung & Einsatzzweck | Rolle im Chat (Intent) | Interview Schema (WP07) | Matrix-Logik (WP11) |
|
||||
| :--- | :--- | :--- | :--- | :--- |
|
||||
| **`concept`** | Fachbegriffe, Theorien. Zeitloses Wissen. | **FACT** | Titel, Definition, Tags | Ziel für `uses` |
|
||||
| **`project`** | Ein Vorhaben mit Ziel, Dauer und Aufgaben. | **FACT / DECISION** | Ziel, Status, Stakeholder | Quelle für `uses`, `depends_on` |
|
||||
| **`experience`** | Persönliche Erfahrung, Lektion oder Erkenntnis. | **EMPATHY** | Situation, Erkenntnis, Emotionen | Quelle für `based_on`, `derived_from` |
|
||||
| **`decision`** | Eine bewusst getroffene Entscheidung (ADR). | **DECISION** | Kontext, Entscheidung, Alternativen | Quelle für `depends_on`, `caused_by` |
|
||||
| **`value`** | Ein persönlicher Wert oder ein Prinzip. | **DECISION** | Definition, Anti-Beispiel | Ziel für `based_on` |
|
||||
| **`principle`** | Handlungsleitlinie. | **DECISION** | Regel, Ausnahme | Quelle für `derived_from` |
|
||||
| **`goal`** | Ein strategisches Ziel (kurz- oder langfristig). | **DECISION** | Zeitrahmen, KPIs, Werte | Ziel für `related_to` |
|
||||
| **`risk`** | Ein identifiziertes Risiko oder eine Gefahr. | **DECISION** | Auswirkung, Wahrscheinlichkeit | Quelle für `blocks` |
|
||||
| **`belief`** | Glaubenssatz / Überzeugung. | **EMPATHY** | Ursprung, Mantra | - |
|
||||
| **`person`** | Eine reale Person (Netzwerk, Autor). | **FACT** | Rolle, Kontext | - |
|
||||
| **`journal`** | Zeitbezogener Log-Eintrag, Daily Note. | **FACT** | Datum, Tags | - |
|
||||
| **`source`** | Externe Quelle (Buch, PDF, Artikel). | **FACT** | Autor, URL | - |
|
||||
|
||||
### 3.2 Zusammenspiel mit `types.yaml`
|
||||
|
||||
Der `type` steuert im Hintergrund drei technische Mechanismen:
|
||||
|
||||
1. **`retriever_weight` (Wichtigkeit):**
|
||||
* Ein `concept` (0.6) wiegt weniger als ein `project` (0.97) oder eine `decision` (1.0).
|
||||
2. **`chunk_profile` (Textzerlegung):**
|
||||
* `journal` (short): Wird fein zerlegt.
|
||||
* `experience` (sliding_smart_edges): Wird intelligent analysiert.
|
||||
3. **`enable_smart_edge_allocation` (WP15):**
|
||||
* Wenn `true`: Das System analysiert jeden Abschnitt mit KI, um zu prüfen, ob verlinkte Themen dort wirklich relevant sind. Das erhöht die Präzision massiv.
|
||||
|
||||
---
|
||||
|
||||
## 4. Edges & Referenzen in Notes
|
||||
|
||||
Um aus isolierten Dateien ein **Netzwerk** zu machen, nutzen wir Verlinkungen. In Version 2.2 sind diese Verlinkungen die Basis für den **Hybrid Retriever** (Suche über Nachbarn).
|
||||
|
||||
### 4.1 Wikilinks (Die Basis-Referenz)
|
||||
Der klassische Obsidian-Link.
|
||||
|
||||
Wir nutzen [[Qdrant]] als Vektordatenbank.
|
||||
|
||||
* **Bedeutung:** "Diese Notiz erwähnt Qdrant."
|
||||
* **Edge-Typ:** `references`
|
||||
|
||||
### 4.2 Inline-Relationen (Semantische Verknüpfung)
|
||||
Dies ist die **mächtigste** Methode. Du sagst dem System explizit, **wie** Dinge zusammenhängen.
|
||||
|
||||
Daher [[rel:depends_on Qdrant]].
|
||||
Dieses Konzept ist [[rel:similar_to Pinecone]].
|
||||
|
||||
* **Syntax:** `[[rel:RELATION ZIEL]]`.
|
||||
* **Gültige Relationen:**
|
||||
* `depends_on`: Hängt ab von / Benötigt. (Trigger für hohe Graph-Relevanz).
|
||||
* `similar_to`: Ähnelt / Ist vergleichbar mit.
|
||||
* `related_to`: Hat zu tun mit (allgemein).
|
||||
* `caused_by`: Wurde verursacht durch (Kausalität).
|
||||
* `solves`: Löst (Problem).
|
||||
* **`blocks`:** Blockiert oder gefährdet (z.B. Risiko -> Projekt).
|
||||
* **`derived_from`:** Stammt ab von (z.B. Prinzip -> Buch, Erfahrung -> Wert).
|
||||
* **`based_on`:** Basiert auf (Fundament).
|
||||
* **`uses`:** Nutzt (Werkzeug/Konzept).
|
||||
|
||||
### 4.3 Callout-Edges (Kuratierte Listen)
|
||||
Für Zusammenfassungen oder "Siehe auch"-Blöcke am Ende einer Notiz.
|
||||
|
||||
> [!edge] related_to: [[Vector Embeddings]] [[AI Agents]]
|
||||
|
||||
* **Funktion:** Erzeugt `related_to`-Kanten zu allen genannten Zielen in dieser Zeile.
|
||||
|
||||
---
|
||||
|
||||
## 5. Schreiben für den KI-Zwilling (New in v2.3/2.4)
|
||||
|
||||
Damit der **RAG-Chat (WP05/06)** nicht nur dumm Fakten wiedergibt, sondern dich berät, musst du "Futter" für die Decision Engine und das Empathie-Modul liefern.
|
||||
|
||||
### 5.1 Futter für die Decision Engine (`DECISION`)
|
||||
Das System soll abwägen: "Passt Tool X zu mir?". Dazu muss es wissen, was "Du" bist.
|
||||
|
||||
**Best Practice: Werte definieren**
|
||||
Erstelle Notizen mit `type: value`.
|
||||
|
||||
---
|
||||
type: value
|
||||
title: Prinzip: Datensparsamkeit
|
||||
---
|
||||
# Prinzip: Datensparsamkeit
|
||||
Wir speichern nur das Minimum an Daten. Cloud-Uploads persönlicher Daten sind verboten, es sei denn, sie sind E2E-verschlüsselt.
|
||||
|
||||
**Best Practice: Ziele definieren**
|
||||
Erstelle Notizen mit `type: goal`.
|
||||
|
||||
---
|
||||
type: goal
|
||||
title: Ziel: Unabhängigkeit 2026
|
||||
---
|
||||
# Ziel: Unabhängigkeit 2026
|
||||
Bis Ende 2026 wollen wir alle SaaS-Abos durch Self-Hosted Lösungen ersetzt haben.
|
||||
|
||||
*Effekt:* Wenn du fragst "Soll ich Notion nutzen?", lädt die Engine diese beiden Notizen und antwortet: *"Nein, Notion ist SaaS und nicht E2E-verschlüsselt. Das verletzt dein Prinzip der Datensparsamkeit und dein Ziel der Unabhängigkeit."*
|
||||
|
||||
### 5.2 Futter für den Empathie-Modus (`EMPATHY`)
|
||||
Das System soll dich verstehen, wenn du sagst: "Alles ist grau." Dazu braucht es deine Resonanzerfahrungen.
|
||||
|
||||
**Best Practice: Erfahrungen & Bridging**
|
||||
Erstelle Notizen mit `type: experience`. Nutze im Text **emotionale Brückenwörter**, damit der Retriever auch bei abstrakten Gefühlen ("grau") einen Treffer landet.
|
||||
|
||||
---
|
||||
type: experience
|
||||
title: Erfahrung: Der Durchbruch nach der Krise
|
||||
tags: [krise, hoffnung, grau, angst]
|
||||
---
|
||||
# Erfahrung: Der Durchbruch nach der Krise
|
||||
Es gibt Projektphasen, da wirkt alles **sinnlos** und **grau**.
|
||||
Ich habe gelernt: Das ist oft das Zeichen kurz vor dem Durchbruch.
|
||||
Mein Mantra in solchen Zeiten: "Einfach weitermachen, der Nebel lichtet sich."
|
||||
|
||||
*Effekt:* Wenn du im Chat jammerst ("Alles ist sinnlos"), findet das System diese Notiz und spiegelt dir deine eigene Erfahrung zurück.
|
||||
|
||||
### 5.3 Schreiben für den Chat (UI Optimization)
|
||||
Da deine Notizen im Web-Interface (WP10) angezeigt werden:
|
||||
* **Kurze Absätze:** Das LLM liest besser, und der Mensch scannt schneller.
|
||||
* **Klare Headings:** Nutze H1/H2, um dem Chunker logische Trennlinien zu geben.
|
||||
|
||||
### 5.4 Der Interview-Modus (Auto-Drafting)
|
||||
Seit v2.4 (WP07) kann Mindnet Notizen für dich entwerfen.
|
||||
|
||||
* **Wie:** Schreibe im Chat einfach: *"Ich möchte ein neues Projekt 'Alpha' anlegen, Ziel ist die Markteroberung."*
|
||||
* **Was passiert:** Mindnet erkennt den Wunsch (`INTERVIEW`), wählt das Schema für `project` und generiert **sofort** einen Markdown-Entwurf.
|
||||
* **Ergebnis:** Du erhältst einen Code-Block mit `status: draft`. Diesen kannst du im Draft-Editor (UI) direkt bearbeiten und herunterladen.
|
||||
* **Drafts:** Enthalten oft Platzhalter `[TODO]`. Das ist Absicht. Ergänze sie im Editor.
|
||||
|
||||
### 5.5 Futter für das Risikomanagement (`DECISION`)
|
||||
Damit Mindnet dich vor Fehlern warnen kann, musst du Risiken explizit machen.
|
||||
|
||||
**Best Practice: Risiken definieren**
|
||||
Erstelle Notizen mit `type: risk`. Nutze `blocks` oder `related_to`, um sie mit Projekten zu verknüpfen.
|
||||
|
||||
---
|
||||
type: risk
|
||||
title: Risiko: Vendor Lock-in bei Cloud-DBs
|
||||
tags: [architektur, kosten, abhängigkeit]
|
||||
---
|
||||
# Risiko: Vendor Lock-in bei Cloud-DBs
|
||||
Die Nutzung proprietärer Cloud-Datenbanken führt langfristig zu hohen Migrationskosten.
|
||||
Dies [[rel:blocks Ziel Unabhängigkeit 2026]].
|
||||
|
||||
*Effekt:* Wenn du fragst "Soll ich AWS DynamoDB nutzen?", erkennt die Decision Engine den Konflikt mit deinem Ziel "Unabhängigkeit" durch die Kante `blocks` und den hohen `retriever_weight` des Risikos.
|
||||
|
||||
---
|
||||
|
||||
## 6. Best Practices & Beispiele (Klassik)
|
||||
|
||||
### 6.1 Beispiel: Projekt-Notiz
|
||||
Projekte profitieren von `depends_on`, um Abhängigkeiten zu klären.
|
||||
|
||||
---
|
||||
id: 20251115-proj-mindnet
|
||||
title: Mindnet Implementierung
|
||||
type: project
|
||||
status: active
|
||||
---
|
||||
|
||||
# Mindnet Implementierung
|
||||
|
||||
Wir bauen ein persönliches Wissensnetz.
|
||||
|
||||
## Tech Stack
|
||||
Wir nutzen [[rel:depends_on Qdrant]] für die Vektorsuche und [[rel:depends_on FastAPI]] für das Backend.
|
||||
|
||||
## Architektur
|
||||
Das Konzept basiert auf [[RAG Architecture]]. (Automatisch 'depends_on' durch Typ-Default).
|
||||
|
||||
### 6.2 Beispiel: Entscheidung (Decision Record)
|
||||
Entscheidungen sind hoch gewichtet (`retriever_weight: 1.0`).
|
||||
|
||||
---
|
||||
id: 20251120-adr-vektordb
|
||||
title: ADR: Wahl von Qdrant
|
||||
type: decision
|
||||
status: final
|
||||
tags: [architektur, db]
|
||||
---
|
||||
|
||||
# Entscheidung: Qdrant
|
||||
|
||||
Wir haben uns für Qdrant entschieden.
|
||||
|
||||
## Alternativen
|
||||
Wir haben auch [[rel:similar_to Pinecone]] und [[rel:similar_to Weaviate]] betrachtet.
|
||||
|
||||
## Begründung
|
||||
Qdrant erlaubt lokalen Betrieb und [[rel:solves Payload Filtering Requirements]].
|
||||
|
||||
---
|
||||
|
||||
## 7. Langfristige Stabilität & Virtual Schema Layer
|
||||
|
||||
Mindnet ist auf Langlebigkeit ausgelegt.
|
||||
|
||||
### 7.1 Das "Virtual Schema" Prinzip
|
||||
Wir vermeiden es, Logik in den Markdown-Dateien hart zu kodieren.
|
||||
* Statt in jeder Notiz zu schreiben `chunk_size: 500`, schreiben wir nur `type: essay`.
|
||||
* Wie groß ein Chunk für ein Essay ist, definieren wir in der Konfiguration (`types.yaml`).
|
||||
|
||||
### 7.2 Was bedeutet das für dich?
|
||||
* Du kannst dich auf den Inhalt konzentrieren.
|
||||
* Wenn wir in Zukunft basierend auf Feedback lernen, dass "Projekte" noch wichtiger sind, ändern wir **eine Zeile** in der Konfiguration, und das gesamte System passt sich beim nächsten Import an.
|
||||
@@ -0,0 +1,105 @@
|
||||
# Mindnet v2.4 – Overview & Einstieg
|
||||
**Datei:** `docs/mindnet_overview_v2.6.md`
|
||||
**Stand:** 2025-12-12
|
||||
**Status:** **FINAL** (Inkl. Smart Edges, Traffic Control & Healing UI)
|
||||
**Version:** 2.6.0
|
||||
|
||||
---
|
||||
|
||||
## 1. Einführung: Was ist Mindnet?
|
||||
|
||||
**Mindnet** ist ein persönliches, lokales KI-Gedächtnis. Es ist der Versuch, einen **Digitalen Zwilling** deines Wissens und deiner Persönlichkeit zu erschaffen.
|
||||
|
||||
Anders als herkömmliche Notiz-Apps (wie Obsidian oder Evernote), die Texte nur passiv speichern, ist Mindnet ein **aktives System**:
|
||||
* Es **versteht** Zusammenhänge über einen Wissensgraphen.
|
||||
* Es **begründet** Antworten ("Warum ist das so?").
|
||||
* Es **unterstützt** beim Schreiben: Es schlägt automatisch Verbindungen zu bestehendem Wissen vor ("Active Intelligence").
|
||||
* Es **antwortet** situativ angepasst: Mal als Strategieberater, mal als empathischer Spiegel, und neu: **als Interviewer, der hilft, Wissen zu erfassen.**
|
||||
|
||||
### Die Vision
|
||||
> „Ein System, das nicht nur speichert, was ich weiß, sondern auch wie ich denke, fühle und arbeite.“
|
||||
|
||||
---
|
||||
|
||||
## 2. Die drei Ebenen des Systems
|
||||
|
||||
Mindnet arbeitet auf drei Schichten, die aufeinander aufbauen:
|
||||
|
||||
### Ebene 1: Content (Das Gedächtnis)
|
||||
* **Quelle:** Dein lokaler Obsidian-Vault (Markdown).
|
||||
* **Funktion:** Speicherung von Fakten, Projekten und Logs.
|
||||
* **Technik:** Async Import-Pipeline, Smart Chunking (LLM-gestützte Kantenzuweisung), Vektor-Datenbank (Qdrant).
|
||||
* **Status:** 🟢 Live (WP01–WP03, WP11, WP15).
|
||||
|
||||
### Ebene 2: Semantik (Das Verstehen)
|
||||
* **Funktion:** Verknüpfung von isolierten Notizen zu einem Netzwerk.
|
||||
* **Logik:** "Projekt A *hängt ab von* Entscheidung B".
|
||||
* **Technik:** Hybrider Retriever (Graph + Nomic Embeddings), Explanation Engine.
|
||||
* **Status:** 🟢 Live (WP04, WP11, WP15).
|
||||
|
||||
### Ebene 3: Identität & Interaktion (Die Persönlichkeit)
|
||||
* **Funktion:** Interaktion, Bewertung und Co-Creation.
|
||||
* **Logik:**
|
||||
* "Ich empfehle Lösung X, weil sie unserem Wert 'Datensparsamkeit' entspricht."
|
||||
* "Ich sehe, du willst ein Projekt starten. Lass uns die Eckdaten erfassen."
|
||||
* **Technik:**
|
||||
* **Hybrid Router v5:** Erkennt Absichten (Frage vs. Befehl) und unterscheidet Objekte (`types.yaml`) von Handlungen (`decision_engine.yaml`).
|
||||
* **Traffic Control:** Priorisiert Chat-Anfragen ("Realtime") vor Hintergrund-Jobs ("Background").
|
||||
* **One-Shot Extraction:** Generiert Entwürfe für neue Notizen.
|
||||
* **Active Intelligence:** Schlägt Links während des Schreibens vor.
|
||||
* **Status:** 🟢 Live (WP05–WP07, WP10, WP15).
|
||||
|
||||
---
|
||||
|
||||
## 3. End-to-End Architektur
|
||||
|
||||
Der Datenfluss in Mindnet ist zyklisch ("Data Flywheel"):
|
||||
|
||||
1. **Input:** Du schreibst Notizen in Obsidian **ODER** lässt sie von Mindnet im Chat entwerfen.
|
||||
2. **Intelligence (Live):** Während du schreibst, analysiert Mindnet den Text und schlägt Verknüpfungen vor (Sliding Window Analyse).
|
||||
3. **Ingest:** Ein asynchrones Python-Skript importiert und zerlegt die Daten.
|
||||
* **Neu (Smart Edges):** Ein LLM analysiert jeden Textabschnitt und entscheidet, welche Kanten relevant sind.
|
||||
4. **Intent Recognition:** Der Router analysiert deine Eingabe: Ist es eine Frage (RAG) oder ein Befehl (Interview)?
|
||||
5. **Retrieval / Action:**
|
||||
* Bei Fragen: Das System sucht Inhalte passend zum Intent.
|
||||
* Bei Interviews: Das System wählt das passende Schema (z.B. Projekt-Vorlage).
|
||||
6. **Generation:** Ein lokales LLM (Ollama) formuliert die Antwort oder den Markdown-Draft.
|
||||
7. **Feedback:** Du bewertest die Antwort. Das System lernt (langfristig) daraus.
|
||||
|
||||
**Tech-Stack:**
|
||||
* **Backend:** Python 3.10+, FastAPI (Async).
|
||||
* **Datenbank:** Qdrant (Vektor & Graph, 768 Dim).
|
||||
* **KI:** Ollama (Phi-3 Mini für Chat, Nomic für Embeddings) – 100% lokal.
|
||||
* **Traffic Control:** Semaphore-Logik zur Lastverteilung zwischen Chat und Import.
|
||||
* **Frontend:** Streamlit Web-UI (v2.5) mit Healing Parser.
|
||||
|
||||
---
|
||||
|
||||
## 4. Dokumentations-Wegweiser
|
||||
|
||||
Wo findest du was?
|
||||
|
||||
| Wenn du... | ...lies dieses Dokument |
|
||||
| :--- | :--- |
|
||||
| **...wissen willst, wie man Notizen schreibt.** | `mindnet_knowledge_design_manual_v2.6.md` |
|
||||
| **...das System installieren oder betreiben musst.** | `mindnet_admin_guide_v2.6.md` |
|
||||
| **...am Python-Code entwickeln willst.** | `mindnet_developer_guide_v2.6.md` |
|
||||
| **...die Pipeline (Import -> RAG) verstehen willst.** | `mindnet_pipeline_playbook_v2.6.md` |
|
||||
| **...die genaue JSON-Struktur oder APIs suchst.** | `mindnet_technical_architecture_v2.6.md` |
|
||||
| **...verstehen willst, was fachlich passiert.** | `mindnet_functional_architecture_v2.6.md` |
|
||||
| **...den aktuellen Projektstatus suchst.** | `mindnet_appendices_v2.6.md` |
|
||||
|
||||
---
|
||||
|
||||
## 5. Rollen im System
|
||||
|
||||
* **Mindmaster (User/Owner):** Du. Du erstellst Inhalte, stellst Fragen und gibst Feedback. Du definierst die Werte (`type: value`).
|
||||
* **Mindnet (Der Agent):** Der digitale Zwilling. Er agiert als pragmatischer, transparenter Assistent und Analyst.
|
||||
* **Administrator:** Verantwortlich für Docker-Container, Backups und LLM-Ressourcen.
|
||||
|
||||
---
|
||||
|
||||
## 6. Aktueller Fokus
|
||||
|
||||
Wir haben die **Smart Edge Allocation (WP15)** und die **System-Stabilisierung (Traffic Control)** erfolgreich abgeschlossen.
|
||||
Das System kann nun aktiv helfen, Wissen zu strukturieren, ohne dabei unter Last zusammenzubrechen. Der Fokus verschiebt sich nun in Richtung **Conversational Memory (WP17)** und **MCP Integration (WP13)**.
|
||||
@@ -0,0 +1,238 @@
|
||||
# Mindnet v2.4 – Admin Guide
|
||||
**Datei:** `docs/mindnet_admin_guide_v2.6.md`
|
||||
**Stand:** 2025-12-12
|
||||
**Status:** **FINAL** (Inkl. Traffic Control & Smart Edge Config)
|
||||
**Quellen:** `Handbuch.md`, `mindnet_developer_guide_v2.6.md`.
|
||||
|
||||
> Dieses Handbuch richtet sich an **Administratoren**. Es beschreibt Installation, Konfiguration, Backup-Strategien, Monitoring und den sicheren Betrieb der Mindnet-Instanz (API + UI + DB).
|
||||
|
||||
---
|
||||
|
||||
## 1. Zielgruppe & Scope
|
||||
|
||||
Mindnet ist als **Multi-Service-Architektur** konzipiert, die lokal oder auf einem privaten Server läuft.
|
||||
Wir unterscheiden strikt zwischen:
|
||||
* **Production:** Backend (8001) + Frontend (8501). Stabiler `main` Branch.
|
||||
* **Development:** Backend (8002) + Frontend (8502). Experimentelle Feature-Branches.
|
||||
|
||||
---
|
||||
|
||||
## 2. Initial Setup & Installation
|
||||
|
||||
### 2.1 Systemvoraussetzungen
|
||||
* **OS:** Linux (Ubuntu 22.04+ empfohlen) oder macOS.
|
||||
* **Runtime:** Python 3.10+, Docker (für Qdrant), Ollama (für LLM).
|
||||
* **Hardware:**
|
||||
* CPU: 4+ Cores empfohlen (für Async Import & Inference).
|
||||
* RAM: Min. 8GB empfohlen (4GB System + 4GB für Phi-3/Qdrant).
|
||||
* Disk: SSD empfohlen für Qdrant-Performance.
|
||||
|
||||
### 2.2 Installation (Code)
|
||||
|
||||
# 1. Repository klonen
|
||||
git clone <repo-url> /home/llmadmin/mindnet
|
||||
cd /home/llmadmin/mindnet
|
||||
|
||||
# 2. Umgebung einrichten
|
||||
python3 -m venv .venv
|
||||
source .venv/bin/activate
|
||||
|
||||
# 3. Dependencies installieren (inkl. Streamlit, HTTPX)
|
||||
pip install -r requirements.txt
|
||||
|
||||
# 4. Verzeichnisse anlegen
|
||||
mkdir -p logs qdrant_storage data/logs vault
|
||||
|
||||
### 2.3 Qdrant Setup (Docker)
|
||||
Wir nutzen Qdrant als Vektor-Datenbank. Persistenz ist wichtig.
|
||||
|
||||
docker run -d \
|
||||
--name mindnet_qdrant \
|
||||
--restart always \
|
||||
-p 6333:6333 \
|
||||
-v $(pwd)/qdrant_storage:/qdrant/storage \
|
||||
qdrant/qdrant
|
||||
|
||||
### 2.4 Ollama Setup (LLM & Embeddings)
|
||||
Mindnet benötigt einen lokalen LLM-Server für Chat UND Embeddings.
|
||||
**WICHTIG (Update v2.4):** Es muss zwingend `nomic-embed-text` installiert sein, sonst startet der Import nicht.
|
||||
|
||||
# 1. Installieren (Linux Script)
|
||||
curl -fsSL https://ollama.com/install.sh | sh
|
||||
|
||||
# 2. Modelle laden
|
||||
ollama pull phi3:mini # Für Chat/Reasoning
|
||||
ollama pull nomic-embed-text # Für Vektoren (768 Dim)
|
||||
|
||||
# 3. Testen
|
||||
curl http://localhost:11434/api/generate -d '{"model": "phi3:mini", "prompt":"Hi"}'
|
||||
|
||||
### 2.5 Konfiguration (ENV)
|
||||
Erstelle eine `.env` Datei im Root-Verzeichnis. Achte besonders auf `VECTOR_DIM` und das neue `MINDNET_LLM_BACKGROUND_LIMIT`.
|
||||
|
||||
# Server Config
|
||||
UVICORN_HOST=0.0.0.0
|
||||
|
||||
# Qdrant Verbindung
|
||||
QDRANT_URL="http://localhost:6333"
|
||||
|
||||
# Mindnet Core Settings
|
||||
COLLECTION_PREFIX="mindnet"
|
||||
MINDNET_TYPES_FILE="./config/types.yaml"
|
||||
MINDNET_VAULT_ROOT="./vault"
|
||||
|
||||
# WICHTIG: Dimension auf 768 setzen (für Nomic)
|
||||
VECTOR_DIM=768
|
||||
|
||||
# AI Modelle (Ollama)
|
||||
MINDNET_OLLAMA_URL="http://127.0.0.1:11434"
|
||||
MINDNET_LLM_MODEL="phi3:mini"
|
||||
MINDNET_EMBEDDING_MODEL="nomic-embed-text"
|
||||
|
||||
# Timeouts (Erhöht für Async/Nomic/Smart Edges)
|
||||
MINDNET_LLM_TIMEOUT=300.0
|
||||
MINDNET_API_TIMEOUT=300.0 # Wichtig: Frontend muss warten können
|
||||
|
||||
# Traffic Control (Neu in v2.6)
|
||||
# Begrenzt parallele LLM-Calls im Import, um Chat stabil zu halten.
|
||||
MINDNET_LLM_BACKGROUND_LIMIT=2
|
||||
|
||||
# Configs
|
||||
MINDNET_PROMPTS_PATH="./config/prompts.yaml"
|
||||
MINDNET_DECISION_CONFIG="./config/decision_engine.yaml"
|
||||
|
||||
### 2.6 Deployment via Systemd (Backend & Frontend)
|
||||
|
||||
Mindnet benötigt zwei Services pro Umgebung: API (Uvicorn) und UI (Streamlit).
|
||||
|
||||
**Production Backend (`/etc/systemd/system/mindnet-prod.service`):**
|
||||
|
||||
[Unit]
|
||||
Description=Mindnet API Prod (8001)
|
||||
After=network.target
|
||||
|
||||
[Service]
|
||||
User=llmadmin
|
||||
Group=llmadmin
|
||||
WorkingDirectory=/home/llmadmin/mindnet
|
||||
# Async Server Start
|
||||
ExecStart=/home/llmadmin/mindnet/.venv/bin/uvicorn app.main:app --host 0.0.0.0 --port 8001 --env-file .env
|
||||
Restart=always
|
||||
RestartSec=5
|
||||
|
||||
[Install]
|
||||
WantedBy=multi-user.target
|
||||
|
||||
**Production Frontend (`/etc/systemd/system/mindnet-ui-prod.service`):**
|
||||
|
||||
[Unit]
|
||||
Description=Mindnet UI Prod (8501)
|
||||
After=mindnet-prod.service
|
||||
|
||||
[Service]
|
||||
User=llmadmin
|
||||
Group=llmadmin
|
||||
WorkingDirectory=/home/llmadmin/mindnet
|
||||
|
||||
# Environment Variables
|
||||
Environment="MINDNET_API_URL=http://localhost:8001"
|
||||
Environment="MINDNET_API_TIMEOUT=300"
|
||||
Environment="STREAMLIT_SERVER_PORT=8501"
|
||||
Environment="STREAMLIT_SERVER_ADDRESS=0.0.0.0"
|
||||
Environment="STREAMLIT_SERVER_HEADLESS=true"
|
||||
|
||||
ExecStart=/home/llmadmin/mindnet/.venv/bin/streamlit run app/frontend/ui.py
|
||||
Restart=always
|
||||
RestartSec=5
|
||||
|
||||
[Install]
|
||||
WantedBy=multi-user.target
|
||||
|
||||
**Firewall (UFW):**
|
||||
Öffne die Ports für den Zugriff:
|
||||
|
||||
sudo ufw allow 8501/tcp # Prod UI
|
||||
sudo ufw allow 8502/tcp # Dev UI (falls gewünscht)
|
||||
|
||||
---
|
||||
|
||||
## 3. Betrieb im Alltag
|
||||
|
||||
### 3.1 Regelmäßige Importe
|
||||
Der Vault-Zustand sollte regelmäßig (z.B. stündlich per Cronjob) nach Qdrant synchronisiert werden. Das Skript nutzt nun **AsyncIO**, **Smart Edges** und **Traffic Control**.
|
||||
|
||||
**Cronjob-Beispiel (stündlich):**
|
||||
|
||||
0 * * * * cd /home/llmadmin/mindnet && .venv/bin/python3 -m scripts.import_markdown --vault ./vault --prefix "mindnet" --apply --purge-before-upsert --sync-deletes >> ./logs/import.log 2>&1
|
||||
|
||||
**Hinweis zu Smart Edges:**
|
||||
Der Import dauert nun länger (ca. 2-3 Min pro Datei), da das LLM intensiv genutzt wird. Dank `MINDNET_LLM_BACKGROUND_LIMIT=2` bleibt der Server dabei aber für den Chat responsive.
|
||||
|
||||
### 3.2 Health-Checks
|
||||
Prüfe regelmäßig, ob alle Komponenten laufen.
|
||||
|
||||
sudo systemctl status mindnet-prod
|
||||
sudo systemctl status mindnet-ui-prod
|
||||
sudo systemctl status ollama
|
||||
|
||||
### 3.3 Logs & Monitoring
|
||||
* **Backend Fehler:** `journalctl -u mindnet-prod -f`
|
||||
* **Frontend Fehler:** `journalctl -u mindnet-ui-prod -f`
|
||||
* **LLM Fehler:** `journalctl -u ollama -f`
|
||||
* **Fachliche Logs:** `data/logs/search_history.jsonl`
|
||||
|
||||
---
|
||||
|
||||
## 4. Troubleshooting (Update v2.6)
|
||||
|
||||
### "Vector dimension error: expected dim: 768, got 384"
|
||||
* **Ursache:** Du versuchst, in eine alte Qdrant-Collection (mit 384 Dim aus v2.2) neue Embeddings (mit 768 Dim von Nomic) zu schreiben.
|
||||
* **Lösung:** Full Reset erforderlich.
|
||||
1. `python -m scripts.reset_qdrant --mode wipe --prefix mindnet --yes` (Löscht DB).
|
||||
2. `python -m scripts.import_markdown ...` (Baut neu auf).
|
||||
|
||||
### "500 Internal Server Error" beim Speichern/Chatten
|
||||
* **Ursache:** Oft Timeout bei Ollama, wenn `nomic-embed-text` noch nicht im RAM geladen ist ("Cold Start") oder der Import die GPU blockiert.
|
||||
* **Lösung:**
|
||||
1. `MINDNET_LLM_TIMEOUT` in `.env` auf `300.0` setzen.
|
||||
2. `MINDNET_LLM_BACKGROUND_LIMIT` auf `1` reduzieren (falls Hardware schwach).
|
||||
|
||||
### Import ist sehr langsam
|
||||
* **Ursache:** Smart Edges sind aktiv (`types.yaml`) und analysieren jeden Chunk.
|
||||
* **Lösung:**
|
||||
* Akzeptieren (für bessere Qualität).
|
||||
* Oder für Massen-Initial-Import in `types.yaml` temporär `enable_smart_edge_allocation: false` setzen.
|
||||
|
||||
---
|
||||
|
||||
## 5. Backup & Restore
|
||||
|
||||
Datensicherheit ruht auf drei Säulen: Vault (Source), Qdrant (Index), JSONL-Logs (Lern-Daten).
|
||||
|
||||
### 5.1 Vault-Backup (Priorität 1)
|
||||
Der Markdown-Vault ist die **Single Source of Truth**.
|
||||
|
||||
### 5.2 Qdrant-Snapshots (Priorität 2)
|
||||
Für schnelle Wiederherstellung des Suchindex.
|
||||
|
||||
docker stop mindnet_qdrant
|
||||
tar -czf qdrant_backup_$(date +%F).tar.gz ./qdrant_storage
|
||||
docker start mindnet_qdrant
|
||||
|
||||
### 5.3 Notfall-Wiederherstellung (Rebuild)
|
||||
Wenn die Datenbank korrupt ist oder Modelle gewechselt werden:
|
||||
|
||||
# 1. DB komplett leeren (Wipe)
|
||||
python3 -m scripts.reset_qdrant --mode wipe --prefix "mindnet" --yes
|
||||
# 2. Alles neu importieren (Force re-calculates Hashes)
|
||||
python3 -m scripts.import_markdown --vault ./vault --prefix "mindnet" --apply --force
|
||||
|
||||
---
|
||||
|
||||
## 6. Governance & Sicherheit
|
||||
|
||||
### 6.1 Zugriffsschutz
|
||||
Mindnet hat aktuell **keine integrierte Authentifizierung**.
|
||||
* **Frontend:** Streamlit auf Port 8501 ist offen. Nutze Nginx Basic Auth oder VPN.
|
||||
* **API:** Sollte nicht direkt im öffentlichen Netz stehen.
|
||||
* **Qdrant:** Auf `127.0.0.1` beschränken.
|
||||
@@ -0,0 +1,174 @@
|
||||
# Mindnet v2.4 – Appendices & Referenzen
|
||||
**Datei:** `docs/mindnet_appendices_v2.6.md`
|
||||
**Stand:** 2025-12-12
|
||||
**Status:** **FINAL** (Integrierter Stand WP01–WP15)
|
||||
**Quellen:** `TYPE_REGISTRY_MANUAL.md`, `chunking_strategy.md`, `mindnet_technical_architecture.md`, `Handbuch.md`.
|
||||
|
||||
> Dieses Dokument bündelt Tabellen, Schemata und technische Referenzen, die in den Prozess-Dokumenten (Playbook, Guides) den Lesefluss stören würden.
|
||||
|
||||
---
|
||||
|
||||
## Anhang A: Typ-Registry Referenz (Default-Werte)
|
||||
|
||||
Diese Tabelle zeigt die Standard-Konfiguration der `types.yaml` (Stand v2.6 / Config v1.6).
|
||||
|
||||
| Typ (`type`) | Chunk Profile | Retriever Weight | Smart Edges? | Beschreibung |
|
||||
| :--- | :--- | :--- | :--- | :--- |
|
||||
| **concept** | `sliding_smart_edges` | 0.60 | **Ja** | Abstrakte Begriffe, Theorien. |
|
||||
| **project** | `sliding_smart_edges` | 0.97 | **Ja** | Aktive Vorhaben. Hohe Priorität. |
|
||||
| **decision** | `structured_smart_edges` | 1.00 | **Ja** | Entscheidungen (ADRs). Höchste Prio. |
|
||||
| **experience** | `sliding_smart_edges` | 0.90 | **Ja** | Persönliche Learnings. Intensiv analysiert. |
|
||||
| **journal** | `sliding_standard` | 0.80 | Nein | Zeitgebundene Logs. Performance-optimiert. |
|
||||
| **person** | `sliding_standard` | 0.50 | Nein | Personen-Profile. |
|
||||
| **source** | `sliding_standard` | 0.50 | Nein | Externe Quellen (Bücher, PDFs). |
|
||||
| **event** | `sliding_standard` | 0.60 | Nein | Meetings, Konferenzen. |
|
||||
| **value** | `structured_smart_edges` | 1.00 | **Ja** | Persönliche Werte/Prinzipien. |
|
||||
| **principle** | `structured_smart_edges` | 1.00 | **Ja** | Handlungsleitlinien. |
|
||||
| **profile** | `structured_smart_edges` | 0.80 | **Ja** | Eigene Identitäts-Beschreibungen. |
|
||||
| **goal** | `sliding_standard` | 0.95 | Nein | Strategische Ziele. |
|
||||
| **belief** | `sliding_short` | 0.90 | Nein | Glaubenssätze. |
|
||||
| **risk** | `sliding_short` | 0.90 | Nein | Risiken & Gefahren. |
|
||||
| **task** | `sliding_short` | 0.70 | Nein | Aufgaben. |
|
||||
| **glossary** | `sliding_short` | 0.50 | Nein | Begriffsdefinitionen. |
|
||||
| **default** | `sliding_standard` | 1.00 | Nein | Fallback, wenn Typ unbekannt. |
|
||||
|
||||
---
|
||||
|
||||
## Anhang B: Edge-Typen & Semantik
|
||||
|
||||
Referenz aller implementierten Kantenarten (`kind`).
|
||||
|
||||
| Kind | Herkunft (Primär) | Symmetrisch? | Bedeutung & Nutzung |
|
||||
| :--- | :--- | :--- | :--- |
|
||||
| `references` | Wikilink `[[...]]` | Nein | Standard-Verweis. "Erwähnt X". |
|
||||
| `belongs_to` | Struktur (Auto) | Nein | Verknüpft Chunk mit seiner Note. |
|
||||
| `next` / `prev` | Struktur (Auto) | Ja (Logisch) | Definiert Lesereihenfolge der Chunks. |
|
||||
| `depends_on` | Inline / Default | Nein | Harte Abhängigkeit. "Braucht X um zu funktionieren". |
|
||||
| `related_to` | Callout / Default | Ja (Oft) | Thematische Nähe. "Siehe auch X". |
|
||||
| `similar_to` | Inline | Ja | Inhaltliche Ähnlichkeit. "Ist wie X". |
|
||||
| `caused_by` | Inline | Nein | Kausalität. "X ist der Grund für Y". |
|
||||
| `solves` | Inline | Nein | Lösung. "Tool X löst Problem Y". |
|
||||
| `blocks` | Inline | Nein | **NEU:** Blockade. "Risiko X blockiert Projekt Y". |
|
||||
| `derived_from` | Matrix / Default | Nein | Herkunft. "Erkenntnis stammt aus Prinzip X". |
|
||||
| `based_on` | Matrix | Nein | Fundament. "Erfahrung basiert auf Wert Y". |
|
||||
| `uses` | Matrix | Nein | Nutzung. "Projekt nutzt Konzept Z". |
|
||||
|
||||
---
|
||||
|
||||
## Anhang C: Datenmodelle (JSON Payloads)
|
||||
|
||||
Diese sind die Felder, die effektiv in Qdrant gespeichert werden.
|
||||
|
||||
### C.1 Note Payload (`mindnet_notes`)
|
||||
|
||||
{
|
||||
"note_id": "string (keyword)", // UUIDv5 oder Slug
|
||||
"title": "string (text)", // Titel aus Frontmatter
|
||||
"type": "string (keyword)", // Typ (z.B. 'project')
|
||||
"retriever_weight": "float", // Numerische Wichtigkeit (0.0-1.0)
|
||||
"chunk_profile": "string", // Genutztes Profil (z.B. 'sliding_smart_edges')
|
||||
"edge_defaults": ["string"], // Liste der aktiven Default-Kanten
|
||||
"tags": ["string"], // Liste von Tags
|
||||
"created": "string (iso-date)", // Erstellungsdatum
|
||||
"updated": "integer", // Timestamp
|
||||
"fulltext": "string (no-index)" // Gesamter Text (für Recovery)
|
||||
}
|
||||
|
||||
### C.2 Chunk Payload (`mindnet_chunks`)
|
||||
|
||||
{
|
||||
"chunk_id": "string (keyword)", // Format: {note_id}#c{index}
|
||||
"note_id": "string (keyword)", // FK zur Note
|
||||
"type": "string (keyword)", // Typ-Kopie aus Note
|
||||
"text": "string (text)", // Reintext für Anzeige (ohne Overlap)
|
||||
"window": "string (text)", // Text + Overlap (für Embedding)
|
||||
"ord": "integer", // Laufende Nummer (1..N)
|
||||
"retriever_weight": "float", // Kopie aus Note (für Query-Speed)
|
||||
"chunk_profile": "string", // Vererbt von Note
|
||||
"neighbors_prev": ["string"], // ID des Vorgängers
|
||||
"neighbors_next": ["string"] // ID des Nachfolgers
|
||||
}
|
||||
|
||||
### C.3 Edge Payload (`mindnet_edges`)
|
||||
|
||||
{
|
||||
"edge_id": "string (keyword)", // Deterministischer Hash
|
||||
"source_id": "string (keyword)", // Chunk-ID (Start)
|
||||
"target_id": "string (keyword)", // Chunk-ID oder Note-Titel (Ziel)
|
||||
"kind": "string (keyword)", // z.B. 'depends_on'
|
||||
"scope": "string (keyword)", // Immer 'chunk'
|
||||
"rule_id": "string (keyword)", // Traceability: 'inline:rel', 'explicit:wikilink'
|
||||
"confidence": "float", // 0.0 - 1.0
|
||||
"note_id": "string (keyword)", // Owner Note ID
|
||||
"provenance": "keyword" // 'explicit', 'rule', 'smart' (NEU)
|
||||
}
|
||||
|
||||
---
|
||||
|
||||
## Anhang D: Environment Variablen
|
||||
|
||||
Diese Variablen steuern das Verhalten der Skripte und Container.
|
||||
|
||||
| Variable | Default | Beschreibung |
|
||||
| :--- | :--- | :--- |
|
||||
| `QDRANT_URL` | `http://localhost:6333` | URL zur Vektor-DB. |
|
||||
| `QDRANT_API_KEY` | *(leer)* | API-Key für Absicherung (optional). |
|
||||
| `COLLECTION_PREFIX` | `mindnet` | Namensraum für Collections (`{prefix}_notes` etc). |
|
||||
| `VECTOR_DIM` | `768` | **NEU:** Dimension für Embeddings (für Nomic). |
|
||||
| `MINDNET_TYPES_FILE` | `config/types.yaml` | Pfad zur Typ-Registry. |
|
||||
| `MINDNET_RETRIEVER_CONFIG`| `config/retriever.yaml`| Pfad zur Scoring-Konfiguration. |
|
||||
| `MINDNET_PROMPTS_PATH` | `config/prompts.yaml` | Pfad zu LLM-Prompts (Neu in v2.2). |
|
||||
| `MINDNET_DECISION_CONFIG` | `config/decision_engine.yaml` | Router & Interview Config (Neu in v2.3). |
|
||||
| `MINDNET_LLM_MODEL` | `phi3:mini` | Name des Chat-Modells. |
|
||||
| `MINDNET_EMBEDDING_MODEL` | `nomic-embed-text` | **NEU:** Name des Vektor-Modells. |
|
||||
| `MINDNET_OLLAMA_URL` | `http://127.0.0.1:11434`| URL zum LLM-Server (Neu in v2.2). |
|
||||
| `MINDNET_LLM_TIMEOUT` | `300.0` | Timeout für Ollama (Erhöht für CPU-Inference). |
|
||||
| `MINDNET_API_TIMEOUT` | `300.0` | **NEU:** Frontend Timeout (Erhöht für Smart Edges). |
|
||||
| `MINDNET_LLM_BACKGROUND_LIMIT`| `2` | **NEU:** Max. parallele Import-Tasks (Traffic Control). |
|
||||
| `MINDNET_VAULT_ROOT` | `./vault` | **NEU:** Pfad für Write-Back Operationen. |
|
||||
| `MINDNET_HASH_COMPARE` | `Body` | Vergleichsmodus für Import (`Body`, `Frontmatter`, `Full`). |
|
||||
| `MINDNET_HASH_SOURCE` | `parsed` | Quelle für Hash (`parsed`, `raw`, `file`). |
|
||||
|
||||
---
|
||||
|
||||
## Anhang E: Glossar
|
||||
|
||||
* **Active Intelligence:** Feature, das während des Schreibens Links vorschlägt.
|
||||
* **Async Ingestion:** Non-blocking Import-Prozess zur Vermeidung von Timeouts.
|
||||
* **Decision Engine:** Komponente, die den Intent prüft und Strategien wählt (WP06).
|
||||
* **Draft Editor:** Web-Komponente zur Bearbeitung generierter Notizen (WP10a).
|
||||
* **Explanation Layer:** Komponente, die Scores und Graphen als Begründung liefert.
|
||||
* **Healing Parser:** UI-Funktion, die defektes YAML von LLMs repariert (v2.5).
|
||||
* **Hybrid Router:** Kombination aus Keyword-Matching und LLM-Klassifizierung für Intents.
|
||||
* **Matrix Logic:** Regelwerk, das Kanten-Typen basierend auf Quell- und Ziel-Typ bestimmt.
|
||||
* **Nomic:** Das neue, hochpräzise Embedding-Modell (768 Dim).
|
||||
* **One-Shot Extractor:** LLM-Strategie zur sofortigen Generierung von Drafts ohne Rückfragen (WP07).
|
||||
* **RAG (Retrieval Augmented Generation):** Kombination aus Suche und Text-Generierung.
|
||||
* **Resurrection Pattern:** UI-Technik, um Eingaben bei Tab-Wechseln zu erhalten.
|
||||
* **Smart Edge Allocation:** LLM-basierte Prüfung, ob ein Link zu einem Chunk passt (WP15).
|
||||
* **Traffic Control:** Priorisierung von Chat-Anfragen ("Realtime") vor Import-Last ("Background") im LLM-Service (v2.6).
|
||||
|
||||
---
|
||||
|
||||
## Anhang F: Workpackage Status (v2.6.0)
|
||||
|
||||
Aktueller Implementierungsstand der Module.
|
||||
|
||||
| WP | Titel | Status | Anmerkung |
|
||||
| :--- | :--- | :--- | :--- |
|
||||
| **WP01** | Knowledge Design | 🟢 Live | Typen, Frontmatter definiert. |
|
||||
| **WP02** | Chunking Strategy | 🟢 Live | Profilbasiertes Chunking aktiv. |
|
||||
| **WP03** | Edge Logic / Import | 🟢 Live | Neue Importer-Pipeline mit Provenance. |
|
||||
| **WP04a**| Retriever Scoring | 🟢 Live | Hybrider Score (Semantik + Graph). |
|
||||
| **WP04b**| Explanation Layer | 🟢 Live | API liefert Reasons & Breakdown. |
|
||||
| **WP04c**| Feedback Loop | 🟢 Live | Logging (JSONL) & Traceability aktiv. |
|
||||
| **WP05** | Persönlichkeit / Chat | 🟢 Live | RAG-Integration mit Context Enrichment. |
|
||||
| **WP06** | Decision Engine | 🟢 Live | Hybrid Router v5, Strategic Retrieval. |
|
||||
| **WP07** | Interview Assistent | 🟢 Live | **One-Shot Extractor & Schemas aktiv.** |
|
||||
| **WP08** | Self-Tuning | 🔴 Geplant | Auto-Adjustment der Gewichte. |
|
||||
| **WP10** | Chat Interface | 🟢 Live | Web-Interface (Streamlit). |
|
||||
| **WP10a**| Draft Editor | 🟢 Live | **Interaktives UI & Healing Parser.** |
|
||||
| **WP11** | Backend Intelligence | 🟢 Live | **Async Ingestion, Nomic, Matrix.** |
|
||||
| **WP15** | Smart Edge Allocation | 🟢 Live | **LLM-Filter & Traffic Control.** |
|
||||
| **WP16** | Auto-Discovery | 🟡 Geplant | UX & Retrieval Tuning. |
|
||||
| **WP17** | Conversational Memory | 🟡 Geplant | Dialog-Gedächtnis. |
|
||||
@@ -0,0 +1,220 @@
|
||||
# Mindnet v2.4 – Entwickler-Workflow
|
||||
**Datei:** `docs/DEV_WORKFLOW.md`
|
||||
**Stand:** 2025-12-12 (Aktualisiert: v2.6 mit Traffic Control)
|
||||
|
||||
Dieses Handbuch beschreibt den Entwicklungszyklus zwischen **Windows PC** (IDE), **Raspberry Pi** (Gitea) und **Beelink** (Runtime/Server).
|
||||
|
||||
---
|
||||
|
||||
## 1. Die Architektur
|
||||
|
||||
* **Windows 11 (VS Code):** Hier schreibst du Code. **Nie** direkt auf `main` arbeiten!
|
||||
* **Raspberry Pi (Gitea):** Der Tresor. Speichert den Code und verwaltet Versionen.
|
||||
* **Beelink (Runtime):** Hier läuft die Software. Wir nutzen **Systemd-Services**:
|
||||
* **PROD:**
|
||||
* API: `mindnet-prod` (Port 8001). Ordner: `~/mindnet`.
|
||||
* UI: `mindnet-ui-prod` (Port 8501).
|
||||
* **DEV:**
|
||||
* API: `mindnet-dev` (Port 8002). Ordner: `~/mindnet_dev`.
|
||||
* UI: `mindnet-ui-dev` (Port 8502).
|
||||
|
||||
---
|
||||
|
||||
## 2. Der Zyklus: Von der Idee zum Release
|
||||
|
||||
### Phase 1: Entwicklung (Windows / VS Code)
|
||||
|
||||
Hier erstellst du die neue Funktion in einer sicheren Umgebung.
|
||||
|
||||
1. **Basis aktualisieren (WICHTIG!):**
|
||||
Bevor du startest, muss dein lokales `main` auf dem Stand des Servers sein.
|
||||
* Klicke unten links auf den aktuellen Branch und wähle **`main`**.
|
||||
* Klicke links im Menü "Source Control" auf die **drei Punkte (...)** -> **Pull** (oder das Synchronisieren-Symbol).
|
||||
* *Erst jetzt hast du alle Dateien!*
|
||||
|
||||
2. **Branch erstellen:**
|
||||
* Klicke wieder unten links auf `main`.
|
||||
* Wähle `+ Create new branch...`.
|
||||
* Gib den Namen ein: `feature/was-ich-tue` (z.B. `feature/wp15-traffic-control`).
|
||||
* Drücke **Enter**.
|
||||
|
||||
3. **Sicherheits-Check:**
|
||||
* Steht unten links jetzt dein Feature-Branch? **Nur dann darfst du Code ändern!**
|
||||
|
||||
4. **Coden:**
|
||||
* Nimm deine Änderungen vor (z.B. neue Schemas in `types.yaml` oder Async-Logik in `ingestion.py`).
|
||||
|
||||
5. **Sichern & Hochladen:**
|
||||
* **Source Control** Icon (Gabel-Symbol) -> Nachricht eingeben -> **Commit**.
|
||||
* **Publish Branch** (oder "Sync Changes"), um den Branch zum Raspberry Pi (Gitea) zu senden.
|
||||
|
||||
---
|
||||
|
||||
### Phase 2: Testen (Beelink / `mindnet_dev`)
|
||||
|
||||
Hier prüfst du, ob dein neuer Code auf dem echten Server läuft.
|
||||
|
||||
1. **Einloggen:**
|
||||
`ssh user@<BEELINK-IP>`
|
||||
|
||||
2. **In die Werkstatt gehen:**
|
||||
`cd /home/llmadmin/mindnet_dev`
|
||||
|
||||
3. **Code holen:**
|
||||
```bash
|
||||
git fetch
|
||||
# Tipp: 'git branch -r' zeigt alle verfügbaren Branches an
|
||||
git checkout feature/wp15-traffic-control
|
||||
git pull
|
||||
```
|
||||
|
||||
4. **Umgebung vorbereiten (WICHTIG für v2.6):**
|
||||
Prüfe deine `.env` Datei. Sie benötigt jetzt Einträge für die Traffic Control.
|
||||
```bash
|
||||
nano .env
|
||||
```
|
||||
**Ergänze/Prüfe:**
|
||||
```ini
|
||||
# Traffic Control (Neu in v2.6)
|
||||
MINDNET_LLM_BACKGROUND_LIMIT=2 # Max. parallele Import-Tasks
|
||||
MINDNET_API_TIMEOUT=300.0 # Frontend wartet länger
|
||||
MINDNET_EMBEDDING_MODEL="nomic-embed-text"
|
||||
```
|
||||
|
||||
**Dependencies aktualisieren:**
|
||||
```bash
|
||||
source .venv/bin/activate
|
||||
pip install -r requirements.txt
|
||||
ollama pull nomic-embed-text
|
||||
```
|
||||
|
||||
5. **Test-Server aktualisieren (WICHTIG):**
|
||||
Der Code ist da, aber die Prozesse im RAM sind noch alt. Wir müssen die Services neustarten.
|
||||
|
||||
**Option A: Standard (Als Service laufen lassen)**
|
||||
Ideal, wenn du nur testen willst, ob es läuft.
|
||||
```bash
|
||||
# 1. API neustarten (Backend)
|
||||
sudo systemctl restart mindnet-dev
|
||||
# 2. UI neustarten (Frontend)
|
||||
sudo systemctl restart mindnet-ui-dev
|
||||
|
||||
# Logs prüfen (um Fehler zu sehen):
|
||||
journalctl -u mindnet-dev -f
|
||||
```
|
||||
|
||||
**Option B: Manuell Debuggen (Direct Output)**
|
||||
Ideal, wenn du Print-Ausgaben direkt sehen willst oder der Service dauernd crasht.
|
||||
```bash
|
||||
# 1. Services stoppen (wichtig, sonst sind Ports 8002/8502 belegt!)
|
||||
sudo systemctl stop mindnet-dev
|
||||
sudo systemctl stop mindnet-ui-dev
|
||||
|
||||
# 2. Manuell starten (z.B. API)
|
||||
uvicorn app.main:app --host 0.0.0.0 --port 8002 --env-file .env
|
||||
```
|
||||
|
||||
6. **Validieren (Smoke Tests v2.6):**
|
||||
|
||||
* **Test A: Last-Test (Traffic Control):**
|
||||
1. Starte einen Import im Terminal: `python3 -m scripts.import_markdown ...`
|
||||
2. Öffne **gleichzeitig** `http://<IP>:8502` im Browser.
|
||||
3. Stelle eine Chat-Frage ("Was ist Mindnet?").
|
||||
4. **Erwartung:** Der Chat antwortet sofort (Realtime Lane), während der Import im Hintergrund weiterläuft (Background Lane).
|
||||
|
||||
* **Test B: API Check**
|
||||
```bash
|
||||
curl -X POST "http://localhost:8002/ingest/analyze" -d '{"text": "mindnet", "type": "journal"}'
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
### Phase 3: Release (Gitea / Raspberry Pi)
|
||||
|
||||
Wenn der Test auf Port 8002 / 8502 erfolgreich war:
|
||||
|
||||
1. Öffne Gitea im Browser.
|
||||
2. Erstelle einen **Pull Request** (Dein Branch -> `main`).
|
||||
3. **Merge** den Pull Request.
|
||||
|
||||
---
|
||||
|
||||
### Phase 4: Deployment (Beelink / `mindnet`)
|
||||
|
||||
Jetzt bringen wir die Änderung in das Live-System (Port 8001 / 8501).
|
||||
|
||||
1. **Deploy-Agent (Automatisch):**
|
||||
Wenn dein `deploy.yml` aktiv ist, passiert das jetzt von selbst!
|
||||
|
||||
2. **Manuell (Falls nötig):**
|
||||
```bash
|
||||
cd /home/llmadmin/mindnet
|
||||
git pull origin main
|
||||
|
||||
# Dependencies updaten & Modelle checken
|
||||
source .venv/bin/activate
|
||||
pip install -r requirements.txt
|
||||
ollama pull nomic-embed-text
|
||||
|
||||
# .env prüfen (Traffic Control)
|
||||
# Ggf. MINDNET_LLM_BACKGROUND_LIMIT=2 hinzufügen
|
||||
|
||||
# Falls sich die Vektor-Dimension geändert hat (v2.4 Upgrade):
|
||||
# python3 -m scripts.reset_qdrant --mode wipe --prefix "mindnet" --yes
|
||||
# python3 -m scripts.import_markdown --vault ./vault --prefix "mindnet" --apply --force
|
||||
|
||||
# Produktions-Services neustarten
|
||||
sudo systemctl restart mindnet-prod
|
||||
sudo systemctl restart mindnet-ui-prod
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
### Phase 5: Aufräumen (Optional aber empfohlen)
|
||||
|
||||
Damit das Chaos nicht wächst, löschen wir den fertigen Branch.
|
||||
|
||||
1. **Gitea:** Im Pull Request auf "Delete Branch" klicken.
|
||||
2. **Beelink (Dev):**
|
||||
```bash
|
||||
cd ~/mindnet_dev
|
||||
git checkout main
|
||||
git pull
|
||||
git branch -d feature/wp15-traffic-control
|
||||
```
|
||||
3. **VS Code:**
|
||||
* Auf `main` wechseln.
|
||||
* Sync drücken.
|
||||
* `F1` -> `Git: Delete Branch` -> Branch auswählen.
|
||||
|
||||
---
|
||||
|
||||
## 3. Cheat Sheet: Die wichtigsten Befehle
|
||||
|
||||
| Wo? | Befehl | Was tut es? |
|
||||
| :--- | :--- | :--- |
|
||||
| **Beelink** | `sudo systemctl restart mindnet-dev` | **Neustart Dev-Backend (Port 8002).** |
|
||||
| **Beelink** | `sudo systemctl restart mindnet-ui-dev` | **Neustart Dev-Frontend (Port 8002).** |
|
||||
| **Beelink** | `journalctl -u mindnet-dev -f` | **Live-Logs Backend.** |
|
||||
| **Beelink** | `python debug_analysis.py` | **Prüft Aliases & Scores.** |
|
||||
| **Beelink** | `python3 -m scripts.reset_qdrant --mode wipe --prefix "mindnet_dev" --yes` | **Löscht & Repariert DB.** |
|
||||
| **Beelink** | `python3 -m scripts.import_markdown --vault ./vault_master --prefix "mindnet_dev" --apply --force` | **Löscht & Repariert DB.** |
|
||||
| **Beelink** | `source .venv/bin/activate` | **Aktivieren des virtual environments** |
|
||||
|
||||
---
|
||||
|
||||
## 4. Troubleshooting
|
||||
|
||||
**"Read timed out" im Frontend**
|
||||
* **Ursache:** Backend braucht für Smart Edges länger als 60s.
|
||||
* **Lösung:** `MINDNET_API_TIMEOUT=300.0` in `.env` setzen und Services neustarten.
|
||||
|
||||
**Import ist extrem langsam**
|
||||
* **Ursache:** Smart Edges analysieren jeden Chunk mit LLM.
|
||||
* **Lösung:**
|
||||
* Akzeptieren (Qualität vor Speed).
|
||||
* Oder temporär in `config/types.yaml`: `enable_smart_edge_allocation: false`.
|
||||
|
||||
**"UnicodeDecodeError in .env"**
|
||||
* **Ursache:** Umlaute oder Sonderzeichen in der `.env` Datei.
|
||||
* **Lösung:** `.env` bereinigen (nur ASCII nutzen) und sicherstellen, dass sie UTF-8 ohne BOM ist.
|
||||
@@ -0,0 +1,310 @@
|
||||
# Mindnet v2.4 – Developer Guide
|
||||
**Datei:** `docs/mindnet_developer_guide_v2.6.md`
|
||||
**Stand:** 2025-12-12
|
||||
**Status:** **FINAL** (Inkl. Async Core, Nomic, Traffic Control & Frontend State)
|
||||
**Quellen:** `mindnet_technical_architecture.md`, `Handbuch.md`, `DEV_WORKFLOW.md`.
|
||||
|
||||
> **Zielgruppe:** Entwickler:innen.
|
||||
> **Zweck:** Anleitung zum Aufsetzen der Entwicklungsumgebung, Verständnis der Modulstruktur und Durchführung von Tests.
|
||||
|
||||
---
|
||||
- [Mindnet v2.4 – Developer Guide](#mindnet-v24--developer-guide)
|
||||
- [1. Projektstruktur (Post-WP15)](#1-projektstruktur-post-wp15)
|
||||
- [2. Lokales Setup (Development)](#2-lokales-setup-development)
|
||||
- [2.1 Voraussetzungen](#21-voraussetzungen)
|
||||
- [2.2 Installation](#22-installation)
|
||||
- [2.3 Konfiguration (Environment)](#23-konfiguration-environment)
|
||||
- [2.4 Dienste starten (API \& UI)](#24-dienste-starten-api--ui)
|
||||
- [3. Core-Module \& Entwicklung](#3-core-module--entwicklung)
|
||||
- [3.1 Der Importer (`scripts.import_markdown`)](#31-der-importer-scriptsimport_markdown)
|
||||
- [3.2 Der Hybrid Router (`app.routers.chat`)](#32-der-hybrid-router-approuterschat)
|
||||
- [3.3 Der Retriever (`app.core.retriever`)](#33-der-retriever-appcoreretriever)
|
||||
- [3.4 Das Frontend (`app.frontend.ui`)](#34-das-frontend-appfrontendui)
|
||||
- [3.5 Embedding Service (`app.services.embeddings_client`)](#35-embedding-service-appservicesembeddings_client)
|
||||
- [3.6 Traffic Control (`app.services.llm_service`)](#36-traffic-control-appservicesllm_service)
|
||||
- [4. Tests \& Debugging](#4-tests--debugging)
|
||||
- [4.1 Unit Tests (Pytest)](#41-unit-tests-pytest)
|
||||
- [4.2 Integration / Pipeline Tests](#42-integration--pipeline-tests)
|
||||
- [4.3 Smoke Tests (E2E)](#43-smoke-tests-e2e)
|
||||
- [5. Das "Teach-the-AI" Paradigma (Context Intelligence)](#5-das-teach-the-ai-paradigma-context-intelligence)
|
||||
- [A. Workflow: Einen neuen Typ implementieren (z. B. `type: risk`)](#a-workflow-einen-neuen-typ-implementieren-z-b-type-risk)
|
||||
- [B. Workflow: Neue Beziehungen (Edges) nutzen (z. B. `beeinflusst_von`)](#b-workflow-neue-beziehungen-edges-nutzen-z-b-beeinflusst_von)
|
||||
- [C. Workflow: Interview-Schema anpassen (WP07)](#c-workflow-interview-schema-anpassen-wp07)
|
||||
- [Fazit](#fazit)
|
||||
- [6. Nützliche Einzeiler](#6-nützliche-einzeiler)
|
||||
|
||||
---
|
||||
|
||||
## 1. Projektstruktur (Post-WP15)
|
||||
|
||||
Der Code ist modular in `app` (Logik), `scripts` (CLI) und `config` (Steuerung) getrennt.
|
||||
|
||||
mindnet/
|
||||
├── app/
|
||||
│ ├── core/ # Kernlogik
|
||||
│ │ ├── ingestion.py # NEU: Async Ingestion Service mit Change Detection
|
||||
│ │ ├── chunker.py # Smart Chunker Orchestrator
|
||||
│ │ ├── derive_edges.py # Edge-Erzeugung (WP03 Logik)
|
||||
│ │ ├── retriever.py # Scoring & Hybrid Search
|
||||
│ │ ├── qdrant.py # DB-Verbindung
|
||||
│ │ └── ...
|
||||
│ ├── models/ # Pydantic DTOs
|
||||
│ │ └── dto.py # Zentrale DTO-Definition
|
||||
│ ├── routers/ # FastAPI Endpoints
|
||||
│ │ ├── query.py # Suche
|
||||
│ │ ├── ingest.py # NEU: Save/Analyze (WP11)
|
||||
│ │ ├── chat.py # Hybrid Router v5 & Interview Logic
|
||||
│ │ ├── feedback.py # Feedback (WP04c)
|
||||
│ │ └── ...
|
||||
│ ├── services/ # Interne & Externe Dienste
|
||||
│ │ ├── llm_service.py # Ollama Client mit Traffic Control
|
||||
│ │ ├── semantic_analyzer.py# NEU: LLM-Filter für Edges (WP15)
|
||||
│ │ ├── embeddings_client.py# Async Embeddings (HTTPX)
|
||||
│ │ ├── feedback_service.py # Logging (JSONL Writer)
|
||||
│ │ └── discovery.py # NEU: Intelligence Logic (WP11)
|
||||
│ ├── frontend/ # NEU (WP10)
|
||||
│ │ └── ui.py # Streamlit Application inkl. Healing Parser
|
||||
│ └── main.py # Entrypoint der API
|
||||
├── config/ # YAML-Konfigurationen (Single Source of Truth)
|
||||
│ ├── types.yaml # Import-Regeln & Smart-Edge Config
|
||||
│ ├── prompts.yaml # LLM Prompts & Interview Templates
|
||||
│ ├── decision_engine.yaml # Router-Strategien (Actions only)
|
||||
│ └── retriever.yaml # Scoring-Regeln & Kantengewichte
|
||||
├── data/
|
||||
│ └── logs/ # Lokale Logs (search_history.jsonl, feedback.jsonl)
|
||||
├── scripts/ # CLI-Tools (Import, Diagnose, Reset)
|
||||
├── tests/ # Pytest Suite & Smoke Scripts
|
||||
└── vault/ # Dein lokaler Markdown-Content (Git-ignored)
|
||||
|
||||
---
|
||||
|
||||
## 2. Lokales Setup (Development)
|
||||
|
||||
### 2.1 Voraussetzungen
|
||||
* **Python:** 3.10 oder höher.
|
||||
* **Docker:** Für Qdrant.
|
||||
* **Ollama:** Für lokale LLM-Inference (erforderlich für `/chat` und Embeddings).
|
||||
* **Vault:** Ein Ordner mit Markdown-Dateien (z.B. `./mindnet_v2_test_vault` für Tests).
|
||||
|
||||
### 2.2 Installation
|
||||
|
||||
# 1. Repository klonen & Verzeichnis wechseln
|
||||
git clone <repo> mindnet
|
||||
cd mindnet
|
||||
|
||||
# 2. Virtual Environment erstellen
|
||||
python3 -m venv .venv
|
||||
source .venv/bin/activate
|
||||
|
||||
# 3. Abhängigkeiten installieren (inkl. Streamlit)
|
||||
pip install -r requirements.txt
|
||||
|
||||
# 4. Ollama Setup (Modelle laden)
|
||||
# Chat-Modell (Phi-3)
|
||||
ollama pull phi3:mini
|
||||
# Embedding-Modell (Nomic) - PFLICHT für v2.4!
|
||||
ollama pull nomic-embed-text
|
||||
|
||||
### 2.3 Konfiguration (Environment)
|
||||
Erstelle eine `.env` Datei im Root-Verzeichnis.
|
||||
|
||||
# Qdrant Verbindung
|
||||
QDRANT_URL="http://localhost:6333"
|
||||
QDRANT_API_KEY="" # Leer lassen für lokal
|
||||
|
||||
# Mindnet Core Settings
|
||||
COLLECTION_PREFIX="mindnet_dev"
|
||||
VECTOR_DIM=768 # NEU: 768 für Nomic (vorher 384)
|
||||
MINDNET_TYPES_FILE="./config/types.yaml"
|
||||
MINDNET_RETRIEVER_CONFIG="./config/retriever.yaml"
|
||||
MINDNET_VAULT_ROOT="./vault"
|
||||
|
||||
# LLM / RAG Settings (WP06/07)
|
||||
MINDNET_LLM_MODEL="phi3:mini"
|
||||
MINDNET_EMBEDDING_MODEL="nomic-embed-text" # NEU
|
||||
MINDNET_OLLAMA_URL="http://127.0.0.1:11434"
|
||||
MINDNET_LLM_TIMEOUT=300.0 # Timeout für CPU-Inference Cold-Starts
|
||||
MINDNET_DECISION_CONFIG="./config/decision_engine.yaml"
|
||||
MINDNET_LLM_BACKGROUND_LIMIT=2 # NEU: Limit für parallele Import-Tasks
|
||||
|
||||
# Frontend Settings (WP10)
|
||||
MINDNET_API_URL="http://localhost:8002"
|
||||
MINDNET_API_TIMEOUT=300.0 # Erhöht wegen Smart Edge Berechnung
|
||||
|
||||
# Import-Strategie
|
||||
MINDNET_HASH_COMPARE="Body"
|
||||
MINDNET_HASH_SOURCE="parsed"
|
||||
|
||||
### 2.4 Dienste starten (API & UI)
|
||||
|
||||
Wir entwickeln mit zwei Services. Du kannst sie manuell in zwei Terminals starten oder die Systemd-Services nutzen (siehe `admin_guide.md`).
|
||||
|
||||
**Terminal A: Backend (API)**
|
||||
|
||||
# Startet auf Port 8002 (Dev Standard)
|
||||
uvicorn app.main:app --host 0.0.0.0 --port 8002 --env-file .env --reload
|
||||
|
||||
**Terminal B: Frontend (UI)**
|
||||
|
||||
# Startet auf Port 8502 (Dev Standard)
|
||||
# --server.port 8502 verhindert Konflikte mit Prod (8501)
|
||||
streamlit run app/frontend/ui.py --server.port 8502
|
||||
|
||||
---
|
||||
|
||||
## 3. Core-Module & Entwicklung
|
||||
|
||||
### 3.1 Der Importer (`scripts.import_markdown`)
|
||||
Dies ist das komplexeste Modul.
|
||||
* **Einstieg:** `scripts/import_markdown.py` -> `main_async()`.
|
||||
* **Smart Edges:** Nutzt `app.core.chunker` und `app.services.semantic_analyzer` zur Kanten-Filterung.
|
||||
* **Idempotenz:** Der Importer muss mehrfach laufen können, ohne Duplikate zu erzeugen. Wir nutzen deterministische IDs (UUIDv5).
|
||||
* **Robustheit:** In `ingestion.py` sind Mechanismen wie Change Detection und Robust File I/O (fsync) implementiert.
|
||||
|
||||
### 3.2 Der Hybrid Router (`app.routers.chat`)
|
||||
Hier liegt die Logik für Intent Detection (WP06) und Interview-Modus (WP07).
|
||||
* **Question Detection:** Prüft zuerst, ob der Input eine Frage ist. Falls ja -> RAG.
|
||||
* **Keyword Match:** Prüft Keywords in `decision_engine.yaml` und `types.yaml`.
|
||||
* **Priority:** Ruft `llm_service` mit `priority="realtime"` auf.
|
||||
|
||||
### 3.3 Der Retriever (`app.core.retriever`)
|
||||
Hier passiert das Scoring.
|
||||
* **Hybrid Search:** Der Chat-Endpoint erzwingt `mode="hybrid"`.
|
||||
* **Strategic Retrieval:** In `chat.py` wird der Retriever *zweimal* aufgerufen, wenn ein Intent (z.B. `DECISION`) eine Injection (`value`) erfordert.
|
||||
|
||||
### 3.4 Das Frontend (`app.frontend.ui`)
|
||||
Eine Streamlit-App (WP10).
|
||||
* **Resurrection Pattern:** Das UI nutzt ein spezielles State-Management, um Eingaben bei Tab-Wechseln (Chat <-> Editor) zu erhalten. Widgets synchronisieren sich mit `st.session_state`.
|
||||
* **Healing Parser:** Die Funktion `parse_markdown_draft` repariert defekte YAML-Frontmatter (fehlendes `---`) automatisch.
|
||||
* **Logik:** Ruft `/chat`, `/feedback` und `/ingest/analyze` Endpoints der API auf.
|
||||
|
||||
### 3.5 Embedding Service (`app.services.embeddings_client`)
|
||||
**Neu in v2.4:**
|
||||
* Nutzt `httpx.AsyncClient` für non-blocking Calls an Ollama (Primary Mode).
|
||||
* Besitzt einen **Fallback** auf `requests` (Synchron), falls Legacy-Skripte ihn nutzen.
|
||||
* Unterstützt dediziertes Embedding-Modell (`nomic-embed-text`) getrennt vom Chat-Modell.
|
||||
|
||||
### 3.6 Traffic Control (`app.services.llm_service`)
|
||||
**Neu in v2.6 (Version 2.8.0):**
|
||||
* Stellt sicher, dass Batch-Prozesse (Import) den Live-Chat nicht ausbremsen.
|
||||
* **Methode:** `generate_raw_response(..., priority="background")` aktiviert eine Semaphore.
|
||||
* **Limit:** Konfigurierbar über `MINDNET_LLM_BACKGROUND_LIMIT` (Default: 2) in der `.env`.
|
||||
|
||||
---
|
||||
|
||||
## 4. Tests & Debugging
|
||||
|
||||
Wir unterscheiden drei Test-Ebenen. Ein Pull Request sollte alle passieren.
|
||||
|
||||
### 4.1 Unit Tests (Pytest)
|
||||
Für isolierte Logik (Parsing, Scoring).
|
||||
|
||||
pytest tests/test_retriever_basic.py
|
||||
pytest tests/test_chunking.py
|
||||
pytest tests/test_edges_all.py
|
||||
|
||||
### 4.2 Integration / Pipeline Tests
|
||||
Prüfen den Datenfluss von Markdown bis Qdrant-JSON.
|
||||
* **Payload Dryrun:** Prüft JSON-Schema Konformität.
|
||||
|
||||
python3 -m scripts.payload_dryrun --vault ./mindnet_v2_test_vault
|
||||
|
||||
* **Edge Checks:** Prüft Graph-Invarianten.
|
||||
|
||||
python3 -m scripts.edges_full_check
|
||||
|
||||
### 4.3 Smoke Tests (E2E)
|
||||
Prüfen das laufende System gegen eine echte Qdrant-Instanz und Ollama.
|
||||
|
||||
# 1. API Test (Decision Engine)
|
||||
python tests/test_wp06_decision.py -p 8002 -e DECISION -q "Soll ich X tun?"
|
||||
|
||||
# 2. UI Test (Manuell)
|
||||
# Öffne http://localhost:8502
|
||||
# Stelle eine Frage und prüfe Intent-Badge und Quellen-Anzeige.
|
||||
|
||||
# 3. Feedback Test
|
||||
python tests/test_feedback_smoke.py --url http://localhost:8002/query
|
||||
|
||||
# 4. Intelligence Test (WP11)
|
||||
python debug_analysis.py
|
||||
|
||||
---
|
||||
|
||||
## 5. Das "Teach-the-AI" Paradigma (Context Intelligence)
|
||||
|
||||
Mindnet lernt nicht durch Training (Fine-Tuning), sondern durch **Konfiguration**, **Vernetzung** und **Prompting**. Dies ist der **Core-Workflow** für Erweiterungen.
|
||||
|
||||
### A. Workflow: Einen neuen Typ implementieren (z. B. `type: risk`)
|
||||
|
||||
**1. Daten-Ebene (`config/types.yaml`)**
|
||||
Definiere die "Physik" des Typs (Import-Regeln und Basis-Wichtigkeit).
|
||||
|
||||
risk:
|
||||
chunk_profile: sliding_short # Risiken sind oft kurze Statements
|
||||
retriever_weight: 0.90 # Sehr wichtig
|
||||
edge_defaults: ["blocks"] # Automatische Kante zu verlinkten Projekten
|
||||
detection_keywords: ["gefahr", "risiko"]
|
||||
|
||||
**2. Strategie-Ebene (`config/decision_engine.yaml`)**
|
||||
Damit dieser Typ aktiv geladen wird, musst du ihn einer Strategie zuordnen.
|
||||
|
||||
DECISION:
|
||||
inject_types: ["value", "principle", "goal", "risk"] # <--- "risk" hinzugefügt
|
||||
|
||||
*Ergebnis:* Wenn der Intent `DECISION` erkannt wird, sucht das System nun auch aktiv nach Risiken.
|
||||
|
||||
**3. Kognitive Ebene (`config/prompts.yaml`)**
|
||||
Erkläre dem LLM im Template, was es damit tun soll.
|
||||
|
||||
### B. Workflow: Neue Beziehungen (Edges) nutzen (z. B. `beeinflusst_von`)
|
||||
|
||||
Beziehungen sind der Klebstoff für die "Why"-Erklärungen.
|
||||
|
||||
**1. Erfassung im Vault (Markdown)**
|
||||
Nutze die Inline-Syntax im Fließtext:
|
||||
> "Die Entscheidung für Qdrant wurde [[rel:beeinflusst_von Budgetkürzung 2024]]."
|
||||
|
||||
**2. Gewichtung (`config/retriever.yaml`)**
|
||||
Konfiguriere `edge_weights`, wenn Kausalität wichtiger ist als Ähnlichkeit.
|
||||
|
||||
### C. Workflow: Interview-Schema anpassen (WP07)
|
||||
|
||||
Wenn Mindnet neue Fragen stellen soll:
|
||||
|
||||
**1. Schema erweitern (`config/types.yaml`)**
|
||||
Füge das Feld in die Liste ein (Neu: Schemas liegen jetzt hier).
|
||||
|
||||
project:
|
||||
schema:
|
||||
- "Titel"
|
||||
- "Ziel"
|
||||
- "Budget (Neu)"
|
||||
|
||||
**2. Keine Code-Änderung nötig**
|
||||
Der `One-Shot Extractor` (Prompt Template) liest diese Liste dynamisch.
|
||||
|
||||
### Fazit
|
||||
* **Vault:** Liefert das Wissen.
|
||||
* **Config:** Liefert die Strategie (Router & Weights).
|
||||
* **Prompt:** Liefert die Interpretation.
|
||||
|
||||
---
|
||||
|
||||
## 6. Nützliche Einzeiler
|
||||
|
||||
**DB komplett zurücksetzen (Vorsicht!):**
|
||||
|
||||
# --yes überspringt die Bestätigung
|
||||
python3 -m scripts.reset_qdrant --mode wipe --prefix "mindnet_dev" --yes
|
||||
|
||||
**Einen einzelnen File inspizieren (Parser-Sicht):**
|
||||
|
||||
python3 tests/inspect_one_note.py --file ./vault/MeinFile.md
|
||||
|
||||
**Live-Logs sehen (Systemd):**
|
||||
|
||||
# Backend
|
||||
journalctl -u mindnet-dev -f
|
||||
# Frontend
|
||||
journalctl -u mindnet-ui-dev -f
|
||||
@@ -0,0 +1,494 @@
|
||||
# Mindnet v2.4 – Fachliche Architektur
|
||||
**Datei:** `docs/mindnet_functional_architecture_v2.6.md`
|
||||
**Stand:** 2025-12-12
|
||||
**Status:** **FINAL** (Integrierter Stand WP01–WP15: Smart Edges & Traffic Control)
|
||||
|
||||
> Dieses Dokument beschreibt **was** Mindnet fachlich tut und **warum** – mit Fokus auf die Erzeugung und Nutzung von **Smart Edges** (Kanten), die Logik des Retrievers und den **RAG-Chat** (Decision Engine, Interview-Modus & Persönlichkeit).
|
||||
|
||||
---
|
||||
<details>
|
||||
<summary>📖 <b>Inhaltsverzeichnis (Klicken zum Öffnen)</b></summary>
|
||||
|
||||
- [Mindnet v2.4 – Fachliche Architektur](#mindnet-v24--fachliche-architektur)
|
||||
- [](#)
|
||||
- [0) Zielbild \& Grundprinzip](#0-zielbild--grundprinzip)
|
||||
- [1) Notizen \& Chunks (fachliche Perspektive)](#1-notizen--chunks-fachliche-perspektive)
|
||||
- [1.1 Notiz (Note)](#11-notiz-note)
|
||||
- [1.2 Chunk](#12-chunk)
|
||||
- [2) Edges – fachliche Typen \& Bedeutung](#2-edges--fachliche-typen--bedeutung)
|
||||
- [2.1 Struktur-Kanten (Das Skelett)](#21-struktur-kanten-das-skelett)
|
||||
- [2.2 Inhalts-Kanten (explizit)](#22-inhalts-kanten-explizit)
|
||||
- [2.3 Typ-basierte Default-Kanten (Regelbasiert)](#23-typ-basierte-default-kanten-regelbasiert)
|
||||
- [2.4 Smart Edge Allocation (LLM-gefiltert) – Neu in v2.6](#24-smart-edge-allocation-llm-gefiltert--neu-in-v26)
|
||||
- [2.5 Matrix-Logik (Kontextsensitive Kanten)](#25-matrix-logik-kontextsensitive-kanten)
|
||||
- [3) Edge-Payload – Felder \& Semantik](#3-edge-payload--felder--semantik)
|
||||
- [4) Typ-Registry (`config/types.yaml`)](#4-typ-registry-configtypesyaml)
|
||||
- [4.1 Zweck](#41-zweck)
|
||||
- [4.2 Beispiel (auslieferungsnah)](#42-beispiel-auslieferungsnah)
|
||||
- [5) Der Retriever (Funktionaler Layer)](#5-der-retriever-funktionaler-layer)
|
||||
- [5.1 Scoring-Modell](#51-scoring-modell)
|
||||
- [5.2 Erklärbarkeit (Explainability) – WP04b](#52-erklärbarkeit-explainability--wp04b)
|
||||
- [5.3 Graph-Expansion](#53-graph-expansion)
|
||||
- [6) Context Intelligence \& Intent Router (WP06–WP15)](#6-context-intelligence--intent-router-wp06wp15)
|
||||
- [6.1 Das Problem: Statische vs. Dynamische Antworten](#61-das-problem-statische-vs-dynamische-antworten)
|
||||
- [6.2 Der Hybrid Router v5 (Action vs. Question)](#62-der-hybrid-router-v5-action-vs-question)
|
||||
- [6.3 Traffic Control (Realtime vs. Background)](#63-traffic-control-realtime-vs-background)
|
||||
- [6.4 Strategic Retrieval (Injektion von Werten)](#64-strategic-retrieval-injektion-von-werten)
|
||||
- [6.5 Reasoning (Das Gewissen)](#65-reasoning-das-gewissen)
|
||||
- [6.6 Der Interview-Modus (One-Shot Extraction)](#66-der-interview-modus-one-shot-extraction)
|
||||
- [6.7 Active Intelligence (Link Suggestions)](#67-active-intelligence-link-suggestions)
|
||||
- [7) Future Concepts: The Empathic Digital Twin (Ausblick)](#7-future-concepts-the-empathic-digital-twin-ausblick)
|
||||
- [7.1 Antizipation durch Erfahrung](#71-antizipation-durch-erfahrung)
|
||||
- [7.2 Empathie \& "Ich"-Modus](#72-empathie--ich-modus)
|
||||
- [7.3 Glaubenssätze \& Rituale](#73-glaubenssätze--rituale)
|
||||
- [8) Erweiterbarkeit \& Teaching (Context Intelligence)](#8-erweiterbarkeit--teaching-context-intelligence)
|
||||
- [A. Workflow: Einen neuen Typ implementieren (z. B. `type: risk`)](#a-workflow-einen-neuen-typ-implementieren-z-b-type-risk)
|
||||
- [B. Workflow: Neue Beziehungen nutzen (z. B. `beeinflusst_von`)](#b-workflow-neue-beziehungen-nutzen-z-b-beeinflusst_von)
|
||||
- [9) Feedback \& Lernen – WP04c/WP10](#9-feedback--lernen--wp04cwp10)
|
||||
- [9.1 Der Feedback-Loop](#91-der-feedback-loop)
|
||||
- [10) Confidence \& Provenance – wozu?](#10-confidence--provenance--wozu)
|
||||
- [11) Semantik ausgewählter `kind`-Werte](#11-semantik-ausgewählter-kind-werte)
|
||||
- [12) Frontmatter-Eigenschaften – Rolle \& Empfehlung](#12-frontmatter-eigenschaften--rolle--empfehlung)
|
||||
- [13) Lösch-/Update-Garantien (Idempotenz)](#13-lösch-update-garantien-idempotenz)
|
||||
- [14) Beispiel – Von Markdown zu Kanten](#14-beispiel--von-markdown-zu-kanten)
|
||||
- [15) Referenzen (Projektdateien \& Leitlinien)](#15-referenzen-projektdateien--leitlinien)
|
||||
- [16) Workpackage Status (v2.6.0)](#16-workpackage-status-v260)
|
||||
|
||||
</details>
|
||||
---
|
||||
|
||||
## 0) Zielbild & Grundprinzip
|
||||
|
||||
Mindnet wandelt Obsidian-Markdown-Notizen in einen **dynamischen Graphen aus Punkten und Kanten** um.
|
||||
Die drei zentralen Artefakt-Sammlungen lauten:
|
||||
|
||||
- `mindnet_notes` – genau **eine** Note pro Markdown-Datei (Metadaten & Hashes)
|
||||
- `mindnet_chunks` – semantische Teilstücke einer Note (Fenster/„Chunks“)
|
||||
- `mindnet_edges` – gerichtete Beziehungen zwischen Knoten (Chunks/Notes)
|
||||
|
||||
Die Import-Pipeline (seit v2.6 mit **Traffic Control** und **Smart Edges**) erzeugt diese Artefakte **deterministisch** und **idempotent** (erneute Läufe überschreiben konsistent statt zu duplizieren). Die Import-Schritte sind: *parse → chunk → embed → smart-edge-allocation → upsert*.
|
||||
|
||||
---
|
||||
|
||||
## 1) Notizen & Chunks (fachliche Perspektive)
|
||||
|
||||
### 1.1 Notiz (Note)
|
||||
- Repräsentiert eine fachliche Einheit (z. B. *„Vector DB Basics“*, *„KI-Projekt“*).
|
||||
- Trägt Eigenschaften (Titel, Typ, Zeitstempel, optionale Policies).
|
||||
- **Typ** (*type*) steuert u. a. Chunk-Profil und Default-Relationen (siehe §4).
|
||||
- **retriever_weight** und **chunk_profile** werden systematisch an Note **und** Chunks gespiegelt, damit der Retriever beides nutzen kann.
|
||||
|
||||
### 1.2 Chunk
|
||||
- Ausschnitt/Textfenster aus der Note, als eigenständiger Such-Anker.
|
||||
- Jeder Chunk gehört **genau einer** Note.
|
||||
- Chunks bilden eine Sequenz (1…N) – das ermöglicht *next/prev*.
|
||||
- **Update v2.4:** Chunks werden jetzt durch das Modell `nomic-embed-text` in **768-dimensionale Vektoren** umgewandelt. Dies erlaubt eine deutlich höhere semantische Auflösung als frühere Modelle (384 Dim).
|
||||
- **Update v2.6 (Smart Chunking):** Ein Chunk ist nicht mehr nur ein dummer Textblock, der alle Links der Mutter-Notiz erbt. Durch die **Smart Edge Allocation (WP15)** "weiß" jeder Chunk genau, welche Kanten inhaltlich zu ihm gehören (siehe 2.4).
|
||||
|
||||
> **Wichtig:** Chunking-Profile (short/medium/long/sliding_smart_edges) kommen aus `types.yaml` (per Note-Typ), können aber lokal überschrieben werden. Die effektiven Werte werden bei der Payload-Erzeugung bestimmt.
|
||||
|
||||
---
|
||||
|
||||
## 2) Edges – fachliche Typen & Bedeutung
|
||||
|
||||
Edges kodieren Beziehungen. Sie sind **gerichtet** und werden in `mindnet_edges` gespeichert. Die Erzeugung folgt einer strengen Priorität: **Inline > Callout > Defaults > Struktur**.
|
||||
|
||||
### 2.1 Struktur-Kanten (Das Skelett)
|
||||
- **belongs_to**: *Chunk → Note* (Zuordnung)
|
||||
- **next / prev**: Kettenbeziehungen zwischen aufeinanderfolgenden Chunks derselben Note.
|
||||
→ ermöglichen „lineares Weiterlesen“ oder Kontextpfade in Antworten.
|
||||
Diese Kanten entstehen immer, unabhängig von Inhalten.
|
||||
|
||||
### 2.2 Inhalts-Kanten (explizit)
|
||||
Hier unterscheidet v2.6 präzise zwischen verschiedenen Quellen der Evidenz:
|
||||
|
||||
1. **Explizite Inline-Relationen (Höchste Priorität):**
|
||||
Im Fließtext notierte, semantisch qualifizierte Relationen.
|
||||
* Syntax: `[[rel:depends_on Embeddings 101]]`
|
||||
* Fachliche Aussage: "Hängt ab von", "Ähnlich zu".
|
||||
* *rule_id*: `inline:rel`
|
||||
* *confidence*: ~0.95
|
||||
|
||||
2. **Callout-Edges (Kuratierte Listen):**
|
||||
Redaktionell gepflegte Listen am Ende einer Notiz (z.B. "Siehe auch").
|
||||
* Syntax: `> [!edge] related_to: [[Vector DB Basics]]`
|
||||
* *rule_id*: `callout:edge`
|
||||
* *confidence*: ~0.90
|
||||
|
||||
3. **Wikilinks (Standard-Referenzen):**
|
||||
Der klassische Obsidian-Link.
|
||||
* Syntax: `[[Vector DB Basics]]`
|
||||
* Typ: `references`
|
||||
* *rule_id*: `explicit:wikilink`
|
||||
* *confidence*: 1.0
|
||||
|
||||
> Alle expliziten Quellen (Wikilink, Inline-Rel, Callout) sind **Primärbelege**.
|
||||
|
||||
### 2.3 Typ-basierte Default-Kanten (Regelbasiert)
|
||||
Jede Note hat einen *Typ* (z. B. `concept`, `project`, `profile`). In `config/types.yaml` definieren wir pro Typ **edge_defaults**, z. B.:
|
||||
|
||||
- `concept`: `["references","related_to"]`
|
||||
- `project`: `["references","depends_on"]`
|
||||
|
||||
Regel: **Für jede gefundene explizite Referenz** (s. o.) werden **zusätzliche** Edges nach diesen Defaults erzeugt.
|
||||
Beispiel: Ein *project* mit `edge_defaults=["depends_on"]` erzeugt zu *jedem* explizit referenzierten Ziel **zusätzlich** eine `depends_on`-Kante.
|
||||
Diese Kanten tragen *provenance=rule* und eine **rule_id** der Form `edge_defaults:{note_type}:{relation}` sowie eine geringere Confidence (~0.7).
|
||||
|
||||
### 2.4 Smart Edge Allocation (LLM-gefiltert) – Neu in v2.6
|
||||
Mit **WP15** wurde ein intelligenter Filter eingeführt, um das Problem des "Broadcasting" zu lösen. Früher erbte jeder Chunk einer Notiz *alle* Links der Notiz, was zu unpräzisem Retrieval führte.
|
||||
|
||||
**Der neue Prozess:**
|
||||
1. **Scan:** Das System sammelt alle expliziten Links der gesamten Notiz.
|
||||
2. **Chunking:** Der Text wird in Abschnitte zerlegt.
|
||||
3. **Analyse (LLM):** Ein lokales LLM (Semantic Analyzer) liest jeden Chunk einzeln.
|
||||
4. **Entscheidung:** Das LLM entscheidet für jeden Link aus Schritt 1: *"Ist dieser Link im Kontext dieses spezifischen Textabschnitts relevant?"*
|
||||
5. **Zuweisung:** Nur wenn das LLM zustimmt, wird die Kante am Chunk erstellt.
|
||||
|
||||
*Steuerung:* Dies ist pro Typ in der `types.yaml` konfigurierbar (`enable_smart_edge_allocation: true`).
|
||||
|
||||
### 2.5 Matrix-Logik (Kontextsensitive Kanten)
|
||||
Mit WP-11 wurde eine Intelligenz eingeführt, die Kanten-Typen nicht nur anhand des Quell-Typs, sondern auch anhand des Ziel-Typs bestimmt ("Matrix").
|
||||
|
||||
**Beispiel für `Source Type: experience`:**
|
||||
* Wenn Ziel ist `value` -> Kante: `based_on`
|
||||
* Wenn Ziel ist `principle` -> Kante: `derived_from`
|
||||
* Wenn Ziel ist `project` -> Kante: `related_to`
|
||||
|
||||
Dies ermöglicht im Graphen präzise Abfragen wie "Zeige alle Erfahrungen, die auf Wert X basieren" (via `based_on`), was mit generischen `related_to` Kanten nicht möglich wäre.
|
||||
|
||||
---
|
||||
|
||||
## 3) Edge-Payload – Felder & Semantik
|
||||
|
||||
Jede Kante hat mindestens:
|
||||
|
||||
- `kind` – Beziehungsart *(belongs_to, next, prev, references, related_to, depends_on, similar_to, based_on, uses, …)*
|
||||
- `scope` – `"chunk"` (Standard in v2.2)
|
||||
- `source_id`, `target_id` – Quell-/Ziel-Knoten (Chunk-IDs oder Note-Titel bei unresolved Targets)
|
||||
- `note_id` – **Owner-Note** (die Note, aus der die Kante stammt)
|
||||
|
||||
Erweiterte/abgeleitete Felder (WP03 Superset):
|
||||
|
||||
- `provenance` – `"explicit"` (Wikilink/Inline/Callout), `"rule"` (Typ-Defaults) oder neu `"smart"` (vom LLM validiert).
|
||||
- `rule_id` – maschinenlesbare Regelquelle (z.B. `inline:rel`, `edge_defaults:project:depends_on`)
|
||||
- `confidence` – 0.0–1.0; Heuristik zur Gewichtung im Scoring.
|
||||
|
||||
**Dedup-Schlüssel** (fachlich): Gleichlautende `(source_id, target_id, kind, scope, rule_id)` werden nicht mehrfach geschrieben.
|
||||
|
||||
---
|
||||
|
||||
## 4) Typ-Registry (`config/types.yaml`)
|
||||
|
||||
### 4.1 Zweck
|
||||
- Steuert **Chunking-Profile** (`short|medium|long`) **pro Typ**
|
||||
- Liefert **retriever_weight** (Note-/Chunk-Gewichtung im Ranking) **pro Typ**
|
||||
- Definiert **edge_defaults** je Typ (s. o.)
|
||||
- **Neu in v2.6:** Steuert `enable_smart_edge_allocation` (LLM-Filter) und `detection_keywords` für den Hybrid Router.
|
||||
|
||||
Der Importer lädt die Registry aus `MINDNET_TYPES_FILE` oder nutzt Fallbacks. **Frontmatter-Overrides** für Profile werden in v2.2 weitgehend ignoriert zugunsten einer zentralen Governance in der YAML-Datei.
|
||||
|
||||
### 4.2 Beispiel (auslieferungsnah)
|
||||
version: 2.6.0
|
||||
types:
|
||||
concept:
|
||||
chunk_profile: medium
|
||||
edge_defaults: ["references", "related_to"]
|
||||
retriever_weight: 0.60
|
||||
experience:
|
||||
chunk_profile: sliding_smart_edges
|
||||
enable_smart_edge_allocation: true # WP15: LLM prüft Kanten
|
||||
detection_keywords: ["passiert", "erlebt", "situation"] # WP06: Router-Trigger
|
||||
schema: # WP07: Interview-Struktur
|
||||
- "Situation (Was ist passiert?)"
|
||||
- "Meine Reaktion (Was habe ich getan?)"
|
||||
|
||||
**Auflösung im Importer**
|
||||
- `effective_chunk_profile(note_type, registry)` → `"short|medium|long"|None`
|
||||
- `effective_retriever_weight(note_type, registry)` → `float|None`
|
||||
- Ergebnis wird in `note_payload` **und** `chunk_payloads` gespiegelt.
|
||||
|
||||
---
|
||||
|
||||
## 5) Der Retriever (Funktionaler Layer)
|
||||
|
||||
Der Retriever ist in v2.2 der zentrale Zugangspunkt. Er realisiert die **Hybride Suche**.
|
||||
|
||||
### 5.1 Scoring-Modell
|
||||
Die Relevanz eines Treffers ergibt sich nicht mehr nur aus Textähnlichkeit, sondern aus einer gewichteten Formel:
|
||||
|
||||
total_score =
|
||||
semantic_weight * semantic_score
|
||||
+ edge_weight * edge_bonus
|
||||
+ centrality_weight * centrality_bonus
|
||||
+ type_weight * retriever_weight
|
||||
|
||||
* **semantic_score:** Vektorähnlichkeit (Qdrant).
|
||||
* **retriever_weight:** Wichtigkeit des Typs (z.B. Projekte > Quellen).
|
||||
* **edge_bonus:** Belohnung für Chunks, die im Kontext der Anfrage stark vernetzt sind (Summe der Confidence eingehender relevanter Kanten).
|
||||
* **centrality_bonus:** Belohnung für Knoten, die zentrale Hubs im lokalen Graphen darstellen.
|
||||
|
||||
### 5.2 Erklärbarkeit (Explainability) – WP04b
|
||||
Der Retriever ist keine Blackbox mehr. Er liefert auf Wunsch (`explain=True`) eine strukturierte Begründung (`Explanation`-Objekt).
|
||||
|
||||
**Die "Warum"-Logik:**
|
||||
1. **Semantik:** Prüfung der Cosine-Similarity ("Sehr hohe textuelle Übereinstimmung").
|
||||
2. **Typ:** Prüfung des `retriever_weight` ("Bevorzugt, da Entscheidung").
|
||||
3. **Graph (Kontext):**
|
||||
* **Hub (Outgoing):** Worauf verweist dieser Treffer? ("Verweist auf Qdrant").
|
||||
* **Authority (Incoming):** Wer verweist auf diesen Treffer? ("Wird referenziert von Projekt Alpha").
|
||||
|
||||
Die API gibt diese Analysen als menschenlesbare Sätze (`reasons`) und als Datenstruktur (`score_breakdown`) zurück.
|
||||
|
||||
### 5.3 Graph-Expansion
|
||||
Der Hybrid-Modus lädt dynamisch die Nachbarschaft der Top-K Vektor-Treffer ("Seeds") über `graph_adapter.expand`. Dies baut einen temporären `NetworkX`-artigen Graphen im Speicher (Klasse `Subgraph`), auf dem Boni berechnet werden.
|
||||
|
||||
---
|
||||
|
||||
## 6) Context Intelligence & Intent Router (WP06–WP15)
|
||||
|
||||
Seit WP06 agiert Mindnet nicht mehr statisch, sondern passt seine Suchstrategie dem **Intent** (der Absicht) des Nutzers an. Dies ist die Transformation vom reinen Wissens-Abrufer zum strategischen Partner.
|
||||
|
||||
### 6.1 Das Problem: Statische vs. Dynamische Antworten
|
||||
* **Früher (Pre-WP06):** Jede Frage ("Was ist X?" oder "Soll ich X?") wurde gleich behandelt -> Fakten-Retrieval.
|
||||
* **Heute (WP06):** Das System erkennt, *was* der User will (Rat, Fakten oder Datenerfassung) und wechselt den Modus.
|
||||
|
||||
### 6.2 Der Hybrid Router v5 (Action vs. Question)
|
||||
Der Router wurde in v2.6 (WP15) weiterentwickelt, um Fehlalarme zu vermeiden.
|
||||
|
||||
1. **Frage-Erkennung:**
|
||||
* Das System prüft zuerst: Enthält der Satz ein `?` oder typische W-Wörter (Wer, Wie, Was)?
|
||||
* Wenn **JA** -> Gehe in den **RAG Modus** (Intent `FACT` oder `DECISION`). Interviews werden hier blockiert.
|
||||
|
||||
2. **Befehls-Erkennung (Fast Path):**
|
||||
* Wenn **NEIN** (keine Frage), prüft das System auf Keywords in `types.yaml` ("Projekt", "Erfahrung").
|
||||
* Treffer -> **INTERVIEW Modus** (Erfassen). Das Schema wird aus `types.yaml` geladen.
|
||||
|
||||
3. **LLM Fallback (Slow Path):**
|
||||
* Wenn beides fehlschlägt, entscheidet das LLM über den Intent.
|
||||
|
||||
### 6.3 Traffic Control (Realtime vs. Background)
|
||||
Um den Live-Betrieb (Chat) nicht durch den ressourcenintensiven Smart-Import (LLM-Analyse) zu gefährden, implementiert v2.6 ein **Traffic Control System** im `LLMService`.
|
||||
|
||||
* **Realtime Lane (Chat):** Anfragen aus dem Chat erhalten `priority="realtime"`. Sie umgehen alle Warteschlangen und werden sofort bearbeitet.
|
||||
* **Background Lane (Import):** Anfragen zur Kantenanalyse erhalten `priority="background"`. Sie werden durch eine **Semaphore** gedrosselt (Standard: max 2 parallel), um die Hardware nicht zu überlasten.
|
||||
|
||||
### 6.4 Strategic Retrieval (Injektion von Werten)
|
||||
Im Modus `DECISION` führt das System eine **zweite Suchstufe** aus. Es sucht nicht nur nach semantisch passenden Texten zur Frage, sondern erzwingt das Laden von strategischen Notizen wie:
|
||||
* **Values (`type: value`):** Moralische Werte (z.B. "Privacy First").
|
||||
* **Principles (`type: principle`):** Handlungsanweisungen.
|
||||
* **Goals (`type: goal`):** Strategische Ziele.
|
||||
|
||||
### 6.5 Reasoning (Das Gewissen)
|
||||
Das LLM erhält im Prompt die explizite Anweisung: *"Wäge die Fakten (aus der Suche) gegen die injizierten Werte ab."*
|
||||
Dadurch entstehen Antworten, die nicht nur technisch korrekt sind, sondern subjektiv passend ("Tool X passt nicht zu deinem Ziel Z").
|
||||
|
||||
### 6.6 Der Interview-Modus (One-Shot Extraction)
|
||||
Wenn der User Wissen erfassen will ("Ich möchte ein neues Projekt anlegen"), wechselt Mindnet in den **Interview-Modus**.
|
||||
|
||||
* **Late Binding Schema:** Das System lädt ein konfiguriertes Schema für den Ziel-Typ (z.B. `project`: Pflichtfelder sind Titel, Ziel, Status).
|
||||
* **One-Shot Extraction:** Statt eines langen Dialogs extrahiert das LLM **sofort** alle verfügbaren Infos aus dem Prompt und generiert einen validen Markdown-Draft mit Frontmatter.
|
||||
* **Healing Parser (v2.5):** Falls das LLM die YAML-Syntax beschädigt (z.B. fehlendes Ende), repariert das Frontend den Entwurf automatisch.
|
||||
* **UI-Integration:** Das Frontend rendert statt einer Chat-Antwort einen **interaktiven Editor** (WP10), in dem der Entwurf finalisiert werden kann.
|
||||
|
||||
### 6.7 Active Intelligence (Link Suggestions)
|
||||
Im **Draft Editor** (Frontend) unterstützt das System den Autor aktiv.
|
||||
* **Analyse:** Ein "Sliding Window" scannt den Text im Hintergrund (auch lange Entwürfe).
|
||||
* **Erkennung:** Es findet Begriffe ("Mindnet") und semantische Konzepte ("Autofahrt in Italien").
|
||||
* **Matching:** Es prüft gegen den Index (Aliases und Vektoren).
|
||||
* **Vorschlag:** Es bietet fertige Markdown-Links an (z.B. `[[rel:related_to ...]]`), die per Klick eingefügt werden.
|
||||
* **Logik:** Dabei kommt die in 2.5 beschriebene **Matrix-Logik** zum Einsatz, um den korrekten Kanten-Typ vorzuschlagen.
|
||||
|
||||
---
|
||||
|
||||
## 7) Future Concepts: The Empathic Digital Twin (Ausblick)
|
||||
|
||||
Um Mindnet von einer Entscheidungsmaschine zu einem echten **Spiegel der Persönlichkeit** zu entwickeln, sind folgende Erweiterungen konzeptionell vorgesehen:
|
||||
|
||||
### 7.1 Antizipation durch Erfahrung
|
||||
* **Konzept:** Das System soll Konsequenzen vorhersagen ("Was passiert, wenn...?").
|
||||
* **Umsetzung:** Neben Werten werden vergangene Erfahrungen (`type: experience`) geladen.
|
||||
* **Logik:** *"In einer ähnlichen Situation (Projekt A) hat Entscheidung X zu Ergebnis Y geführt."*
|
||||
|
||||
### 7.2 Empathie & "Ich"-Modus
|
||||
* **Konzept:** Das System antwortet nicht wie ein Roboter, sondern im Tonfall und Stil des Nutzers.
|
||||
* **Umsetzung (Few-Shot Prompting):** Der System-Prompt wird dynamisch mit Beispielen gefüttert, wie der Nutzer typischerweise auf E-Mails oder Fragen antwortet.
|
||||
* **Datenbasis:** `type: profile` oder `type: manifesto` definieren das Selbstbild.
|
||||
|
||||
### 7.3 Glaubenssätze & Rituale
|
||||
* **Konzept:** Berücksichtigung weicher Faktoren und Gewohnheiten.
|
||||
* **Umsetzung:** Erweiterung der `decision_engine.yaml` um `inject_types: ["belief", "ritual"]`.
|
||||
* **Szenario:** Bei Terminplanungen werden Rituale ("Keine Meetings vor 10 Uhr") automatisch als harte Restriktion gegen Anfragen geprüft.
|
||||
|
||||
---
|
||||
|
||||
## 8) Erweiterbarkeit & Teaching (Context Intelligence)
|
||||
|
||||
Mindnet lernt nicht durch klassisches Training (Fine-Tuning), sondern durch **Konfiguration**, **Vernetzung** und **Prompting**. Dies ist das **"Teach-the-AI" Paradigma**: Wenn du dem System ein neues Konzept beibringen willst, musst du an drei Stellen eingreifen.
|
||||
|
||||
### A. Workflow: Einen neuen Typ implementieren (z. B. `type: risk`)
|
||||
|
||||
1. **Physik definieren (`config/types.yaml`)**
|
||||
Steuere, wie schwer der Inhalt wiegt und wie er vernetzt wird.
|
||||
```yaml
|
||||
risk:
|
||||
chunk_profile: short # Risiken sind oft kurze Statements
|
||||
retriever_weight: 0.90 # Hohe Priorität im Ranking
|
||||
edge_defaults: ["blocks"] # Automatische Kante zu verlinkten Projekten
|
||||
detection_keywords: ["gefahr", "risiko"] # Für den Hybrid Router
|
||||
```
|
||||
*Effekt:* Der Router erkennt das Wort "Risiko" und bietet ein Interview an. Der Retriever spült diese Notizen bei relevanten Anfragen nach oben.
|
||||
|
||||
2. **Semantik erklären (`config/prompts.yaml` / `decision_engine.yaml`)**
|
||||
Bringe dem LLM bei, wie es mit diesem Typ umgehen soll. Füge `risk` zur `DECISION`-Strategie hinzu (`inject_types`), damit es bei Entscheidungen geladen wird.
|
||||
|
||||
### B. Workflow: Neue Beziehungen nutzen (z. B. `beeinflusst_von`)
|
||||
|
||||
Beziehungen sind der Klebstoff für logische Schlussfolgerungen.
|
||||
|
||||
1. **Erfassung im Vault (Markdown)**
|
||||
Nutze die Inline-Syntax. Du musst nichts vorab definieren.
|
||||
> "Die Entscheidung für Qdrant wurde [[rel:beeinflusst_von Budgetkürzung 2024]]."
|
||||
|
||||
2. **Gewichtung justieren (`config/retriever.yaml`)**
|
||||
Standardmäßig sind alle Kanten gleich `1.0`. Wenn Kausalität wichtiger ist als Ähnlichkeit, definiere dies hier:
|
||||
```yaml
|
||||
retriever:
|
||||
edge_weights:
|
||||
beeinflusst_von: 1.5 # Starker Boost: Zieht Ursachen in den Kontext
|
||||
related_to: 0.5 # Schwacher Boost: Nur "nice to know"
|
||||
```
|
||||
*Effekt:* Bei der Frage nach "Qdrant" landet die "Budgetkürzung" (Ursache) im Kontext, weil die Kante stark ist.
|
||||
|
||||
3. **Interpretation (Prompting)**
|
||||
Das LLM erkennt im RAG-Kontext: `Qdrant --[beeinflusst_von]--> Budgetkürzung`.
|
||||
Es kann daraus den Satz formulieren: *"Die Wahl fiel vermutlich aufgrund der Budgetkürzung auf Qdrant."*
|
||||
|
||||
**Fazit:** Nur wenn **Daten** (Vault), **Physik** (Config) und **Semantik** (Prompt) zusammenspielen, entsteht ein intelligenter Zwilling.
|
||||
|
||||
---
|
||||
|
||||
## 9) Feedback & Lernen – WP04c/WP10
|
||||
|
||||
Das System verfügt nun über ein **Kurzzeitgedächtnis für Interaktionen**, das die Basis für zukünftiges Lernen bildet.
|
||||
|
||||
### 9.1 Der Feedback-Loop
|
||||
Die Interaktion erfolgt primär über das **Web-Interface (WP10)**.
|
||||
|
||||
1. **Suche (Situation):**
|
||||
Wenn ein Nutzer eine Anfrage stellt, loggt Mindnet die "Situation":
|
||||
* Den Query-Text.
|
||||
* Die Top-K Ergebnisse.
|
||||
* Den exakten `score_breakdown` zu diesem Zeitpunkt.
|
||||
* Eine eindeutige `query_id` wird generiert.
|
||||
|
||||
2. **Bewertung (Label):**
|
||||
Der Nutzer bewertet die Antwort (**Sterne**) oder einzelne Quellen (**Faces**) im Frontend.
|
||||
Dieses Feedback wird unter Referenzierung der `query_id` in `feedback.jsonl` gespeichert.
|
||||
|
||||
3. **Lernen (Perspektive WP08):**
|
||||
Durch die Verknüpfung von Situation und Bewertung entstehen Trainingsdaten. Mindnet kann später analysieren: *"Nutzer bevorzugen Treffer mit hohem Edge-Bonus, auch wenn der Text weniger passt."* -> Konsequenz: `edge_weight` erhöhen.
|
||||
|
||||
---
|
||||
|
||||
## 10) Confidence & Provenance – wozu?
|
||||
|
||||
Der Retriever kann Edges gewichten:
|
||||
- **provenance**: *explicit* > *smart* (Neu) > *rule*
|
||||
- **confidence**: numerische Feinsteuerung
|
||||
- **retriever_weight (Note/Chunk)**: skaliert die Relevanz des gesamten Knotens
|
||||
|
||||
Eine typische Gewichtung (konfigurierbar in `retriever.yaml`) ist:
|
||||
`explicit: 1.0`, `smart: 0.9`, `rule: 0.8`. Damit bevorzugt der Graph **kuratiertes Wissen** (explizit notierte Links) vor „erweiterten“ Default-Ableitungen.
|
||||
|
||||
---
|
||||
|
||||
## 11) Semantik ausgewählter `kind`-Werte
|
||||
|
||||
- `references` – „Nutzt/erwähnt“; neutral, aber stützend für Kontext.
|
||||
- `related_to` – Ähnlichkeit/Verwandtschaft (symmetrisch interpretierbar).
|
||||
- `similar_to` – noch engere Ähnlichkeit; oft aus Inline-Rel (bewusst gesetzt).
|
||||
- `depends_on` – fachliche Abhängigkeit (z. B. „Projekt X hängt von Y ab“).
|
||||
- **Neu in v2.4 (Matrix):**
|
||||
- `based_on` – Erfahrung basiert auf Wert.
|
||||
- `derived_from` – Erkenntnis stammt aus Prinzip.
|
||||
- `uses` – Projekt nutzt Konzept.
|
||||
- `belongs_to`, `next`, `prev` – Struktur.
|
||||
|
||||
> Symmetrische Relationen (z. B. `related_to`, `similar_to`) können **explizit** nur einseitig notiert sein, aber im Retriever beidseitig interpretiert werden.
|
||||
|
||||
---
|
||||
|
||||
## 12) Frontmatter-Eigenschaften – Rolle & Empfehlung
|
||||
|
||||
Frontmatter-Eigenschaften (Properties) bleiben **minimiert**:
|
||||
- **type** – steuert Typ-Defaults via Registry (Pflicht für differenziertes Verhalten).
|
||||
- **tags** – für klassische Filterung.
|
||||
- **retriever_weight / chunk_profile** – Sollten **nicht** manuell gesetzt werden (Best Practice: `types.yaml` nutzen).
|
||||
- **links** – Veraltet. Bitte Links primär über Text (Wikilink/Inline/Callout) pflegen.
|
||||
|
||||
---
|
||||
|
||||
## 13) Lösch-/Update-Garantien (Idempotenz)
|
||||
|
||||
- Jede Note hat einen stabilen **note_id** (Frontmatter/Hash).
|
||||
- Vor einem Upsert können *alte Chunks/Edges einer Note* gefiltert gelöscht werden (`note_id`-Filter) – das hält Collections sauber bei Re-Imports.
|
||||
- Die Import-Skripte unterstützen Modi wie `--purge-before-upsert` und `--sync-deletes`, um den Graph sauber zu halten.
|
||||
|
||||
---
|
||||
|
||||
## 14) Beispiel – Von Markdown zu Kanten
|
||||
|
||||
**Markdown (Auszug)**
|
||||
# Relations Showcase
|
||||
…
|
||||
Wir nutzen [[rel:depends_on Qdrant Vektordatenbank]] für die Suche.
|
||||
…
|
||||
Siehe auch: [[Embeddings 101]]
|
||||
|
||||
> [!edge] related_to: [[Vector DB Basics]]
|
||||
|
||||
**Ergebnis (fachlich - Smart Edges)**
|
||||
Das LLM analysiert jeden Chunk.
|
||||
1. Chunk 1 ("Wir nutzen..."): Enthält `depends_on(Chunk→Qdrant)`. Das LLM bestätigt: Relevant. -> Kante wird erstellt.
|
||||
2. Chunk 2 ("Siehe auch..."): Enthält `references(Chunk→Embeddings)`. Das LLM bestätigt.
|
||||
3. **Wichtig:** Ein Chunk 3 ("Die Benutzeroberfläche ist blau..."), der keine Erwähnung von Qdrant hat, bekommt **keine** `depends_on` Kante zu Qdrant, auch wenn die Note global verlinkt ist. Das ist der Gewinn von WP15.
|
||||
|
||||
---
|
||||
|
||||
## 15) Referenzen (Projektdateien & Leitlinien)
|
||||
|
||||
- Import-Pipeline & Registry-Auflösung: `scripts/import_markdown.py`.
|
||||
- Kantenbildung (V2-Logic): `app/core/derive_edges.py`.
|
||||
- Smart Chunking & Traffic Control: `app/core/chunker.py` & `app/services/llm_service.py`.
|
||||
- Typ-Registry: `config/types.yaml` & `TYPE_REGISTRY_MANUAL.md`.
|
||||
- Retriever-Scoring & Explanation: `app/core/retriever.py`.
|
||||
- Persönlichkeit & Chat: `config/prompts.yaml` & `app/routers/chat.py`.
|
||||
- Decision Engine: `config/decision_engine.yaml`.
|
||||
- Logging Service: `app/services/feedback_service.py`.
|
||||
- Frontend UI: `app/frontend/ui.py`.
|
||||
- Intelligence Logic: `app/services/discovery.py`.
|
||||
|
||||
---
|
||||
|
||||
## 16) Workpackage Status (v2.6.0)
|
||||
|
||||
Aktueller Implementierungsstand der Module.
|
||||
|
||||
| WP | Titel | Status | Anmerkung |
|
||||
| :--- | :--- | :--- | :--- |
|
||||
| **WP01** | Knowledge Design | 🟢 Live | Typen, Frontmatter definiert. |
|
||||
| **WP02** | Chunking Strategy | 🟢 Live | Profilbasiertes Chunking aktiv. |
|
||||
| **WP03** | Edge Logic / Import | 🟢 Live | Neue Importer-Pipeline mit Provenance. |
|
||||
| **WP04a**| Retriever Scoring | 🟢 Live | Hybrider Score (Semantik + Graph). |
|
||||
| **WP04b**| Explanation Layer | 🟢 Live | API liefert Reasons & Breakdown. |
|
||||
| **WP04c**| Feedback Loop | 🟢 Live | Logging (JSONL) & Traceability aktiv. |
|
||||
| **WP05** | Persönlichkeit / Chat | 🟢 Live | RAG-Integration mit Context Enrichment. |
|
||||
| **WP06** | Decision Engine | 🟢 Live | Hybrid Router, Strategic Retrieval. |
|
||||
| **WP07** | Interview Assistent | 🟢 Live | **One-Shot Extractor & Schemas aktiv.** |
|
||||
| **WP08** | Self-Tuning | 🔴 Geplant | Auto-Adjustment der Gewichte. |
|
||||
| **WP10** | Chat Interface | 🟢 Live | Web-Interface (Streamlit). |
|
||||
| **WP10a**| Draft Editor | 🟢 Live | **Interaktives UI & Healing Parser.** |
|
||||
| **WP11** | Backend Intelligence | 🟢 Live | **Async Ingestion, Nomic Embeddings, Matrix Logic.** |
|
||||
| **WP15** | Smart Edge Allocation | 🟢 Live | **LLM-Filter & Traffic Control aktiv.** |
|
||||
| **WP16** | Auto-Discovery | 🟡 Geplant | UX & Retrieval Tuning. |
|
||||
| **WP17** | Conversational Memory | 🟡 Geplant | Dialog-Gedächtnis. |
|
||||
@@ -0,0 +1,450 @@
|
||||
# Mindnet v2.6 – Technische Architektur
|
||||
**Datei:** `docs/mindnet_technical_architecture_v2.6.md`
|
||||
**Stand:** 2025-12-12
|
||||
**Status:** **FINAL** (Integrierter Stand WP01–WP15: Smart Edges & Traffic Control)
|
||||
**Quellen:** `Programmplan_V2.6.md`, `Handbuch.md`, `chunking_strategy.md`, `wp04_retriever_scoring.md`.
|
||||
|
||||
> **Ziel dieses Dokuments:**
|
||||
> Vollständige Beschreibung der technischen Architektur inkl. Graph-Datenbank, Retrieval-Logik, der **RAG-Komponenten (Decision Engine & Hybrid Router)**, des **Traffic Control Systems** und dem **Frontend (Streamlit)**.
|
||||
|
||||
---
|
||||
<details>
|
||||
<summary>📖 <b>Inhaltsverzeichnis (Klicken zum Öffnen)</b></summary>
|
||||
|
||||
- [Mindnet v2.6 – Technische Architektur](#mindnet-v26--technische-architektur)
|
||||
- [](#)
|
||||
- [1. Systemüberblick](#1-systemüberblick)
|
||||
- [1.1 Architektur-Zielbild](#11-architektur-zielbild)
|
||||
- [1.2 Verzeichnisstruktur \& Komponenten (Post-WP15)](#12-verzeichnisstruktur--komponenten-post-wp15)
|
||||
- [2. Datenmodell \& Collections (Qdrant)](#2-datenmodell--collections-qdrant)
|
||||
- [2.1 Notes Collection (`<prefix>_notes`)](#21-notes-collection-prefix_notes)
|
||||
- [2.2 Chunks Collection (`<prefix>_chunks`)](#22-chunks-collection-prefix_chunks)
|
||||
- [2.3 Edges Collection (`<prefix>_edges`)](#23-edges-collection-prefix_edges)
|
||||
- [3. Konfiguration](#3-konfiguration)
|
||||
- [3.1 Typ-Registry (`config/types.yaml`)](#31-typ-registry-configtypesyaml)
|
||||
- [3.2 Retriever-Config (`config/retriever.yaml`)](#32-retriever-config-configretrieveryaml)
|
||||
- [3.3 Decision Engine (`config/decision_engine.yaml`)](#33-decision-engine-configdecision_engineyaml)
|
||||
- [3.4 Prompts (`config/prompts.yaml`)](#34-prompts-configpromptsyaml)
|
||||
- [3.5 Environment (`.env`)](#35-environment-env)
|
||||
- [4. Import-Pipeline (Markdown → Qdrant)](#4-import-pipeline-markdown--qdrant)
|
||||
- [4.1 Verarbeitungsschritte (Async + Smart)](#41-verarbeitungsschritte-async--smart)
|
||||
- [5. Retriever-Architektur \& Scoring](#5-retriever-architektur--scoring)
|
||||
- [5.1 Betriebsmodi](#51-betriebsmodi)
|
||||
- [5.2 Scoring-Formel (WP04a)](#52-scoring-formel-wp04a)
|
||||
- [5.3 Explanation Layer (WP04b)](#53-explanation-layer-wp04b)
|
||||
- [5.4 Graph-Expansion](#54-graph-expansion)
|
||||
- [6. RAG \& Chat Architektur (WP06 Hybrid Router + WP07 Interview)](#6-rag--chat-architektur-wp06-hybrid-router--wp07-interview)
|
||||
- [6.1 Architektur-Pattern: Intent Router v5](#61-architektur-pattern-intent-router-v5)
|
||||
- [6.2 Traffic Control (Priorisierung)](#62-traffic-control-priorisierung)
|
||||
- [6.3 Schritt 1: Intent Detection (Question vs. Action)](#63-schritt-1-intent-detection-question-vs-action)
|
||||
- [6.4 Schritt 2: Strategy Resolution](#64-schritt-2-strategy-resolution)
|
||||
- [6.5 Schritt 3: Retrieval vs. Extraction](#65-schritt-3-retrieval-vs-extraction)
|
||||
- [6.6 Schritt 4: Generation \& Response](#66-schritt-4-generation--response)
|
||||
- [7. Frontend Architektur (WP10)](#7-frontend-architektur-wp10)
|
||||
- [7.1 Kommunikation](#71-kommunikation)
|
||||
- [7.2 Features \& UI-Logik](#72-features--ui-logik)
|
||||
- [7.3 Draft-Editor \& Healing Parser (Neu in WP10a/v2.5)](#73-draft-editor--healing-parser-neu-in-wp10av25)
|
||||
- [7.4 State Management (Resurrection Pattern)](#74-state-management-resurrection-pattern)
|
||||
- [7.5 Deployment Ports](#75-deployment-ports)
|
||||
- [8. Feedback \& Logging Architektur (WP04c)](#8-feedback--logging-architektur-wp04c)
|
||||
- [8.1 Komponenten](#81-komponenten)
|
||||
- [8.2 Log-Dateien](#82-log-dateien)
|
||||
- [8.3 Traceability](#83-traceability)
|
||||
- [9. Indizes \& Performance](#9-indizes--performance)
|
||||
- [10. Offene Punkte / Known Limitations](#10-offene-punkte--known-limitations)
|
||||
|
||||
|
||||
</details>
|
||||
---
|
||||
|
||||
## 1. Systemüberblick
|
||||
|
||||
### 1.1 Architektur-Zielbild
|
||||
Mindnet ist ein **lokales RAG-System (Retrieval Augmented Generation)** mit Web-Interface.
|
||||
1. **Source:** Markdown-Notizen in einem Vault (Obsidian-kompatibel).
|
||||
2. **Pipeline:** Ein Python-Importer transformiert diese in **Notes**, **Chunks** und **Edges**.
|
||||
* **Neu in v2.6:** Intelligente Kanten-Zuweisung durch lokale LLMs (**Smart Edge Allocation**).
|
||||
3. **Storage:**
|
||||
* **Qdrant:** Vektor-Datenbank für Graph und Semantik (Collections: notes, chunks, edges).
|
||||
* **Local Files (JSONL):** Append-Only Logs für Feedback und Search-History (Data Flywheel).
|
||||
4. **Backend:** Eine FastAPI-Anwendung stellt Endpunkte für **Semantische** und **Hybride Suche** sowie **Feedback** bereit.
|
||||
* **Update v2.6:** Der Core arbeitet nun vollständig **asynchron (AsyncIO)** mit **Traffic Control** (Semaphore zur Lastverteilung).
|
||||
5. **Frontend:** Streamlit-App (`ui.py`) für Interaktion und Visualisierung inkl. **Draft Editor**, **Active Intelligence** und **Healing Parser**.
|
||||
6. **Inference:** Lokales LLM (Ollama: Phi-3 Mini) für RAG-Chat und Antwortgenerierung. Embedding via `nomic-embed-text`.
|
||||
|
||||
Das System arbeitet **deterministisch** (stabile IDs) und ist **konfigurationsgetrieben** (`types.yaml`, `retriever.yaml`, `decision_engine.yaml`, `prompts.yaml`).
|
||||
|
||||
### 1.2 Verzeichnisstruktur & Komponenten (Post-WP15)
|
||||
|
||||
/mindnet/
|
||||
├── app/
|
||||
│ ├── main.py # FastAPI Einstiegspunkt
|
||||
│ ├── core/
|
||||
│ │ ├── ingestion.py # NEU: Async Ingestion mit Change Detection
|
||||
│ │ ├── qdrant.py # Client-Factory & Connection
|
||||
│ │ ├── qdrant_points.py # Low-Level Point Operations (Upsert/Delete)
|
||||
│ │ ├── note_payload.py # Bau der Note-Objekte
|
||||
│ │ ├── chunk_payload.py # Bau der Chunk-Objekte
|
||||
│ │ ├── chunker.py # Smart Chunker Orchestrator (WP15)
|
||||
│ │ ├── edges.py # Edge-Datenstrukturen
|
||||
│ │ ├── derive_edges.py # Logik der Kantenableitung (WP03)
|
||||
│ │ ├── graph_adapter.py # Subgraph & Reverse-Lookup (WP04b)
|
||||
│ │ └── retriever.py # Scoring, Expansion & Explanation (WP04a/b)
|
||||
│ ├── models/ # Pydantic DTOs
|
||||
│ │ └── dto.py # Zentrale DTO-Definition
|
||||
│ ├── routers/
|
||||
│ │ ├── query.py # Such-Endpunkt
|
||||
│ │ ├── ingest.py # NEU: API für Save & Analyze (WP11)
|
||||
│ │ ├── chat.py # Hybrid Router v5 & Interview Logic (WP06/07)
|
||||
│ │ ├── feedback.py # Feedback-Endpunkt (WP04c)
|
||||
│ │ └── ...
|
||||
│ ├── services/
|
||||
│ │ ├── llm_service.py # Ollama Chat Client mit Traffic Control (v2.8.0)
|
||||
│ │ ├── semantic_analyzer.py# NEU: LLM-Filter für Edges (WP15)
|
||||
│ │ ├── embeddings_client.py# NEU: Async Embeddings (HTTPX)
|
||||
│ │ ├── feedback_service.py # Logging (JSONL Writer)
|
||||
│ │ └── discovery.py # NEU: Intelligence Logic (WP11)
|
||||
│ ├── frontend/ # NEU (WP10)
|
||||
│ │ └── ui.py # Streamlit Application inkl. Healing Parser
|
||||
│ └── main.py # Entrypoint der API
|
||||
├── config/ # YAML-Konfigurationen (Single Source of Truth)
|
||||
│ ├── types.yaml # Import-Regeln & Smart-Edge Config
|
||||
│ ├── prompts.yaml # LLM Prompts & Interview Templates (WP06/07)
|
||||
│ ├── decision_engine.yaml # Router-Strategien (Actions only)
|
||||
│ └── retriever.yaml # Scoring-Regeln & Kantengewichte
|
||||
├── data/
|
||||
│ └── logs/ # Lokale Logs (search_history.jsonl, feedback.jsonl)
|
||||
├── scripts/ # CLI-Tools (Import, Diagnose, Reset)
|
||||
│ ├── import_markdown.py # Haupt-Importer CLI (Async)
|
||||
│ ├── payload_dryrun.py # Diagnose: JSON-Generierung ohne DB
|
||||
│ └── edges_full_check.py # Diagnose: Graph-Integrität
|
||||
├── tests/ # Pytest Suite & Smoke Scripts
|
||||
└── vault/ # Dein lokaler Markdown-Content (Git-ignored)
|
||||
|
||||
---
|
||||
|
||||
## 2. Datenmodell & Collections (Qdrant)
|
||||
|
||||
Das Datenmodell verteilt sich auf drei Collections, definiert durch `COLLECTION_PREFIX` (Standard: `mindnet`).
|
||||
|
||||
### 2.1 Notes Collection (`<prefix>_notes`)
|
||||
Repräsentiert die Metadaten einer Datei.
|
||||
* **Zweck:** Filterung, Metadaten-Haltung, Vererbung von Eigenschaften an Chunks.
|
||||
* **Schema (Payload):**
|
||||
|
||||
| Feld | Datentyp | Beschreibung | Herkunft |
|
||||
| :--- | :--- | :--- | :--- |
|
||||
| `note_id` | Keyword | Stabile ID (UUIDv5 oder Slug). | Frontmatter |
|
||||
| `title` | Text | Titel der Notiz. | Frontmatter |
|
||||
| `type` | Keyword | Logischer Typ (z.B. `concept`). | `types.yaml` Resolver |
|
||||
| `retriever_weight` | Float | Wichtigkeit im Retrieval. | `types.yaml` |
|
||||
| `chunk_profile` | Keyword | Genutztes Chunking-Profil. | `types.yaml` |
|
||||
| `edge_defaults` | List[Str] | Aktive Default-Relationen. | `types.yaml` |
|
||||
| `tags` | List[Kw] | Tags zur Filterung. | Frontmatter |
|
||||
| `updated` | Integer | Zeitstempel (z.B. YYYYMMDD...). | File Stats |
|
||||
| `fulltext` | Text | Gesamter Inhalt (für Export/Rekonstruktion). | Body |
|
||||
|
||||
### 2.2 Chunks Collection (`<prefix>_chunks`)
|
||||
Die atomaren Sucheinheiten.
|
||||
* **Zweck:** Vektorsuche (Embeddings), Granulares Ergebnis.
|
||||
* **Update v2.4:** Vektor-Dimension ist jetzt **768** (für `nomic-embed-text`).
|
||||
* **Schema (Payload):**
|
||||
|
||||
| Feld | Datentyp | Beschreibung |
|
||||
| :--- | :--- | :--- |
|
||||
| `chunk_id` | Keyword | Deterministisch: `{note_id}#c{index:02d}`. |
|
||||
| `note_id` | Keyword | Referenz zur Note. |
|
||||
| `type` | Keyword | **Kopie des Note-Typs** (Denormalisiert für Filter). |
|
||||
| `text` | Text | **Reiner Inhalt** (ohne Overlap). Anzeige-Text. |
|
||||
| `window` | Text | **Kontext-Fenster** (mit Overlap). Embedding-Basis. |
|
||||
| `ord` | Integer | Sortierreihenfolge (1..N). |
|
||||
| `retriever_weight` | Float | Vererbt von Note. |
|
||||
| `chunk_profile` | Keyword | Vererbt von Note. |
|
||||
| `neighbors_prev` | List[Str] | ID des Vorgänger-Chunks. |
|
||||
| `neighbors_next` | List[Str] | ID des Nachfolger-Chunks. |
|
||||
|
||||
### 2.3 Edges Collection (`<prefix>_edges`)
|
||||
Gerichtete Kanten. Massiv erweitert in WP03 für Provenienz-Tracking.
|
||||
* **Zweck:** Graph-Traversal, Kontext-Anreicherung.
|
||||
* **Schema (Payload):**
|
||||
|
||||
| Feld | Datentyp | Beschreibung | Wertebereich (Bsp.) |
|
||||
| :--- | :--- | :--- | :--- |
|
||||
| `edge_id` | Keyword | Hash aus (src, dst, kind). | |
|
||||
| `source_id` | Keyword | ID des Start-Chunks. | |
|
||||
| `target_id` | Keyword | ID des Ziel-Chunks (oder Note-Titel). | |
|
||||
| `note_id` | Keyword | Note, die diese Kante definiert. | |
|
||||
| `kind` | Keyword | Art der Beziehung. | `references`, `depends_on`, `next` |
|
||||
| `scope` | Keyword | Geltungsbereich. | Immer `"chunk"` (v2.2). |
|
||||
| `rule_id` | Keyword | Herkunftsregel. | `explicit:wikilink`, `inline:rel` |
|
||||
| `confidence` | Float | Vertrauenswürdigkeit (0.0-1.0). | 1.0, 0.95, 0.7 |
|
||||
| `provenance` | Keyword | Quelle der Kante (Neu in v2.6). | `explicit`, `rule`, `smart` |
|
||||
|
||||
---
|
||||
|
||||
## 3. Konfiguration
|
||||
|
||||
Die Logik ist ausgelagert in YAML-Dateien.
|
||||
|
||||
### 3.1 Typ-Registry (`config/types.yaml`)
|
||||
Steuert den Import-Prozess.
|
||||
* **Priorität:** Frontmatter > Pfad > Default.
|
||||
* **Neu in v2.6:**
|
||||
* `enable_smart_edge_allocation`: (Bool) Aktiviert den LLM-Filter für diesen Typ.
|
||||
* `detection_keywords`: (List) Keywords für den Hybrid Router ("Objekterkennung").
|
||||
* **Inhalt (Beispiel):**
|
||||
|
||||
types:
|
||||
concept:
|
||||
chunk_profile: sliding_standard
|
||||
edge_defaults: ["references", "related_to"]
|
||||
retriever_weight: 0.60
|
||||
experience:
|
||||
chunk_profile: sliding_smart_edges
|
||||
enable_smart_edge_allocation: true
|
||||
detection_keywords: ["erfahrung", "erlebt"]
|
||||
|
||||
### 3.2 Retriever-Config (`config/retriever.yaml`)
|
||||
Steuert das Scoring zur Laufzeit (WP04a).
|
||||
* **Inhalt (Beispiel):**
|
||||
|
||||
scoring:
|
||||
semantic_weight: 1.0
|
||||
edge_weight: 0.7
|
||||
centrality_weight: 0.5
|
||||
|
||||
### 3.3 Decision Engine (`config/decision_engine.yaml`)
|
||||
**Neu in WP06/07:** Steuert den Intent-Router.
|
||||
* Definiert Strategien (`DECISION`, `INTERVIEW`, etc.).
|
||||
* **Update v2.6:** Enthält nur noch **Handlungs-Keywords** (Verben wie "neu", "erstellen"). Objektnamen ("Projekt") werden nun über `types.yaml` aufgelöst.
|
||||
* Definiert LLM-Router-Settings (`llm_fallback_enabled`).
|
||||
|
||||
### 3.4 Prompts (`config/prompts.yaml`)
|
||||
Steuert die LLM-Persönlichkeit und Templates.
|
||||
* Enthält Templates für alle Strategien inkl. `interview_template` und neu `router_prompt`.
|
||||
|
||||
### 3.5 Environment (`.env`)
|
||||
Erweiterung für LLM-Steuerung und Embedding-Modell:
|
||||
|
||||
MINDNET_LLM_MODEL=phi3:mini
|
||||
MINDNET_EMBEDDING_MODEL=nomic-embed-text # NEU in v2.3.10
|
||||
MINDNET_OLLAMA_URL=http://127.0.0.1:11434
|
||||
MINDNET_LLM_TIMEOUT=300.0 # Neu: Erhöht für CPU-Inference Cold-Starts
|
||||
MINDNET_API_TIMEOUT=300.0 # Neu: Timeout für Frontend-API (Smart Edges brauchen Zeit)
|
||||
MINDNET_DECISION_CONFIG="config/decision_engine.yaml"
|
||||
MINDNET_VAULT_ROOT="./vault" # Neu: Pfad für Write-Back
|
||||
MINDNET_LLM_BACKGROUND_LIMIT=2 # Neu: Limit für parallele Hintergrund-Jobs (Traffic Control)
|
||||
|
||||
---
|
||||
|
||||
## 4. Import-Pipeline (Markdown → Qdrant)
|
||||
|
||||
Das Skript `scripts/import_markdown.py` orchestriert den Prozess.
|
||||
**Neu in v2.6:** Der Import nutzt `asyncio` und **Traffic Control**, um Ollama nicht zu überlasten.
|
||||
|
||||
### 4.1 Verarbeitungsschritte (Async + Smart)
|
||||
|
||||
1. **Discovery & Parsing:** Hash-Vergleich zur Erkennung von Änderungen.
|
||||
2. **Typauflösung:** Bestimmung des `type` via `types.yaml`.
|
||||
3. **Config Check:** Laden des `chunk_profile` und `enable_smart_edge_allocation`.
|
||||
4. **Chunking & Smart Edges (WP15):**
|
||||
* Zerlegung des Textes via `chunker.py`.
|
||||
* Wenn Smart Edges aktiv: Der `SemanticAnalyzer` sendet Chunks an das LLM.
|
||||
* **Traffic Control:** Der Request nutzt `priority="background"`. Die Semaphore (Limit: 2) drosselt die Parallelität.
|
||||
5. **Kantenableitung (Edge Derivation):**
|
||||
* `derive_edges.py` erzeugt Inline-, Callout- und Default-Edges.
|
||||
6. **Embedding (Async):**
|
||||
* Der `EmbeddingsClient` (`app/services/embeddings_client.py`) sendet Text-Chunks asynchron an Ollama.
|
||||
* Modell: `nomic-embed-text` (768d).
|
||||
7. **Upsert:**
|
||||
* Schreiben in Qdrant. Nutzung von `--purge-before-upsert`.
|
||||
* **Strict Mode:** Der Prozess bricht ab, wenn Embeddings leer sind oder Dimension `0` haben.
|
||||
|
||||
---
|
||||
|
||||
## 5. Retriever-Architektur & Scoring
|
||||
|
||||
Der Retriever (`app/core/retriever.py`) unterstützt zwei Modi. Für den Chat wird **zwingend** der Hybrid-Modus genutzt.
|
||||
|
||||
### 5.1 Betriebsmodi
|
||||
* **Semantic:** Reine Vektorsuche (768d).
|
||||
* **Hybrid:** Vektorsuche + Graph-Expansion (Tiefe N) + Re-Ranking.
|
||||
|
||||
### 5.2 Scoring-Formel (WP04a)
|
||||
Die Relevanzberechnung ist nun eine gewichtete Summe:
|
||||
|
||||
$$
|
||||
TotalScore = (W_{sem} \cdot S_{sem} \cdot \max(W_{type}, 0)) + (W_{edge} \cdot B_{edge}) + (W_{cent} \cdot B_{cent})
|
||||
$$
|
||||
|
||||
* **Komponenten:**
|
||||
* $S_{sem}$: Semantic Score (Cosine Similarity).
|
||||
* $W_{type}$: `retriever_weight` (aus Note/Chunk Payload).
|
||||
* $B_{edge}$: Edge-Bonus (Summe der Konfidenzen eingehender relevanter Kanten).
|
||||
* $B_{cent}$: Centrality-Bonus (im lokalen Subgraphen).
|
||||
* **Gewichte ($W$):** Stammen aus `retriever.yaml`.
|
||||
|
||||
### 5.3 Explanation Layer (WP04b)
|
||||
Der Retriever ist keine Blackbox mehr. Er liefert auf Wunsch (`explain=True`) eine strukturierte Begründung (`Explanation`-Objekt).
|
||||
|
||||
**Die "Warum"-Logik:**
|
||||
1. **Semantik:** Prüfung der Cosine-Similarity ("Sehr hohe textuelle Übereinstimmung").
|
||||
2. **Typ:** Prüfung des `retriever_weight` ("Bevorzugt, da Entscheidung").
|
||||
3. **Graph (Kontext):**
|
||||
* **Hub (Outgoing):** Worauf verweist dieser Treffer? ("Verweist auf Qdrant").
|
||||
* **Authority (Incoming):** Wer verweist auf diesen Treffer? ("Wird referenziert von Projekt Alpha").
|
||||
|
||||
Die API gibt diese Analysen als menschenlesbare Sätze (`reasons`) und als Datenstruktur (`score_breakdown`) zurück.
|
||||
|
||||
### 5.4 Graph-Expansion
|
||||
Der Hybrid-Modus lädt dynamisch die Nachbarschaft der Top-K Vektor-Treffer ("Seeds") über `graph_adapter.expand`. Dies baut einen temporären `NetworkX`-artigen Graphen im Speicher (Klasse `Subgraph`), auf dem Boni berechnet werden.
|
||||
|
||||
---
|
||||
|
||||
## 6. RAG & Chat Architektur (WP06 Hybrid Router + WP07 Interview)
|
||||
|
||||
Der Flow für eine Chat-Anfrage (`/chat`) wurde in WP06 auf eine **Configuration-Driven Architecture** umgestellt und in WP15 (v2.6) verfeinert.
|
||||
|
||||
### 6.1 Architektur-Pattern: Intent Router v5
|
||||
Die Behandlung einer Anfrage ist nicht mehr hartkodiert, sondern wird dynamisch zur Laufzeit entschieden.
|
||||
* **Input:** User Message.
|
||||
* **Config:** `decision_engine.yaml` (Strategien) + `types.yaml` (Objekte).
|
||||
* **Komponenten:**
|
||||
* **Traffic Control:** `LLMService` priorisiert Chat-Anfragen.
|
||||
* **Question Detection:** Unterscheidung Frage vs. Befehl.
|
||||
|
||||
### 6.2 Traffic Control (Priorisierung)
|
||||
Der `LLMService` implementiert zwei Spuren basierend auf `app/services/llm_service.py` (v2.8.0):
|
||||
* **Realtime (Chat):** `priority="realtime"`. Umgeht die Semaphore. Antwortet sofort.
|
||||
* **Background (Import/Analyse):** `priority="background"`. Wartet in der Semaphore (`asyncio.Semaphore`), die lazy mit `MINDNET_LLM_BACKGROUND_LIMIT` initialisiert wird.
|
||||
|
||||
### 6.3 Schritt 1: Intent Detection (Question vs. Action)
|
||||
Der Router ermittelt die Absicht (`Intent`) des Nutzers.
|
||||
1. **Frage-Check:** Wenn der Input ein `?` enthält oder mit W-Wörtern beginnt, wird der **RAG-Modus** erzwungen (oder LLM-Entscheidung). Interviews werden hier unterdrückt.
|
||||
2. **Keyword Scan (Fast Path):**
|
||||
* Prüfung auf `trigger_keywords` (Handlung) in `decision_engine.yaml`.
|
||||
* Prüfung auf `detection_keywords` (Objekt) in `types.yaml`.
|
||||
* Treffer -> **INTERVIEW Modus** (Erfassen).
|
||||
3. **LLM Fallback (Slow Path):**
|
||||
* Greift, wenn keine Keywords passen. Sendet Query an LLM Router.
|
||||
|
||||
### 6.4 Schritt 2: Strategy Resolution
|
||||
Basierend auf dem Intent lädt der Router die Parameter:
|
||||
* **Bei RAG (FACT/DECISION):** `inject_types` für Strategic Retrieval.
|
||||
* **Bei INTERVIEW (WP07):** `schemas` (Pflichtfelder) basierend auf der erkannten Ziel-Entität (`_detect_target_type`).
|
||||
|
||||
### 6.5 Schritt 3: Retrieval vs. Extraction
|
||||
Der Router verzweigt hier:
|
||||
|
||||
**A) RAG Modus (FACT, DECISION, EMPATHY):**
|
||||
1. **Primary Retrieval:** Hybride Suche nach der User-Query.
|
||||
2. **Strategic Retrieval (Conditional):** Wenn `inject_types` definiert sind, erfolgt eine zweite Suche, die explizit auf diese Typen filtert.
|
||||
3. **Merge:** Ergebnisse werden dedupliziert zusammengeführt.
|
||||
|
||||
**B) Interview Modus (INTERVIEW):**
|
||||
1. **Kein Retrieval:** Der Kontext ist der Chat-Verlauf (oder initial die Query).
|
||||
2. **Schema Injection:** Das Schema für den erkannten Typ (z.B. "Project") wird geladen.
|
||||
3. **Prompt Assembly:** Der `interview_template` Prompt wird mit der Schema-Definition ("Ziel", "Status") gefüllt.
|
||||
|
||||
### 6.6 Schritt 4: Generation & Response
|
||||
* **Templating:** Das LLM erhält den Prompt basierend auf dem gewählten Template.
|
||||
* **Execution:** Der `LLMService` führt den Call mit `priority="realtime"` aus.
|
||||
* **Response:** Rückgabe enthält Antworttext (im Interview-Modus: Markdown Codeblock), Quellenliste und den erkannten `intent`.
|
||||
|
||||
---
|
||||
|
||||
## 7. Frontend Architektur (WP10)
|
||||
|
||||
Das Frontend ist eine **Streamlit-Anwendung** (`app/frontend/ui.py`), die als separater Prozess läuft und via HTTP mit dem Backend kommuniziert.
|
||||
|
||||
### 7.1 Kommunikation
|
||||
* **Backend-URL:** Konfiguriert via `MINDNET_API_URL` (Default: `http://localhost:8002`).
|
||||
* **Endpoints:**
|
||||
* `/chat` (Interaktion)
|
||||
* `/feedback` (Bewertungen)
|
||||
* `/ingest/analyze` (Active Intelligence / Link-Vorschläge)
|
||||
* `/ingest/save` (Persistence / Speichern im Vault)
|
||||
* **Resilienz:** Das Frontend nutzt `MINDNET_API_TIMEOUT` (300s), um auf langsame Backend-Prozesse (Smart Edges) zu warten.
|
||||
|
||||
### 7.2 Features & UI-Logik
|
||||
* **State Management:** Session-State speichert Chat-Verlauf und `query_id`.
|
||||
* **Visualisierung:**
|
||||
* **Intent Badges:** Zeigt Router-Entscheidung (`DECISION`, `INTERVIEW`, etc.).
|
||||
* **Source Expanders:** Zeigt verwendete Chunks inkl. Score und "Why"-Explanation.
|
||||
* **Sidebar:** Zeigt Suchhistorie (Log-basiert) und Konfiguration.
|
||||
|
||||
### 7.3 Draft-Editor & Healing Parser (Neu in WP10a/v2.5)
|
||||
Wenn der Intent `INTERVIEW` ist, rendert die UI statt einer Textblase den **Draft-Editor**.
|
||||
|
||||
1. **Parsing:** Die Funktion `parse_markdown_draft` extrahiert den Codeblock aus der LLM-Antwort.
|
||||
* **Healing:** Erkennt und repariert defekte YAML-Frontmatter (z.B. fehlendes schließendes `---`), falls das LLM unter Last Fehler macht.
|
||||
2. **Sanitization (`normalize_meta_and_body`):**
|
||||
* Prüft den YAML-Frontmatter auf unerlaubte Felder (Halluzinationen des LLMs).
|
||||
* Verschiebt ungültige Felder (z.B. "Situation") in den Body der Notiz.
|
||||
3. **Editor Widget:** `st.text_area` erlaubt das Bearbeiten des Inhalts vor dem Speichern.
|
||||
4. **Save Action:** Speichert über `/ingest/save` atomar in Vault und DB. Erzeugt intelligente Dateinamen via `slugify`.
|
||||
|
||||
### 7.4 State Management (Resurrection Pattern)
|
||||
Um Datenverlust bei Tab-Wechseln (Chat <-> Editor) zu verhindern, nutzt `ui.py` ein Persistenz-Muster:
|
||||
* Daten liegen in `st.session_state[data_key]`.
|
||||
* Widgets liegen in `st.session_state[widget_key]`.
|
||||
* Callbacks (`on_change`) synchronisieren Widget -> Data.
|
||||
* Beim Neu-Rendern wird Widget-State aus Data-State wiederhergestellt.
|
||||
|
||||
### 7.5 Deployment Ports
|
||||
Zur sauberen Trennung von Prod und Dev laufen Frontend und Backend auf dedizierten Ports:
|
||||
|
||||
| Umgebung | Backend (FastAPI) | Frontend (Streamlit) |
|
||||
| :--- | :--- | :--- |
|
||||
| **Production** | 8001 | 8501 |
|
||||
| **Development** | 8002 | 8502 |
|
||||
|
||||
---
|
||||
|
||||
## 8. Feedback & Logging Architektur (WP04c)
|
||||
|
||||
Mindnet implementiert ein "Data Flywheel" zur späteren Optimierung (Self-Tuning).
|
||||
|
||||
### 8.1 Komponenten
|
||||
* **Feedback Service (`app/services/feedback_service.py`):** Kapselt die Schreibzugriffe.
|
||||
* **Storage:** Lokales Dateisystem (`data/logs/`), Format JSONL (Line-delimited JSON).
|
||||
|
||||
### 8.2 Log-Dateien
|
||||
1. **`search_history.jsonl`**:
|
||||
* Speichert jede Anfrage an `/query` und `/chat`.
|
||||
* Enthält: `query_id`, `query_text`, `timestamp`, `hits` (inkl. `score_breakdown` Snapshots).
|
||||
* Zweck: Trainingsdaten ("Was hat das System gesehen?").
|
||||
2. **`feedback.jsonl`**:
|
||||
* Speichert User-Reaktionen an `/feedback`.
|
||||
* Enthält: `query_id`, `node_id`, `score` (1-5), `comment`.
|
||||
* **Granularität:** Kann sich auf `generated_answer` (Global) oder eine spezifische `node_id` (Quelle) beziehen.
|
||||
* Zweck: Labels ("War es gut?").
|
||||
|
||||
### 8.3 Traceability
|
||||
Die `query_id` (UUIDv4) wird im `/query` Response generiert und muss vom Client beim `/feedback` Aufruf mitgesendet werden. Dies ermöglicht den Join zwischen Snapshot und Bewertung.
|
||||
|
||||
---
|
||||
|
||||
## 9. Indizes & Performance
|
||||
|
||||
Damit Qdrant performant bleibt, sind Payload-Indizes essenziell.
|
||||
|
||||
**Erforderliche Indizes:**
|
||||
* **Notes:** `note_id`, `type`, `tags`.
|
||||
* **Chunks:** `note_id`, `chunk_id`, `type`.
|
||||
* **Edges:** `source_id`, `target_id`, `kind`, `scope`, `note_id`.
|
||||
|
||||
Validierung erfolgt über `tests/ensure_indexes_and_show.py`.
|
||||
|
||||
---
|
||||
|
||||
## 10. Offene Punkte / Known Limitations
|
||||
|
||||
1. **Multi-Target Inline-Relations:**
|
||||
* `rel: similar_to [[A]] [[B]]` wird aktuell parser-seitig nicht unterstützt.
|
||||
* Workaround: Zwei separate Inline-Links `[[rel:similar_to A]] [[rel:similar_to B]]`.
|
||||
2. **Unresolved Targets:**
|
||||
* Kanten zu Notizen, die noch nicht existieren, werden mit `target_id="Titel"` angelegt.
|
||||
* Heilung durch `scripts/resolve_unresolved_references.py` möglich.
|
||||
3. **Hardware-Last bei Smart Import:**
|
||||
* Der "Smart Edge" Import ist rechenintensiv. Trotz Traffic Control kann die Antwortzeit im Chat leicht steigen, wenn die GPU am VRAM-Limit arbeitet.
|
||||
@@ -0,0 +1,291 @@
|
||||
# mindnet v2.4 – Pipeline Playbook
|
||||
**Datei:** `docs/mindnet_pipeline_playbook_v2.6.md`
|
||||
**Stand:** 2025-12-12
|
||||
**Status:** **FINAL** (Inkl. Smart Edges & Traffic Control)
|
||||
**Quellen:** `mindnet_v2_implementation_playbook.md`, `Handbuch.md`, `chunking_strategy.md`, `docs_mindnet_retriever.md`, `mindnet_admin_guide_v2.4.md`.
|
||||
|
||||
---
|
||||
<details>
|
||||
<summary>📖 <b>Inhaltsverzeichnis (Klicken zum Öffnen)</b></summary>
|
||||
|
||||
- [mindnet v2.4 – Pipeline Playbook](#mindnet-v24--pipeline-playbook)
|
||||
- [](#)
|
||||
- [1. Zweck \& Einordnung](#1-zweck--einordnung)
|
||||
- [2. Die Import-Pipeline (Runbook)](#2-die-import-pipeline-runbook)
|
||||
- [2.1 Der 13-Schritte-Prozess (Async + Smart)](#21-der-13-schritte-prozess-async--smart)
|
||||
- [2.2 Standard-Betrieb (Inkrementell)](#22-standard-betrieb-inkrementell)
|
||||
- [2.3 Deployment \& Restart (Systemd)](#23-deployment--restart-systemd)
|
||||
- [2.4 Full Rebuild (Clean Slate)](#24-full-rebuild-clean-slate)
|
||||
- [3. Chunking \& Payload-Aufbau](#3-chunking--payload-aufbau)
|
||||
- [3.1 Chunk-Profile](#31-chunk-profile)
|
||||
- [3.2 Payload-Felder](#32-payload-felder)
|
||||
- [4. Edge-Erzeugung (Die V2-Logik)](#4-edge-erzeugung-die-v2-logik)
|
||||
- [4.1 Prioritäten \& Provenance](#41-prioritäten--provenance)
|
||||
- [4.2 Smart Edge Allocation (WP15)](#42-smart-edge-allocation-wp15)
|
||||
- [4.3 Typ-Defaults](#43-typ-defaults)
|
||||
- [5. Retriever, Chat \& Generation (RAG Pipeline)](#5-retriever-chat--generation-rag-pipeline)
|
||||
- [5.1 Retrieval (Hybrid)](#51-retrieval-hybrid)
|
||||
- [5.2 Intent Router (WP06/07)](#52-intent-router-wp0607)
|
||||
- [5.3 Context Enrichment](#53-context-enrichment)
|
||||
- [5.4 Generation (LLM) mit Traffic Control](#54-generation-llm-mit-traffic-control)
|
||||
- [5.5 Active Intelligence Pipeline (Neu in v2.4)](#55-active-intelligence-pipeline-neu-in-v24)
|
||||
- [6. Feedback \& Lernen (WP04c)](#6-feedback--lernen-wp04c)
|
||||
- [7. Quality Gates \& Tests](#7-quality-gates--tests)
|
||||
- [7.1 Pflicht-Tests vor Commit](#71-pflicht-tests-vor-commit)
|
||||
- [7.2 Smoke-Test (E2E)](#72-smoke-test-e2e)
|
||||
- [8. Ausblick \& Roadmap (Technische Skizzen)](#8-ausblick--roadmap-technische-skizzen)
|
||||
- [8.1 WP-08: Self-Tuning (Skizze)](#81-wp-08-self-tuning-skizze)
|
||||
- [16. Workpackage Status (v2.6.0)](#16-workpackage-status-v260)
|
||||
|
||||
</details>
|
||||
---
|
||||
|
||||
## 1. Zweck & Einordnung
|
||||
|
||||
Dieses Playbook ist das zentrale operative Handbuch für die **mindnet-Pipeline**. Es beschreibt, wie Daten vom Markdown-Vault in den Wissensgraphen (Qdrant) gelangen, wie der Retriever betrieben wird und wie die **RAG-Generierung** (inkl. Decision Engine & Interviewer) funktioniert.
|
||||
|
||||
**Zielgruppe:** Dev/Ops, Tech-Leads.
|
||||
**Scope:**
|
||||
* **Ist-Stand (WP01–WP15):** Async Import, Smart Chunking, Edge-Erzeugung, Hybrider Retriever, RAG-Chat (Hybrid Router), Feedback Loop, Frontend, Draft Editor, Active Intelligence.
|
||||
* **Roadmap (Ausblick):** Technische Skizze für Self-Tuning (WP08).
|
||||
|
||||
---
|
||||
|
||||
## 2. Die Import-Pipeline (Runbook)
|
||||
|
||||
Der Import ist der kritischste Prozess ("Data Ingestion"). Er muss **deterministisch** und **idempotent** sein. Wir nutzen `scripts/import_markdown.py` als zentralen Entrypoint.
|
||||
|
||||
### 2.1 Der 13-Schritte-Prozess (Async + Smart)
|
||||
Seit v2.6 läuft der Import vollständig asynchron, nutzt intelligente Kantenvalidierung (Smart Edges) und drosselt sich selbst ("Traffic Control").
|
||||
|
||||
1. **Markdown lesen:** Rekursives Scannen des Vaults.
|
||||
2. **Frontmatter extrahieren:** Validierung von Pflichtfeldern (`id`, `type`, `title`).
|
||||
3. **Typauflösung:** Bestimmung des `type` via `types.yaml` (Prio: Frontmatter > Pfad > Default).
|
||||
4. **Note-Payload generieren:** Erstellen des JSON-Objekts für `mindnet_notes`.
|
||||
5. **Chunking anwenden:** Zerlegung des Textes basierend auf dem `chunk_profile` des Typs (z.B. `sliding_smart_edges`).
|
||||
6. **Smart Edge Allocation (Neu in WP15):**
|
||||
* Wenn in `types.yaml` aktiviert (`enable_smart_edge_allocation`):
|
||||
* Der `SemanticAnalyzer` sendet jeden Chunk an das LLM.
|
||||
* **Resilienz & Traffic Control:**
|
||||
* **Priority:** Der Request nutzt `priority="background"`.
|
||||
* **Semaphore:** Eine globale Semaphore (Limit: 2, konfigurierbar) verhindert System-Überlastung.
|
||||
* **Retry & Backoff:** Bei Fehlern (Timeouts) wird bis zu 5-mal mit exponentieller Wartezeit wiederholt.
|
||||
* **JSON Repair:** Der Analyzer erkennt fehlerhaftes JSON (z.B. Dict statt Liste) und repariert es automatisch.
|
||||
* **Safety Fallback:** Schlagen alle Versuche fehl, werden die Kanten *allen* Chunks zugewiesen, um Datenverlust zu vermeiden.
|
||||
* Ergebnis: Das LLM filtert irrelevante Links aus dem Chunk ("Broadcasting" verhindern).
|
||||
7. **Inline-Kanten finden:** Parsing von `[[rel:...]]` im Fließtext.
|
||||
8. **Callout-Kanten finden:** Parsing von `> [!edge]` Blöcken.
|
||||
9. **Default-Edges erzeugen:** Anwendung der `edge_defaults` aus der Typ-Registry.
|
||||
10. **Strukturkanten erzeugen:** `belongs_to`, `next`, `prev` (Sequenz).
|
||||
11. **Embedding & Upsert (Async):**
|
||||
* Generierung der Vektoren via `nomic-embed-text` (768 Dim).
|
||||
12. **Strict Mode:** Der Prozess bricht sofort ab, wenn ein Embedding leer ist oder die Dimension `0` hat.
|
||||
13. **Diagnose:** Automatischer Check der Integrität nach dem Lauf.
|
||||
|
||||
### 2.2 Standard-Betrieb (Inkrementell)
|
||||
Für regelmäßige Updates (z.B. Cronjob). Erkennt Änderungen via Hash.
|
||||
|
||||
export QDRANT_URL="http://localhost:6333"
|
||||
export COLLECTION_PREFIX="mindnet"
|
||||
|
||||
# Import starten (Apply = Schreiben, Purge = Sauberer Upsert)
|
||||
# Nutzt das Venv der Produktionsumgebung
|
||||
/home/llmadmin/mindnet/.venv/bin/python3 -m scripts.import_markdown \
|
||||
--vault ./vault \
|
||||
--prefix "$COLLECTION_PREFIX" \
|
||||
--apply \
|
||||
--purge-before-upsert \
|
||||
--sync-deletes
|
||||
|
||||
* `--apply`: Ohne dieses Flag läuft ein Dry-Run (nur Simulation).
|
||||
* `--purge-before-upsert`: Löscht vor dem Schreiben einer Note ihre alten Chunks/Edges. Essentiell, um "Geister-Chunks" zu vermeiden, wenn Text gekürzt wurde.
|
||||
* `--sync-deletes`: Entfernt Notizen aus Qdrant, die im Vault gelöscht wurden.
|
||||
|
||||
### 2.3 Deployment & Restart (Systemd)
|
||||
Nach einem Import oder Code-Update müssen die API-Prozesse neu gestartet werden.
|
||||
|
||||
# Neustart des Produktions-Services (API + UI)
|
||||
sudo systemctl restart mindnet-prod
|
||||
sudo systemctl restart mindnet-ui-prod
|
||||
|
||||
# Prüfung
|
||||
sudo systemctl status mindnet-prod
|
||||
|
||||
### 2.4 Full Rebuild (Clean Slate)
|
||||
Notwendig bei Änderungen an `types.yaml` (z.B. Smart Edges an/aus) oder beim Wechsel des Embedding-Modells.
|
||||
|
||||
**WICHTIG:** Vorher das Modell pullen, sonst schlägt der Import fehl!
|
||||
|
||||
# 0. Modell sicherstellen (WICHTIG für v2.4+)
|
||||
ollama pull nomic-embed-text
|
||||
|
||||
# 1. Qdrant Collections löschen und neu anlegen (Wipe inkl. Schema 768d)
|
||||
python3 -m scripts.reset_qdrant --mode wipe --prefix "mindnet" --yes
|
||||
|
||||
# 2. Vollständiger Import aller Dateien
|
||||
python3 -m scripts.import_markdown --vault ./vault --prefix "mindnet" --apply --force
|
||||
|
||||
---
|
||||
|
||||
## 3. Chunking & Payload-Aufbau
|
||||
|
||||
Das Chunking ist profilbasiert und typgesteuert.
|
||||
|
||||
### 3.1 Chunk-Profile
|
||||
In `types.yaml` definiert. Standard-Profile (in `chunk_config.py` implementiert):
|
||||
* `sliding_short`: Max 128 Tokens (z.B. für Logs, Chats).
|
||||
* `sliding_standard`: Max 512 Tokens (Standard für Massendaten).
|
||||
* `sliding_smart_edges`: Sliding Window, optimiert für LLM-Analyse (Fließtext).
|
||||
* `structured_smart_edges`: Trennt strikt an Überschriften (für strukturierte Daten).
|
||||
|
||||
### 3.2 Payload-Felder
|
||||
Jeder Chunk erhält zwei Text-Felder:
|
||||
* `text`: Der reine Inhalt des Chunks (ohne Overlap). Wird dem Nutzer angezeigt.
|
||||
* `window`: Der Inhalt plus Overlap zu Vorgänger/Nachfolger. Wird für das Embedding genutzt (besserer Kontext).
|
||||
|
||||
---
|
||||
|
||||
## 4. Edge-Erzeugung (Die V2-Logik)
|
||||
|
||||
In v2.6 entstehen Kanten nach strenger Priorität.
|
||||
|
||||
### 4.1 Prioritäten & Provenance
|
||||
Der Importer setzt `provenance`, `rule_id` und `confidence` automatisch:
|
||||
|
||||
| Priorität | Quelle | Syntax (Bsp.) | Rule ID | Confidence |
|
||||
| :--- | :--- | :--- | :--- | :--- |
|
||||
| **1** | Inline | `[[rel:depends_on X]]` | `inline:rel` | ~0.95 |
|
||||
| **2** | Callout | `> [!edge] related_to: [[X]]` | `callout:edge` | ~0.90 |
|
||||
| **3** | Wikilink | `[[X]]` | `explicit:wikilink` | 1.00 |
|
||||
| **4** | Smart | *(via LLM Filter)* | `smart:llm_filter` | 0.90 |
|
||||
| **5** | Default | *(via types.yaml)* | `edge_defaults:...` | ~0.70 |
|
||||
| **6** | Struktur | *(automatisch)* | `structure:...` | 1.00 |
|
||||
|
||||
### 4.2 Smart Edge Allocation (WP15)
|
||||
Dieser Mechanismus löst das Problem, dass Chunks sonst alle Links der Note erben.
|
||||
* **Prozess:** Der `SemanticAnalyzer` prüft jeden Chunk: "Ist Link X im Kontext von Chunk Y relevant?"
|
||||
* **Ergebnis:** Kanten werden präzise an den Chunk gebunden, nicht global an die Note.
|
||||
* **Steuerung:** Das Feature wird in `types.yaml` per Typ aktiviert (`enable_smart_edge_allocation: true`).
|
||||
|
||||
### 4.3 Typ-Defaults
|
||||
Wenn in `types.yaml` für einen Typ `edge_defaults` definiert sind, werden diese **additiv** zu expliziten Links erzeugt.
|
||||
* *Beispiel:* Note Typ `project` verlinkt `[[Tool A]]`.
|
||||
* *Ergebnis:* Kante `references` (explizit) UND Kante `depends_on` (Default).
|
||||
|
||||
---
|
||||
|
||||
## 5. Retriever, Chat & Generation (RAG Pipeline)
|
||||
|
||||
Der Datenfluss endet nicht beim Finden. Er geht weiter bis zur Antwort.
|
||||
|
||||
### 5.1 Retrieval (Hybrid)
|
||||
Der `/chat` Endpunkt nutzt **Hybrid Retrieval** (Semantic + Graph), um auch logisch verbundene, aber textlich unterschiedliche Notizen zu finden (z.B. Decisions zu einem Projekt).
|
||||
|
||||
### 5.2 Intent Router (WP06/07)
|
||||
Der Request durchläuft den **Hybrid Router v5**:
|
||||
1. **Question Detection:** Ist es eine Frage (`?`, W-Wörter)? -> RAG Modus. Interviews werden hier blockiert.
|
||||
2. **Keyword Scan:** Enthält es Keywords aus `types.yaml` (Objekt, z.B. "Projekt") oder `decision_engine.yaml` (Action, z.B. "erstellen")? -> INTERVIEW Modus.
|
||||
3. **LLM Fallback:** Wenn unklar, entscheidet das LLM.
|
||||
|
||||
### 5.3 Context Enrichment
|
||||
Der Router (`chat.py`) reichert die gefundenen Chunks mit Metadaten an:
|
||||
* **Typ-Injection:** `[DECISION]`, `[PROJECT]`.
|
||||
* **Reasoning-Infos:** `(Score: 0.75)`.
|
||||
|
||||
### 5.4 Generation (LLM) mit Traffic Control
|
||||
* **Engine:** Ollama (lokal).
|
||||
* **Modell:** `phi3:mini` (Standard).
|
||||
* **Prompting:** Template wird basierend auf Intent gewählt (`decision_template`, `interview_template` etc.).
|
||||
* **Traffic Control:** Der `LLMService` unterscheidet:
|
||||
* **Chat-Requests** (`priority="realtime"`) -> Sofortige Ausführung.
|
||||
* **Import-Requests** (`priority="background"`) -> Gedrosselt durch Semaphore (Standard: 2).
|
||||
|
||||
### 5.5 Active Intelligence Pipeline (Neu in v2.4)
|
||||
Ein paralleler Datenfluss im Frontend ("Draft Editor") zur Unterstützung des Autors.
|
||||
1. **Trigger:** User klickt "Analyse starten" oder tippt.
|
||||
2. **Service:** `ingest/analyze` (Backend).
|
||||
3. **Discovery:**
|
||||
* **Sliding Window:** Zerlegt Text in Abschnitte.
|
||||
* **Embedding:** Vektorisiert Abschnitte via Nomic (Async).
|
||||
* **Exact Match:** Sucht nach Aliases ("KI-Gedächtnis").
|
||||
* **Matrix Logic:** Bestimmt Kanten-Typ (`experience` -> `based_on` -> `value`).
|
||||
4. **Feedback:** UI zeigt Vorschläge (`[[rel:...]]`) zum Einfügen an.
|
||||
|
||||
---
|
||||
|
||||
## 6. Feedback & Lernen (WP04c)
|
||||
|
||||
Das System schreibt kontinuierlich Logs ("Data Flywheel"):
|
||||
* `data/logs/search_history.jsonl`: Trainingsdaten (Query + Ergebnisse + Breakdown).
|
||||
* `data/logs/feedback.jsonl`: Labels (User-Rating zur `query_id`).
|
||||
|
||||
---
|
||||
|
||||
## 7. Quality Gates & Tests
|
||||
|
||||
Diese Tests garantieren die Stabilität der Pipeline.
|
||||
|
||||
### 7.1 Pflicht-Tests vor Commit
|
||||
|
||||
1. **Payload Dryrun (Schema-Check):**
|
||||
Simuliert Import, prüft JSON-Schema Konformität.
|
||||
|
||||
python3 -m scripts.payload_dryrun --vault ./test_vault
|
||||
|
||||
2. **Full Edge Check (Graph-Integrität):**
|
||||
Prüft Invarianten (z.B. `next` muss reziprok zu `prev` sein).
|
||||
|
||||
python3 -m scripts.edges_full_check
|
||||
|
||||
### 7.2 Smoke-Test (E2E)
|
||||
Prüft am laufenden System (Prod oder Dev), ob Semantik, Graph und Feedback funktionieren.
|
||||
|
||||
# Retriever Test
|
||||
python scripts/test_retriever_smoke.py --mode hybrid --top-k 5
|
||||
|
||||
# Intelligence Test (WP11)
|
||||
curl -X POST "http://localhost:8002/ingest/analyze" -d '{"text": "mindnet", "type": "journal"}'
|
||||
|
||||
# Decision Engine Test (WP06)
|
||||
python tests/test_wp06_decision.py -p 8002 -e EMPATHY -q "Alles ist grau"
|
||||
|
||||
# Feedback Test
|
||||
python tests/test_feedback_smoke.py --url http://localhost:8001/query
|
||||
|
||||
---
|
||||
|
||||
## 8. Ausblick & Roadmap (Technische Skizzen)
|
||||
|
||||
Wie entwickeln wir die Pipeline weiter?
|
||||
|
||||
### 8.1 WP-08: Self-Tuning (Skizze)
|
||||
**Ziel:** Die Gewichte in `retriever.yaml` basierend auf `feedback.jsonl` optimieren.
|
||||
**Ansatz:** Ein Offline-Learning-Skript `scripts/optimize_weights.py`.
|
||||
1. **Load:** Liest `search_history.jsonl` und joint mit `feedback.jsonl` via `query_id`.
|
||||
2. **Analyze:** Korrelation Scores vs. User-Rating.
|
||||
3. **Optimize:** Vorschlag neuer Gewichte für `retriever.yaml`.
|
||||
|
||||
---
|
||||
|
||||
## 16. Workpackage Status (v2.6.0)
|
||||
|
||||
Aktueller Implementierungsstand der Module.
|
||||
|
||||
| WP | Titel | Status | Anmerkung |
|
||||
| :--- | :--- | :--- | :--- |
|
||||
| **WP01** | Knowledge Design | 🟢 Live | Typen, Frontmatter definiert. |
|
||||
| **WP02** | Chunking Strategy | 🟢 Live | Profilbasiertes Chunking aktiv. |
|
||||
| **WP03** | Edge Logic / Import | 🟢 Live | Neue Importer-Pipeline mit Provenance. |
|
||||
| **WP04a**| Retriever Scoring | 🟢 Live | Hybrider Score (Semantik + Graph). |
|
||||
| **WP04b**| Explanation Layer | 🟢 Live | API liefert Reasons & Breakdown. |
|
||||
| **WP04c**| Feedback Loop | 🟢 Live | Logging (JSONL) & Traceability aktiv. |
|
||||
| **WP05** | Persönlichkeit / Chat | 🟢 Live | RAG-Integration mit Context Enrichment. |
|
||||
| **WP06** | Decision Engine | 🟢 Live | Hybrid Router, Strategic Retrieval. |
|
||||
| **WP07** | Interview Assistent | 🟢 Live | **One-Shot Extractor & Schemas aktiv.** |
|
||||
| **WP08** | Self-Tuning | 🔴 Geplant | Auto-Adjustment der Gewichte. |
|
||||
| **WP10** | Chat Interface | 🟢 Live | Web-Interface (Streamlit). |
|
||||
| **WP10a**| Draft Editor | 🟢 Live | **Interaktives UI für WP07 Drafts.** |
|
||||
| **WP11** | Backend Intelligence | 🟢 Live | **Async Ingestion, Nomic Embeddings, Matrix Logic.** |
|
||||
| **WP15** | Smart Edge Allocation | 🟢 Live | **LLM-Filter & Traffic Control aktiv.** |
|
||||
| **WP16** | Auto-Discovery | 🟡 Geplant | UX & Retrieval Tuning. |
|
||||
| **WP17** | Conversational Memory | 🟡 Geplant | Dialog-Gedächtnis. |
|
||||
@@ -0,0 +1,139 @@
|
||||
# Mindnet v2.4 – User Guide
|
||||
**Datei:** `docs/mindnet_user_guide_v2.6.md`
|
||||
**Stand:** 2025-12-12
|
||||
**Status:** **FINAL** (Inkl. Smart Edges, Hybrid Router v5 & Healing UI)
|
||||
**Quellen:** `knowledge_design.md`, `wp04_retriever_scoring.md`, `Programmplan_V2.2.md`, `Handbuch.md`.
|
||||
|
||||
> **Willkommen bei Mindnet.**
|
||||
> Dies ist dein persönliches Wissensnetzwerk und dein Digitaler Zwilling. Es hilft dir beim Erinnern, beim Entscheiden, beim Reflektieren und beim **Erstellen von Inhalten**.
|
||||
|
||||
---
|
||||
|
||||
## 1. Was Mindnet für dich tut
|
||||
|
||||
Mindnet ist ein **assoziatives Gedächtnis** mit Persönlichkeit. Es unterscheidet sich von einer reinen Suche (wie Google) dadurch, dass es **kontextsensitiv** agiert.
|
||||
|
||||
### 1.1 Das Gedächtnis (Der Graph)
|
||||
Wenn du nach "Projekt Alpha" suchst, findet Mindnet nicht nur das Dokument. Es findet auch:
|
||||
* **Abhängigkeiten:** "Technologie X wird benötigt".
|
||||
* **Entscheidungen:** "Warum nutzen wir X?".
|
||||
* **Ähnliches:** "Projekt Beta war ähnlich".
|
||||
* **Neu in v2.6 (Smart Edges):** Mindnet zeigt dir präzise Verknüpfungen an, die für den spezifischen Textabschnitt relevant sind, statt pauschal alle Links der Notiz anzuzeigen.
|
||||
|
||||
### 1.2 Der Zwilling (Die Personas)
|
||||
Mindnet passt seinen Charakter dynamisch an deine Frage an:
|
||||
1. **Der Bibliothekar (FACT):** Liefert präzise Fakten und Definitionen.
|
||||
2. **Der Berater (DECISION):** Hilft dir beim Abwägen, basierend auf deinen Werten und Zielen.
|
||||
3. **Der Spiegel (EMPATHY):** Hört zu und antwortet basierend auf deinen Erfahrungen ("Ich"-Perspektive).
|
||||
4. **Der Analyst (INTERVIEW):** Hilft dir, neue Notizen zu entwerfen und strukturiert zu erfassen.
|
||||
|
||||
---
|
||||
|
||||
## 2. Die Oberfläche (Web UI)
|
||||
|
||||
Seit Version 2.3.1 bedienst du Mindnet über eine grafische Oberfläche im Browser.
|
||||
|
||||
### 2.1 Der Chat-Bereich
|
||||
* **Eingabe:** Unten findest du das Textfeld.
|
||||
* **Intent-Badge:** Über jeder Antwort zeigt ein kleines Label (z.B. **⚖️ Intent: DECISION**), in welchem Modus das System arbeitet und ob dies durch ein Schlüsselwort oder die KI erkannt wurde.
|
||||
* **Quellen-Karten:** Unter der Antwort findest du ausklappbare Karten ("Expanders").
|
||||
* **Grüner Punkt:** Hohe Relevanz (Score > 0.8).
|
||||
* **Gelber Punkt:** Mittlere Relevanz.
|
||||
* **Klick darauf:** Zeigt den Textauszug und die **Begründung** ("Warum wurde das gefunden?").
|
||||
|
||||
### 2.2 Die Sidebar (Einstellungen & Verlauf)
|
||||
* **Modus-Wahl:** Umschalten zwischen "💬 Chat" und "📝 Manueller Editor".
|
||||
* *Neu in v2.4:* Der manuelle Editor speichert deine Eingaben auch beim Wechseln der Tabs ("State Resurrection").
|
||||
* **Verlauf:** Die letzten Suchanfragen sind hier gelistet. Ein Klick führt die Suche erneut aus.
|
||||
* **Settings:**
|
||||
* **Top-K:** Wie viele Quellen sollen gelesen werden? (Standard: 5).
|
||||
* **Explanation Layer:** Schaltet die "Warum"-Erklärungen an/aus.
|
||||
|
||||
---
|
||||
|
||||
## 3. Den Chat steuern (Intents)
|
||||
|
||||
Du steuerst die Persönlichkeit von Mindnet durch deine Wortwahl. Das System nutzt einen **Hybrid Router v5**, der intelligent zwischen Frage und Befehl unterscheidet.
|
||||
|
||||
### 3.1 Frage-Modus (Wissen abrufen)
|
||||
Sobald du ein Fragezeichen `?` benutzt oder Wörter wie "Wer", "Wie", "Was", "Soll ich" verwendest, sucht Mindnet nach Antworten (**RAG**).
|
||||
|
||||
* **Entscheidung ("Soll ich?"):** Mindnet lädt deine **Werte** (`type: value`) und **Ziele** (`type: goal`) in den Kontext und prüft die Fakten dagegen.
|
||||
* *Beispiel:* "Soll ich Tool X nutzen?" -> "Nein, Tool X speichert Daten in den USA. Das verstößt gegen dein Prinzip 'Privacy First' und dein Ziel 'Digitale Autarkie'."
|
||||
* **Empathie ("Ich fühle..."):** Mindnet lädt deine **Erfahrungen** (`type: experience`) und **Glaubenssätze** (`type: belief`). Es antwortet verständnisvoll und zitiert deine eigenen Lektionen.
|
||||
* *Beispiel:* "Ich bin frustriert." -> "Das erinnert mich an Projekt Y, da ging es uns ähnlich..."
|
||||
|
||||
### 3.2 Befehls-Modus (Wissen erfassen / Interview)
|
||||
Wenn du keine Frage stellst, sondern eine Absicht äußerst, wechselt Mindnet in den **Interview-Modus**.
|
||||
|
||||
* **Auslöser:** "Neues Projekt", "Notiz erstellen", "Ich will etwas festhalten", "Neue Entscheidung dokumentieren".
|
||||
* **Was passiert:** Mindnet sucht nicht im Archiv, sondern öffnet den **Draft-Editor**.
|
||||
* **Beispiel:** "Neue Erfahrung: Streit am Recyclinghof." -> Das System erstellt sofort eine strukturierte Notiz mit den Feldern "Situation", "Reaktion" und "Learning".
|
||||
|
||||
---
|
||||
|
||||
## 4. Ergebnisse interpretieren (Explanation Layer)
|
||||
|
||||
Mindnet liefert nicht einfach nur Treffer. Es liefert eine **Begründung** (Explanation), warum es etwas gefunden hat.
|
||||
|
||||
### 4.1 Die Gründe ("Reasons")
|
||||
Öffne eine Quellen-Karte, um zu sehen:
|
||||
* *"Hohe textuelle Übereinstimmung."* (Semantik)
|
||||
* *"Bevorzugt aufgrund des Typs 'decision'."* (Wichtigkeit)
|
||||
* *"Verweist auf 'Projekt X' via 'depends_on'."* (Graph-Kontext)
|
||||
|
||||
---
|
||||
|
||||
## 5. Feedback & Lernen
|
||||
|
||||
Mindnet wird schlauer, wenn du es pflegst. Nutze die Feedback-Funktionen im Chat:
|
||||
|
||||
### 5.1 Globales Feedback (Antwort-Qualität)
|
||||
* **Wie:** Klicke auf die **Sterne (1-5)** unter der Antwort.
|
||||
* **Bedeutung:** Bewertet, wie gut die generierte Antwort war (Prompting, Tonfall).
|
||||
|
||||
### 5.2 Granulares Feedback (Quellen-Relevanz)
|
||||
* **Wie:** Klicke innerhalb einer Quellen-Karte auf die **Smileys (Faces)**.
|
||||
* **Bedeutung:**
|
||||
* 😞 (Sad): Diese Quelle ist irrelevant/falsch. (Senkt zukünftig das Gewicht).
|
||||
* 😐 (Neutral): Okay, aber nicht entscheidend.
|
||||
* 😀 (Grin): Das ist der perfekte Treffer! (Stärkt diesen Typ/Kante).
|
||||
|
||||
---
|
||||
|
||||
## 6. Neues Wissen beisteuern (Authoring)
|
||||
|
||||
Mindnet lebt von deinem Input. Du musst kein Techniker sein, um gutes Wissen zu designen. Siehe dazu das **Knowledge Design Manual** für Details.
|
||||
|
||||
### 6.1 Die Goldene Regel: "Verlinke semantisch"
|
||||
Statt einfach nur `[[Link]]` zu schreiben, versuche zu sagen, *wie* es zusammenhängt.
|
||||
* Hängt es davon ab? -> `[[rel:depends_on Ziel]]`
|
||||
* Ist es ähnlich? -> `[[rel:similar_to Ziel]]`
|
||||
|
||||
### 6.2 Typen nutzen (Wichtig!)
|
||||
Setze im Frontmatter deiner Notizen den richtigen Typ. Das ist der wichtigste Hebel für den Chat:
|
||||
* Willst du, dass Mindnet etwas als **Regel** nutzt? -> `type: principle`
|
||||
* Willst du, dass Mindnet dich an eine **Lektion** erinnert? -> `type: experience`
|
||||
|
||||
### 6.3 Der Interview-Assistent (Drafting)
|
||||
Mindnet kann dir helfen, Markdown-Notizen zu schreiben.
|
||||
|
||||
1. **Start:** Schreibe im Chat: *"Ich möchte ein neues Projekt 'Apollo' starten, Ziel ist die Mondlandung."*
|
||||
2. **Generierung:** Mindnet erkennt den Wunsch (`INTERVIEW`), analysiert den Satz und erstellt **sofort** einen Entwurf.
|
||||
3. **Editor:** Die UI wechselt von der Chat-Blase zu einem **Draft-Editor**.
|
||||
* Du siehst das generierte Frontmatter (`type: project`, `status: draft`).
|
||||
* **Healing UI (v2.5):** Falls das LLM Syntax-Fehler gemacht hat (z.B. fehlendes `---`), hat der Editor das bereits automatisch repariert.
|
||||
* Du siehst den Body-Text mit Platzhaltern (`[TODO]`), wo Infos fehlten (z.B. Stakeholder).
|
||||
4. **Finalisierung:** Ergänze die fehlenden Infos direkt im Editor und klicke auf **Download** oder **Kopieren**.
|
||||
5. **Speichern:** Klicke auf "💾 Speichern". Die Notiz landet sofort im Vault und im Index.
|
||||
|
||||
### 6.4 Der Intelligence-Workflow (Neu in v2.4)
|
||||
Wenn du Texte im **manuellen Editor** schreibst, unterstützt dich Mindnet aktiv bei der Vernetzung:
|
||||
|
||||
1. **Schreiben:** Tippe deinen Text im Tab **"✏️ Inhalt"**.
|
||||
2. **Analysieren:** Wechsle zum Tab **"🧠 Intelligence"** und klicke auf **"🔍 Analyse starten"**. Das System scannt deinen Text (Vektor-Suche & Exact Match).
|
||||
3. **Vorschläge nutzen:**
|
||||
* **Exakte Treffer:** Das System erkennt Begriffe wie "KI-Gedächtnis" automatisch als Alias für "Mindnet (System)".
|
||||
* **Semantische Treffer:** Das System findet inhaltlich verwandte Notizen.
|
||||
* **Klick auf "➕ Einfügen":** Fügt den Link (z.B. `[[rel:related_to Mindnet]]`) an der Cursor-Position oder am Ende ein.
|
||||
4. **Speichern:** Klicke auf "💾 Speichern & Indizieren". Der Text wird sofort in den Vault geschrieben und in Qdrant indiziert.
|
||||
@@ -0,0 +1,27 @@
|
||||
# Architecture Snapshot v2.2.1
|
||||
**Stand:** Nach Abschluss von WP-04c
|
||||
**Kontext:** Wichtig für WP-05 Entwicklung.
|
||||
|
||||
## 1. Neue Komponenten (Seit v2.2.0)
|
||||
|
||||
### A. Feedback Service (`app/services/feedback_service.py`)
|
||||
- **Zweck:** Logging von Trainingsdaten für späteres Self-Tuning (WP-08).
|
||||
- **Storage:** Lokale JSONL-Dateien in `data/logs/` (Append-Only).
|
||||
- `search_history.jsonl`: Query + Snapshot der Ergebnisse (Scores).
|
||||
- `feedback.jsonl`: User-Rating zu spezifischer `node_id`.
|
||||
|
||||
### B. Explanation Layer (`app/core/retriever.py`)
|
||||
- **Logik:** Der Retriever berechnet nicht nur Scores, sondern generiert `Explanation`-Objekte.
|
||||
- **Graph:** `Subgraph` (in `graph_adapter.py`) führt jetzt auch `reverse_adj` (Incoming Edges), um zu erklären, warum ein Knoten wichtig ist ("Referenziert von...").
|
||||
|
||||
### C. DTOs (`app/models/dto.py`)
|
||||
Das Datenmodell wurde massiv erweitert. Wichtige Klassen für WP-05:
|
||||
- `QueryResponse`: Enthält jetzt `query_id` (UUID).
|
||||
- `QueryHit`: Enthält optional `explanation` (Typ `Explanation`).
|
||||
- `FeedbackRequest`: Für den Feedback-Loop.
|
||||
|
||||
## 2. Implikationen für WP-05 (Chat)
|
||||
|
||||
1. **Logging:** Auch der neue `/chat` Endpoint sollte idealerweise die `query_id` loggen oder nutzen, um Konsistenz zu wahren.
|
||||
2. **DTO-Nutzung:** Der Chat-Service wird intern den Retriever aufrufen. Er muss mit den `QueryHit`-Objekten arbeiten, um den Kontext für das LLM zu bauen.
|
||||
3. **Config:** Die Persönlichkeit wird in `config/prompts.yaml` definiert (Late Binding), nicht im Python-Code hardcodiert.
|
||||
@@ -0,0 +1,21 @@
|
||||
# Changelog — WP-03 Type-Registry (2025-11-08)
|
||||
|
||||
## Added
|
||||
- `app/core/type_registry.py` — Loader & Helper (cached), robust Fallbacks.
|
||||
- `config/types.yaml` — Beispiel-Registry (version 1.0).
|
||||
- `scripts/import_markdown.py` v3.8.0 — Registry-Integration:
|
||||
- typvalidierung (unbekannt → `concept`, Warnung)
|
||||
- `chunk_profile` → an `make_chunk_payloads(...)`
|
||||
- `retriever_weight` → persistiert im Note-Payload
|
||||
- `edge_defaults["references"]` schaltet Note-Scope-Refs additiv ein
|
||||
- `app/core/chunk_payload.py` v2.3.0 — optionales `chunk_profile` für
|
||||
synthetische Overlaps (keine Schemaänderung).
|
||||
- `app/core/derive_edges.py` v1.5.0 — Type-Registry aktiviert note-scope
|
||||
References/Backlinks additiv.
|
||||
|
||||
## Changed
|
||||
- Keine Breaking Changes. Alle CLI-Flags, ENV-Variablen und Collection-
|
||||
Prefix-Logik bleiben unverändert.
|
||||
|
||||
## Removed
|
||||
- N/A
|
||||
@@ -0,0 +1,349 @@
|
||||
# 📘 Mindnet Skript-Handbuch (aktualisiert)
|
||||
|
||||
Dieses Handbuch dokumentiert die Skripte und Tests für das Projekt **mindnet Wissensnetzwerk**.
|
||||
Es beschreibt Zweck, Parameter, typische Aufrufe sowie aktuelle Verhaltensweisen (Hash-Modi, Parser-Robustheit, `window`/`text`-Trennung in Chunks, Export-Fixes).
|
||||
Alle Beispiele sind so formatiert, dass sie direkt kopierbar sind. **Code/CLI-Beispiele sind eingerückt**, damit die Markdown-Darstellung nicht abbricht.
|
||||
|
||||
---
|
||||
|
||||
## 0) Umgebung & Konfiguration
|
||||
|
||||
**Wichtige ENV-Variablen**
|
||||
|
||||
- `QDRANT_URL` – z. B. `http://localhost:6333`
|
||||
- `QDRANT_API_KEY` – API-Key (falls aktiviert)
|
||||
- `COLLECTION_PREFIX` – Prefix der drei Collections, Standard: `mindnet` → `mindnet_notes`, `mindnet_chunks`, `mindnet_edges`
|
||||
- `VECTOR_DIM` – Embedding-Dimension (Chunks), Standard: `384`
|
||||
|
||||
**Hash-Vergleich & Änderungserkennung**
|
||||
|
||||
- `MINDNET_HASH_COMPARE` – steuert, **welcher Anteil** für „changed“ verglichen wird
|
||||
Werte: `Body` (Standard), `Frontmatter`, `Full`
|
||||
- `MINDNET_HASH_SOURCE` – Quelle: `parsed` (Standard), `raw`, `file`
|
||||
- `MINDNET_HASH_NORMALIZE` – Normalisierung: `canonical` (Standard) oder `none`
|
||||
|
||||
**Beispiel (nur Body berücksichtigen, kanonisch, geparst):**
|
||||
|
||||
export MINDNET_HASH_COMPARE=Body
|
||||
export MINDNET_HASH_SOURCE=parsed
|
||||
export MINDNET_HASH_NORMALIZE=canonical
|
||||
source .venv/bin/activate
|
||||
|
||||
**Baseline-Signaturen (mehrere Modi):**
|
||||
Der Importer kann **Signaturen aller Modi** (Body/Frontmatter/Full) vorhalten, damit spätere Moduswechsel deterministisch sind (keine „Mass-Changes“). Siehe `--baseline-modes` unter **Importer**.
|
||||
|
||||
---
|
||||
|
||||
## 1) Vault anlegen (für Tests)
|
||||
|
||||
### `scripts/make_test_vault.py`
|
||||
|
||||
**Zweck:**
|
||||
Erstellt einen kleinen, nachvollziehbaren Test-Vault mit Markdown-Dateien.
|
||||
Szenarien: offene Links, nachträgliche Anlage fehlender Notes, geänderte Chunk-Grenzen.
|
||||
|
||||
**Parameter:**
|
||||
- `--out PATH` : Zielverzeichnis (Default: `./test_vault`)
|
||||
- `--force` : Existierenden Ordner löschen und neu anlegen
|
||||
- `--with-missing` : Optional – auch die `missing-note` gleich anlegen
|
||||
|
||||
**Hinweise für Tests**
|
||||
1. Erster Import (dry-run oder `--apply`): Es gibt einen „leeren“ Link `[[missing-note]]`.
|
||||
2. Lege danach eine Datei für „missing-note“ an (mit gleicher `id` im YAML) und importiere erneut:
|
||||
→ Erwartung: Edges für ehemals leeren Link werden korrekt nachgezogen (`references` + `backlink`).
|
||||
3. Ändere den Body von `exp-one.md` so, dass andere Chunk-Grenzen entstehen und importiere erneut:
|
||||
→ Erwartung: Chunks/Edges/Note werden für betroffene Noten aktualisiert.
|
||||
|
||||
**Kompatibilität:**
|
||||
- `note.schema.json`: `created`/`updated` sind Strings.
|
||||
|
||||
**Beispiele:**
|
||||
|
||||
python3 -m scripts.make_test_vault --out ./test_vault --force
|
||||
python3 -m scripts.make_test_vault --out ./test_vault --force --with-missing
|
||||
|
||||
---
|
||||
|
||||
## 2) Import in Qdrant
|
||||
|
||||
### `scripts/import_markdown.py`
|
||||
|
||||
**Zweck:**
|
||||
Importiert Notes/Chunks/Edges aus einem Vault nach Qdrant.
|
||||
- validiert Frontmatter
|
||||
- chunked Inhalte + Embeddings
|
||||
- erzeugt Edges (`references`, `references_at`, `backlink`, `next`, `prev`, `belongs_to`)
|
||||
- erkennt geänderte Dateien **modusgesteuert** (Body/Frontmatter/Full)
|
||||
- optional: Purge der alten Chunks/Edges pro Note
|
||||
|
||||
**Parameter:**
|
||||
- `--vault PATH` : (Pflicht) Vault-Verzeichnis
|
||||
- `--apply` : Änderungen wirklich durchführen (ohne: Dry-Run)
|
||||
- `--purge-before-upsert` : Vor Upsert alte Chunks/Edges **nur der geänderten Notes** löschen
|
||||
- `--prefix STR` : überschreibt `COLLECTION_PREFIX`
|
||||
- `--note-id ID` : nur eine bestimmte Note importieren
|
||||
- `--note-scope-refs` : zusätzlich **note-weite** `references` erzeugen (nicht nur chunk-weise)
|
||||
- `--baseline-modes` : berechne & speichere Hash-Signaturen für **alle** Modi (`Body`, `Frontmatter`, `Full`) als Baseline
|
||||
|
||||
**Erwartetes Verhalten:**
|
||||
- Unveränderte Notes → `"changed": false`, Entscheidung: `apply-skip-unchanged` (bei `--apply`)
|
||||
- Geänderte Notes → `"changed": true` (abhängig von `MINDNET_HASH_COMPARE`)
|
||||
- Idempotenz: mehrfacher Lauf ohne Änderungen erzeugt **keine** neuen Punkte
|
||||
- Baseline: Bei `--baseline-modes` erscheinen Felder wie `hash_signature`, `hash_fulltext`, ggf. `hash_frontmatter` und `needs_baseline_for_mode: false` bei Folgeläufen.
|
||||
|
||||
**Beispiele:**
|
||||
|
||||
# Dry-Run (zeigt Änderungen, schreibt NICHT)
|
||||
python3 -m scripts.import_markdown --vault ./vault --prefix mindnet
|
||||
|
||||
# Apply + gezielte Vorreinigung pro geänderter Note
|
||||
python3 -m scripts.import_markdown --vault ./vault --prefix mindnet --apply --purge-before-upsert
|
||||
|
||||
# Baseline-Signaturen aller Modi vorhalten
|
||||
python3 -m scripts.import_markdown --vault ./vault --apply --baseline-modes
|
||||
|
||||
**Hash-Modi in der Praxis:**
|
||||
- `MINDNET_HASH_COMPARE=Body` → Änderungen im Body werden erkannt; reine Frontmatter-Änderungen bleiben **ohne Effekt**.
|
||||
- `MINDNET_HASH_COMPARE=Frontmatter` → nur Frontmatter maßgeblich.
|
||||
- `MINDNET_HASH_COMPARE=Full` → beide Anteile zählen.
|
||||
|
||||
---
|
||||
|
||||
## 3) Konsistenzprüfungen
|
||||
|
||||
### `scripts/audit_vault_vs_qdrant.py`
|
||||
|
||||
**Zweck:**
|
||||
Vergleicht Vault-Inhalte mit Qdrant.
|
||||
- Zählt Notes/Chunks/Edges
|
||||
- Verifiziert Anzahl Wikilinks vs. Edges
|
||||
- Meldet Deltas (z. B. `references` im Vault vs. in Qdrant)
|
||||
|
||||
**Parameter:**
|
||||
- `--vault PATH` : Vault-Verzeichnis
|
||||
- `--prefix STR` : Prefix für Qdrant-Collections (Default: `mindnet`)
|
||||
|
||||
**Beispiel:**
|
||||
|
||||
python3 -m scripts.audit_vault_vs_qdrant --vault ./vault --prefix mindnet
|
||||
|
||||
### `scripts/validate_edges.py`
|
||||
|
||||
**Zweck:**
|
||||
Prüft die Edges-Collection in Qdrant.
|
||||
- Zählt Edges pro Typ (`references`, `references_at`, `backlink`, `next`, `prev`, `belongs_to`)
|
||||
- Kontrolliert Invarianten (z. B. jede `references` hat einen `backlink`)
|
||||
- Listet `unresolved` Edges auf
|
||||
|
||||
**Parameter:**
|
||||
- `--prefix STR` : Prefix für Qdrant-Collections
|
||||
- `--details` : Detailausgabe mit Beispielen
|
||||
|
||||
**Beispiel:**
|
||||
|
||||
python3 -m scripts.validate_edges --prefix mindnet --details
|
||||
|
||||
---
|
||||
|
||||
## 4) Export Qdrant → Markdown (Vault)
|
||||
|
||||
### `scripts/export_markdown.py`
|
||||
|
||||
**Zweck:**
|
||||
Exportiert Notes + rekonstruierten Body in einen Zielordner.
|
||||
- Pfade werden **relativ** aus `note.payload.path` abgeleitet (führende `/` entfernt, Backslashes → Slashes; Unicode-NFC empfohlen)
|
||||
- **Body-Rekonstruktion** priorisiert:
|
||||
1. `fulltext` (falls in Note-Payload vorhanden)
|
||||
2. sonst **Chunks**: Sortierung `seq` → `chunk_index` → Nummer in `chunk_id`; **nur `text`** (Overlap bereits entfernt)
|
||||
- `--prefix` (CLI) wird unterstützt (oder ENV `COLLECTION_PREFIX`)
|
||||
|
||||
**Parameter:**
|
||||
- `--out PATH` : Ziel-Root (muss existieren)
|
||||
- `--overwrite` : vorhandene Dateien überschreiben
|
||||
- `--note-id ID` : nur eine bestimmte Note exportieren
|
||||
- `--prefix STR` : überschreibt `COLLECTION_PREFIX`
|
||||
- `--include-edges {none,footer,yaml}` *(optional, falls aktiviert)*: Edges als YAML-Liste im Frontmatter oder im Footer beilegen
|
||||
|
||||
**Beispiele:**
|
||||
|
||||
export COLLECTION_PREFIX="mindnet"
|
||||
python3 -m scripts.export_markdown --out ./_exportVault
|
||||
|
||||
# Nur eine bestimmte Note:
|
||||
python3 -m scripts.export_markdown --out ./_exportVault --note-id 20250821-architektur-ki-trainerassistent-761cfe
|
||||
|
||||
# Existierende Dateien überschreiben:
|
||||
python3 -m scripts.export_markdown --out ./_exportVault --overwrite
|
||||
|
||||
---
|
||||
|
||||
## 5) Qdrant zurücksetzen
|
||||
|
||||
### `scripts/reset_qdrant.py`
|
||||
|
||||
**Zweck:**
|
||||
Setzt die Qdrant-Collections zurück.
|
||||
- `wipe`: löscht Collections komplett (inkl. Schema)
|
||||
- `truncate`: löscht nur Inhalte, behält Collections
|
||||
- `truncate-edges`: löscht nur Punkte in `*_edges`
|
||||
|
||||
**Parameter:**
|
||||
- `--mode {wipe,truncate,truncate-edges}`
|
||||
- `--prefix STR` : Prefix der Collections (Default: `mindnet`)
|
||||
- `--yes` : Automatische Bestätigung
|
||||
- `--dry-run` : Nur anzeigen, nicht ausführen
|
||||
|
||||
**Beispiele:**
|
||||
|
||||
python3 -m scripts.reset_qdrant --mode truncate-edges --prefix mindnet
|
||||
python3 -m scripts.reset_qdrant --mode truncate --prefix mindnet --yes
|
||||
python3 -m scripts.reset_qdrant --mode wipe --prefix mindnet --yes
|
||||
|
||||
---
|
||||
|
||||
## 6) Diagnose & Tools
|
||||
|
||||
### `scripts/diagnose_changed.py`
|
||||
|
||||
**Zweck:**
|
||||
Prüft, ob Datei-Hashes (`sha256`) mit gespeicherten `hash_*` in Qdrant übereinstimmen.
|
||||
Hilft, wenn der Importer zu viele Dateien als „changed“ erkennt oder Moduswechsel geplant sind.
|
||||
|
||||
**Parameter:**
|
||||
- `--vault PATH` : Vault-Verzeichnis
|
||||
- `--prefix STR` : Prefix (Default: `mindnet`)
|
||||
- `--note-id ID` : Nur bestimmte Note prüfen
|
||||
- `--all` : Alle Notes prüfen
|
||||
|
||||
**Beispiel:**
|
||||
|
||||
python3 -m scripts.diagnose_changed --vault ./vault --prefix mindnet --all
|
||||
|
||||
### `scripts/resolve_unresolved_references.py`
|
||||
|
||||
**Zweck:**
|
||||
Prüft offene Wikilinks (`status=unresolved`) und fügt Edges nach, wenn inzwischen passende Notizen existieren.
|
||||
Ersetzt `unresolved` durch gültige `references`/`backlink`.
|
||||
|
||||
**Parameter:**
|
||||
- `--prefix STR` : Prefix für Qdrant-Collections
|
||||
- `--apply` : Änderungen wirklich ausführen (sonst nur Vorschau)
|
||||
|
||||
**Beispiele:**
|
||||
|
||||
python3 -m scripts.resolve_unresolved_references --prefix mindnet
|
||||
python3 -m scripts.resolve_unresolved_references --prefix mindnet --apply
|
||||
|
||||
---
|
||||
|
||||
## 7) Parser-Verhalten (robust & abwärtskompatibel)
|
||||
|
||||
- Der Parser liest Markdown **fehlertolerant** (UTF-8 mit Fallbacks), extrahiert YAML-Frontmatter und Body.
|
||||
- Keine harten Abhängigkeiten von alten Regex-Symbolen (`FRONTMATTER_RE` entfällt zugunsten interner Marker).
|
||||
- `read_markdown(path)` gibt `(frontmatter_dict, body_str)` zurück.
|
||||
- **Sonderfälle aus Fremd-Tools** (z. B. Silverbullet-Dateien wie `CONFIG.md`, `index.md`) werden **nicht importiert**, sofern sie nicht zum Vault gehören.
|
||||
|
||||
---
|
||||
|
||||
## 8) Chunk-Payload (Fenster vs. Kern)
|
||||
|
||||
- **`window`** = kontextualisierter Fenster-Text (mit linkem Overlap)
|
||||
- **`text`** = **Kerntext** ohne das vom vorherigen Chunk übernommene Overlap
|
||||
- Felder: `start`, `end`, `overlap_left`, `overlap_right`, `chunk_index`, `seq`, `path`, `section_title`, `section_path`, `token_count` (falls vorhanden)
|
||||
- **Fallback (synthetisch):** Falls der Chunker **keinen** Overlap-Fenstertext liefert, erzeugt die Payload-Schicht Fenster mit typgerechtem Overlap aus `chunk_config.get_sizes(type)['overlap']` (unterer Wert).
|
||||
- **Edges** werden aus `window` abgeleitet (um Links an Chunk-Grenzen nicht zu verlieren); der **Export** rekonstruiert den Body aus `text` (Overlap-frei).
|
||||
|
||||
---
|
||||
|
||||
## 9) Edge-Modell & IDs
|
||||
|
||||
- Collections:
|
||||
`*_notes` (optional Vektor / Nullvektor), `*_chunks` (384-d Embeddings), `*_edges` (1-d Dummy-Vektor)
|
||||
- **Deterministische IDs** (UUIDv5 / stabile Keys):
|
||||
- `note_id` stabil aus Frontmatter/Slug
|
||||
- `chunk_id` i. d. R. `note_id#<n>`
|
||||
- `edge_id` stabil aus `(kind, source_id, target_id, seq)`
|
||||
- Kantenarten: `references`, `references_at`, `backlink`, `next`, `prev`, `belongs_to`
|
||||
- `unresolved` wird gekennzeichnet und kann per Resolver später aufgelöst werden.
|
||||
|
||||
---
|
||||
|
||||
## 10) Tests & Qualitätssicherung
|
||||
|
||||
**Tests unter `tests/`**
|
||||
|
||||
- `check_chunks_window_vs_text.py` – vergleicht je Chunk `window` vs. `text`, schätzt Overlap
|
||||
- `compare_vaults.py` – rekursiver Vault-Vergleich (Body/Frontmatter/All, Key: auto/id/title/filename), Unicode-NFC-robust
|
||||
- `verify_chunks_integrity.py` – prüft, ob Rekonstruktion aus Chunks (`text`) zu `fulltext` bzw. zum Vault-Body passt
|
||||
- `list_md_seen_by_importer.py` – zeigt, welche `.md` der Importer sieht (inkl. Gründe/Filter)
|
||||
- `inspect_one_note.py` – Parser-Diagnose für eine konkrete Datei
|
||||
- `run_e2e_roundtrip.sh` – End-to-End: Reset → Import → Audit → (optional) Hash-Reporter → Export → Vergleich
|
||||
|
||||
**Typische Aufrufe:**
|
||||
|
||||
# Overlap-Qualität (Fenster vs. Kern)
|
||||
python3 tests/check_chunks_window_vs_text.py --prefix "$COLLECTION_PREFIX"
|
||||
|
||||
# Roundtrip-Vergleich (rekursiv)
|
||||
python3 tests/compare_vaults.py --src ./vault --dst ./_exportVault --focus body
|
||||
|
||||
# Chunks-Rekonstruktion (gegen Vault-Body)
|
||||
python3 tests/verify_chunks_integrity.py --prefix "$COLLECTION_PREFIX" --vault ./vault
|
||||
|
||||
---
|
||||
|
||||
## 11) Typische Workflows
|
||||
|
||||
**A) Clean-Start mit Test-Vault**
|
||||
|
||||
python3 -m scripts.make_test_vault --out ./test_vault --force
|
||||
python3 -m scripts.reset_qdrant --mode truncate --prefix mindnet --yes
|
||||
python3 -m scripts.import_markdown --vault ./test_vault --prefix mindnet
|
||||
python3 -m scripts.import_markdown --vault ./test_vault --prefix mindnet --apply --purge-before-upsert
|
||||
python3 -m scripts.audit_vault_vs_qdrant --vault ./test_vault --prefix mindnet
|
||||
python3 -m scripts.validate_edges --prefix mindnet --details
|
||||
export COLLECTION_PREFIX="mindnet"
|
||||
python3 -m scripts.export_markdown --out ./_exportVault
|
||||
|
||||
**B) Änderungs-Propagation & Idempotenz**
|
||||
|
||||
python3 -m scripts.import_markdown --vault ./test_vault --prefix mindnet
|
||||
python3 -m scripts.import_markdown --vault ./test_vault --prefix mindnet --apply --purge-before-upsert
|
||||
python3 -m scripts.audit_vault_vs_qdrant --vault ./test_vault --prefix mindnet
|
||||
python3 -m scripts.validate_edges --prefix mindnet --details
|
||||
python3 -m scripts.import_markdown --vault ./test_vault --prefix mindnet
|
||||
|
||||
**C) Unresolved Links lösen**
|
||||
|
||||
python3 -m scripts.import_markdown --vault ./test_vault --apply --prefix mindnet
|
||||
python3 -m scripts.resolve_unresolved_references --prefix mindnet --apply
|
||||
python3 -m scripts.validate_edges --prefix mindnet --details
|
||||
|
||||
**D) Export & Roundtrip (Produkt-Vault)**
|
||||
|
||||
export COLLECTION_PREFIX="mindnet"
|
||||
python3 -m scripts.import_markdown --vault ./vault --apply --purge-before-upsert --prefix "$COLLECTION_PREFIX"
|
||||
python3 -m scripts.export_markdown --out ./_exportVault --prefix "$COLLECTION_PREFIX"
|
||||
python3 tests/compare_vaults.py --src ./vault --dst ./_exportVault --focus body
|
||||
|
||||
---
|
||||
|
||||
## 12) Troubleshooting (kurz)
|
||||
|
||||
- **Importer markiert alle als changed (Moduswechsel):**
|
||||
→ `--baseline-modes` einmalig laufen lassen; sicherstellen: `MINDNET_HASH_COMPARE` passt zum Ziel.
|
||||
- **Edges verschwinden / nur 1 Edge sichtbar:**
|
||||
→ `app/core/qdrant_points.py` muss Edge-Payload normalisieren (Schema Alt/Neu) und `edge_id` eindeutig bilden.
|
||||
- **Export ohne Body / falsches Zielverzeichnis:**
|
||||
→ Exporter nutzt relativierte Pfade und rekonstruiert Body aus `fulltext` oder Chunks (`text`). ENV/CLI `--prefix` beachten.
|
||||
- **Parser-Fehler (UTF-8):**
|
||||
→ Neuer Parser arbeitet mit Fallbacks; mit `tests/inspect_one_note.py` prüfen, was ankommt.
|
||||
- **„Fehlende“ Dateien im Vergleich:**
|
||||
→ Prüfe, ob Dateien **wirklich zum Vault gehören** (z. B. Silverbullet-Artefakte `CONFIG.md`, `index.md` ausblenden).
|
||||
|
||||
---
|
||||
|
||||
## 13) Hinweise zu Silverbullet-Dateien
|
||||
|
||||
- Dateien wie `CONFIG.md` oder `index.md`, die **nicht** zum inhaltlichen Vault gehören, werden **nicht importiert** und erscheinen daher nicht im Export-Roundtrip.
|
||||
- Diese Dateien bitte vom produktiven Vault trennen oder im Vergleich (`tests/compare_vaults.py
|
||||
@@ -0,0 +1,74 @@
|
||||
# Kurzhandbuch — Type-Registry (WP-03)
|
||||
|
||||
## Zweck
|
||||
Die Type-Registry macht den `type:`-Wert im Frontmatter maschinenlesbar
|
||||
und steuert:
|
||||
- Chunk-Profile (indirekt über Overlap bei fensterlosen Chunks),
|
||||
- typabhängige Default-Kanten (hier: Aktivierung von Note-Scope-References),
|
||||
- optionale Retriever-Gewichtungen (`retriever_weight`) für WP‑04.
|
||||
|
||||
## Aktivierung
|
||||
1. Legen Sie `config/types.yaml` an (siehe Beispiel in diesem Paket).
|
||||
2. Starten Sie Import/Server neu. Die Registry wird beim Prozessstart
|
||||
geladen und gecached.
|
||||
|
||||
Fehlt die Datei oder ist sie defekt, bleibt das System voll funktionsfähig
|
||||
(der Typ `concept` wird genutzt; Warnhinweis im Log).
|
||||
|
||||
## Schema (Beispiel)
|
||||
```yaml
|
||||
version: 1.0
|
||||
types:
|
||||
concept:
|
||||
chunk_profile: long
|
||||
edge_defaults: ["references", "related_to"]
|
||||
retriever_weight: 1.0
|
||||
task:
|
||||
chunk_profile: short
|
||||
edge_defaults: ["depends_on", "belongs_to"]
|
||||
retriever_weight: 0.8
|
||||
experience:
|
||||
chunk_profile: medium
|
||||
edge_defaults: ["derived_from", "inspired_by"]
|
||||
retriever_weight: 0.9
|
||||
project:
|
||||
chunk_profile: medium
|
||||
edge_defaults: ["references", "depends_on"]
|
||||
retriever_weight: 0.95
|
||||
```
|
||||
|
||||
## Verhalten
|
||||
- **Chunking**: Die eigentliche Chunk-Länge bleibt weiterhin typabhängig über
|
||||
`chunk_config.get_sizes(type)` gesteuert. Falls der Chunker keine Fenster
|
||||
mit Overlap liefert, werden in `chunk_payload` synthetische Fenster erzeugt.
|
||||
Hier greift das `chunk_profile` mit folgenden Overlap-Empfehlungen:
|
||||
- short → (20,30), medium → (40,60), long → (60,80).
|
||||
- **Edges**: Enthält `edge_defaults` den Eintrag `references`, werden Note-
|
||||
Scope-References/Backlinks additiv aktiviert (kein Abbruch, keine Duplikate).
|
||||
Weitere Kantenarten bleiben unverändert.
|
||||
- **Retriever**: `retriever_weight` wird in der Note gespeichert und kann von
|
||||
WP‑04 im Ranking/Scoring berücksichtigt werden.
|
||||
|
||||
## Tests / Validierung
|
||||
- Dry-Run:
|
||||
```bash
|
||||
python3 -m scripts.import_markdown --vault ./test_vault
|
||||
```
|
||||
- Vollimport + Purge:
|
||||
```bash
|
||||
python3 -m scripts.import_markdown --vault ./test_vault --apply --purge-before-upsert --prefix "$COLLECTION_PREFIX"
|
||||
```
|
||||
- Chunks-Qualität (Window vs Text):
|
||||
```bash
|
||||
python3 tests/check_chunks_window_vs_text.py --prefix "$COLLECTION_PREFIX"
|
||||
```
|
||||
- Roundtrip:
|
||||
```bash
|
||||
python3 -m scripts.export_markdown --out ./_exportVault --prefix "$COLLECTION_PREFIX"
|
||||
python3 tests/compare_vaults.py --src ./test_vault --dst ./_exportVault --focus body
|
||||
```
|
||||
|
||||
## Fallbacks & Robustheit
|
||||
- Registry nicht vorhanden/ungültig → `concept`, Warnung, keine Abbrüche.
|
||||
- Alle bestehenden ENV/Flags bleiben identisch.
|
||||
- Keine Änderungen an Punkt-IDs, Feldern oder Vektoren.
|
||||
@@ -0,0 +1,204 @@
|
||||
# WP-02 Chunking & Embedding-Strategie
|
||||
**Projekt:** mindnet Wissensnetzwerk
|
||||
**Bezug:** `knowledge_design.md` (IDs, Dateinamen, Tags, Edge-Typen, Abschnitts-Konventionen)
|
||||
|
||||
---
|
||||
|
||||
## 1) Ziel & Rahmen
|
||||
Entwickle eine robuste, parser-freundliche **Chunking-Strategie** für Markdown-Notizen, die:
|
||||
- die **Frontmatter** (YAML) als Meta nutzt, aber nicht (standardmäßig) embedden lässt,
|
||||
- den **Body** in semantisch sinnvolle Chunks zerlegt (Überschriften/Absätze/Listen),
|
||||
- **Edges** zwischen Chunks und Notizen/Links erzeugt (u. a. `belongs_to`, `references`, `backlink`).
|
||||
|
||||
---
|
||||
|
||||
## 2) Annahmen aus `knowledge_design.md`
|
||||
- **IDs**: deterministische, stabile `id` pro Note (Slug / semantischer Identifier), ggf. `aliases`.
|
||||
- **Dateinamen**: entweder `YYYY-MM-DD_title.md` oder `slug.md`; Pfade sind **relativ** zum Vault.
|
||||
- **Frontmatter-Pflichtfelder**: `id`, `title`, `type`, `created`, `updated` (Details in `knowledge_design.md`).
|
||||
- **Backlink-/Link-Regeln**: Wikilinks `[[id]]` im Body; am Ende optional redaktionelle Sektion „Mögliche Verbindungen“ (erzeugt **keine** Kanten).
|
||||
|
||||
---
|
||||
|
||||
## 3) Chunking-Prinzipien
|
||||
- **Semantische Schnitte**: Chunks enden an Absätzen, Überschriften, Listenpunkten, Codeblöcken, Zitaten.
|
||||
- **Frontmatter**: YAML **nicht** embedden; stattdessen komplett im Note-Payload speichern.
|
||||
- **Verlustfreiheit**:
|
||||
- Note-Payload: `fulltext` (gesamter Body).
|
||||
- Chunk-Payload: `text` (Originalchunk).
|
||||
Damit kann der Export den Body **verlustfrei** rekonstruieren (erst `fulltext`, sonst Chunks).
|
||||
|
||||
---
|
||||
|
||||
## 4) Optimale Chunkgrößen & Overlaps
|
||||
- **Zielgröße**: 250–400 Tokens (Richtwert, abhängig vom `type`).
|
||||
- **Maxgröße**: 600–800 Tokens (nur in Ausnahmen).
|
||||
- **Mingröße**: 80–120 Tokens (sonst mit Nachbar verschmelzen).
|
||||
- **Overlap**: 40–60 Tokens, um Kontextverlust zu vermeiden.
|
||||
- **Kontextabhängig**:
|
||||
- `concept`, `thought`, `experience`: 250–350 Tokens
|
||||
- `task`, `project`: eher 200–300 Tokens (mehr Bullet-Struktur)
|
||||
- `journal`: 300–400 Tokens (tagesabschnittsweise)
|
||||
|
||||
---
|
||||
|
||||
## 4.1 Overlap-Regeln
|
||||
- Overlap betrifft **nur den Body**; die YAML-Frontmatter bleibt **außerhalb**.
|
||||
- Keine Overlaps, die Codeblöcke oder Tabellen „aufreißen“. Falls nötig: Chunk-Grenze an Blockgrenze ziehen.
|
||||
- Bei reinen Listen: zusammenhängende Bullets gruppieren, ggf. kleinere Overlaps.
|
||||
|
||||
---
|
||||
|
||||
## 5) Semantische Regeln je Strukturelement
|
||||
- **Überschriften**: vorzugsweise an H2/H3 trennen; H1 meist Dokumenttitel → Teil der Frontmatter.
|
||||
- **Absätze**: primäre Trennkandidaten.
|
||||
- **Listen**: zusammenhängende Gruppe als ein Chunk, wenn sie einen semantischen Block bilden.
|
||||
- **Codeblöcke**: niemals splitten; Code bleibt in einem Chunk.
|
||||
- **Zitate**: ab 2+ Zeilen als eigener Chunk.
|
||||
- **Bilder/Anhänge**: Referenzen im Text belassen; Pfade relativ halten.
|
||||
|
||||
---
|
||||
|
||||
## 6) Normalisierung & Preprocessing
|
||||
- **Zeilenenden**: `\r\n` → `\n`, trailing spaces trimmen (nur für Hashing, nicht für Anzeige).
|
||||
- **Whitespace**: mehrfach-Blankzeilen reduzieren (optional, Hash-Modus beachten).
|
||||
- **Links**: `[[Titel|id]]` zu `(display="Titel", target_id="id")` normalisieren.
|
||||
- **Pfade**: `path` im Payload **zwingend relativ** (Backslashes → Slashes).
|
||||
|
||||
---
|
||||
|
||||
## 7) Edge-Modell (Graph)
|
||||
- **Chunk → Note:** `belongs_to(note_id)` (obligatorisch; Edge-Payload enthält zusätzlich `note_id` als Owner-Note).
|
||||
- **Chunk → Chunk (gleiche Note):** `prev`, `next` (symmetrisch für lineare Navigation; beide Richtungen werden erzeugt).
|
||||
- **Chunk → Note:** `references(target_id)` aus `[[Wikilinks]]` oder Markdown-Links im Chunk-Text (Standard; *Chunk-Scope*).
|
||||
- **Note → Note:** `backlink(target_id)` automatisch generiert, dedupliziert pro Note (*Note-Scope*).
|
||||
- **Optional:** `references:note` (Note-Scope-References) per Flag/ENV aktivierbar; **Default = aus**, um Doppelzählungen zu vermeiden.
|
||||
- **Unresolved:** Wenn `target_id` nicht existiert, wird eine Kante mit `status: "unresolved"` angelegt (später durch Resolver/Agent heilbar).
|
||||
|
||||
---
|
||||
|
||||
## 8) Datenmodell (Qdrant-tauglich)
|
||||
|
||||
**Point (Chunk)**
|
||||
|
||||
{
|
||||
"id": "20250902-1830-thought-yaml-recall#c02",
|
||||
"vector": [/* embedding */],
|
||||
"payload": {
|
||||
"note_id": "20250902-1830-thought-yaml-recall",
|
||||
"note_title": "Gedanke: Einheitliche YAML-Standards steigern Recall",
|
||||
"path": "10_thoughts/20250902-1830-thought-yaml-recall.md",
|
||||
"type": "thought",
|
||||
"area": "mindnet",
|
||||
"project": "project-mindnet",
|
||||
"tags": ["area/mindnet","type/thought","topic/yaml"],
|
||||
"chunk_index": 2,
|
||||
"char_start": 1024,
|
||||
"char_end": 1789,
|
||||
"section_title": "Begründung / Details",
|
||||
"section_path": "Begründung / Details",
|
||||
"neighbors": {"prev": "…#c01", "next": "…#c03"},
|
||||
"wikilinks": ["concept-yaml-styleguide"],
|
||||
"references": [{"kind":"wikilink", "target_id":"concept-yaml-styleguide"}],
|
||||
"text": "… ursprünglicher Chunk-Text …"
|
||||
}
|
||||
}
|
||||
|
||||
**Point (Note)**
|
||||
|
||||
{
|
||||
"id": "20250902-1830-thought-yaml-recall",
|
||||
"vector": [/* optional Nullvektor oder Zentroid */],
|
||||
"payload": {
|
||||
"note_id": "20250902-1830-thought-yaml-recall",
|
||||
"title": "Gedanke: Einheitliche YAML-Standards steigern Recall",
|
||||
"type": "thought",
|
||||
"status": "draft",
|
||||
"created": "2025-09-02",
|
||||
"updated": "2025-09-02",
|
||||
"path": "10_thoughts/20250902-1830-thought-yaml-recall.md",
|
||||
"tags": ["area/mindnet","type/thought","topic/yaml"],
|
||||
"hash_fulltext": "sha256:…",
|
||||
"fulltext": "… gesamter Body für verlustfreie Rekonstruktion …",
|
||||
"references": ["concept-yaml-styleguide"] // Fallback für Note-Level-Backlinks
|
||||
}
|
||||
}
|
||||
|
||||
**Edges (Payload; neues Schema)**
|
||||
|
||||
{
|
||||
"kind": "references" | "backlink" | "belongs_to" | "prev" | "next",
|
||||
"source_id": "<chunk_id|note_id>",
|
||||
"target_id": "<note_id|chunk_id>",
|
||||
"scope": "chunk" | "note",
|
||||
"note_id": "<owner-note-id>", // neu: für schnelles Filtern/Purge
|
||||
"status": "ok" | "unresolved" // optional
|
||||
}
|
||||
|
||||
**Performance-Hinweis (Qdrant):** Für schnelle Filter/Deletes Payload-Indizes anlegen: **edges** → `kind`, `scope`, `source_id`, `target_id`, `note_id`; **chunks** → `note_id`, `chunk_index`; **notes** → `note_id`.
|
||||
|
||||
---
|
||||
|
||||
## 9) Algorithmus (Python-ready Outline)
|
||||
|
||||
def chunk_markdown_note(md_text: str, file_path: str) -> list[Chunk]:
|
||||
fm, body = split_frontmatter(md_text) # YAML -> dict
|
||||
meta = normalize_frontmatter(fm) # enforce schema defaults
|
||||
ast = parse_markdown_to_ast(body) # any mdast-compatible lib
|
||||
|
||||
sections = split_by_headings(ast, levels=(2,3)) # H2/H3 primary
|
||||
raw_chunks = []
|
||||
for sec in sections:
|
||||
blocks = group_blocks(sec, keep_code=True, keep_lists=True)
|
||||
for group in soft_wrap(blocks, target_tokens=target_size(meta["type"]),
|
||||
max_tokens=max_size(meta["type"])):
|
||||
raw_chunks.append(render_md(group))
|
||||
|
||||
chunks = apply_overlap(raw_chunks, overlap_tokens=overlap(meta["type"]))
|
||||
chunks = normalize_chunks(chunks) # trim, fix code fences, etc.
|
||||
|
||||
# IDs & Nachbarn
|
||||
for i, ch in enumerate(chunks, start=1):
|
||||
ch.id = f"{meta['id']}#c{i:02d}"
|
||||
ch.index = i
|
||||
ch.neighbors_prev = chunks[i-2].id if i > 1 else None
|
||||
ch.neighbors_next = chunks[i].id if i < len(chunks) else None
|
||||
|
||||
# Wikilinks je Chunk
|
||||
for ch in chunks:
|
||||
ch.wikilinks = extract_wikilinks(ch.text)
|
||||
|
||||
return chunks
|
||||
|
||||
---
|
||||
|
||||
## 10) Einbettung (Embeddings)
|
||||
- Modell: MiniLM/all-MiniLM-L6-v2 (384d) oder E5 (besseres Retrieval, ggf. multilingual).
|
||||
- **Note-Embeddings** optional (Zentroid der Chunks).
|
||||
- **Hashing für Change-Detection** (Importer):
|
||||
- `MINDNET_HASH_MODE = body|frontmatter|body+frontmatter` (Default: `body`)
|
||||
- `MINDNET_HASH_NORMALIZE = canonical|none` (Default: `canonical`)
|
||||
|
||||
---
|
||||
|
||||
## 11) Qualitätssicherung
|
||||
- **Zähler**: `notes/chunks/edges` je Lauf prüfen.
|
||||
- **Edge-Invarianten**:
|
||||
- `belongs_to == #Chunks`
|
||||
- `next == prev == Σ(max(chunks_in_note-1, 0))`
|
||||
- `references (chunk) == Σ(Chunk-Wikilinks)`
|
||||
- `backlink == Σ(eindeutige Wikilinks je Note)`
|
||||
- **Unresolved**: sollten durch Resolver-Jobs über Zeit abnehmen.
|
||||
- **Roundtrip-Test**: Import → Export → Diff; exakt rekonstruierbare Bodies.
|
||||
|
||||
---
|
||||
|
||||
## 12) Deliverables
|
||||
- Code: Parser, Chunker, Importer, Exporter, Edges.
|
||||
- Schemas: `note.schema.json`, Payload-Layouts.
|
||||
- Tests: Mini-Vault (`scripts/make_test_vault.py`), Audit/Validate.
|
||||
|
||||
---
|
||||
|
||||
## 13) Prompt für neues Chatfenster (kopieren & einfügen)
|
||||
*(Unverändert)*
|
||||
@@ -0,0 +1,96 @@
|
||||
# mindnet Retriever (WP-04 / Step 4a) – Kurz-Dokumentation
|
||||
|
||||
## 1. Überblick
|
||||
|
||||
Der Retriever besteht aus:
|
||||
|
||||
- **Semantic Retriever** (`semantic_retrieve`)
|
||||
- **Hybrid Retriever** (`hybrid_retrieve`)
|
||||
- Qdrant-Backend (`*_chunks`, `*_edges`)
|
||||
- optionaler Edge-Expansion über `graph_adapter.expand`
|
||||
|
||||
Die API nutzt das bestehende `/query`-Endpoint (FastAPI), das `QueryRequest` und `QueryResponse` aus `app.models.dto` verwendet.
|
||||
|
||||
## 2. Scoring-Formel
|
||||
|
||||
Pro Treffer werden folgende Komponenten geführt:
|
||||
|
||||
- `semantic_score` – direkt aus Qdrant (Cosine/Euclidean, je nach Collection)
|
||||
- `retriever_weight` – aus Chunk-Payload (`types.yaml` / Frontmatter)
|
||||
- `edge_bonus` – Bonus aus dem Subgraph (z. B. Zahl der eingehenden/ausgehenden Edges, Beziehungstypen)
|
||||
- `centrality_bonus` – Bonus aus einer einfachen Zentralitäts-Heuristik im Subgraph
|
||||
|
||||
Aktuelle Formel (Step 4a):
|
||||
|
||||
```text
|
||||
total_score = semantic_score * max(retriever_weight, 0.0)
|
||||
+ edge_bonus
|
||||
+ centrality_bonus
|
||||
```
|
||||
|
||||
Die Sortierung der Ergebnisse erfolgt absteigend nach `total_score`.
|
||||
|
||||
## 3. Modi
|
||||
|
||||
### 3.1 Semantic Mode
|
||||
|
||||
- Funktion: `semantic_retrieve`
|
||||
- Request-Feld `mode = "semantic"`
|
||||
- Keine Edge-Expansion, kein Graph-Call.
|
||||
- Kandidaten nur aus Vektorsuche in `<prefix>_chunks`.
|
||||
|
||||
### 3.2 Hybrid Mode
|
||||
|
||||
- Funktion: `hybrid_retrieve`
|
||||
- Request-Feld `mode = "hybrid"`
|
||||
- Schritte:
|
||||
1. Semantische Chunk-Suche wie im Semantic Mode
|
||||
2. Falls `expand.depth > 0` gesetzt ist:
|
||||
- Seeds = `chunk_id` (Fallback: `note_id`) der Treffer
|
||||
- Aufruf `graph_adapter.expand(client, prefix, seed_ids, depth, edge_types)`
|
||||
- Ergebnis-Subgraph liefert `edge_bonus` und `centrality_bonus` pro Node
|
||||
3. Scores werden nach obiger Formel kombiniert.
|
||||
|
||||
## 4. Request-Struktur (JSON)
|
||||
|
||||
Beispiel-Hybrid-Request:
|
||||
|
||||
```json
|
||||
{
|
||||
"mode": "hybrid",
|
||||
"query": "embeddings und qdrant",
|
||||
"top_k": 10,
|
||||
"expand": {
|
||||
"depth": 1,
|
||||
"edge_types": ["references", "depends_on"]
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
Minimaler Semantic-Request:
|
||||
|
||||
```json
|
||||
{
|
||||
"mode": "semantic",
|
||||
"query": "karate trainingsplan",
|
||||
"top_k": 5
|
||||
}
|
||||
```
|
||||
|
||||
## 5. Smoke-Test
|
||||
|
||||
Für einen schnellen End-to-End-Test kann folgendes Skript verwendet werden:
|
||||
|
||||
```bash
|
||||
python scripts/test_retriever_smoke.py --query "karate" --mode hybrid --expand-depth 1 --top-k 5
|
||||
```
|
||||
|
||||
Das Skript ruft `/query` auf, wertet Statuscode und JSON-Antwort aus und zeigt die Scores der Top-K-Treffer an.
|
||||
|
||||
## 6. Tests
|
||||
|
||||
Die wichtigsten Tests für den Retriever sind:
|
||||
|
||||
- `tests/test_retriever_basic.py` – Basisfunktion (Semantic + Hybrid)
|
||||
- `tests/test_retriever_weight.py` – Einfluss von `retriever_weight` auf das Ranking
|
||||
- `tests/test_retriever_edges.py` – Einfluss von Edge-/Centrality-Boni im Hybrid-Modus
|
||||
@@ -0,0 +1,255 @@
|
||||
# mindnet v2.2 – Knowledge Design Manual
|
||||
**Datei:** `docs/mindnet_knowledge_design_manual_v2.2.md`
|
||||
**Stand:** 2025-12-09
|
||||
**Status:** **FINAL** (Integrierter Stand WP01–WP06)
|
||||
**Quellen:** `knowledge_design.md`, `TYPE_REGISTRY_MANUAL.md`, `chunking_strategy.md`, `mindnet_functional_architecture.md`.
|
||||
|
||||
---
|
||||
|
||||
## ⚡ Die 5 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"), damit der Vektor-Retriever sie bei Gefühls-Anfragen findet.
|
||||
|
||||
---
|
||||
|
||||
## 1. Zweck & Scope
|
||||
|
||||
Dieses Handbuch ist die **primäre Arbeitsanweisung** für dich als Mindmaster (Owner) und alle Autoren, die Inhalte im mindnet-Vault erstellen.
|
||||
|
||||
### 1.1 Zielsetzung
|
||||
Mindnet ist mehr als eine Dokumentablage. Es ist ein vernetztes System, das deine Persönlichkeit, Entscheidungen und Erfahrungen abbildet.
|
||||
Seit Version 2.3.1 verfügt Mindnet über:
|
||||
* **Hybrid Router:** Das System erkennt, ob du Fakten, Entscheidungen oder Empathie brauchst.
|
||||
* **Context Intelligence:** Das System lädt je nach Situation unterschiedliche Notiz-Typen (z.B. Werte bei Entscheidungen).
|
||||
|
||||
### 1.2 Der Vault als „Source of Truth“
|
||||
Die Markdown-Dateien in deinem Vault sind die **einzige Quelle der Wahrheit**.
|
||||
* Mindnet importiert diesen Zustand deterministisch in die Datenbank (Qdrant).
|
||||
* Änderungen an IDs, Typen oder Inhalten müssen **immer** im Markdown erfolgen, niemals direkt in der Datenbank.
|
||||
* Was nicht im Markdown steht (z. B. implizites Wissen im Kopf), existiert für das System nicht.
|
||||
|
||||
---
|
||||
|
||||
## 2. Note-Struktur & Frontmatter
|
||||
|
||||
Jede Notiz benötigt einen YAML-Header (Frontmatter) am Dateianfang. Dieser Block macht die Notiz maschinenlesbar.
|
||||
|
||||
### 2.1 Pflichtfelder
|
||||
Jede Datei muss mindestens folgende Felder enthalten, um korrekt verarbeitet zu werden:
|
||||
|
||||
---
|
||||
id: 20251110-projekt-alpha-8a9b2c # Eindeutige Kennung (YYYYMMDD-slug)
|
||||
title: Projekt Alpha # Sprechender Titel (wird in Suchergebnissen angezeigt)
|
||||
type: project # Steuert Verarbeitung & Vernetzung (siehe Kap. 3)
|
||||
status: active # Status (z.B. draft, active, archived)
|
||||
created: 2025-11-10 # Erstellungsdatum (ISO 8601 oder YYYY-MM-DD)
|
||||
updated: 2025-12-07 # Letzte Änderung
|
||||
tags: [ki, entwicklung] # Taxonomie für Filterung
|
||||
---
|
||||
|
||||
### 2.2 Optionale Felder
|
||||
Diese Felder sind technisch nicht zwingend, aber für bestimmte Typen sinnvoll:
|
||||
|
||||
lang: de # Sprache (Default: de)
|
||||
aliases: [Alpha Projekt, Project A] # Synonyme für die Suche
|
||||
visibility: internal # internal (default), public, private
|
||||
|
||||
> **Hinweis:** Felder wie `retriever_weight` oder `chunk_profile` sollten **nicht** mehr manuell im Frontmatter gesetzt werden. Diese werden zentral über den `type` gesteuert (siehe Kap. 3), um die Wartbarkeit zu sichern.
|
||||
|
||||
### 2.3 Empfehlungen für IDs und Pfade
|
||||
|
||||
**Die ID (Identifikator):**
|
||||
* Muss global eindeutig und **stabil** sein.
|
||||
* Darf sich nicht ändern, wenn die Datei umbenannt oder verschoben wird.
|
||||
* **Empfehlung:** `YYYYMMDD-slug-hash` (z. B. `20231027-vektor-db-a1b2`). Dies garantiert Eindeutigkeit und Chronologie.
|
||||
|
||||
**Dateinamen & Pfade:**
|
||||
* Pfade dienen der menschlichen Ordnung (Ordnerstruktur), sind für Mindnet aber sekundär.
|
||||
* Dateinamen sollten dem Titel entsprechen (`Projekt Alpha.md`) oder dem Slug (`projekt-alpha.md`).
|
||||
* Sonderzeichen vermeiden (außer Bindestrich und Unterstrich).
|
||||
|
||||
---
|
||||
|
||||
## 3. Note-Typen & Typ-Registry
|
||||
|
||||
Der `type` ist der wichtigste Hebel im Knowledge Design. Er steuert nicht nur das Gewicht bei der Suche, sondern seit WP-06 auch, **wann** eine Notiz aktiv in den Chat geholt wird ("Strategic Retrieval").
|
||||
|
||||
### 3.1 Übersicht der Kern-Typen
|
||||
|
||||
Mindnet unterscheidet verschiedene Wissensarten. Wähle den Typ, der die **Rolle** der Notiz am besten beschreibt:
|
||||
|
||||
| Typ | Beschreibung & Einsatzzweck | Rolle im Chat (Intent) |
|
||||
| :--- | :--- | :--- |
|
||||
| **`concept`** | Fachbegriffe, Theorien. Zeitloses Wissen. | **FACT** (Basiswissen) |
|
||||
| **`project`** | Ein Vorhaben mit Ziel, Dauer und Aufgaben. | **FACT / DECISION** (Kontext) |
|
||||
| **`experience`** | Persönliche Erfahrung, Lektion oder Erkenntnis. | **EMPATHY** (Spiegelung) |
|
||||
| **`decision`** | Eine bewusst getroffene Entscheidung (ADR). | **DECISION** (Begründung "Warum") |
|
||||
| **`value`** | Ein persönlicher Wert oder ein Prinzip. | **DECISION** (Moralischer Kompass) |
|
||||
| **`goal`** | Ein strategisches Ziel (kurz- oder langfristig). | **DECISION** (Abgleich) |
|
||||
| **`person`** | Eine reale Person (Netzwerk, Autor). | **FACT** |
|
||||
| **`journal`** | Zeitbezogener Log-Eintrag, Daily Note. | **FACT** (Historie) |
|
||||
| **`source`** | Externe Quelle (Buch, PDF, Artikel). | **FACT** (Faktenbasis) |
|
||||
|
||||
### 3.2 Zusammenspiel mit `types.yaml`
|
||||
|
||||
Der `type` steuert im Hintergrund drei technische Mechanismen:
|
||||
|
||||
1. **`retriever_weight` (Wichtigkeit):**
|
||||
* Ein `concept` (0.6) wiegt weniger als ein `project` (0.97) oder eine `decision` (1.0).
|
||||
* **Warum?** Bei einer Suche nach "Datenbank" soll Mindnet bevorzugt deine *Entscheidung* ("Warum wir X nutzen") anzeigen.
|
||||
2. **`chunk_profile` (Textzerlegung):**
|
||||
* `journal` (short): Wird fein zerlegt.
|
||||
* `project` (long): Längere Kontext-Fenster.
|
||||
3. **`edge_defaults` (Automatische Vernetzung):**
|
||||
* Mindnet ergänzt automatisch Kanten.
|
||||
* Beispiel: Ein Link in einem `project` wird automatisch als `depends_on` (Abhängigkeit) interpretiert.
|
||||
|
||||
---
|
||||
|
||||
## 4. Edges & Referenzen in Notes
|
||||
|
||||
Um aus isolierten Dateien ein **Netzwerk** zu machen, nutzen wir Verlinkungen. In Version 2.2 sind diese Verlinkungen die Basis für den **Hybrid Retriever** (Suche über Nachbarn).
|
||||
|
||||
### 4.1 Wikilinks (Die Basis-Referenz)
|
||||
Der klassische Obsidian-Link.
|
||||
|
||||
Wir nutzen [[Qdrant]] als Vektordatenbank.
|
||||
|
||||
* **Bedeutung:** "Diese Notiz erwähnt Qdrant."
|
||||
* **Edge-Typ:** `references`
|
||||
|
||||
### 4.2 Inline-Relationen (Semantische Verknüpfung)
|
||||
Dies ist die **mächtigste** Methode. Du sagst dem System explizit, **wie** Dinge zusammenhängen.
|
||||
|
||||
Daher [[rel:depends_on Qdrant]].
|
||||
Dieses Konzept ist [[rel:similar_to Pinecone]].
|
||||
|
||||
* **Syntax:** `[[rel:RELATION ZIEL]]`.
|
||||
* **Gültige Relationen:**
|
||||
* `depends_on`: Hängt ab von / Benötigt. (Trigger für hohe Graph-Relevanz).
|
||||
* `similar_to`: Ähnelt / Ist vergleichbar mit.
|
||||
* `related_to`: Hat zu tun mit (allgemein).
|
||||
* `caused_by`: Wurde verursacht durch.
|
||||
* `solves`: Löst (Problem).
|
||||
|
||||
### 4.3 Callout-Edges (Kuratierte Listen)
|
||||
Für Zusammenfassungen oder "Siehe auch"-Blöcke am Ende einer Notiz.
|
||||
|
||||
> [!edge] related_to: [[Vector Embeddings]] [[AI Agents]]
|
||||
|
||||
* **Funktion:** Erzeugt `related_to`-Kanten zu allen genannten Zielen in dieser Zeile.
|
||||
|
||||
---
|
||||
|
||||
## 5. Schreiben für den KI-Zwilling (New in v2.3)
|
||||
|
||||
Damit der **RAG-Chat (WP05/06)** nicht nur dumm Fakten wiedergibt, sondern dich berät, musst du "Futter" für die Decision Engine und das Empathie-Modul liefern.
|
||||
|
||||
### 5.1 Futter für die Decision Engine (`DECISION`)
|
||||
Das System soll abwägen: "Passt Tool X zu mir?". Dazu muss es wissen, was "Du" bist.
|
||||
|
||||
**Best Practice: Werte definieren**
|
||||
Erstelle Notizen mit `type: value`.
|
||||
|
||||
---
|
||||
type: value
|
||||
title: Prinzip: Datensparsamkeit
|
||||
---
|
||||
# Prinzip: Datensparsamkeit
|
||||
Wir speichern nur das Minimum an Daten. Cloud-Uploads persönlicher Daten sind verboten, es sei denn, sie sind E2E-verschlüsselt.
|
||||
|
||||
**Best Practice: Ziele definieren**
|
||||
Erstelle Notizen mit `type: goal`.
|
||||
|
||||
---
|
||||
type: goal
|
||||
title: Ziel: Unabhängigkeit 2026
|
||||
---
|
||||
# Ziel: Unabhängigkeit 2026
|
||||
Bis Ende 2026 wollen wir alle SaaS-Abos durch Self-Hosted Lösungen ersetzt haben.
|
||||
|
||||
*Effekt:* Wenn du fragst "Soll ich Notion nutzen?", lädt die Engine diese beiden Notizen und antwortet: *"Nein, Notion ist SaaS und nicht E2E-verschlüsselt. Das verletzt dein Prinzip der Datensparsamkeit und dein Ziel der Unabhängigkeit."*
|
||||
|
||||
### 5.2 Futter für den Empathie-Modus (`EMPATHY`)
|
||||
Das System soll dich verstehen, wenn du sagst: "Alles ist grau." Dazu braucht es deine Resonanzerfahrungen.
|
||||
|
||||
**Best Practice: Erfahrungen & Bridging**
|
||||
Erstelle Notizen mit `type: experience`. Nutze im Text **emotionale Brückenwörter**, damit der Retriever auch bei abstrakten Gefühlen ("grau") einen Treffer landet.
|
||||
|
||||
---
|
||||
type: experience
|
||||
title: Erfahrung: Der Durchbruch nach der Krise
|
||||
tags: [krise, hoffnung, grau, angst]
|
||||
---
|
||||
# Erfahrung: Der Durchbruch nach der Krise
|
||||
Es gibt Projektphasen, da wirkt alles **sinnlos** und **grau**.
|
||||
Ich habe gelernt: Das ist oft das Zeichen kurz vor dem Durchbruch.
|
||||
Mein Mantra in solchen Zeiten: "Einfach weitermachen, der Nebel lichtet sich."
|
||||
|
||||
*Effekt:* Wenn du im Chat jammerst ("Alles ist sinnlos"), findet das System diese Notiz und spiegelt dir deine eigene Erfahrung zurück.
|
||||
|
||||
---
|
||||
|
||||
## 6. Best Practices & Beispiele (Klassik)
|
||||
|
||||
### 6.1 Beispiel: Projekt-Notiz
|
||||
Projekte profitieren von `depends_on`, um Abhängigkeiten zu klären.
|
||||
|
||||
---
|
||||
id: 20251115-proj-mindnet
|
||||
title: Mindnet Implementierung
|
||||
type: project
|
||||
status: active
|
||||
---
|
||||
|
||||
# Mindnet Implementierung
|
||||
|
||||
Wir bauen ein persönliches Wissensnetz.
|
||||
|
||||
## Tech Stack
|
||||
Wir nutzen [[rel:depends_on Qdrant]] für die Vektorsuche und [[rel:depends_on FastAPI]] für das Backend.
|
||||
|
||||
## Architektur
|
||||
Das Konzept basiert auf [[RAG Architecture]]. (Automatisch 'depends_on' durch Typ-Default).
|
||||
|
||||
### 6.2 Beispiel: Entscheidung (Decision Record)
|
||||
Entscheidungen sind hoch gewichtet (`retriever_weight: 1.0`).
|
||||
|
||||
---
|
||||
id: 20251120-adr-vektordb
|
||||
title: ADR: Wahl von Qdrant
|
||||
type: decision
|
||||
status: final
|
||||
tags: [architektur, db]
|
||||
---
|
||||
|
||||
# Entscheidung: Qdrant
|
||||
|
||||
Wir haben uns für Qdrant entschieden.
|
||||
|
||||
## Alternativen
|
||||
Wir haben auch [[rel:similar_to Pinecone]] und [[rel:similar_to Weaviate]] betrachtet.
|
||||
|
||||
## Begründung
|
||||
Qdrant erlaubt lokalen Betrieb und [[rel:solves Payload Filtering Requirements]].
|
||||
|
||||
---
|
||||
|
||||
## 7. Langfristige Stabilität & Virtual Schema Layer
|
||||
|
||||
Mindnet ist auf Langlebigkeit ausgelegt.
|
||||
|
||||
### 7.1 Das "Virtual Schema" Prinzip
|
||||
Wir vermeiden es, Logik in den Markdown-Dateien hart zu kodieren.
|
||||
* Statt in jeder Notiz zu schreiben `chunk_size: 500`, schreiben wir nur `type: essay`.
|
||||
* Wie groß ein Chunk für ein Essay ist, definieren wir in der Konfiguration (`types.yaml`).
|
||||
|
||||
### 7.2 Was bedeutet das für dich?
|
||||
* Du kannst dich auf den Inhalt konzentrieren.
|
||||
* Wenn wir in Zukunft (WP08) basierend auf Feedback lernen, dass "Projekte" noch wichtiger sind, ändern wir **eine Zeile** in der Konfiguration, und das gesamte System passt sich beim nächsten Import an.
|
||||
@@ -0,0 +1,365 @@
|
||||
# mindnet v2 – Implementierungs-Playbook & Handover (Side‑by‑Side zu v1)
|
||||
*Stand:* 2025-11-10 08:03
|
||||
*Autor:* ChatGPT (Projekt‑Handover)
|
||||
*Zweck:* Vollständige, ausführbare Anleitung zur Weiterentwicklung von **mindnet** auf eine versionierte, testbare v2‑Architektur (neben v1), inklusive Prompt für den Folgethread, Akzeptanzkriterien, Dateiliste, Test‑ und Rollback‑Pläne.
|
||||
|
||||
---
|
||||
|
||||
## 0) Kontext & Zielbild (kurz)
|
||||
- **Mission:** Persönliches Wissensnetz, das langfristig die eigene Persönlichkeit, Erfahrungen und Entscheidungslogik abbildet; später nachvollziehbare Erklärungen für Familie/Nachwelt.
|
||||
- **Heutiger Stand (v1):** `mindnet_notes` in Qdrant vorhanden; **Chunks** und **Edges** bisher nur teilweise/nicht konsistent; Edge‑Defaults („1 Dot“) vorhanden, aber Ziele teils nicht materialisiert. Importskripte: `import_markdown.py`, `edges.py` (historisch).
|
||||
- **Ziel (v2):**
|
||||
- **Collections:** `mindnet_notes_v2`, `mindnet_chunks_v2`, `mindnet_edges_v2` (saubere Payload‑Schemata + Indizes).
|
||||
- **Chunker v2:** Block/Heading‑aware, Ziel 900–1200 Zeichen, Überlappung 120–180, deterministische `chunk_id`s.
|
||||
- **Edge‑Builder v2:** Reihenfolge: **explicit → rule → default_resolved → default**; saubere `provenance`.
|
||||
- **Importer‑Pipeline v2:** Parse → Chunk → Edge → Embeddings → Batch‑Upsert + Payload‑Indexpflege + Snapshots.
|
||||
- **Policies:** Privacy/Recency/Type‑Gewichte als **Konfiguration** (YAML + JSON‑Schema), nicht hart im Code.
|
||||
- **Observability:** FastAPI + OpenTelemetry (Tracing/Metrics); Import‑Reports (CSV/JSON).
|
||||
- **Side‑by‑Side:** v2 **parallel** zu v1; kein Big‑Bang.
|
||||
|
||||
> **Warum so?** Qdrant‑Payload‑Indizes/Filter → schnelle, erklärbare Selektionen; Snapshots → betriebssicheres Rollback; OTel → Nachvollziehbarkeit; YAML/JSON‑Schema → Validierbarkeit & Stabilität.
|
||||
|
||||
### 0.1 Aktueller Implementierungsstand (2025-11-18)
|
||||
|
||||
- Es existiert eine produktive mindnet-Instanz mit den Collections:
|
||||
- `${prefix}_notes`
|
||||
- `${prefix}_chunks`
|
||||
- `${prefix}_edges`
|
||||
- Import-Pipeline:
|
||||
- `scripts/import_markdown.py` erzeugt Notes, Chunks und Edges vollständig.
|
||||
- `types.yaml` definiert per Note-Typ:
|
||||
- `retriever_weight`
|
||||
- `chunk_profile`
|
||||
- `edge_defaults` (z. B. `depends_on`, `related_to`).
|
||||
- Edges:
|
||||
- Strukturkanten: `belongs_to`, `next`, `prev`
|
||||
- Explizite Kanten aus Wikilinks: `kind="references"`, `rule_id="explicit:wikilink"`
|
||||
- Typbasierte Default-Kanten aus `edge_defaults`: `rule_id="edge_defaults:<type>:<relation>"`
|
||||
- Inline-Kanten im Format `[[rel:<relation> <Zielnote>]]` mit `rule_id="inline:rel"`
|
||||
- alle Edges tragen eine `confidence` im Bereich `[0,1]` als Hinweis für spätere Ranking-Logiken.
|
||||
- Tests:
|
||||
- `tests/test_edges_smoke.py`, `tests/test_edges_all.py` und `scripts/edges_full_check.py` validieren Counts, Konsistenz (`belongs_to == chunks`, `next/prev`-Ketten, keine Duplikate) und Provenienz-Zählungen (`explicit`, `defaults`, `inline`, `structure`).
|
||||
- Offene Punkte:
|
||||
- Mehrere Ziele in einer Inline-Relation (`rel: similar_to [[A]] [[B]]`) sind noch nicht implementiert.
|
||||
- Retrieval-Service nutzt die neuen Edges und Weights bisher nur teilweise; ein edge-bewusster Retriever ist als nächster Schritt geplant.
|
||||
|
||||
|
||||
---
|
||||
|
||||
## 1) Datenmodelle (Schemata, v2)
|
||||
Die tatsächlichen JSON‑Schemata (2020‑12) werden im Repo abgelegt und in CI validiert.
|
||||
|
||||
### 1.1 note.schema.json
|
||||
```json
|
||||
{
|
||||
"$schema": "https://json-schema.org/draft/2020-12/schema",
|
||||
"$id": "https://example.org/mindnet/note.schema.json",
|
||||
"type": "object",
|
||||
"required": ["id", "title", "type", "privacy", "created", "hash_body"],
|
||||
"properties": {
|
||||
"id": { "type": "string", "pattern": "^[a-zA-Z0-9_-]+$" },
|
||||
"title": { "type": "string", "minLength": 1 },
|
||||
"type": { "type": "string" },
|
||||
"privacy": { "type": "string", "enum": ["public","internal","private"] },
|
||||
"created": { "type": "string", "format": "date-time" },
|
||||
"modified": { "type": "string", "format": "date-time" },
|
||||
"tags": { "type": "array", "items": { "type": "string" } },
|
||||
"lang": { "type": "string", "default": "de" },
|
||||
"source_path": { "type": "string" },
|
||||
"source_collection": { "type": "string" },
|
||||
"hash_body": { "type": "string" },
|
||||
"hash_frontmatter": { "type": "string" },
|
||||
"token_count": { "type": "integer", "minimum": 0 }
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### 1.2 chunk.schema.json
|
||||
```json
|
||||
{
|
||||
"$schema": "https://json-schema.org/draft/2020-12/schema",
|
||||
"$id": "https://example.org/mindnet/chunk.schema.json",
|
||||
"type": "object",
|
||||
"required": ["chunk_id","note_id","text","ord"],
|
||||
"properties": {
|
||||
"chunk_id": { "type": "string", "pattern": "^[a-zA-Z0-9_-]+#c\d{4}$" },
|
||||
"note_id": { "type": "string" },
|
||||
"text": { "type": "string" },
|
||||
"ord": { "type": "integer", "minimum": 0 },
|
||||
"span_char_start": { "type": "integer", "minimum": 0 },
|
||||
"span_char_end": { "type": "integer", "minimum": 0 },
|
||||
"heading_path": { "type": "array", "items": { "type": "string" } },
|
||||
"section_title": { "type": "string" },
|
||||
"tokens_start": { "type": "integer", "minimum": 0 },
|
||||
"tokens_end": { "type": "integer", "minimum": 0 },
|
||||
"embeddings_version": { "type": "string" }
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### 1.3 edge.schema.json
|
||||
```json
|
||||
{
|
||||
"$schema": "https://json-schema.org/draft/2020-12/schema",
|
||||
"$id": "https://example.org/mindnet/edge.schema.json",
|
||||
"type": "object",
|
||||
"required": ["edge_id","src_note_id","relation","provenance"],
|
||||
"properties": {
|
||||
"edge_id": { "type": "string" },
|
||||
"src_note_id": { "type": "string" },
|
||||
"src_chunk_id": { "type": "string" },
|
||||
"dst_note_id": { "type": "string" },
|
||||
"dst_chunk_id": { "type": "string" },
|
||||
"relation": { "type": "string" },
|
||||
"evidence_spans":{ "type": "array", "items": {"type":"object","properties":{"chunk_id":{"type":"string"},"span":[{"type":"integer"},{"type":"integer"}]]} },
|
||||
"provenance": { "type": "string", "enum": ["explicit","rule","default_resolved","default"] },
|
||||
"rule_id": { "type": "string" },
|
||||
"confidence": { "type": "number", "minimum": 0, "maximum": 1 }
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### 1.4 default_edge.schema.json
|
||||
```json
|
||||
{
|
||||
"$schema": "https://json-schema.org/draft/2020-12/schema",
|
||||
"$id": "https://example.org/mindnet/default_edge.schema.json",
|
||||
"type": "object",
|
||||
"required": ["src_note_id","relation","target_kind"],
|
||||
"properties": {
|
||||
"src_note_id": { "type": "string" },
|
||||
"relation": { "type": "string" },
|
||||
"target_kind": { "type": "string" },
|
||||
"when": { "type": "string" },
|
||||
"strength_hint":{ "type": "number", "minimum": 0, "maximum": 1 }
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 2) Qdrant: Collections & Indizes (v2)
|
||||
Anlegen **neben** v1:
|
||||
- `mindnet_notes_v2` (Payload‑Index: `type, privacy, created, modified, tags, source_path`)
|
||||
- `mindnet_chunks_v2` (Payload‑Index: `note_id, ord, heading_path`)
|
||||
- `mindnet_edges_v2` (Payload‑Index: `src_note_id, dst_note_id, relation, provenance`)
|
||||
|
||||
> Snapshots für Backups/Restore einplanen (Runbook siehe unten).
|
||||
|
||||
---
|
||||
|
||||
## 3) Import‑Pipeline v2 – Module & Flags
|
||||
- **Chunker v2** (`chunking/block_chunker.py`): `target_len=1000`, `overlap=150`, `respect_headings=True`, `min_chunk_len=600`, `max_chunk_len=1400`, `chunk_id = f\"{note_id}#c{ordinal:04d}\"`
|
||||
- **Edge‑Builder v2** (`graph/edge_builder_v2.py`): Reihenfolge **explicit → rule → default_resolved → default**, `provenance` korrekt setzen.
|
||||
- **Importer** (`scripts/import_markdown.py` erweitern oder `scripts/import_markdown_v2.py`):
|
||||
Flags: `--schema v2`, `--chunker v2`, `--edges v2`, `--dry-run`, `--apply`, `--prefix "$COLLECTION_PREFIX"`.
|
||||
|
||||
**Beispiel‑Run (dry‑run):**
|
||||
```bash
|
||||
python3 -m scripts.import_markdown_v2 --vault ./vault --schema v2 --chunker v2 --edges v2 --dry-run --prefix "$COLLECTION_PREFIX"
|
||||
```
|
||||
|
||||
**Apply:**
|
||||
```bash
|
||||
python3 -m scripts.import_markdown_v2 --vault ./vault --schema v2 --chunker v2 --edges v2 --apply --prefix "$COLLECTION_PREFIX"
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 4) Policies (konfigurierbar, kein Hard‑Code)
|
||||
- `policies/retrieval.schema.json` (JSON‑Schema) und `policies/retrieval.yaml`, z. B.:
|
||||
```yaml
|
||||
privacy_order: [private, internal, public]
|
||||
recency_boost_half_life_days: 90
|
||||
type_priority:
|
||||
person: 1.2
|
||||
event: 1.1
|
||||
concept: 1.0
|
||||
max_chunks_per_note: 8
|
||||
edge_provenance_weights:
|
||||
explicit: 1.0
|
||||
rule: 0.8
|
||||
default_resolved: 0.6
|
||||
default: 0.2
|
||||
rule_sets:
|
||||
- id: "rules:types-v1"
|
||||
enabled: true
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 5) Observability & Reports
|
||||
- **FastAPI + OpenTelemetry**: Traces um Phasen *parse/chunk/edge/upsert*; Metriken (Counter/Histogramme) pro Phase.
|
||||
- **Import‑Report** je Lauf (CSV/JSON): counts für Notes/Chunks/Edges, Fehler, Dauer, Embedding‑Version.
|
||||
|
||||
---
|
||||
|
||||
## 6) Teststrategie
|
||||
- **Gold‑Notizen** (3–5 repräsentative .md) mit erwarteten *Chunk‑Counts* und *Edge‑Sets*.
|
||||
- **Regression:** fixer Soll‑Count (z. B. 171 ± 15 %) über Gesamt‑Vault; keine Duplikate `(src,relation,dst)`.
|
||||
- **Dry‑Run vs Apply**: identische Counts, nur ohne Upserts.
|
||||
- **Filter‑Smoke‑Tests:** Qdrant‑Filter nach `privacy`, `type`, `tags`, `created` funktionieren performant.
|
||||
|
||||
---
|
||||
|
||||
## 7) Akzeptanzkriterien (KPI)
|
||||
1. **Chunk‑Qualität:** ≥ 90 % der Chunks enden an semantischen Grenzen; Ziel‑Länge 900–1200 Zeichen; deterministische IDs.
|
||||
2. **Edge‑Kohärenz:** Keine Duplikate gleicher `(src,relation,dst)`; ≥ 95 % der expliziten Links materialisiert; `default` nur, wenn kein Ziel existiert.
|
||||
3. **Filterbarkeit:** Queries nach `privacy/type/tags/created` performant (Payload‑Index vorhanden).
|
||||
4. **Betriebsfestigkeit:** Telemetrie aktiv; fehlertoleranter Import; Qdrant‑Snapshot nach erfolgreichem Lauf.
|
||||
|
||||
---
|
||||
|
||||
## 8) Roadmap in kleinen, testbaren Schritten
|
||||
|
||||
### Step 0 – Safeguards
|
||||
- Qdrant‑Snapshot v1 erstellen + Restore‑Probe.
|
||||
- ENV: `MINDNET_SCHEMA_VERSION=2` (Importer wird v2 schreiben, v1 bleibt unberührt).
|
||||
|
||||
### Step 1 – Schemata (nur Dateien)
|
||||
- Ablage: `/schemas/note.schema.json`, `/schemas/chunk.schema.json`, `/schemas/edge.schema.json`, `/schemas/default_edge.schema.json`
|
||||
- CI‑Job: `make schema-validate` (jsonschema).
|
||||
- **Abnahme:** Validator grün auf 3 Gold‑Notizen.
|
||||
|
||||
### Step 2 – Qdrant v2‑Collections (Optional)
|
||||
- Anlegen der 3 v2‑Collections + Payload‑Indizes.
|
||||
- **Abnahme:** Filter‑Query liefert erwartbare Ergebnisse.
|
||||
|
||||
### Step 2a – Edge-Pipeline v1 stabilisieren (ERLEDIGT)
|
||||
- Ziel: Vollständige Generierung von Struktur-, expliziten, typbasierten und Inline-Kanten in den bestehenden Collections `${prefix}_notes`, `${prefix}_chunks`, `${prefix}_edges`.
|
||||
- Status: Implementiert und durch `tests/test_edges_smoke.py`, `tests/test_edges_all.py` und `scripts/edges_full_check.py` verifiziert.
|
||||
|
||||
|
||||
### Step 3 – Chunker v2
|
||||
- Implementierung & Flag `--chunker v2`.
|
||||
- **Abnahme:** Chunk‑Counts ~ alt (≈171 ± 15 %), semantische Schnitte.
|
||||
|
||||
### Step 4 – Edge‑Builder v2
|
||||
- Reihenfolge & `provenance` strikt umsetzen, `default_resolved` integrieren.
|
||||
- **Abnahme:** erwartete Relationensätze auf Gold‑Notizen, keine Duplikate.
|
||||
|
||||
### Step 4a – Edge-bewusster Retriever
|
||||
- Implementiere einen Retrieval-Service, der:
|
||||
- Chunks über Vektor-Suche aus `${prefix}_chunks` holt,
|
||||
- dazu passende Nachbar-Chunks (`next/prev`) und typrelevante Notizen (`edge_defaults`, Inline-Relationen, Wikilinks) über `${prefix}_edges` ergänzt,
|
||||
- `retriever_weight` und `confidence` beim Scoring berücksichtigt.
|
||||
- Liefere einen API-Endpoint `/mindnet/query` mit einem einfachen JSON-Response (Chunks + Begründung).
|
||||
- Akzeptanz:
|
||||
- mindestens ein Testfall mit dem Relations-Showcase-Vault,
|
||||
- sichtbarer Einfluss von `edge_defaults` und Inline-Relationen auf die Ergebnisliste.
|
||||
|
||||
|
||||
### Step 5 – Importer‑Pipeline v2
|
||||
- `--schema v2` Side‑by‑Side; Batch‑Upserts; vollständige Payloads; Recency‑Boost Konfig **nur** in Policy.
|
||||
- **Abnahme:** Dry‑Run/Apply‑Parität, Reports, Telemetrie‑Ereignisse sichtbar.
|
||||
|
||||
### Step 6 – Observability
|
||||
- OTel‑Instrumentierung + `/import/status` + Reports.
|
||||
- **Abnahme:** Traces & Metriken vorhanden.
|
||||
|
||||
### Step 7 – Snapshots & Runbook
|
||||
- Snapshot nach Erfolg; Restore‑Dokument.
|
||||
- **Abnahme:** Restore‑Probe erfolgreich.
|
||||
|
||||
### Step 8 – Policies
|
||||
- `policies/retrieval.yaml` + JSON‑Schema; A/B‑Test (Policy ändern → Retrieval ändert sich ohne Reimport).
|
||||
- **Abnahme:** Sichtbarer Effekt laut Testfall.
|
||||
|
||||
### Step 9 – Umschalten
|
||||
- Abnahme‑Doku, KPI‑Delta dokumentiert; Alias/Flag‑Switch auf v2.
|
||||
- **Abnahme:** Funktionale Gleichwertigkeit + Qualitätsgewinn.
|
||||
|
||||
---
|
||||
|
||||
## 9) Dateien (neu/ändern)
|
||||
**Neu:**
|
||||
- `schemas/note.schema.json`
|
||||
- `schemas/chunk.schema.json`
|
||||
- `schemas/edge.schema.json`
|
||||
- `schemas/default_edge.schema.json`
|
||||
- `policies/retrieval.schema.json`
|
||||
- `policies/retrieval.yaml`
|
||||
- `chunking/block_chunker.py`
|
||||
- `graph/edge_builder_v2.py`
|
||||
- `docs/OPERATIONS.md` (Snapshots/Restore/Runbook)
|
||||
- `tests/gold_notes/manifest.yaml` (+ 3–5 Notizen Kopien)
|
||||
|
||||
**Änderungen:**
|
||||
- `scripts/import_markdown.py` **oder** `scripts/import_markdown_v2.py` neu (Flags `--schema/--chunker/--edges`).
|
||||
- `edges.py` (falls weiterverwendet): auf **v2‑Edge‑Builder** migrieren oder auslaufen lassen.
|
||||
- `types.yaml`: Regel‑Definitionen klarisieren (IDs, Bedingungen), **nicht** hart in Code.
|
||||
|
||||
---
|
||||
|
||||
## 10) Beispiel‑Kommandos
|
||||
```bash
|
||||
# Step 2: Collections prüfen
|
||||
curl -s http://127.0.0.1:6333/collections | jq
|
||||
|
||||
# Step 3: Chunker v2 (dry-run)
|
||||
python3 -m scripts.import_markdown_v2 --vault ./vault --schema v2 --chunker v2 --edges v2 --dry-run --prefix "$COLLECTION_PREFIX"
|
||||
|
||||
# Step 5: Apply + Report
|
||||
python3 -m scripts.import_markdown_v2 --vault ./vault --schema v2 --chunker v2 --edges v2 --apply --prefix "$COLLECTION_PREFIX" --report ./reports/import_$(date +%F_%H%M).json
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 11) Rollback
|
||||
- v2‑Collections droppen (wenn Side‑by‑Side).
|
||||
- Aus Snapshot wiederherstellen (v1).
|
||||
- Flags zurück auf v1.
|
||||
|
||||
---
|
||||
|
||||
## 12) Referenzen (offizielle Quellen)
|
||||
- Qdrant – Collections, Payload‑Index, Filter: <https://qdrant.tech/documentation/>
|
||||
- Qdrant – Snapshots/Backup: <https://qdrant.tech/documentation/guides/backup/>
|
||||
- OpenTelemetry (Python/FastAPI): <https://opentelemetry.io/docs/instrumentation/python/>
|
||||
- JSON‑Schema 2020‑12: <https://json-schema.org/>
|
||||
- YAML 1.2: <https://yaml.org/spec/1.2.2/>
|
||||
- Obsidian Frontmatter: <https://help.obsidian.md/Editing+and+formatting/Properties>
|
||||
- Ollama CLI/API (lokale Modelle): <https://github.com/ollama/ollama>
|
||||
|
||||
---
|
||||
|
||||
## 13) **PROMPT für den neuen Chat (bitte exakt so einfügen)**
|
||||
```
|
||||
Rolle: Du bist mein Senior‑Entwickler & Architekt für mindnet. Arbeite strikt in kleinen, testbaren Schritten (Side‑by‑Side v2 neben v1). Liefere komplette Dateien als Downloads. Frage immer zuerst nach den **aktuellsten** Projektdateien, wenn du sie brauchst (z. B. import_markdown.py, edges.py, types.yaml), ändere keine Systemfunktion „workaround‑artig“ ohne die Gesamtwirkung zu prüfen.
|
||||
|
||||
Kontext (Kurzfassung):
|
||||
- v1 hat nur mindnet_notes zuverlässig. Chunks/Edges sind inkonsistent/teilweise leer. Ziel: v2 mit drei Collections (notes/chunks/edges), neuem Chunker v2, Edge‑Builder v2 (explicit → rule → default_resolved → default), Policies (YAML), Observability (OTel), Snapshots. Kein Big‑Bang; v2 parallel zu v1.
|
||||
- Siehe angehängte Datei **mindnet_v2_implementation_playbook.md** (Pfad/Download im Chat). Alles daraus ist verbindlich.
|
||||
|
||||
Deine ersten Aufgaben (Step‑by‑Step):
|
||||
1) **Schemata anlegen (Step 1)**
|
||||
- Erstelle die Dateien:
|
||||
- schemas/note.schema.json
|
||||
- schemas/chunk.schema.json
|
||||
- schemas/edge.schema.json
|
||||
- schemas/default_edge.schema.json
|
||||
- Nutze die in der Playbook‑Datei vorgegebenen Strukturen als Basis.
|
||||
- Liefere zusätzlich ein einfaches `Makefile`‑Ziel `schema-validate` (jsonschema via Python), plus `requirements.txt`.
|
||||
- Output: komplette Dateien als Downloads + kurze Testanleitung.
|
||||
|
||||
2) **Qdrant v2‑Collections (Step 2)**
|
||||
- Erzeuge die Collections + Payload‑Indizes.
|
||||
- Liefere ein kleines Python‑Skript `tools/qdrant_bootstrap_v2.py`, das diese Anlage idempotent durchführt (inkl. Prüf‑Output).
|
||||
|
||||
3) **Chunker v2 (Step 3)**
|
||||
- Implementiere `chunking/block_chunker.py` mit den im Playbook genannten Parametern.
|
||||
- Teste gegen 3 Gold‑Notizen (liefere mini Test‑Harness in `tests/gold_notes/…`).
|
||||
|
||||
Arbeitsweise:
|
||||
- Jede Aufgabe einzeln, mit klaren Akzeptanzkriterien (aus Playbook) und Download‑Artefakten.
|
||||
- Keine parallelen Großumbauten.
|
||||
- Immer deterministische IDs, idempotente Upserts.
|
||||
|
||||
Dateien, die ich dir anfänglich bereitstelle:
|
||||
- **mindnet_v2_implementation_playbook.md** (diese Datei)
|
||||
- **import_markdown.py** (aktuelle Version aus dem Projekt)
|
||||
- **edges.py** (aktuelle Version aus dem Projekt)
|
||||
- **types.yaml** (aktuelle Version)
|
||||
|
||||
Sage mir jeweils, welche Datei du als Nächstes brauchst. Beginne jetzt mit Aufgabe 1 (Schemata).
|
||||
```
|
||||
@@ -0,0 +1,260 @@
|
||||
# WP-04 / Step 4a – Retriever Scoring & Konfiguration
|
||||
|
||||
Dieses Dokument beschreibt den aktuellen Stand (2025-11-30) der Scoring-Logik des mindnet-Retrievers in WP-04 / Step 4a.
|
||||
Es dient als Referenz für:
|
||||
|
||||
- Nachvollziehbarkeit des Rankings
|
||||
- Konfiguration und Feintuning (ohne Codeänderungen)
|
||||
- spätere Automatisierung / „Selbstjustierung“ des Retrievers
|
||||
|
||||
---
|
||||
|
||||
## 1. Überblick
|
||||
|
||||
Der Retriever kombiniert drei Signalquellen zu einem einheitlichen Score:
|
||||
|
||||
1. **Semantik** – Vektorsuche über `mindnet_chunks`
|
||||
2. **Typ-Gewichtung** – `retriever_weight` pro Note/Chunk (aus `types.yaml`)
|
||||
3. **Graph-Boni** – `edge_bonus` und `centrality_bonus` aus dem Subgraph (Edges)
|
||||
|
||||
Die Berechnung erfolgt in `app/core/retriever.py` und ist über `config/retriever.yaml` konfigurierbar.
|
||||
Die API stellt die Funktionalität über den `/query`-Endpoint (FastAPI) bereit.
|
||||
|
||||
---
|
||||
|
||||
## 2. Datenbasis (Kurzüberblick)
|
||||
|
||||
### 2.1 Notes (`<prefix>_notes`)
|
||||
|
||||
Relevante Felder:
|
||||
|
||||
- note_id: keyword
|
||||
- title: text
|
||||
- type: keyword
|
||||
- retriever_weight: float
|
||||
- chunk_profile: keyword
|
||||
- edge_defaults: keyword[]
|
||||
- tags: keyword[]
|
||||
- path: text
|
||||
- fulltext: text
|
||||
|
||||
### 2.2 Chunks (`<prefix>_chunks`)
|
||||
|
||||
Relevante Felder:
|
||||
|
||||
- note_id: keyword
|
||||
- chunk_id: keyword
|
||||
- text: text
|
||||
- window: text
|
||||
- retriever_weight: float
|
||||
- type: keyword
|
||||
- path: text
|
||||
- section: text
|
||||
- neighbors_prev / neighbors_next
|
||||
- chunk_profile: keyword
|
||||
|
||||
### 2.3 Edges (`<prefix>_edges`)
|
||||
|
||||
Relevante Felder:
|
||||
|
||||
- kind: keyword
|
||||
- source_id: keyword
|
||||
- target_id: keyword
|
||||
- note_id: keyword
|
||||
- confidence: float
|
||||
- rule_id, provenance, edge_id, scope, relation, ref_text
|
||||
|
||||
Edges stammen stets aus der Import-/Edge-Pipeline (WP-03) und bilden die graphbasierte Grundlage des Retrievers.
|
||||
|
||||
---
|
||||
|
||||
## 3. Scoring-Formel (Retriever)
|
||||
|
||||
### 3.1 Eingangsgrößen
|
||||
|
||||
Für jeden Treffer gelten:
|
||||
|
||||
semantic_score – aus der Vektorsuche (Qdrant)
|
||||
retriever_weight – typabhängiges Gewicht (aus types.yaml)
|
||||
edge_bonus – aggregierter Graph-Bonus
|
||||
centrality_bonus – Zentralitätsbonus aus dem Subgraph
|
||||
|
||||
### 3.2 Globale Gewichte (aus retriever.yaml)
|
||||
|
||||
Datei: `config/retriever.yaml`
|
||||
Beispiel:
|
||||
|
||||
version: 1.0
|
||||
|
||||
scoring:
|
||||
semantic_weight: 1.0 # W_sem
|
||||
edge_weight: 0.7 # W_edge
|
||||
centrality_weight: 0.5 # W_cent
|
||||
|
||||
Falls diese Datei fehlt, greifen ENV-basierte Defaults (`RETRIEVER_W_*`).
|
||||
|
||||
### 3.3 Formel
|
||||
|
||||
total_score =
|
||||
W_sem * semantic_score * max(retriever_weight, 0.0)
|
||||
+ W_edge * edge_bonus
|
||||
+ W_cent * centrality_bonus
|
||||
|
||||
Bemerkungen:
|
||||
|
||||
- Negative `retriever_weight` werden abgefangen.
|
||||
- Die rohen `edge_bonus` und `centrality_bonus` werden im API-/Smoke-Output angezeigt.
|
||||
- Die Gewichte aus `retriever.yaml` beeinflussen **nur den total_score**, nicht die Anzeige.
|
||||
|
||||
---
|
||||
|
||||
## 4. Konfigurationsdateien
|
||||
|
||||
### 4.1 Typen-Registry (`types.yaml`)
|
||||
|
||||
Beispielauszug:
|
||||
|
||||
defaults:
|
||||
retriever_weight: 1.0
|
||||
chunk_profile: default
|
||||
|
||||
types:
|
||||
types:
|
||||
concept:
|
||||
retriever_weight: 0.60
|
||||
edge_defaults: ["references", "related_to"]
|
||||
|
||||
project:
|
||||
retriever_weight: 0.97
|
||||
edge_defaults: ["references", "depends_on"]
|
||||
|
||||
journal:
|
||||
retriever_weight: 0.80
|
||||
edge_defaults: ["references", "related_to"]
|
||||
|
||||
source:
|
||||
retriever_weight: 0.50
|
||||
edge_defaults: []
|
||||
|
||||
Diese Werte bestimmen, wie wichtig eine Note/Chunk **prinzipiell** für den Retriever ist.
|
||||
|
||||
### 4.2 Retriever-Konfiguration (`retriever.yaml`)
|
||||
|
||||
Beispiel:
|
||||
|
||||
version: 1.0
|
||||
|
||||
scoring:
|
||||
semantic_weight: 1.0
|
||||
edge_weight: 0.7
|
||||
centrality_weight: 0.5
|
||||
|
||||
# Blueprint für spätere Edge-Feinsteuerung:
|
||||
edge_types:
|
||||
references: 0.20
|
||||
depends_on: 0.18
|
||||
related_to: 0.15
|
||||
similar_to: 0.12
|
||||
belongs_to: 0.10
|
||||
next: 0.06
|
||||
prev: 0.06
|
||||
|
||||
Die Datei befindet sich standardmäßig unter `config/retriever.yaml`.
|
||||
Override per ENV:
|
||||
|
||||
MINDNET_RETRIEVER_CONFIG=/pfad/zur/datei.yaml
|
||||
|
||||
### 4.3 Aktive Gewichte auslesen
|
||||
|
||||
python - << 'PY'
|
||||
from app.core.retriever import _get_scoring_weights
|
||||
print(_get_scoring_weights())
|
||||
PY
|
||||
|
||||
Beispielausgabe:
|
||||
|
||||
(1.0, 0.7, 0.5)
|
||||
|
||||
---
|
||||
|
||||
## 5. Betriebsmodi
|
||||
|
||||
### 5.1 Semantikmodus (semantic)
|
||||
|
||||
Ablauf:
|
||||
|
||||
- Query-Vektor über embed_text()
|
||||
- Qdrant-Suche über mindnet_chunks
|
||||
- kein Subgraph → edge_bonus = centrality = 0
|
||||
- total_score = W_sem * semantic_score * retriever_weight
|
||||
|
||||
### 5.2 Hybridmodus (hybrid)
|
||||
|
||||
Ablauf:
|
||||
|
||||
- Semantik wie oben
|
||||
- falls expand.depth > 0:
|
||||
- Subgraph-Berechnung über ga.expand()
|
||||
- Ermittlung von edge_bonus und centrality_bonus
|
||||
- total_score = kombinierte Formel aus Semantik + Graph
|
||||
|
||||
---
|
||||
|
||||
## 6. Tests
|
||||
|
||||
### Ausführung (Unit & Integration)
|
||||
|
||||
pytest tests/test_retriever_basic.py \
|
||||
tests/test_retriever_weight.py \
|
||||
tests/test_retriever_edges.py
|
||||
|
||||
pytest tests/test_query_unit.py \
|
||||
tests/test_query_text_embed_unit.py
|
||||
|
||||
Tests decken ab:
|
||||
|
||||
- Semantiktreffer
|
||||
- Typ-Gewichte
|
||||
- Edge-Boni
|
||||
- Hybridmodus / FastAPI-Endpunkt
|
||||
|
||||
### Smoke-Test
|
||||
|
||||
python tests/test_retriever_smoke.py \
|
||||
--url "http://127.0.0.1:8001/query" \
|
||||
--query "embeddings" \
|
||||
--mode hybrid \
|
||||
--expand-depth 1 \
|
||||
--top-k 5
|
||||
|
||||
Beispielausgabe:
|
||||
|
||||
[1] note_id=...retriever-design
|
||||
total=1.5054 (semantic=0.4038 edge=1.5910 centrality=0.0000)
|
||||
|
||||
Interpretation:
|
||||
|
||||
- `semantic`, `edge`, `centrality` = Rohwerte
|
||||
- `total` = skaliert mit `retriever.yaml`
|
||||
|
||||
---
|
||||
|
||||
## 7. Betriebs-Hinweise
|
||||
|
||||
### 7.1 Änderung der Gewichte
|
||||
|
||||
- retriever.yaml anpassen
|
||||
- FastAPI/uvicorn neu starten
|
||||
- Smoke-Test prüfen
|
||||
|
||||
### 7.2 Zielbild WP-04
|
||||
|
||||
Der jetzige Stand ermöglicht:
|
||||
|
||||
- transparente, konfigurierbare Score-Berechnung
|
||||
- Kombination aus Semantik, Typwissen und Graphstruktur
|
||||
- spätere agentenbasierte Selbstjustierung
|
||||
- alternative Profile (z. B. „mehr Semantik“, „mehr Graph“)
|
||||
|
||||
Dieses Dokument dient als stabile Referenz für Entwickler, Tests und spätere Automatisierungsschritte.
|
||||
|
||||
@@ -0,0 +1,307 @@
|
||||
# mindnet v2 — Dokumentationsreview (vollständig & konsolidiert)
|
||||
|
||||
Dieses Dokument fasst alle notwendigen Anpassungen der mindnet-v2 Dokumentation zusammen.
|
||||
Der Fokus liegt ausschließlich auf Aspekten, die durch die aktuellen Arbeiten verändert wurden:
|
||||
|
||||
- neue Edge-Mechanik
|
||||
- neuer Importer
|
||||
- neues Verhalten von note_payload & chunk_payload
|
||||
- Default-Typregeln aus `types.yaml`
|
||||
- Inline- und Callout-Relations
|
||||
- WP04a – Einführung der Retriever-Schicht
|
||||
- neue Diagnose- und Testskripte
|
||||
|
||||
Es handelt sich um eine strukturelle Analyse.
|
||||
Nichts davon überschreibt bestehende Inhalte — es markiert nur, **was angepasst werden muss**.
|
||||
|
||||
---
|
||||
|
||||
# 1) knowledge_design.md
|
||||
## Erforderliche Anpassungen
|
||||
|
||||
### 1.1 Neue Edge-Arten dokumentieren
|
||||
Es müssen vier neue Kategorien beschrieben werden:
|
||||
|
||||
1. **Inline-Edges**
|
||||
|
||||
Beispiel:
|
||||
`[ [rel:depends_on Embeddings 101] ]`
|
||||
(Leerzeichen hier zur Demonstration; im echten Dokument ohne Leerzeichen)
|
||||
|
||||
2. **Callout-Edges**
|
||||
|
||||
> [!edge] related_to: [[Vector DB Basics]] [[Embeddings 101]]
|
||||
|
||||
3. **Typbasierte Default-Kanten**
|
||||
Aus `types.yaml` → `edge_defaults`
|
||||
|
||||
4. **Strukturkanten**
|
||||
- belongs_to
|
||||
- next
|
||||
- prev
|
||||
|
||||
### 1.2 Neue Edge-Felder ergänzen
|
||||
Jeder Edge enthält jetzt:
|
||||
|
||||
- `rule_id`
|
||||
- `confidence`
|
||||
- `scope = "chunk"`
|
||||
- deterministischer `edge_id`
|
||||
|
||||
Diese Felder müssen vollständig erklärt werden.
|
||||
|
||||
### 1.3 Chunk-basierte Kanten
|
||||
Neu: **Alle Kanten entstehen ausschließlich zwischen Chunks**, nie zwischen Notes.
|
||||
Notes dienen nur noch als Metadatencontainer.
|
||||
|
||||
---
|
||||
|
||||
# 2) TYPE_REGISTRY_MANUAL.md
|
||||
## Erforderliche Anpassungen
|
||||
|
||||
### 2.1 Typauflösung dokumentieren
|
||||
Die Regeln sind jetzt:
|
||||
|
||||
- Typ aus Frontmatter → höchste Priorität
|
||||
- Falls nicht gesetzt: Typ aus Dateipfad ableiten
|
||||
- Falls unbekannt: Fallback auf `types.default`
|
||||
- Typ definiert:
|
||||
- retriever_weight
|
||||
- chunk_profile
|
||||
- edge_defaults
|
||||
|
||||
Diese müssen klar dokumentiert werden.
|
||||
|
||||
### 2.2 Neue Fallback-Regeln
|
||||
Wenn Werte fehlen, werden sie ersetzt durch:
|
||||
|
||||
types.default.retriever_weight
|
||||
types.default.chunk_profile
|
||||
types.default.edge_defaults
|
||||
|
||||
### 2.3 Beispiele aktualisieren
|
||||
Alle Beispiele müssen auf die neue Inline-Syntax angepasst werden.
|
||||
|
||||
---
|
||||
|
||||
# 3) wp04_retriever_scoring.md
|
||||
## Erforderliche Anpassungen
|
||||
|
||||
### 3.1 Neue Scoring-Formel
|
||||
total_score =
|
||||
semantic_weight * semantic_score
|
||||
+ edge_weight * edge_bonus
|
||||
+ centrality_weight * centrality_bonus
|
||||
+ type_weight * retriever_weight
|
||||
|
||||
### 3.2 Bedeutung von `confidence`
|
||||
confidence wirkt multiplikativ bei edge_bonus.
|
||||
Inline > Callout > Default (Standardwerte im Code hinterlegt).
|
||||
|
||||
### 3.3 Pfadbegründungen
|
||||
Der Retriever gibt optional `paths[]` zurück:
|
||||
|
||||
paths: [
|
||||
{
|
||||
"via": "depends_on",
|
||||
"confidence": 0.7,
|
||||
"hops": ["Note A", "Chunk A#01", "Note B"]
|
||||
}
|
||||
]
|
||||
|
||||
Diese Funktion müssen dokumentiert werden.
|
||||
|
||||
---
|
||||
|
||||
# 4) mindnet_v2_implementation_playbook.md
|
||||
## Erforderliche Anpassungen
|
||||
|
||||
### 4.1 Neuer Import-Prozess vollständig dokumentieren
|
||||
Der Importer läuft jetzt so:
|
||||
|
||||
1. Markdown lesen
|
||||
2. Frontmatter extrahieren
|
||||
3. Typauflösung via `types.yaml`
|
||||
4. Note-Payload generieren
|
||||
5. Chunking anwenden
|
||||
6. Inline-Kanten finden
|
||||
7. Callout-Kanten finden
|
||||
8. Default-Edges erzeugen
|
||||
9. Strukturkanten erzeugen
|
||||
10. Chunks in Qdrant upserten
|
||||
11. Edges upserten
|
||||
12. Diagnose laufen lassen:
|
||||
|
||||
python3 -m scripts.payload_dryrun
|
||||
python3 -m scripts.edges_full_check
|
||||
|
||||
### 4.2 Erweiterte Testpipeline
|
||||
Neu zu dokumentieren:
|
||||
|
||||
tests.test_edges_all
|
||||
scripts.edges_full_check
|
||||
scripts.payload_dryrun
|
||||
|
||||
Diese Testschritte sind jetzt Standardanforderung nach jeder Änderung.
|
||||
|
||||
---
|
||||
|
||||
# 5) mindnet_technical_architecture.md
|
||||
## Erforderliche Anpassungen
|
||||
|
||||
### 5.1 Aktualisiertes Schema für Qdrant Collections
|
||||
|
||||
#### Notes:
|
||||
note_id
|
||||
title
|
||||
type
|
||||
fulltext
|
||||
retriever_weight
|
||||
chunk_profile
|
||||
edge_defaults
|
||||
tags
|
||||
updated
|
||||
|
||||
#### Chunks:
|
||||
chunk_id
|
||||
note_id
|
||||
text
|
||||
window
|
||||
ord
|
||||
retriever_weight
|
||||
chunk_profile
|
||||
neighbors_prev
|
||||
neighbors_next
|
||||
|
||||
#### Edges:
|
||||
edge_id
|
||||
source_id
|
||||
target_id
|
||||
kind
|
||||
scope = "chunk"
|
||||
rule_id
|
||||
confidence
|
||||
|
||||
### 5.2 Dokumentation der Edge-Pipeline
|
||||
Neu beschreiben:
|
||||
|
||||
- Inline-Parser
|
||||
- Callout-Parser
|
||||
- Default-Edge-Resolver
|
||||
- Strukturkanten
|
||||
- Normalisierung für Qdrant
|
||||
- deterministische ID-Bildung
|
||||
|
||||
---
|
||||
|
||||
# 6) mindnet_functional_architecture.md
|
||||
## Erforderliche Anpassungen
|
||||
|
||||
### 6.1 Inline-Relations – einzig gültige Syntax
|
||||
Nur diese Syntax erzeugt Kanten:
|
||||
|
||||
[[rel:depends_on Embeddings 101]]
|
||||
|
||||
Nicht unterstützt:
|
||||
|
||||
rel:depends_on [[Embeddings 101]]
|
||||
|
||||
Dies muss klar dokumentiert werden.
|
||||
|
||||
### 6.2 Prioritäten der Kantenerzeugung
|
||||
Gültige Reihenfolge:
|
||||
|
||||
1. Inline
|
||||
2. Callout
|
||||
3. Typdefaults
|
||||
4. Strukturkanten
|
||||
|
||||
### 6.3 Relaunch der Chunk-zentrierten Funktionslogik
|
||||
Alle Beispiele müssen angepasst werden.
|
||||
|
||||
---
|
||||
|
||||
# 7) chunking_strategy.md
|
||||
## Erforderliche Änderungen
|
||||
|
||||
### 7.1 Neues Verhalten der Chunks
|
||||
- `ord` ist jetzt Sortierkriterium
|
||||
- `window` wird über chunk_config erzeugt
|
||||
- Chunkprofile kommen ausschließlich aus `types.yaml`
|
||||
|
||||
### 7.2 Best Practices erneuern
|
||||
Empfehlung:
|
||||
|
||||
- keine manuelle Chunkprofile mehr im Frontmatter setzen
|
||||
|
||||
---
|
||||
|
||||
# 8) docs_mindnet_retriever.md
|
||||
## Erforderliche Änderungen
|
||||
|
||||
### 8.1 Neue Ausgabeparameter dokumentieren
|
||||
Retriever liefert jetzt:
|
||||
|
||||
semantic_score
|
||||
edge_bonus
|
||||
centrality_bonus
|
||||
type_score
|
||||
total_score
|
||||
paths[]
|
||||
|
||||
### 8.2 Graph-Expansion
|
||||
Dokumentieren:
|
||||
|
||||
- Seed-Auswahl
|
||||
- Depth-Limit
|
||||
- Edge-Filterung
|
||||
- Wirkung von `confidence` auf edge_bonus
|
||||
|
||||
---
|
||||
|
||||
# 9) Handbuch.md
|
||||
## Erforderliche Änderungen
|
||||
|
||||
### 9.1 Neuer Import-Workflow
|
||||
Erläuterung der Parser:
|
||||
|
||||
- Inline-Parser
|
||||
- Callout-Parser
|
||||
- Default-Kanten
|
||||
- Struktur-Kanten
|
||||
|
||||
### 9.2 Best Practices
|
||||
Ergänzen:
|
||||
|
||||
- Typenpflege erfolgt nur in `types.yaml`
|
||||
- Tests immer nach Änderungen ausführen
|
||||
|
||||
---
|
||||
|
||||
# Gesamtübersicht der notwendigen Anpassungen
|
||||
|
||||
| Dokument | Anpassungsbedarf |
|
||||
|---------|------------------|
|
||||
| knowledge_design.md | neue Edge-Arten, Felder, Chunk-Edges |
|
||||
| TYPE_REGISTRY_MANUAL.md | Typauflösung, neue Felder, neue Fallbacks |
|
||||
| wp04_retriever_scoring.md | neue Score-Formel, Pfade, confidence |
|
||||
| implementation_playbook.md | neuer Importprozess, Tests |
|
||||
| technical_architecture.md | aktualisierte Schemas |
|
||||
| functional_architecture.md | Syntax + Prioritäten |
|
||||
| chunking_strategy.md | ord, window, neue Profile |
|
||||
| docs_mindnet_retriever.md | neue API-Parameter |
|
||||
| Handbuch.md | Parser + Best Practices |
|
||||
|
||||
---
|
||||
|
||||
# Empfehlung zur Umsetzung
|
||||
1. Dieses Review-Dokument als Master-Referenz verwenden.
|
||||
2. Jedes Dokument strikt nur an den beschriebenen Stellen anpassen.
|
||||
3. Überprüfen, ob Wann/Wo Typen, Kanten und Parser erklärt werden.
|
||||
4. Nach jeder Anpassung Testlauf:
|
||||
|
||||
python3 -m scripts.payload_dryrun
|
||||
python3 -m scripts.edges_full_check
|
||||
|
||||
5. Danach Playbook + Programmplan updaten.
|
||||
|
||||
@@ -0,0 +1,322 @@
|
||||
# mindnet – Änderungs- und Ergänzungsleitfaden für bestehende Dokumentation
|
||||
# (Stand: Tag Wp04a-Retriever_final)
|
||||
|
||||
Dieser Leitfaden listet **alle notwendigen Änderungen und Ergänzungen** für die
|
||||
bestehenden Dokumente auf. Er umfasst ausschließlich Inhalte, die durch die
|
||||
tatsächliche Implementierung von WP-04a (Retriever, Hybrid Scoring, Graph-Integration,
|
||||
retriever.yaml, Explainability-Vorbereitung, Centrality, Edge-Bonus, Query-API)
|
||||
betroffen sind.
|
||||
|
||||
Er dient dazu, dass ein anderer Chat alle Dokumente vollständig und korrekt
|
||||
überarbeiten kann, ohne Interpretationsspielraum oder fehlende Informationen.
|
||||
|
||||
|
||||
============================================================
|
||||
# 1. Änderungen für: knowledge_design.md
|
||||
============================================================
|
||||
|
||||
## 1.1 Ergänzen: Rolle von retriever_weight pro Note-Type
|
||||
Die Implementierung nutzt `retriever_weight`, das im Importer aus `types.yaml`
|
||||
pro Note-Type übernommen und auf *Chunk-Ebene* vererbt wird.
|
||||
|
||||
**Ergänzen:**
|
||||
- Erklärung, dass `retriever_weight` ein konzeptionelles Typ-Attribut ist,
|
||||
das im hybriden Scoring als Multiplikator wirkt.
|
||||
- Klarstellung, dass `retriever_weight` *nicht* durch Markdown-Frontmatter
|
||||
überschrieben werden muss.
|
||||
- Dokumentation, dass Qdrant-Payload dieses Feld für Notes und Chunks enthält.
|
||||
|
||||
## 1.2 Ergänzen: Edge-Typen, die im Retriever genutzt werden
|
||||
Der Retriever unterstützt aktuell:
|
||||
- `references`
|
||||
- `related_to`
|
||||
- `depends_on`
|
||||
- `similar_to`
|
||||
- `belongs_to`
|
||||
- sowie generierte Strukturkanten `next` / `prev`.
|
||||
|
||||
**Ergänzen:**
|
||||
- Welche Edges für den Graph-Bonus ausgewertet werden.
|
||||
- Wie `confidence` aus mindnet_edges genutzt wird.
|
||||
|
||||
## 1.3 Ergänzen: Definition des lokalen Subgraphen
|
||||
Die reale Retrieval-Logik nutzt:
|
||||
- Seed-Notes (aus semantisch Top-K)
|
||||
- Expansionstiefe `depth`
|
||||
- Edge-Typ-Filter
|
||||
- Bonusberechnung pro Knoten
|
||||
|
||||
Dies ist im ursprünglichen Dokument nicht beschrieben und muss hinzugefügt werden.
|
||||
|
||||
============================================================
|
||||
# 2. Änderungen für: chunking_strategy.md
|
||||
============================================================
|
||||
|
||||
## 2.1 Ergänzen: Chunk-Payload-Felder, die der Retriever nutzt
|
||||
Die aktuelle Strategy beschreibt Chunks korrekt, es fehlt jedoch:
|
||||
|
||||
**Ergänzen:**
|
||||
- `retriever_weight` (vererbt vom Note-Type)
|
||||
- `chunk_profile` (aktuell ungenutzt im Retriever, aber Teil der Payload)
|
||||
- Hinweise, dass der Retriever nur aus *Chunks* semantische Seeds bildet,
|
||||
das Ranking aber auf *Notes* aggregiert wird.
|
||||
|
||||
## 2.2 Ergänzen: Section/Window-Felder und ihre Relevanz
|
||||
Die Felder existieren im Qdrant, werden aber im retriever.yaml nicht verändert.
|
||||
|
||||
**Hinweis ergänzen:**
|
||||
- Der Retriever nutzt aktuell `text` und `window`; kein Einfluss der Abschnittslogik.
|
||||
|
||||
|
||||
============================================================
|
||||
# 3. Änderungen für: TYPE_REGISTRY_MANUAL.md
|
||||
============================================================
|
||||
|
||||
Dieses Dokument muss **aktualisiert** werden, da WP-04a folgende Mechanismen nutzt:
|
||||
|
||||
## 3.1 Ergänzen: Bedeutung von retriever_weight
|
||||
- Definition als quantitatives Typ-Merkmal.
|
||||
- Erklärung, dass es in Qdrant gespeichert wird.
|
||||
- Erklärung des Einflusses auf Semantikscore:
|
||||
- Formel:
|
||||
|
||||
final_semantic = semantic_score * retriever_weight
|
||||
|
||||
- Hinweis, dass in future WP-08 das Gewicht durch Feedback lernbar wird.
|
||||
|
||||
## 3.2 Ergänzen: Neue Edge-Typen und ihre Standard-Konfiguration
|
||||
- `similar_to`
|
||||
- `belongs_to`
|
||||
- Strukturkanten `next` / `prev`
|
||||
|
||||
Diese sind im Importer bereits aktiv, aber nicht ausreichend dokumentiert.
|
||||
|
||||
## 3.3 Ergänzen: Edge-Konfidenzen
|
||||
Die automatische Edge-Ableitung generiert `confidence`.
|
||||
Retriever nutzt diesen Wert linear im Edge-Bonus.
|
||||
|
||||
**Dokumentation muss ergänzt werden.**
|
||||
|
||||
|
||||
============================================================
|
||||
# 4. Änderungen für: docs_mindnet_retriever.md
|
||||
============================================================
|
||||
|
||||
Dieses Dokument ist am stärksten betroffen und muss auf den Stand der tatsächlichen
|
||||
Implementierung aktualisiert werden.
|
||||
|
||||
## 4.1 Aktualisieren: Gesamtscoring-Formel
|
||||
Bisher: Semantik + einfache Typgewichtung.
|
||||
|
||||
Neu implementiert:
|
||||
|
||||
total_score =
|
||||
semantic_weight * semantic_score
|
||||
+ edge_weight * edge_bonus
|
||||
+ centrality_weight * centrality_bonus
|
||||
|
||||
Diese Formel muss vollständig dokumentiert werden.
|
||||
|
||||
## 4.2 Aktualisieren: Einführung retriever.yaml
|
||||
Dokumentation benötigt:
|
||||
|
||||
- Speicherort: `app/config/retriever.yaml`
|
||||
- Default-Werte
|
||||
- Abschnittsweise Beschreibung:
|
||||
- semantic_weight
|
||||
- edge_weight
|
||||
- centrality_weight
|
||||
- Hinweis: Änderungen wirken ohne Codeänderung.
|
||||
|
||||
## 4.3 Ergänzen: Beschreibung Graph-Expansion
|
||||
Der Retriever nutzt:
|
||||
|
||||
- Expand-depth (default 1)
|
||||
- Edge-Typ-Filter
|
||||
- Aggregation pro Node
|
||||
- Bonus-Skalierung
|
||||
|
||||
Diese Logik ist neu und muss detailliert erklärt werden.
|
||||
|
||||
## 4.4 Ergänzen: Beschreibung centrality_bonus
|
||||
Aktuell:
|
||||
- proportionale Verteilung anhand Knotendichte
|
||||
- Normalisierung über lokales Subgraph-Maß
|
||||
|
||||
Dokumentation muss Minimum enthalten:
|
||||
- wie centrality gewichtet wird
|
||||
- welche Grenze existieren
|
||||
|
||||
## 4.5 Ergänzen: Explainability-Schnittstelle (WP-04b Vorbereitung)
|
||||
Die Implementierung erzeugt intern:
|
||||
- edge_bonus pro Node
|
||||
- centrality_bonus pro Node
|
||||
- Liste der Edges, die beteiligt waren
|
||||
|
||||
Diese Werte sind abrufbar und müssen dokumentiert werden.
|
||||
|
||||
## 4.6 Ergänzen: Fehlertoleranzen & Timeout (Health Check)
|
||||
Der Retriever kann:
|
||||
- Fallback auf Vektor-Suche (pure semantic)
|
||||
- Fallback bei fehlendem expand
|
||||
|
||||
Diese Sicherheitsmechanismen müssen dokumentiert werden.
|
||||
|
||||
|
||||
============================================================
|
||||
# 5. Änderungen für: mindnet_technical_architecture.md
|
||||
============================================================
|
||||
|
||||
## 5.1 Ergänzen: Komponentenübersicht Retrieval-Layer
|
||||
Eine neue Abbildung oder Abschnitt muss hinzu:
|
||||
|
||||
- QueryRequest-Parsing
|
||||
- Embedding-Lookup oder Vector-Passthrough
|
||||
- Semantic Seed Search (Qdrant)
|
||||
- Graph-Expansion (mindnet_edges)
|
||||
- Node-/Note-Aggregation
|
||||
- Score-Combination
|
||||
- Response-Ausgabe via FastAPI
|
||||
|
||||
## 5.2 Ergänzen: Datenstruktur mindnet_edges
|
||||
Vor WP-04 nicht vollständig dokumentiert.
|
||||
|
||||
Benötigt:
|
||||
|
||||
- Felder:
|
||||
- edge_id
|
||||
- kind
|
||||
- source_id
|
||||
- target_id
|
||||
- confidence
|
||||
- rule_id
|
||||
- Wie Edges im Retriever ausgewertet werden.
|
||||
|
||||
## 5.3 Ergänzen: retriever.yaml als Konfigurationsquelle
|
||||
Architekturdiagramm muss updated werden:
|
||||
- Retriever nutzt YAML
|
||||
- Keine Hardcodierung im Python
|
||||
|
||||
## 5.4 Ergänzen: Health Check Script
|
||||
Technischer Abschnitt muss dokumentieren:
|
||||
|
||||
- health_check_mindnet.py
|
||||
- Semantik:
|
||||
- semantic query
|
||||
- hybrid query
|
||||
- Fehlercodes
|
||||
|
||||
|
||||
============================================================
|
||||
# 6. Änderungen für: mindnet_functional_architecture.md
|
||||
============================================================
|
||||
|
||||
## 6.1 Ergänzen: Funktionale Rolle des Retrievers
|
||||
Retriever ist jetzt:
|
||||
|
||||
- Teil des Functional Layers
|
||||
- Grundlage für Agenten / Decision Engine
|
||||
- Hauptquelle für Begründungen
|
||||
|
||||
## 6.2 Ergänzen: Einbindung des Explainability-Layers
|
||||
Funktional gehört dies zwischen:
|
||||
- Retriever
|
||||
- Antwortgenerierung (LLM)
|
||||
|
||||
Der Explainability-Layer formuliert Gründe:
|
||||
- Welche Edges?
|
||||
- Welche Scores?
|
||||
- Warum diese Note?
|
||||
|
||||
## 6.3 Ergänzen: Self-Tuning als neuen Funktionsblock (WP-08)
|
||||
Muss aufgenommen werden:
|
||||
|
||||
- Logging von Feedback
|
||||
- Bewertung
|
||||
- Tuning der retriever.yaml
|
||||
- Human-in-the-loop Freigabe
|
||||
|
||||
|
||||
============================================================
|
||||
# 7. Änderungen für: wp04_retriever_scoring.md
|
||||
============================================================
|
||||
|
||||
Dieses Dokument ist **direkt WP-04** und muss am stärksten überarbeitet werden.
|
||||
|
||||
## 7.1 Aktualisieren: Finale Scoring-Formel
|
||||
Die Formel muss exakt so dokumentiert werden, wie inzwischen implementiert.
|
||||
|
||||
## 7.2 Ergänzen: Bonusberechnung
|
||||
Die bisherige Planung wurde implementiert, aber der Text muss aktualisiert werden:
|
||||
|
||||
- Bonusberechnung je Edge
|
||||
- confidence-Einfluss
|
||||
- Node-Aggregation
|
||||
- Note-Aggregation
|
||||
|
||||
## 7.3 Ergänzen: Centrality
|
||||
Dokument ist zu ergänzen um:
|
||||
|
||||
- Definition
|
||||
- Berechnung
|
||||
- Normalisierung
|
||||
- Gewichtung über retriever.yaml
|
||||
|
||||
## 7.4 Ergänzen: Teststrategie
|
||||
Die finale Testbasis muss dokumentiert werden:
|
||||
|
||||
- Unit-Tests
|
||||
- Hybrid-Tests
|
||||
- API-Tests
|
||||
- Smoke-Test
|
||||
- Diagnose-Skripte
|
||||
|
||||
## 7.5 Ergänzen: Einschränkungen & Offene Punkte
|
||||
Hinweis für WP-04b:
|
||||
- Explainability fehlt noch
|
||||
- Edge-Type Weights noch nicht implementiert
|
||||
- Self-Tuning in WP-08
|
||||
|
||||
|
||||
============================================================
|
||||
# 8. Änderungen für: mindnet_v2_implementation_playbook.md
|
||||
============================================================
|
||||
|
||||
## 8.1 Ergänzen: Arbeitsablauf mit Retriever
|
||||
Einrichtung, Nutzung und Test sollte ergänzt werden:
|
||||
|
||||
- Starten von FastAPI
|
||||
- Testen des Retrievers via health_check
|
||||
- Import-Workflow (neue Vaults → Qdrant → Retriever)
|
||||
|
||||
## 8.2 Ergänzen: Konfigurationsverwaltung
|
||||
Einbindung in Gitea-Workflows:
|
||||
- retriever.yaml versionieren
|
||||
- Tags/Branches für Funktionsstände setzen
|
||||
|
||||
## 8.3 Ergänzen: Self-Tuning-Prozess (nur Rahmen)
|
||||
Der Playbook-Abschnitt soll die späteren Mechanismen vorbeschreiben.
|
||||
|
||||
|
||||
============================================================
|
||||
# 9. Änderungen für: Handbuch.md
|
||||
============================================================
|
||||
|
||||
## 9.1 Ergänzen: Einfache Erklärung des Retrievers
|
||||
Das Handbuch benötigt eine verständliche, nicht-technische Beschreibung:
|
||||
|
||||
- Was macht der Retriever?
|
||||
- Warum kommt ein Ergebnis zustande?
|
||||
- Welche Rolle spielen Edges?
|
||||
- Wie kann der Nutzer die Gewichtung beeinflussen (YAML)?
|
||||
|
||||
## 9.2 Ergänzen: Troubleshooting
|
||||
Aufnehmen:
|
||||
- „Ergebnisse wirken unpassend“ → Prüfe retriever.yaml
|
||||
- „Edge-Bonus fehlt“ → Prüfe mindnet_edges
|
||||
- health_check-Skript nutzen
|
||||
|
||||
## 9.3 Ergänzen: API-Nutzung für Endanwender
|
||||
Einfacher Abschnitt:
|
||||
- Wie man `/query` testet
|
||||
- Beispiele für semantic & hybrid queries
|
||||
Reference in new issue
Block a user