Compare commits
21
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
27497fd6be | ||
|
|
466ce3ca82 | ||
|
|
8b5af5ec65 | ||
|
|
34cbc0c0eb | ||
|
|
52ff4bbff5 | ||
|
|
9e7104e362 | ||
|
|
882ae5368f | ||
|
|
12a424ce23 | ||
|
|
c3230761e8 | ||
|
|
f5104008c2 | ||
|
|
013e8c6d0c | ||
|
|
603bba533b | ||
|
|
e202a8d88b | ||
|
|
c56a31c6bc | ||
|
|
b73b18bf9a | ||
|
|
0f351252b2 | ||
|
|
d7d7411fa0 | ||
|
|
45af7f074c | ||
|
|
70ab118612 | ||
|
|
ba0cdea9d0 | ||
|
|
09500ff764 |
No files matched your search
Vendored
+3
@@ -0,0 +1,3 @@
|
|||||||
|
{
|
||||||
|
"CodeGPT.apiKey": "Google AI Studio"
|
||||||
|
}
|
||||||
@@ -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,772 @@
|
|||||||
|
# mindnet v2.2 — Programmplan
|
||||||
|
**Version:** 2.2
|
||||||
|
**Stand:** 2025-12-06
|
||||||
|
**Status:** Aktiv (Fortschreibung von v2.1)
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 1. Programmauftrag
|
||||||
|
|
||||||
|
mindnet v2.2 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 (mindnet-Assistent),
|
||||||
|
- später: Interview-Assistent (strukturierte Dialogerfassung),
|
||||||
|
- 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,
|
||||||
|
- 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.
|
||||||
|
|
||||||
|
- **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`, Policies, Knowledge-Design) festgelegt, nicht in jeder einzelnen Markdown-Datei.
|
||||||
|
|
||||||
|
- **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; mittelfristig entsteht ein Persönlichkeitsmodell, das den KI-Zwilling trägt.
|
||||||
|
|
||||||
|
- **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 (nächste Monate)
|
||||||
|
|
||||||
|
- Automatische Sammlung von Wissen aus Markdown-Vault und ersten Chat-Dialogen.
|
||||||
|
- Aufbau eines stabilen Graph-Speichers in Qdrant (`*_notes`, `*_chunks`, `*_edges`).
|
||||||
|
- Semantischer und graphbasierter Retriever (WP-04a abgeschlossen, WP-04b/04c in Vorbereitung).
|
||||||
|
- Automatisierte Erkennung von Beziehungen:
|
||||||
|
- Wikilinks, Inline-Relationen, Callout-Edges, Typ-Defaults.
|
||||||
|
- Schrittweises Lernen über Feedback (Score-Tuning, noch „manuell“ konfiguriert). :contentReference[oaicite:8]{index=8}
|
||||||
|
- „Mitwachsendes“ Schema ohne Obsidian-Umstrukturierungen:
|
||||||
|
- Neues Wissen kann sofort erfasst werden,
|
||||||
|
- bestehende Notizen bleiben gültig (Virtual Schema Layer).
|
||||||
|
- Technische Basis für die späteren Agenten und den KI-Zwilling:
|
||||||
|
- lokaler FastAPI-Dienst,
|
||||||
|
- Qdrant als Graph-Backend,
|
||||||
|
- konfigurierbarer Retriever (`retriever.yaml`).
|
||||||
|
|
||||||
|
### 3.2 Mittelfristig
|
||||||
|
|
||||||
|
- Persönlichkeitsprofil wird stabil erkannt und für Antworten genutzt (Typen, Werte-Notizen, Entscheidungsnotizen).
|
||||||
|
- Why-Layer: KI-Assistenz für Entscheidungen mit nachvollziehbarer Argumentation.
|
||||||
|
- Interview-Assistent erstellt neue Notes automatisch (strukturierte Dialoge → Markdown).
|
||||||
|
- mindnet erzeugt Vorschläge für neue Notes & Edges und bietet einen „Vernetzungs-Assistenten“ für manuell angelegte Notizen.
|
||||||
|
- Agenten können über MCP-Tools (`mindnet_query`, `mindnet_subgraph`, `mindnet_store_note`, `mindnet_explain`) auf mindnet zugreifen.
|
||||||
|
|
||||||
|
### 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`, Policies, `knowledge_design.md`) definiert, nicht direkt in den Vault-Dateien.
|
||||||
|
- Erlaubt spätere Anpassungen ohne manuelle Massenänderungen.
|
||||||
|
|
||||||
|
2. **Virtual Schema Layer**
|
||||||
|
- Typen, Regeln, Policies, Edge-Defaults werden im Schema-Layer beschrieben (z. B. `knowledge_design.md`, `mindnet_functional_architecture.md`, `types.yaml`).
|
||||||
|
- 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 (ähnliche Inhalte, typisierte Standardbeziehungen, Backlinks).
|
||||||
|
|
||||||
|
4. **Deterministische IDs**
|
||||||
|
- Notes, Chunks und Edges erhalten stabile IDs (z. B. UUIDv5, deterministische `note_id`/`chunk_id`/`edge_id`).
|
||||||
|
- Der Graph ist jederzeit wiederaufbaubar (Import-Pipeline idempotent).
|
||||||
|
|
||||||
|
5. **Full Explainability**
|
||||||
|
- Jeder Score, jede Beziehung, jeder Vorschlag muss über:
|
||||||
|
- Edges,
|
||||||
|
- Scoring-Komponenten (Semantik, Typ, Edge-Bonus, Centrality),
|
||||||
|
- Provenienz (Notizen, Chunks, rule_id, confidence) nachvollziehbar sein.
|
||||||
|
|
||||||
|
6. **Persistence First**
|
||||||
|
- Obsidian bleibt die primäre Quelle der Wahrheit.
|
||||||
|
- mindnet ergänzt, schlägt Änderungen vor, schreibt aber nur kontrolliert (z. B. über Rewriter oder Vernetzungs-Assistent mit Freigabe).
|
||||||
|
|
||||||
|
7. **Minimalinvasives Schreiben**
|
||||||
|
- Automatische Veränderungen an Markdown-Dateien erfolgen ausschließlich nach expliziter Zustimmung.
|
||||||
|
- Rewriter und Vernetzungs-Assistent arbeiten grundsätzlich im Vorschlagsmodus.
|
||||||
|
|
||||||
|
8. **Incremental Growth & Early Value**
|
||||||
|
- Das System muss bereits mit wenigen Notizen und einem kleinen Vault sinnvolle Antworten liefern (Retrieval-MVP).
|
||||||
|
- Spätere Erweiterungen (Typen, Policies, zusätzliche Edges) dürfen bestehende Notizen nicht „ungültig“ machen, sondern ergänzen sie.
|
||||||
|
- Feedback-Mechanismen werden früh eingeführt, auch wenn sie anfangs noch nicht vollautomatisch ausgewertet werden.
|
||||||
|
|
||||||
|
9. **Observability & Testbarkeit**
|
||||||
|
- Jeder Importlauf, jede Retriever-Anfrage und jede Policy-Änderung soll prüfbar sein (Logs, Traces, Tests, Reports).
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 5. Programmstruktur (Phasenmodell)
|
||||||
|
|
||||||
|
Phase A – Fundament & Import
|
||||||
|
Phase B – Semantik, Graph & Lernen
|
||||||
|
Phase C – Persönlichkeitsmodell & KI-Zwilling
|
||||||
|
Phase D – Agenten, MCP & Interaktion
|
||||||
|
Phase E – Review, Refactoring, Dokumentation
|
||||||
|
|
||||||
|
Alle Workpackages sind einer Phase zugeordnet; einige Workpackages (z. B. WP-03, WP-04a) sind bereits abgeschlossen und bilden heute die Basis für alle weiteren Schritte.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 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. :contentReference[oaicite:18]{index=18}
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
### 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`, `principle`, `person`, `event`, etc.).
|
||||||
|
- Standard-Properties (Titel, Typ, Tags, Status, Zeitstempel, Referenzen, Policies).
|
||||||
|
- Grundstruktur von Edges (z. B. `belongs_to`, `references`, `depends_on`, `similar_to`, `related_to`, `influenced_by`).
|
||||||
|
- Abbildung zentraler Lebens-Bereiche, Rollen und Wissenskategorien.
|
||||||
|
|
||||||
|
**Aufwand / Komplexität:**
|
||||||
|
- Aufwand: Mittel
|
||||||
|
- Komplexität: Mittel
|
||||||
|
|
||||||
|
**Erreichte Ergebnisse / Funktionsumfang:**
|
||||||
|
|
||||||
|
- `knowledge_design.md` in Version 1.5 definiert:
|
||||||
|
- Zielarchitektur,
|
||||||
|
- Collections,
|
||||||
|
- Identitätsmodell,
|
||||||
|
- zentrale Typen und Edges. :contentReference[oaicite:20]{index=20}
|
||||||
|
- Das Dokument beschreibt klar:
|
||||||
|
- wie Wissen fachlich strukturiert wird,
|
||||||
|
- welche Typen und Relationen in mindnet „erwartet“ werden,
|
||||||
|
- wie spätere Erweiterungen (neue Typen, zusätzliche Edge-Arten) ohne Retro-Migration möglich sind.
|
||||||
|
|
||||||
|
**DoD:**
|
||||||
|
|
||||||
|
- Schema ist konsistent beschrieben.
|
||||||
|
- Grundtypen und Edge-Arten sind definiert und im Code konzeptionell verankert (z. B. via `types.yaml`).
|
||||||
|
- Das Dokument dient als Referenz für alle folgenden WPs.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
### WP-02 – Chunking & Hash-Strategie (abgeschlossen)
|
||||||
|
|
||||||
|
**Phase:** A
|
||||||
|
**Status:** 🟢 abgeschlossen
|
||||||
|
|
||||||
|
**Ziel:**
|
||||||
|
Festlegen und implementieren einer robusten Chunking-Strategie und einer Hash-Logik zur Änderungserkennung.
|
||||||
|
|
||||||
|
**Umfang (fachlich & technisch):**
|
||||||
|
|
||||||
|
- Text in semantisch sinnvolle Chunks teilen (Heading-/Block-aware).
|
||||||
|
- Parallelhaltung von:
|
||||||
|
- `text` (Chunk-Kern ohne Overlap),
|
||||||
|
- `window` (Chunk-Fenster mit Overlap für Embeddings).
|
||||||
|
- Hash-Modi zur Änderungserkennung (Body / Frontmatter / Full, canonical vs. none).
|
||||||
|
- Unterstützung eines „Baseline-Modus“ (mehrere Hash-Signaturen), um spätere Modus-Wechsel zu ermöglichen, ohne alle Notizen als „geändert“ zu sehen.
|
||||||
|
|
||||||
|
**Aufwand / Komplexität:**
|
||||||
|
- Aufwand: Mittel
|
||||||
|
- Komplexität: Mittel/Hoch
|
||||||
|
|
||||||
|
**Erreichte Ergebnisse / Funktionsumfang:**
|
||||||
|
|
||||||
|
- Implementierte Chunker-Logik mit Ziel-Längen, Overlap und Nachbarschaft (`neighbors_prev`, `neighbors_next`).
|
||||||
|
- Tests zur Überprüfung der Rekonstruktion von Notiz-Bodies aus Chunks (`verify_chunks_integrity.py`, `check_chunks_window_vs_text.py`).
|
||||||
|
- Hash-Konfiguration über ENV-Variablen + Option `--baseline-modes`.
|
||||||
|
- Roundtrip-Tests für Vault → Qdrant → Export-Vault (keine ungewollten Veränderungen an Inhalten).
|
||||||
|
|
||||||
|
**DoD:**
|
||||||
|
|
||||||
|
- Chunking stabil, deterministisch, überprüft.
|
||||||
|
- Hash-Strategie ermöglicht sichere Änderungserkennung ohne Mass-Diffs bei Konfigurationswechsel.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
### 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, typbasierten Defaults und erklärbarem Edge-Modell.
|
||||||
|
|
||||||
|
**Umfang:**
|
||||||
|
|
||||||
|
- Parser (robust gegenüber Zeichensatzfehlern, Frontmatter/Body-Erkennung, Sonderfälle wie Silverbullet-Dateien).
|
||||||
|
- Bau von Note-Payloads (`note_payload`):
|
||||||
|
- Typ-Vererbung (`retriever_weight`, `chunk_profile`, `edge_defaults`).
|
||||||
|
- Bau von Chunk-Payloads (`chunk_payload`):
|
||||||
|
- `text`, `window`, Nachbarn, Typ-Information.
|
||||||
|
- Edge-System:
|
||||||
|
- Strukturkanten (`belongs_to`, `next`, `prev`),
|
||||||
|
- explizite Wikilinks (`[[Note]]` → `references`),
|
||||||
|
- Inline-Relationen (`[[rel:depends_on Note]]`),
|
||||||
|
- Callout-Edges (`> [!edge] related_to: [[Note]]`),
|
||||||
|
- typbasierte Standardkanten aus `types.yaml` (`edge_defaults`).
|
||||||
|
- Idempotente Upserts in Qdrant (Notes/Chunks/Edges).
|
||||||
|
|
||||||
|
**Aufwand / Komplexität:**
|
||||||
|
- Aufwand: Hoch
|
||||||
|
- Komplexität: Hoch
|
||||||
|
|
||||||
|
**Erreichte Ergebnisse / Funktionsumfang:**
|
||||||
|
|
||||||
|
- Vollständige E2E-Import-Pipeline incl. Tests (`run_e2e_roundtrip.sh`, `compare_vaults.py`, `validate_edges`, `edges_full_check`).
|
||||||
|
- deterministische ID-Vergabe für Notes/Chunks/Edges.
|
||||||
|
- vollständiges Edge-Modell gemäß Facharchitektur (`mindnet_functional_architecture.md`). :contentReference[oaicite:26]{index=26}
|
||||||
|
- Exporte zurück nach Markdown (Export-Pipeline) ermöglicht Roundtrip-Vergleich.
|
||||||
|
|
||||||
|
**DoD:**
|
||||||
|
|
||||||
|
- Importer generiert stabile Notes/Chunks/Edges für gesamten Vault.
|
||||||
|
- Edge-Invarianten (`belongs_to == #Chunks`, `next/prev` konsistent) erfüllt.
|
||||||
|
- Roundtrip: Exportierte Vault-Version stimmt inhaltlich mit originalem Vault überein (bis auf bewusst ausgeschlossene Dateien).
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
### WP-04a – Retriever & Graph-Scoring (abgeschlossen)
|
||||||
|
|
||||||
|
**Phase:** B
|
||||||
|
**Status:** 🟢 abgeschlossen
|
||||||
|
|
||||||
|
**Ziel:**
|
||||||
|
Aufbau eines hybriden Retrievers, der Semantik (Embeddings), Typwissen (`retriever_weight`) und Graph-Informationen (Edges, Centrality) zu einem erklärbaren Score kombiniert.
|
||||||
|
|
||||||
|
**Umfang:**
|
||||||
|
|
||||||
|
- Retriever-Modul (`app/core/retriever.py`):
|
||||||
|
- Vektorsuche über `*_chunks`,
|
||||||
|
- Zusammenführung von Chunk-Treffern mit Note-Metadaten,
|
||||||
|
- Aufbau eines Subgraphen (Nachbarn über Edges, Centrality-Berechnung).
|
||||||
|
- Scoring-Formel:
|
||||||
|
semantic_score
|
||||||
|
retriever_weight
|
||||||
|
edge_bonus
|
||||||
|
centrality_bonus
|
||||||
|
- Konfiguration über `config/retriever.yaml` (Gewichte, Parameter). :contentReference[oaicite:28]{index=28}
|
||||||
|
- FastAPI-Endpoint `/query` mit Rückgabe:
|
||||||
|
- Trefferliste,
|
||||||
|
- Teil-Scores,
|
||||||
|
- Begründung (inkl. Edge-Kontext).
|
||||||
|
|
||||||
|
**Aufwand / Komplexität:**
|
||||||
|
- Aufwand: Hoch
|
||||||
|
- Komplexität: Hoch
|
||||||
|
|
||||||
|
**Erreichte Ergebnisse / Funktionsumfang:**
|
||||||
|
|
||||||
|
- Hybrides Scoring-Modell mit konfigurierbaren Gewichten (`semantic_weight`, `edge_weight`, `centrality_weight`).
|
||||||
|
- Nutzung von `retriever_weight` aus `types.yaml` in Score-Berechnung.
|
||||||
|
- Graph-boni aus echten Edges (explizit, Inline, Typ-Defaults, Strukturkanten).
|
||||||
|
- Funktionsfähiger `/query`-Endpoint mit Testcases (inkl. Relations-Showcase-Vault).
|
||||||
|
- Basis für spätere Self-Tuning-Mechanismen (Logging von Scores, Konfiguration in `retriever.yaml`).
|
||||||
|
|
||||||
|
**DoD:**
|
||||||
|
|
||||||
|
- `/query` liefert nachvollziehbare Ergebnisse mit sichtbarem Einfluss von:
|
||||||
|
- Typprioritäten,
|
||||||
|
- Edge-Struktur,
|
||||||
|
- Centrality.
|
||||||
|
- Scoring ist rein konfigurierbar (Konfig-Change → Score-Veränderung ohne Code-Änderung).
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
### WP-04b – Explanation Layer (geplant)
|
||||||
|
|
||||||
|
**Phase:** B
|
||||||
|
**Status:** 🟡 geplant
|
||||||
|
|
||||||
|
**Ziel:**
|
||||||
|
Treffererklärungen liefern, die für dich (Mindmaster) und spätere Nutzer verständlich sind (Why-Layer).
|
||||||
|
|
||||||
|
**Umfang:**
|
||||||
|
|
||||||
|
- Erklärungsschicht über dem Retriever:
|
||||||
|
- Aufschlüsselung des Scores pro Treffer,
|
||||||
|
- Ketten von Edges (Pfade) als Begründungsgraph,
|
||||||
|
- Markierung relevanter Chunks / Notizen.
|
||||||
|
- Darstellung von:
|
||||||
|
- verwendeten Typen,
|
||||||
|
- Edges und deren `rule_id` / `confidence`,
|
||||||
|
- Centrality-Beiträgen.
|
||||||
|
|
||||||
|
**Aufwand / Komplexität:**
|
||||||
|
- Aufwand: Mittel
|
||||||
|
- Komplexität: Hoch
|
||||||
|
|
||||||
|
**DoD (Zielbild):**
|
||||||
|
|
||||||
|
- API-Endpoint (z. B. `/query/explain`), der eine strukturierte Erklärung in JSON liefert.
|
||||||
|
- Mindestens ein Beispiel, in dem Score-Änderung nachvollziehbar auf Policies/Edges zurückgeführt werden kann.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
### WP-04c – Feedback Logging & Bewertungsdaten (geplant)
|
||||||
|
|
||||||
|
**Phase:** B
|
||||||
|
**Status:** 🟡 geplant
|
||||||
|
|
||||||
|
**Ziel:**
|
||||||
|
Grundlage für Self-Tuning schaffen, indem Queries, Antworten und Bewertungen systematisch protokolliert werden.
|
||||||
|
|
||||||
|
**Umfang:**
|
||||||
|
|
||||||
|
- Logging von:
|
||||||
|
- Query-Texten,
|
||||||
|
- verwendeten Policies/Config-Versionen,
|
||||||
|
- Trefferlisten (Scores, Edges),
|
||||||
|
- Feedback (z. B. „hilfreich“, „irrelevant“, „falsch“).
|
||||||
|
- Persistente Speicherung (z. B. in einer separaten Sammlung oder Datei-basiert).
|
||||||
|
- Bereitstellung von Auswertungs-Skripten (Statistiken, Ranking-Qualität).
|
||||||
|
|
||||||
|
**Aufwand / Komplexität:**
|
||||||
|
- Aufwand: Mittel
|
||||||
|
- Komplexität: Mittel/Hoch
|
||||||
|
|
||||||
|
**DoD (Zielbild):**
|
||||||
|
|
||||||
|
- Vollständiger Feedback-Trail für ausgewählte Test-Sessions.
|
||||||
|
- Exportfähige Datenbasis zur späteren Optimierung der Retriever-Parameter.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
### WP-05 – Persönlichkeitsmodell (geplant)
|
||||||
|
|
||||||
|
**Phase:** C
|
||||||
|
**Status:** 🟡 geplant
|
||||||
|
|
||||||
|
**Ziel:**
|
||||||
|
Aufbau eines expliziten Persönlichkeitsmodells, das Werte, Prinzipien, prägende Erfahrungen und wiederkehrende Entscheidungsstrategien abbildet.
|
||||||
|
|
||||||
|
**Umfang:**
|
||||||
|
|
||||||
|
- Identifikation und Typisierung relevanter Notes:
|
||||||
|
- `value`, `principle`, `life_event`, `milestone`, `decision`.
|
||||||
|
- Aufbau eines Modells, das:
|
||||||
|
- typische Begründungsmuster erkennt,
|
||||||
|
- Wertprioritäten identifiziert,
|
||||||
|
- langfristig in Scoring & Antwort-Formulierung einfließt.
|
||||||
|
|
||||||
|
**Aufwand / Komplexität:**
|
||||||
|
- Aufwand: Mittel
|
||||||
|
- Komplexität: Mittel
|
||||||
|
|
||||||
|
**DoD (Zielbild):**
|
||||||
|
|
||||||
|
- Dokumentiertes Persönlichkeitsmodell (z. B. YAML/Markdown), das konkrete Wert-/Prinzipien-Strukturen beschreibt.
|
||||||
|
- Basis-Integration in den Retriever (z. B. Wert-Bezüge in Explanation-Layer).
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
### WP-06 – Decision Engine (geplant)
|
||||||
|
|
||||||
|
**Phase:** C
|
||||||
|
**Status:** 🟡 geplant
|
||||||
|
|
||||||
|
**Ziel:**
|
||||||
|
Entscheidungsunterstützung auf Basis von Wissen, Persönlichkeit und Zielen – inklusive nachvollziehbarer Begründung.
|
||||||
|
|
||||||
|
**Umfang:**
|
||||||
|
|
||||||
|
- Identifikation typischer Entscheidungssituationen (z. B. beruflich, familiär, gesundheitlich).
|
||||||
|
- Integration von:
|
||||||
|
- fachlichem Wissen,
|
||||||
|
- Erfahrungen (Vergangenheitsentscheidungen),
|
||||||
|
- Persönlichkeitsmodell.
|
||||||
|
- Ableitung von Entscheidungs-Templates / Heuristiken.
|
||||||
|
|
||||||
|
**Aufwand / Komplexität:**
|
||||||
|
- Aufwand: Mittel
|
||||||
|
- Komplexität: Hoch
|
||||||
|
|
||||||
|
**DoD (Zielbild):**
|
||||||
|
|
||||||
|
- Prototypischer „Decision-Assistant“, der für definierte Szenarien begründete Empfehlungen gibt.
|
||||||
|
- Erklärungen referenzieren konkrete Notes/Edges.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
### WP-07 – Interview-Assistent (geplant)
|
||||||
|
|
||||||
|
**Phase:** C
|
||||||
|
**Status:** 🟡 geplant
|
||||||
|
|
||||||
|
**Ziel:**
|
||||||
|
Dialogbasierter Erfassungs-Assistent, der strukturierte Interviews führt und daraus konsistente Markdown-Notizen generiert.
|
||||||
|
|
||||||
|
**Umfang:**
|
||||||
|
|
||||||
|
- Design von Interview-Flows (z. B. für Lebensereignisse, Projekte, Werte-Workshops).
|
||||||
|
- Konvertierung von Dialogtranskripten in typisierte Notes (inkl. Typ, Tags, erste Edges).
|
||||||
|
- Integration mit Vault-Struktur (Ablagepfade, Namenskonventionen).
|
||||||
|
|
||||||
|
**Aufwand / Komplexität:**
|
||||||
|
- Aufwand: Niedrig/Mittel
|
||||||
|
- Komplexität: Mittel
|
||||||
|
|
||||||
|
**DoD (Zielbild):**
|
||||||
|
|
||||||
|
- Mindestens ein produktionsnaher Flow (z. B. „Erzähle mir von einem prägenden Ereignis“).
|
||||||
|
- Automatische Erzeugung von Markdown-Notizen, die vom Importer direkt verarbeitet werden können.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
### WP-08 – Self-Tuning v1/v2 (geplant)
|
||||||
|
|
||||||
|
**Phase:** B/C
|
||||||
|
**Status:** 🟡 geplant
|
||||||
|
|
||||||
|
**Ziel:**
|
||||||
|
Aufbau eines Self-Tuning-Mechanismus, der auf Basis von Feedback-Daten Vorschläge für Retriever- und Policy-Anpassungen macht.
|
||||||
|
|
||||||
|
**Umfang:**
|
||||||
|
|
||||||
|
- Auswertung der Feedback-Daten (WP-04c).
|
||||||
|
- Regel-basierte Anpassungs-Vorschläge:
|
||||||
|
- Gewichte in `retriever.yaml`,
|
||||||
|
- Typ-Prioritäten,
|
||||||
|
- Edge-Provenance-Gewichte.
|
||||||
|
- Optionale halbautomatische Übernahme (Freigabe durch Mindmaster).
|
||||||
|
|
||||||
|
**Aufwand / Komplexität:**
|
||||||
|
- Aufwand: Hoch
|
||||||
|
- Komplexität: Hoch
|
||||||
|
|
||||||
|
**DoD (Zielbild):**
|
||||||
|
|
||||||
|
- Mindestens ein in der Praxis getesteter Tuning-Zyklus:
|
||||||
|
- Feedback sammeln,
|
||||||
|
- Vorschlag generieren,
|
||||||
|
- Anpassung vornehmen,
|
||||||
|
- Qualitätsgewinn nachweisen.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
### 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/Guides für:
|
||||||
|
- Analyse des Vault-Status (Typen, Edges, Lücken),
|
||||||
|
- Empfehlungen für minimale Anpassungen (z. B. Typ-Setzung, Basis-Tags),
|
||||||
|
- optional automatisierte Ergänzung von Properties (mit Freigabe).
|
||||||
|
- Unterstützung eines „wachsenden Systems“:
|
||||||
|
- erste Notizen liefern sofort Mehrwert im Retriever,
|
||||||
|
- später können Typen und Edges ergänzt werden, ohne alte Notizen zu brechen.
|
||||||
|
|
||||||
|
**Aufwand / Komplexität:**
|
||||||
|
- Aufwand: Mittel
|
||||||
|
- Komplexität: Niedrig/Mittel
|
||||||
|
|
||||||
|
**DoD (Zielbild):**
|
||||||
|
|
||||||
|
- Dokumentierter Onboarding-Prozess für Produkt-Vault.
|
||||||
|
- Mindestens ein erfolgreicher Durchlauf mit deinem realen Vault (Pilot).
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
### WP-10 – Chat-Interface & Writeback (geplant)
|
||||||
|
|
||||||
|
**Phase:** D
|
||||||
|
**Status:** 🟡 geplant
|
||||||
|
|
||||||
|
**Ziel:**
|
||||||
|
Chat-basierter mindnet-Agent, der sowohl Fragen beantwortet als auch neue Notizen erzeugen/aktualisieren kann (Writeback Richtung Vault).
|
||||||
|
|
||||||
|
**Umfang:**
|
||||||
|
|
||||||
|
- Chat-Frontend (z. B. in deiner bestehenden LLM-Umgebung).
|
||||||
|
- Anbindung an:
|
||||||
|
- `/query` (Retriever),
|
||||||
|
- MCP-Tools (WP-13),
|
||||||
|
- Import-/Export-Routinen.
|
||||||
|
- Funktionen:
|
||||||
|
- Antworten aus mindnet-Wissen,
|
||||||
|
- Vorschlag neuer Notes/Edges,
|
||||||
|
- optionales Schreiben ins Vault (Markdown-Erzeugung, Rewriting nur mit Freigabe).
|
||||||
|
|
||||||
|
**Aufwand / Komplexität:**
|
||||||
|
- Aufwand: Hoch
|
||||||
|
- Komplexität: Hoch
|
||||||
|
|
||||||
|
**DoD (Zielbild):**
|
||||||
|
|
||||||
|
- Du kannst im Chat:
|
||||||
|
- Fragen an dein Wissensnetz stellen,
|
||||||
|
- neue Gedanken/Erinnerungen erfassen,
|
||||||
|
- Vorschläge für Ablage & Vernetzung als Markdown-Notizen erhalten.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
### WP-11 – Knowledge-Builder & Vernetzungs-Assistent (geplant)
|
||||||
|
|
||||||
|
**Phase:** D
|
||||||
|
**Status:** 🟡 geplant
|
||||||
|
|
||||||
|
**Ziel:**
|
||||||
|
Assistent, der manuell erstellte oder importierte Notizen analysiert und Vorschläge für Typen, Edges und Einordnung macht.
|
||||||
|
|
||||||
|
**Umfang:**
|
||||||
|
|
||||||
|
- Analyse neuer/aktualisierter Notes:
|
||||||
|
- mögliche Typen,
|
||||||
|
- passende Tags,
|
||||||
|
- potenzielle Relationen zu bestehenden Notes.
|
||||||
|
- Vorschläge:
|
||||||
|
- Inline-Relationen,
|
||||||
|
- Wikilinks,
|
||||||
|
- Typ-Zuweisung.
|
||||||
|
- Optional: Generierung konkreter Patch-Vorschläge für Markdown-Dateien (Diff-basiert).
|
||||||
|
|
||||||
|
**Aufwand / Komplexität:**
|
||||||
|
- Aufwand: Hoch
|
||||||
|
- Komplexität: Hoch
|
||||||
|
|
||||||
|
**DoD (Zielbild):**
|
||||||
|
|
||||||
|
- Mindestens ein produktionsnaher Workflow, bei dem ein neuer Eintrag:
|
||||||
|
- erstellt wird,
|
||||||
|
- analysiert wird,
|
||||||
|
- Vernetzungs-Vorschläge liefert,
|
||||||
|
- und nach Freigabe in den Vault zurückgeschrieben wird.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
### 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. :contentReference[oaicite:31]{index=31}
|
||||||
|
|
||||||
|
**Einschränkungen:**
|
||||||
|
|
||||||
|
- Änderungen an Markdown-Dateien nur nach Freigabe.
|
||||||
|
- Kein „silent overwrite“ existierender Inhalte.
|
||||||
|
|
||||||
|
**Aufwand / Komplexität:**
|
||||||
|
- Aufwand: Niedrig/Mittel
|
||||||
|
- Komplexität: Mittel
|
||||||
|
|
||||||
|
**DoD (Zielbild):**
|
||||||
|
|
||||||
|
- Rewriter generiert Vorschläge (neue Versionen) inklusive Diffs.
|
||||||
|
- Nach Freigabe werden Notes konsistent aktualisiert:
|
||||||
|
- IDs, Edges und Typen bleiben konsistent oder werden sauber mitaktualisiert.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
### 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 (z. B. in deiner n8n- und LLM-Umgebung).
|
||||||
|
|
||||||
|
**Umfang:**
|
||||||
|
|
||||||
|
- MCP-Server mit Tools wie:
|
||||||
|
- `mindnet_query`,
|
||||||
|
- `mindnet_subgraph`,
|
||||||
|
- `mindnet_store_note`,
|
||||||
|
- `mindnet_explain`.
|
||||||
|
- Sichere Konfiguration (lokal, authentifiziert, logging-fähig).
|
||||||
|
|
||||||
|
**Aufwand / Komplexität:**
|
||||||
|
- Aufwand: Mittel
|
||||||
|
- Komplexität: Mittel
|
||||||
|
|
||||||
|
**DoD (Zielbild):**
|
||||||
|
|
||||||
|
- Lokaler MCP-Server läuft und ist aus einem LLM-Client nutzbar.
|
||||||
|
- Tools liefern konsistente Ergebnisse (aligned mit FastAPI-Endpoints).
|
||||||
|
- Sicherheits- und Loggingkonzept dokumentiert.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
### WP-14 – Review / Refactoring / Dokumentation (geplant)
|
||||||
|
|
||||||
|
**Phase:** E
|
||||||
|
**Status:** 🟡 geplant
|
||||||
|
|
||||||
|
**Ziel:**
|
||||||
|
Aufräumen, dokumentieren, stabilisieren – insbesondere für Onboarding Dritter und Langfrist-Betrieb.
|
||||||
|
|
||||||
|
**Deliverables (Beispiele):**
|
||||||
|
|
||||||
|
- konsolidierte technische Architektur (`mindnet_technical_architecture.md`),
|
||||||
|
- fachliche Architektur (`mindnet_functional_architecture.md`),
|
||||||
|
- Identity-Modell (`identity_model.md`),
|
||||||
|
- API-Spezifikation (`api_spec.md`),
|
||||||
|
- MCP-Integration (`mcp_integration.md`),
|
||||||
|
- aktualisiertes Handbuch (`Handbuch.md`).
|
||||||
|
|
||||||
|
**Aufwand / Komplexität:**
|
||||||
|
- Aufwand: Mittel
|
||||||
|
- Komplexität: Niedrig/Mittel
|
||||||
|
|
||||||
|
**DoD (Zielbild):**
|
||||||
|
|
||||||
|
- Aktueller Stand ist sauber dokumentiert.
|
||||||
|
- Wichtige Designentscheidungen sind nachvollziehbar festgehalten.
|
||||||
|
- Onboarding einer dritten Person (z. B. Entwickler:in) ist mit Dokumentation möglich.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 7. Abhängigkeiten (vereinfacht, aktualisiert)
|
||||||
|
|
||||||
|
WP01 → WP02 → WP03 → WP04a
|
||||||
|
WP04a → WP04b → WP04c → WP08
|
||||||
|
WP03 → WP05 → WP06 → WP07
|
||||||
|
WP03 → WP09
|
||||||
|
WP01/WP03 → WP10 → WP11 → WP12
|
||||||
|
WP03/WP04 → WP13
|
||||||
|
Alles → WP14
|
||||||
|
|
||||||
|
Diese Struktur bleibt gegenüber v2.1 unverändert, ist aber jetzt explizit an den bereits implementierten Stand (WP-03, WP-04a) angepasst.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 8. Laufzeit- & Komplexitätsindikatoren (unverändert, ergänzt)
|
||||||
|
|
||||||
|
| WP | Aufwand | Komplexität |
|
||||||
|
|-------|----------------|------------------|
|
||||||
|
| WP04b | Mittel | Hoch |
|
||||||
|
| WP04c | Mittel | Mittel/Hoch |
|
||||||
|
| WP05 | Mittel | Mittel |
|
||||||
|
| WP06 | Mittel | Hoch |
|
||||||
|
| WP07 | Niedrig/Mittel | Mittel |
|
||||||
|
| WP08 | Hoch | Hoch |
|
||||||
|
| WP09 | Mittel | Niedrig/Mittel |
|
||||||
|
| WP10 | Hoch | Hoch |
|
||||||
|
| WP11 | Hoch | Hoch |
|
||||||
|
| WP12 | Niedrig/Mittel | Mittel |
|
||||||
|
| WP13 | Mittel | Mittel |
|
||||||
|
| WP14 | Mittel | Niedrig/Mittel | :contentReference[oaicite:35]{index=35}
|
||||||
|
|
||||||
|
Für WP01–WP04a gilt: Aufwand/Komplexität wie in v2.1; Status jetzt explizit „abgeschlossen“ mit beschriebenem Funktionsumfang.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 9. Programmfortschritt (Ampel, aktualisiert)
|
||||||
|
|
||||||
|
| WP | Status |
|
||||||
|
|-------|--------|
|
||||||
|
| WP01 | 🟢 |
|
||||||
|
| WP02 | 🟢 |
|
||||||
|
| WP03 | 🟢 |
|
||||||
|
| WP04a | 🟢 |
|
||||||
|
| WP04b | 🟡 |
|
||||||
|
| WP04c | 🟡 |
|
||||||
|
| WP05 | 🟡 |
|
||||||
|
| WP06 | 🟡 |
|
||||||
|
| WP07 | 🟡 |
|
||||||
|
| WP08 | 🟡 |
|
||||||
|
| WP09 | 🟡 |
|
||||||
|
| WP10 | 🟡 |
|
||||||
|
| WP11 | 🟡 |
|
||||||
|
| WP12 | 🟡 |
|
||||||
|
| WP13 | 🟡 |
|
||||||
|
| WP14 | 🟡 | :contentReference[oaicite:36]{index=36}
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 10. Governance & Versionierung
|
||||||
|
|
||||||
|
- Versionierung über Gitea (Branches, Tags, Releases).
|
||||||
|
- Jede wesentliche Änderung an Architektur/Schema:
|
||||||
|
- eigener Commit,
|
||||||
|
- kurze Doku (z. B. in `CHANGELOG.md` oder Projekt-Notiz).
|
||||||
|
- Jedes Workpackage erhält ein eigenes Chat-Fenster mit dediziertem Prompt (WP-Hand-Over).
|
||||||
|
- Programmleitung verantwortet:
|
||||||
|
- Konsistenz von Fach- und Technikdokumenten,
|
||||||
|
- Abhängigkeiten und Priorisierung,
|
||||||
|
- Freigabe von Meilensteinen,
|
||||||
|
- Sicherstellung, dass Änderungen mit dem langfristigen Ziel (KI-Zwilling) vereinbar sind.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 11. Executive Summary (unverändert, präzisiert)
|
||||||
|
|
||||||
|
mindnet v2.2 ist so aufgesetzt, dass:
|
||||||
|
|
||||||
|
- du **schrittweise** Wissen erfassen kannst (Obsidian + Chat + später Interview-Assistent),
|
||||||
|
- 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, der auf Feedback aufsetzt,
|
||||||
|
- ein **Persönlichkeitsmodell** und eine **Decision Engine** entstehen,
|
||||||
|
- langfristig ein **KI-Zwilling** aufgebaut wird, der deine Werte, Erfahrungen und Denkweise spiegelt,
|
||||||
|
- die technische Architektur (FastAPI, Qdrant, YAML-Policies, MCP-Integration) lokal, nachvollziehbar und erweiterbar bleibt.
|
||||||
|
|
||||||
|
Dieser Programmplan bildet die konsolidierte Grundlage (v2.2) für alle weiteren Arbeiten.
|
||||||
|
Er integriert die bisherigen Ergebnisse (WP-01 bis WP-04a) und die zusätzlichen Anforderungen aus der späteren Planung (Feedback-basiertes Tuning, wachsendes System, Chat-/Interview-Eingabe, Vault-Writeback) in ein einheitliches, versionierbares Dokument.
|
||||||
|
|
||||||
@@ -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
|
||||||
@@ -33,3 +33,7 @@ python3 scripts/import_markdown.py --vault /path/to/Obsidian
|
|||||||
- `POST /qdrant/query` → semantic search over chunks with optional filters
|
- `POST /qdrant/query` → semantic search over chunks with optional filters
|
||||||
|
|
||||||
See `scripts/quick_test.sh` for a runnable example.
|
See `scripts/quick_test.sh` for a runnable example.
|
||||||
|
|
||||||
|
>Anmerkung:
|
||||||
|
Diese Datei ist veraltet
|
||||||
|
|
||||||
+69
-118
@@ -1,28 +1,22 @@
|
|||||||
#!/usr/bin/env python3
|
#!/usr/bin/env python3
|
||||||
# -*- coding: utf-8 -*-
|
# -*- coding: utf-8 -*-
|
||||||
"""
|
"""
|
||||||
app/core/graph_adapter.py — Adjazenzaufbau & Subgraph-Expansion (WP-04)
|
app/core/graph_adapter.py — Adjazenzaufbau & Subgraph-Expansion
|
||||||
|
|
||||||
Zweck:
|
Zweck:
|
||||||
Baut aus Qdrant-Edges (Collection: *_edges) einen leichten In-Memory-Graph
|
Baut aus Qdrant-Edges (Collection: *_edges) einen leichten In-Memory-Graph.
|
||||||
und liefert Edge-basierte Kennzahlen (In-Degree, Out-Degree, edge_bonus).
|
|
||||||
|
|
||||||
Kompatibilität:
|
Kompatibilität:
|
||||||
- Python 3.12+, qdrant-client 1.x
|
- WP-04a: Liefert Scores (edge_bonus, centrality).
|
||||||
- Wird von app/core/retriever.py im Hybrid-Modus genutzt.
|
- WP-04b: Liefert jetzt auch Struktur-Daten für Erklärungen (Reverse-Lookup).
|
||||||
- Signaturen bleiben kompatibel zu den bestehenden Tests
|
|
||||||
(tests/test_retriever_edges.py patcht expand()).
|
|
||||||
|
|
||||||
Version:
|
Version:
|
||||||
0.3.1 (2025-12-04 – note_id-bewusste Expansion:
|
0.4.0 (Update für WP-04b: Reverse Adjacency für Explainability)
|
||||||
* Seeds = Note-IDs
|
|
||||||
* Subgraph pflegt zusätzlich Adjazenz auf note_id-Basis,
|
|
||||||
damit der Retriever mit note_id arbeiten kann)
|
|
||||||
"""
|
"""
|
||||||
|
|
||||||
from __future__ import annotations
|
from __future__ import annotations
|
||||||
|
|
||||||
from typing import Dict, List, Optional, DefaultDict
|
from typing import Dict, List, Optional, DefaultDict, Any
|
||||||
from collections import defaultdict
|
from collections import defaultdict
|
||||||
|
|
||||||
from qdrant_client import QdrantClient
|
from qdrant_client import QdrantClient
|
||||||
@@ -30,36 +24,27 @@ from qdrant_client.http import models as rest
|
|||||||
|
|
||||||
from app.core.qdrant import collection_names
|
from app.core.qdrant import collection_names
|
||||||
|
|
||||||
# Legacy-Import (wird aktuell nicht mehr verwendet, bleibt aber erhalten,
|
# Legacy-Import Fallback
|
||||||
# damit bestehende Importe/Mocks nicht brechen).
|
|
||||||
try: # pragma: no cover
|
try: # pragma: no cover
|
||||||
from app.core.qdrant_points import get_edges_for_sources # type: ignore
|
from app.core.qdrant_points import get_edges_for_sources # type: ignore
|
||||||
except Exception: # pragma: no cover
|
except Exception: # pragma: no cover
|
||||||
get_edges_for_sources = None # type: ignore
|
get_edges_for_sources = None # type: ignore
|
||||||
|
|
||||||
|
|
||||||
# Basisgewichte je Edge-Typ.
|
# Basisgewichte je Edge-Typ (WP-04a Config)
|
||||||
# Diese Werte werden mit der in der Edge-Payload hinterlegten "confidence"
|
|
||||||
# multipliziert, falls vorhanden.
|
|
||||||
#
|
|
||||||
# Hinweis:
|
|
||||||
# - Strukturkanten (belongs_to, next/prev) sind schwächer gewichtet.
|
|
||||||
# - Wissenskanten (depends_on, related_to, similar_to, references) erhalten
|
|
||||||
# höhere Basisgewichte, damit sie sich im Retriever bemerkbar machen.
|
|
||||||
EDGE_BASE_WEIGHTS: Dict[str, float] = {
|
EDGE_BASE_WEIGHTS: Dict[str, float] = {
|
||||||
# Struktur / Navigationskanten
|
# Struktur
|
||||||
"belongs_to": 0.10,
|
"belongs_to": 0.10,
|
||||||
"next": 0.06,
|
"next": 0.06,
|
||||||
"prev": 0.06,
|
"prev": 0.06,
|
||||||
"backlink": 0.04,
|
"backlink": 0.04,
|
||||||
"references_at": 0.08,
|
"references_at": 0.08,
|
||||||
|
|
||||||
# Wissenskanten
|
# Wissen
|
||||||
"references": 0.20,
|
"references": 0.20,
|
||||||
"depends_on": 0.18,
|
"depends_on": 0.18,
|
||||||
"related_to": 0.15,
|
"related_to": 0.15,
|
||||||
"similar_to": 0.12,
|
"similar_to": 0.12,
|
||||||
# weitere Typen erhalten per Default 0.0 und wirken nur über centrality
|
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
@@ -77,11 +62,8 @@ def _edge_weight(pl: Dict) -> float:
|
|||||||
if conf is None:
|
if conf is None:
|
||||||
return base
|
return base
|
||||||
|
|
||||||
# Confidence vorsichtig in [0.0, 1.0] clampen
|
if conf < 0.0: conf = 0.0
|
||||||
if conf < 0.0:
|
if conf > 1.0: conf = 1.0
|
||||||
conf = 0.0
|
|
||||||
if conf > 1.0:
|
|
||||||
conf = 1.0
|
|
||||||
|
|
||||||
return base * conf
|
return base * conf
|
||||||
|
|
||||||
@@ -95,48 +77,34 @@ def _fetch_edges(
|
|||||||
) -> List[Dict]:
|
) -> List[Dict]:
|
||||||
"""
|
"""
|
||||||
Holt Edges direkt aus der *_edges Collection.
|
Holt Edges direkt aus der *_edges Collection.
|
||||||
|
Filter: source_id IN seeds OR target_id IN seeds OR note_id IN seeds
|
||||||
Filter:
|
|
||||||
- source_id IN seeds ODER target_id IN seeds ODER note_id IN seeds
|
|
||||||
- optional: kind IN edge_types
|
|
||||||
"""
|
"""
|
||||||
if not seeds or limit <= 0:
|
if not seeds or limit <= 0:
|
||||||
return []
|
return []
|
||||||
|
|
||||||
_, _, edges_col = collection_names(prefix)
|
_, _, edges_col = collection_names(prefix)
|
||||||
|
|
||||||
# OR über source_id / target_id / note_id für alle Seeds
|
|
||||||
seed_conditions = []
|
seed_conditions = []
|
||||||
for field in ("source_id", "target_id", "note_id"):
|
for field in ("source_id", "target_id", "note_id"):
|
||||||
for s in seeds:
|
for s in seeds:
|
||||||
seed_conditions.append(
|
seed_conditions.append(
|
||||||
rest.FieldCondition(
|
rest.FieldCondition(key=field, match=rest.MatchValue(value=str(s)))
|
||||||
key=field,
|
|
||||||
match=rest.MatchValue(value=str(s)),
|
|
||||||
)
|
|
||||||
)
|
)
|
||||||
seeds_filter = rest.Filter(should=seed_conditions) if seed_conditions else None
|
seeds_filter = rest.Filter(should=seed_conditions) if seed_conditions else None
|
||||||
|
|
||||||
# Optional: Filter auf bestimmte Edge-Typen (kind)
|
|
||||||
type_filter = None
|
type_filter = None
|
||||||
if edge_types:
|
if edge_types:
|
||||||
type_conds = [
|
type_conds = [
|
||||||
rest.FieldCondition(
|
rest.FieldCondition(key="kind", match=rest.MatchValue(value=str(k)))
|
||||||
key="kind",
|
|
||||||
match=rest.MatchValue(value=str(k)),
|
|
||||||
)
|
|
||||||
for k in edge_types
|
for k in edge_types
|
||||||
]
|
]
|
||||||
type_filter = rest.Filter(should=type_conds)
|
type_filter = rest.Filter(should=type_conds)
|
||||||
|
|
||||||
flt = None
|
|
||||||
must = []
|
must = []
|
||||||
if seeds_filter:
|
if seeds_filter: must.append(seeds_filter)
|
||||||
must.append(seeds_filter)
|
if type_filter: must.append(type_filter)
|
||||||
if type_filter:
|
|
||||||
must.append(type_filter)
|
flt = rest.Filter(must=must) if must else None
|
||||||
if must:
|
|
||||||
flt = rest.Filter(must=must)
|
|
||||||
|
|
||||||
pts, _ = client.scroll(
|
pts, _ = client.scroll(
|
||||||
collection_name=edges_col,
|
collection_name=edges_col,
|
||||||
@@ -155,28 +123,21 @@ def _fetch_edges(
|
|||||||
|
|
||||||
|
|
||||||
class Subgraph:
|
class Subgraph:
|
||||||
"""Leichtgewichtiger Subgraph mit Adjazenzlisten & einfachen Kennzahlen."""
|
"""Leichtgewichtiger Subgraph mit Adjazenzlisten & Kennzahlen."""
|
||||||
|
|
||||||
def __init__(self) -> None:
|
def __init__(self) -> None:
|
||||||
|
# Forward: source -> [targets]
|
||||||
self.adj: DefaultDict[str, List[Dict]] = defaultdict(list)
|
self.adj: DefaultDict[str, List[Dict]] = defaultdict(list)
|
||||||
|
# Reverse: target -> [sources] (Neu für WP-04b Explanation)
|
||||||
|
self.reverse_adj: DefaultDict[str, List[Dict]] = defaultdict(list)
|
||||||
|
|
||||||
self.in_degree: DefaultDict[str, int] = defaultdict(int)
|
self.in_degree: DefaultDict[str, int] = defaultdict(int)
|
||||||
self.out_degree: DefaultDict[str, int] = defaultdict(int)
|
self.out_degree: DefaultDict[str, int] = defaultdict(int)
|
||||||
|
|
||||||
def add_edge(self, e: Dict) -> None:
|
def add_edge(self, e: Dict) -> None:
|
||||||
"""
|
"""
|
||||||
Fügt eine Kante zum Subgraph hinzu.
|
Fügt eine Kante hinzu und aktualisiert Forward/Reverse Indizes.
|
||||||
|
e muss enthalten: source, target, kind, weight.
|
||||||
e enthält:
|
|
||||||
- source: Knoten-ID (z. B. source_id)
|
|
||||||
- target: Knoten-ID (z. B. target_id)
|
|
||||||
- kind: Kantentyp
|
|
||||||
- weight: bereits berechnetes Gewicht
|
|
||||||
- note_id: (optional) Kontext-Note dieser Kante
|
|
||||||
|
|
||||||
Wichtig für den Retriever:
|
|
||||||
- Wir pflegen Adjazenz primär unter `source`.
|
|
||||||
- Zusätzlich pflegen wir, falls vorhanden, eine Adjazenz
|
|
||||||
unter `note_id`, damit der Retriever mit note_id arbeiten kann.
|
|
||||||
"""
|
"""
|
||||||
src = e.get("source")
|
src = e.get("source")
|
||||||
tgt = e.get("target")
|
tgt = e.get("target")
|
||||||
@@ -187,65 +148,57 @@ class Subgraph:
|
|||||||
if not src or not tgt:
|
if not src or not tgt:
|
||||||
return
|
return
|
||||||
|
|
||||||
# Primäre Adjazenz (z. B. source_id → target_id)
|
# 1. Primäre Adjazenz (Forward)
|
||||||
self.adj[src].append(
|
edge_data = {"target": tgt, "kind": kind, "weight": weight}
|
||||||
{
|
self.adj[src].append(edge_data)
|
||||||
"target": tgt,
|
|
||||||
"kind": kind,
|
|
||||||
"weight": weight,
|
|
||||||
}
|
|
||||||
)
|
|
||||||
self.out_degree[src] += 1
|
self.out_degree[src] += 1
|
||||||
self.in_degree[tgt] += 1
|
self.in_degree[tgt] += 1
|
||||||
|
|
||||||
# Sekundäre Adjazenz auf Note-Ebene:
|
# 2. Reverse Adjazenz (Neu für Explanation)
|
||||||
# Falls eine Kontext-Note existiert, bekommt diese ebenfalls
|
# Wir speichern, woher die Kante kam.
|
||||||
# "Ausgangskanten" angerechnet. So kann der Retriever über note_id
|
rev_data = {"source": src, "kind": kind, "weight": weight}
|
||||||
# edge_bonus(...) und centrality_bonus(...) abfragen.
|
self.reverse_adj[tgt].append(rev_data)
|
||||||
if owner:
|
|
||||||
# same edge unter owner registrieren (falls nicht identisch mit src),
|
|
||||||
# damit edge_bonus(owner) > 0 werden kann.
|
|
||||||
if owner != src:
|
|
||||||
self.adj[owner].append(
|
|
||||||
{
|
|
||||||
"target": tgt,
|
|
||||||
"kind": kind,
|
|
||||||
"weight": weight,
|
|
||||||
}
|
|
||||||
)
|
|
||||||
self.out_degree[owner] += 1
|
|
||||||
|
|
||||||
# Zentralität der Kontext-Note leicht erhöhen
|
# 3. Kontext-Note Handling (Forward & Reverse)
|
||||||
|
# Wenn eine Kante "im Kontext einer Note" (owner) definiert ist,
|
||||||
|
# schreiben wir sie der Note gut, damit der Retriever Scores auf Note-Ebene findet.
|
||||||
|
if owner and owner != src:
|
||||||
|
# Forward: Owner -> Target
|
||||||
|
self.adj[owner].append(edge_data)
|
||||||
|
self.out_degree[owner] += 1
|
||||||
|
|
||||||
|
# Reverse: Target wird vom Owner referenziert (indirekt)
|
||||||
if owner != tgt:
|
if owner != tgt:
|
||||||
self.in_degree[owner] += 1
|
rev_owner_data = {"source": owner, "kind": kind, "weight": weight, "via_context": True}
|
||||||
|
self.reverse_adj[tgt].append(rev_owner_data)
|
||||||
|
self.in_degree[owner] += 1 # Leichter Centrality Boost für den Owner
|
||||||
|
|
||||||
def aggregate_edge_bonus(self, node_id: str) -> float:
|
def aggregate_edge_bonus(self, node_id: str) -> float:
|
||||||
"""
|
"""Summe der ausgehenden Kantengewichte (Hub-Score)."""
|
||||||
Summe der ausgehenden Kantengewichte für einen Knoten.
|
|
||||||
"""
|
|
||||||
return sum(edge["weight"] for edge in self.adj.get(node_id, []))
|
return sum(edge["weight"] for edge in self.adj.get(node_id, []))
|
||||||
|
|
||||||
def edge_bonus(self, node_id: str) -> float:
|
def edge_bonus(self, node_id: str) -> float:
|
||||||
"""
|
"""API für Retriever (WP-04a Kompatibilität)."""
|
||||||
Kompatibilitäts-Methode für den Retriever.
|
|
||||||
|
|
||||||
Der Retriever ruft subgraph.edge_bonus(node_id) auf. Intern verwenden
|
|
||||||
wir aggregate_edge_bonus(...), um bestehende Tests nicht zu brechen.
|
|
||||||
"""
|
|
||||||
return self.aggregate_edge_bonus(node_id)
|
return self.aggregate_edge_bonus(node_id)
|
||||||
|
|
||||||
def centrality_bonus(self, node_id: str) -> float:
|
def centrality_bonus(self, node_id: str) -> float:
|
||||||
"""
|
"""Log-gedämpfte Zentralität (In-Degree)."""
|
||||||
Einfache log-gedämpfte Zentralität auf Basis des In-Degree.
|
|
||||||
Obergrenze: 0.15
|
|
||||||
"""
|
|
||||||
import math
|
import math
|
||||||
|
|
||||||
indeg = self.in_degree.get(node_id, 0)
|
indeg = self.in_degree.get(node_id, 0)
|
||||||
if indeg <= 0:
|
if indeg <= 0:
|
||||||
return 0.0
|
return 0.0
|
||||||
return min(math.log1p(indeg) / 10.0, 0.15)
|
return min(math.log1p(indeg) / 10.0, 0.15)
|
||||||
|
|
||||||
|
# --- WP-04b Explanation Helpers ---
|
||||||
|
|
||||||
|
def get_outgoing_edges(self, node_id: str) -> List[Dict[str, Any]]:
|
||||||
|
"""Liefert Liste aller Ziele, auf die dieser Knoten zeigt."""
|
||||||
|
return self.adj.get(node_id, [])
|
||||||
|
|
||||||
|
def get_incoming_edges(self, node_id: str) -> List[Dict[str, Any]]:
|
||||||
|
"""Liefert Liste aller Quellen, die auf diesen Knoten zeigen."""
|
||||||
|
return self.reverse_adj.get(node_id, [])
|
||||||
|
|
||||||
|
|
||||||
def expand(
|
def expand(
|
||||||
client: QdrantClient,
|
client: QdrantClient,
|
||||||
@@ -255,12 +208,7 @@ def expand(
|
|||||||
edge_types: Optional[List[str]] = None,
|
edge_types: Optional[List[str]] = None,
|
||||||
) -> Subgraph:
|
) -> Subgraph:
|
||||||
"""
|
"""
|
||||||
Expandiert ab Seeds entlang von Edges (bis `depth`), optional gefiltert
|
Expandiert ab Seeds entlang von Edges (bis `depth`).
|
||||||
nach Edge-Typen.
|
|
||||||
|
|
||||||
Seeds sind stabile payload-IDs (in unserem Fall vor allem note_id).
|
|
||||||
Es werden Edges berücksichtigt, bei denen source_id ODER target_id ODER
|
|
||||||
note_id einem der Seeds entspricht.
|
|
||||||
"""
|
"""
|
||||||
sg = Subgraph()
|
sg = Subgraph()
|
||||||
frontier = set(seeds)
|
frontier = set(seeds)
|
||||||
@@ -284,22 +232,25 @@ def expand(
|
|||||||
for pl in edges_payloads:
|
for pl in edges_payloads:
|
||||||
src = pl.get("source_id")
|
src = pl.get("source_id")
|
||||||
tgt = pl.get("target_id")
|
tgt = pl.get("target_id")
|
||||||
kind = pl.get("kind", "edge")
|
|
||||||
owner = pl.get("note_id")
|
# Skip invalid edges
|
||||||
|
if not src or not tgt:
|
||||||
|
continue
|
||||||
|
|
||||||
e = {
|
e = {
|
||||||
"source": src,
|
"source": src,
|
||||||
"target": tgt,
|
"target": tgt,
|
||||||
"kind": kind,
|
"kind": pl.get("kind", "edge"),
|
||||||
"weight": _edge_weight(pl),
|
"weight": _edge_weight(pl),
|
||||||
"note_id": owner,
|
"note_id": pl.get("note_id"),
|
||||||
}
|
}
|
||||||
sg.add_edge(e)
|
sg.add_edge(e)
|
||||||
|
|
||||||
if tgt:
|
# Nur weitersuchen, wenn Target noch nicht besucht
|
||||||
|
if tgt and tgt not in visited:
|
||||||
next_frontier.add(tgt)
|
next_frontier.add(tgt)
|
||||||
|
|
||||||
visited |= frontier
|
visited |= frontier
|
||||||
frontier = next_frontier - visited
|
frontier = next_frontier - visited
|
||||||
|
|
||||||
return sg
|
return sg
|
||||||
+187
-76
@@ -3,10 +3,18 @@ from __future__ import annotations
|
|||||||
import os
|
import os
|
||||||
import time
|
import time
|
||||||
from functools import lru_cache
|
from functools import lru_cache
|
||||||
from typing import Any, Dict, List, Tuple, Iterable
|
from typing import Any, Dict, List, Tuple, Iterable, Optional
|
||||||
|
|
||||||
from app.config import get_settings
|
from app.config import get_settings
|
||||||
from app.models.dto import QueryRequest, QueryResponse, QueryHit
|
from app.models.dto import (
|
||||||
|
QueryRequest,
|
||||||
|
QueryResponse,
|
||||||
|
QueryHit,
|
||||||
|
Explanation,
|
||||||
|
ScoreBreakdown,
|
||||||
|
Reason,
|
||||||
|
EdgeDTO
|
||||||
|
)
|
||||||
import app.core.qdrant as qdr
|
import app.core.qdrant as qdr
|
||||||
import app.core.qdrant_points as qp
|
import app.core.qdrant_points as qp
|
||||||
import app.services.embeddings_client as ec
|
import app.services.embeddings_client as ec
|
||||||
@@ -23,12 +31,7 @@ def _get_scoring_weights() -> Tuple[float, float, float]:
|
|||||||
"""Liefert (semantic_weight, edge_weight, centrality_weight) für den Retriever.
|
"""Liefert (semantic_weight, edge_weight, centrality_weight) für den Retriever.
|
||||||
|
|
||||||
Priorität:
|
Priorität:
|
||||||
1. Werte aus config/retriever.yaml (falls vorhanden und gültig),
|
1. Werte aus config/retriever.yaml (falls vorhanden und gültig).
|
||||||
Abschnitt:
|
|
||||||
scoring:
|
|
||||||
semantic_weight: 1.0
|
|
||||||
edge_weight: 0.5
|
|
||||||
centrality_weight: 0.5
|
|
||||||
2. Fallback auf Settings.RETRIEVER_W_* (ENV-basiert).
|
2. Fallback auf Settings.RETRIEVER_W_* (ENV-basiert).
|
||||||
"""
|
"""
|
||||||
settings = get_settings()
|
settings = get_settings()
|
||||||
@@ -64,10 +67,6 @@ def _get_client_and_prefix() -> Tuple[Any, str]:
|
|||||||
def _get_query_vector(req: QueryRequest) -> List[float]:
|
def _get_query_vector(req: QueryRequest) -> List[float]:
|
||||||
"""
|
"""
|
||||||
Liefert den Query-Vektor aus dem Request.
|
Liefert den Query-Vektor aus dem Request.
|
||||||
|
|
||||||
- Falls req.query_vector gesetzt ist, wird dieser unverändert genutzt.
|
|
||||||
- Andernfalls wird req.query über den Embedding-Service in einen Vektor
|
|
||||||
transformiert.
|
|
||||||
"""
|
"""
|
||||||
if req.query_vector:
|
if req.query_vector:
|
||||||
return list(req.query_vector)
|
return list(req.query_vector)
|
||||||
@@ -78,11 +77,9 @@ def _get_query_vector(req: QueryRequest) -> List[float]:
|
|||||||
settings = get_settings()
|
settings = get_settings()
|
||||||
model_name = settings.MODEL_NAME
|
model_name = settings.MODEL_NAME
|
||||||
|
|
||||||
# Kompatibel mit Fakes in Unit-Tests (ohne model_name-Parameter)
|
|
||||||
try:
|
try:
|
||||||
return ec.embed_text(req.query, model_name=model_name) # type: ignore[call-arg]
|
return ec.embed_text(req.query, model_name=model_name) # type: ignore[call-arg]
|
||||||
except TypeError:
|
except TypeError:
|
||||||
# Fallback: einfache Signatur embed_text(text)
|
|
||||||
return ec.embed_text(req.query) # type: ignore[call-arg]
|
return ec.embed_text(req.query) # type: ignore[call-arg]
|
||||||
|
|
||||||
|
|
||||||
@@ -93,13 +90,7 @@ def _semantic_hits(
|
|||||||
top_k: int,
|
top_k: int,
|
||||||
filters: Dict[str, Any] | None = None,
|
filters: Dict[str, Any] | None = None,
|
||||||
) -> List[Tuple[str, float, Dict[str, Any]]]:
|
) -> List[Tuple[str, float, Dict[str, Any]]]:
|
||||||
"""Führt eine semantische Suche über mindnet_chunks aus und liefert Roh-Treffer.
|
"""Führt eine semantische Suche über mindnet_chunks aus und liefert Roh-Treffer."""
|
||||||
|
|
||||||
Rückgabeformat: Liste von (point_id, score, payload)
|
|
||||||
|
|
||||||
Erwartetes Format von qp.search_chunks_by_vector:
|
|
||||||
List[Tuple[str, float, dict]]
|
|
||||||
"""
|
|
||||||
flt = filters or None
|
flt = filters or None
|
||||||
raw_hits = qp.search_chunks_by_vector(client, prefix, vector, top=top_k, filters=flt)
|
raw_hits = qp.search_chunks_by_vector(client, prefix, vector, top=top_k, filters=flt)
|
||||||
results: List[Tuple[str, float, Dict[str, Any]]] = []
|
results: List[Tuple[str, float, Dict[str, Any]]] = []
|
||||||
@@ -108,30 +99,13 @@ def _semantic_hits(
|
|||||||
return results
|
return results
|
||||||
|
|
||||||
|
|
||||||
def _get_semantic_score_and_payload(
|
|
||||||
hit: Tuple[str, float, Dict[str, Any]]
|
|
||||||
) -> Tuple[float, Dict[str, Any]]:
|
|
||||||
"""Extrahiert semantic_score und Payload aus einem Raw-Hit."""
|
|
||||||
_, score, payload = hit
|
|
||||||
return float(score), payload or {}
|
|
||||||
|
|
||||||
|
|
||||||
def _compute_total_score(
|
def _compute_total_score(
|
||||||
semantic_score: float,
|
semantic_score: float,
|
||||||
payload: Dict[str, Any],
|
payload: Dict[str, Any],
|
||||||
edge_bonus: float = 0.0,
|
edge_bonus: float = 0.0,
|
||||||
cent_bonus: float = 0.0,
|
cent_bonus: float = 0.0,
|
||||||
) -> Tuple[float, float, float]:
|
) -> Tuple[float, float, float]:
|
||||||
"""Berechnet total_score aus semantic_score, retriever_weight und Graph-Boni.
|
"""Berechnet total_score aus semantic_score, retriever_weight und Graph-Boni."""
|
||||||
|
|
||||||
Formel (WP-04, konfigurierbar über config/retriever.yaml bzw. ENV):
|
|
||||||
total_score = W_sem * semantic_score * max(retriever_weight, 0.0)
|
|
||||||
+ W_edge * edge_bonus
|
|
||||||
+ W_cent * cent_bonus
|
|
||||||
|
|
||||||
- retriever_weight stammt aus dem Chunk-Payload (types.yaml).
|
|
||||||
- W_sem / W_edge / W_cent kommen aus _get_scoring_weights().
|
|
||||||
"""
|
|
||||||
raw_weight = payload.get("retriever_weight", 1.0)
|
raw_weight = payload.get("retriever_weight", 1.0)
|
||||||
try:
|
try:
|
||||||
weight = float(raw_weight)
|
weight = float(raw_weight)
|
||||||
@@ -145,12 +119,136 @@ def _compute_total_score(
|
|||||||
return float(total), float(edge_bonus), float(cent_bonus)
|
return float(total), float(edge_bonus), float(cent_bonus)
|
||||||
|
|
||||||
|
|
||||||
def _extract_expand_options(req: QueryRequest) -> Tuple[int, List[str] | None]:
|
# --- WP-04b Explanation Logic ---
|
||||||
"""Extrahiert depth und edge_types aus req.expand, falls vorhanden.
|
|
||||||
|
|
||||||
- Falls expand nicht gesetzt ist: depth=0, edge_types=None (keine Expansion).
|
def _build_explanation(
|
||||||
- Unterstützt sowohl Pydantic-Modelle als auch plain dicts.
|
semantic_score: float,
|
||||||
|
payload: Dict[str, Any],
|
||||||
|
edge_bonus: float,
|
||||||
|
cent_bonus: float,
|
||||||
|
subgraph: Optional[ga.Subgraph],
|
||||||
|
node_key: Optional[str]
|
||||||
|
) -> Explanation:
|
||||||
"""
|
"""
|
||||||
|
Erstellt ein detailliertes Explanation-Objekt für einen Treffer.
|
||||||
|
Analysiert Scores, Typen und Kanten (Incoming & Outgoing).
|
||||||
|
"""
|
||||||
|
sem_w, edge_w, cent_w = _get_scoring_weights()
|
||||||
|
|
||||||
|
try:
|
||||||
|
type_weight = float(payload.get("retriever_weight", 1.0))
|
||||||
|
except (TypeError, ValueError):
|
||||||
|
type_weight = 1.0
|
||||||
|
|
||||||
|
note_type = payload.get("type", "unknown")
|
||||||
|
|
||||||
|
breakdown = ScoreBreakdown(
|
||||||
|
semantic_contribution=(sem_w * semantic_score * type_weight),
|
||||||
|
edge_contribution=(edge_w * edge_bonus),
|
||||||
|
centrality_contribution=(cent_w * cent_bonus),
|
||||||
|
raw_semantic=semantic_score,
|
||||||
|
raw_edge_bonus=edge_bonus,
|
||||||
|
raw_centrality=cent_bonus,
|
||||||
|
node_weight=type_weight
|
||||||
|
)
|
||||||
|
|
||||||
|
reasons: List[Reason] = []
|
||||||
|
edges_dto: List[EdgeDTO] = []
|
||||||
|
|
||||||
|
# 1. Semantische Gründe
|
||||||
|
if semantic_score > 0.85:
|
||||||
|
reasons.append(Reason(
|
||||||
|
kind="semantic",
|
||||||
|
message="Sehr hohe textuelle Übereinstimmung.",
|
||||||
|
score_impact=breakdown.semantic_contribution
|
||||||
|
))
|
||||||
|
elif semantic_score > 0.70:
|
||||||
|
reasons.append(Reason(
|
||||||
|
kind="semantic",
|
||||||
|
message="Gute textuelle Übereinstimmung.",
|
||||||
|
score_impact=breakdown.semantic_contribution
|
||||||
|
))
|
||||||
|
|
||||||
|
# 2. Typ-Gründe
|
||||||
|
if type_weight != 1.0:
|
||||||
|
msg = "Bevorzugt" if type_weight > 1.0 else "Leicht abgewertet"
|
||||||
|
reasons.append(Reason(
|
||||||
|
kind="type",
|
||||||
|
message=f"{msg} aufgrund des Typs '{note_type}' (Gewicht: {type_weight}).",
|
||||||
|
score_impact=(sem_w * semantic_score * (type_weight - 1.0))
|
||||||
|
))
|
||||||
|
|
||||||
|
# 3. Graph-Gründe (Edges)
|
||||||
|
if subgraph and node_key and edge_bonus > 0:
|
||||||
|
# Wir sammeln die stärksten Kanten (egal ob rein oder raus),
|
||||||
|
# die zum Score beitragen.
|
||||||
|
|
||||||
|
# A) Outgoing (Ich verweise auf...) - Das ist oft der Hub-Score
|
||||||
|
if hasattr(subgraph, "get_outgoing_edges"):
|
||||||
|
outgoing = subgraph.get_outgoing_edges(node_key)
|
||||||
|
for edge in outgoing:
|
||||||
|
target = edge.get("target", "Unknown")
|
||||||
|
kind = edge.get("kind", "edge")
|
||||||
|
weight = edge.get("weight", 0.0)
|
||||||
|
|
||||||
|
# Nur relevante Kanten aufnehmen
|
||||||
|
if weight > 0.05:
|
||||||
|
edges_dto.append(EdgeDTO(
|
||||||
|
id=f"{node_key}->{target}:{kind}",
|
||||||
|
kind=kind, source=node_key, target=target, weight=weight, direction="out"
|
||||||
|
))
|
||||||
|
|
||||||
|
# B) Incoming (Ich werde verwiesen von...)
|
||||||
|
if hasattr(subgraph, "get_incoming_edges"):
|
||||||
|
incoming = subgraph.get_incoming_edges(node_key)
|
||||||
|
for edge in incoming:
|
||||||
|
src = edge.get("source", "Unknown")
|
||||||
|
kind = edge.get("kind", "edge")
|
||||||
|
weight = edge.get("weight", 0.0)
|
||||||
|
|
||||||
|
if weight > 0.05:
|
||||||
|
edges_dto.append(EdgeDTO(
|
||||||
|
id=f"{src}->{node_key}:{kind}",
|
||||||
|
kind=kind, source=src, target=node_key, weight=weight, direction="in"
|
||||||
|
))
|
||||||
|
|
||||||
|
# Sortieren nach Gewicht und Top-3 als Reasons generieren
|
||||||
|
all_edges = sorted(edges_dto, key=lambda e: e.weight, reverse=True)
|
||||||
|
|
||||||
|
for top_edge in all_edges[:3]:
|
||||||
|
# Impact schätzen (grob, da Edge-Bonus eine Summe ist)
|
||||||
|
impact = edge_w * top_edge.weight
|
||||||
|
|
||||||
|
if top_edge.direction == "out":
|
||||||
|
msg = f"Verweist auf '{top_edge.target}' via '{top_edge.kind}'"
|
||||||
|
else:
|
||||||
|
msg = f"Referenziert von '{top_edge.source}' via '{top_edge.kind}'"
|
||||||
|
|
||||||
|
reasons.append(Reason(
|
||||||
|
kind="edge",
|
||||||
|
message=msg,
|
||||||
|
score_impact=impact,
|
||||||
|
details={"kind": top_edge.kind, "weight": top_edge.weight}
|
||||||
|
))
|
||||||
|
|
||||||
|
# 4. Centrality
|
||||||
|
if cent_bonus > 0.01:
|
||||||
|
reasons.append(Reason(
|
||||||
|
kind="centrality",
|
||||||
|
message="Knoten liegt zentral im Kontext.",
|
||||||
|
score_impact=breakdown.centrality_contribution
|
||||||
|
))
|
||||||
|
|
||||||
|
return Explanation(
|
||||||
|
breakdown=breakdown,
|
||||||
|
reasons=reasons,
|
||||||
|
related_edges=edges_dto if edges_dto else None
|
||||||
|
)
|
||||||
|
# --- End Explanation Logic ---
|
||||||
|
|
||||||
|
|
||||||
|
def _extract_expand_options(req: QueryRequest) -> Tuple[int, List[str] | None]:
|
||||||
|
"""Extrahiert depth und edge_types aus req.expand."""
|
||||||
expand = getattr(req, "expand", None)
|
expand = getattr(req, "expand", None)
|
||||||
if not expand:
|
if not expand:
|
||||||
return 0, None
|
return 0, None
|
||||||
@@ -158,7 +256,6 @@ def _extract_expand_options(req: QueryRequest) -> Tuple[int, List[str] | None]:
|
|||||||
depth = 1
|
depth = 1
|
||||||
edge_types: List[str] | None = None
|
edge_types: List[str] | None = None
|
||||||
|
|
||||||
# Pydantic-Modell oder Objekt mit Attributen
|
|
||||||
if hasattr(expand, "depth") or hasattr(expand, "edge_types"):
|
if hasattr(expand, "depth") or hasattr(expand, "edge_types"):
|
||||||
depth = int(getattr(expand, "depth", 1) or 1)
|
depth = int(getattr(expand, "depth", 1) or 1)
|
||||||
types_val = getattr(expand, "edge_types", None)
|
types_val = getattr(expand, "edge_types", None)
|
||||||
@@ -166,7 +263,6 @@ def _extract_expand_options(req: QueryRequest) -> Tuple[int, List[str] | None]:
|
|||||||
edge_types = list(types_val)
|
edge_types = list(types_val)
|
||||||
return depth, edge_types
|
return depth, edge_types
|
||||||
|
|
||||||
# Plain dict
|
|
||||||
if isinstance(expand, dict):
|
if isinstance(expand, dict):
|
||||||
if "depth" in expand:
|
if "depth" in expand:
|
||||||
depth = int(expand.get("depth") or 1)
|
depth = int(expand.get("depth") or 1)
|
||||||
@@ -182,32 +278,30 @@ def _build_hits_from_semantic(
|
|||||||
top_k: int,
|
top_k: int,
|
||||||
used_mode: str,
|
used_mode: str,
|
||||||
subgraph: ga.Subgraph | None = None,
|
subgraph: ga.Subgraph | None = None,
|
||||||
|
explain: bool = False, # WP-04b
|
||||||
) -> QueryResponse:
|
) -> QueryResponse:
|
||||||
"""Baut aus Raw-Hits und optionalem Subgraph strukturierte QueryHits.
|
"""Baut aus Raw-Hits und optionalem Subgraph strukturierte QueryHits.
|
||||||
|
|
||||||
- Aggregation auf Note-Ebene (note_id),
|
WP-04b: Wenn explain=True, wird _build_explanation aufgerufen.
|
||||||
- Berechnung von total_score unter Nutzung von retriever_weight + Graph-Boni,
|
|
||||||
- Rückgabe als QueryResponse mit Latenz.
|
|
||||||
"""
|
"""
|
||||||
t0 = time.time()
|
t0 = time.time()
|
||||||
|
|
||||||
enriched: List[Tuple[str, float, Dict[str, Any], float, float, float]] = []
|
enriched: List[Tuple[str, float, Dict[str, Any], float, float, float]] = []
|
||||||
|
|
||||||
for pid, semantic_score, payload in hits:
|
for pid, semantic_score, payload in hits:
|
||||||
# Graph-Scores, falls Subgraph und stabiler Key vorhanden
|
|
||||||
edge_bonus = 0.0
|
edge_bonus = 0.0
|
||||||
cent_bonus = 0.0
|
cent_bonus = 0.0
|
||||||
if subgraph is not None:
|
node_key = payload.get("chunk_id") or payload.get("note_id")
|
||||||
node_key = payload.get("chunk_id") or payload.get("note_id")
|
|
||||||
if node_key:
|
if subgraph is not None and node_key:
|
||||||
try:
|
try:
|
||||||
edge_bonus = float(subgraph.edge_bonus(node_key))
|
edge_bonus = float(subgraph.edge_bonus(node_key))
|
||||||
except Exception:
|
except Exception:
|
||||||
edge_bonus = 0.0
|
edge_bonus = 0.0
|
||||||
try:
|
try:
|
||||||
cent_bonus = float(subgraph.centrality_bonus(node_key))
|
cent_bonus = float(subgraph.centrality_bonus(node_key))
|
||||||
except Exception:
|
except Exception:
|
||||||
cent_bonus = 0.0
|
cent_bonus = 0.0
|
||||||
|
|
||||||
total, edge_bonus, cent_bonus = _compute_total_score(
|
total, edge_bonus, cent_bonus = _compute_total_score(
|
||||||
semantic_score,
|
semantic_score,
|
||||||
@@ -225,8 +319,20 @@ def _build_hits_from_semantic(
|
|||||||
for pid, semantic_score, payload, total, edge_bonus, cent_bonus in limited:
|
for pid, semantic_score, payload, total, edge_bonus, cent_bonus in limited:
|
||||||
note_id = payload.get("note_id")
|
note_id = payload.get("note_id")
|
||||||
path = payload.get("path")
|
path = payload.get("path")
|
||||||
# mindnet_chunks: section (aktuell genutzt); ältere Stände nutzen ggf. section_title
|
|
||||||
section = payload.get("section") or payload.get("section_title")
|
section = payload.get("section") or payload.get("section_title")
|
||||||
|
node_key = payload.get("chunk_id") or payload.get("note_id")
|
||||||
|
|
||||||
|
# WP-04b: Explanation bauen?
|
||||||
|
explanation_obj = None
|
||||||
|
if explain:
|
||||||
|
explanation_obj = _build_explanation(
|
||||||
|
semantic_score=float(semantic_score),
|
||||||
|
payload=payload,
|
||||||
|
edge_bonus=edge_bonus,
|
||||||
|
cent_bonus=cent_bonus,
|
||||||
|
subgraph=subgraph,
|
||||||
|
node_key=node_key
|
||||||
|
)
|
||||||
|
|
||||||
results.append(
|
results.append(
|
||||||
QueryHit(
|
QueryHit(
|
||||||
@@ -241,6 +347,7 @@ def _build_hits_from_semantic(
|
|||||||
"path": path,
|
"path": path,
|
||||||
"section": section,
|
"section": section,
|
||||||
},
|
},
|
||||||
|
explanation=explanation_obj
|
||||||
)
|
)
|
||||||
)
|
)
|
||||||
|
|
||||||
@@ -255,22 +362,21 @@ def semantic_retrieve(req: QueryRequest) -> QueryResponse:
|
|||||||
top_k = req.top_k or get_settings().RETRIEVER_TOP_K
|
top_k = req.top_k or get_settings().RETRIEVER_TOP_K
|
||||||
|
|
||||||
hits = _semantic_hits(client, prefix, vector, top_k=top_k, filters=req.filters)
|
hits = _semantic_hits(client, prefix, vector, top_k=top_k, filters=req.filters)
|
||||||
return _build_hits_from_semantic(hits, top_k=top_k, used_mode="semantic", subgraph=None)
|
|
||||||
|
# explain Flag durchreichen
|
||||||
|
return _build_hits_from_semantic(
|
||||||
|
hits,
|
||||||
|
top_k=top_k,
|
||||||
|
used_mode="semantic",
|
||||||
|
subgraph=None,
|
||||||
|
explain=req.explain
|
||||||
|
)
|
||||||
|
|
||||||
|
|
||||||
def hybrid_retrieve(req: QueryRequest) -> QueryResponse:
|
def hybrid_retrieve(req: QueryRequest) -> QueryResponse:
|
||||||
"""Hybrid-Retriever: semantische Suche + optionale Edge-Expansion.
|
"""Hybrid-Retriever: semantische Suche + optionale Edge-Expansion."""
|
||||||
|
|
||||||
Aktueller Stand (Step 3):
|
|
||||||
- Semantische Suche über mindnet_chunks (wie semantic_retrieve),
|
|
||||||
- Bei expand.depth > 0 wird ein Subgraph aus mindnet_edges aufgebaut,
|
|
||||||
und edge_bonus / centrality_bonus in das Scoring einbezogen.
|
|
||||||
"""
|
|
||||||
client, prefix = _get_client_and_prefix()
|
client, prefix = _get_client_and_prefix()
|
||||||
|
|
||||||
# Query-Vektor:
|
|
||||||
# - Falls explizit gesetzt, unverändert nutzen.
|
|
||||||
# - Andernfalls über embed_text erzeugen.
|
|
||||||
if req.query_vector:
|
if req.query_vector:
|
||||||
vector = list(req.query_vector)
|
vector = list(req.query_vector)
|
||||||
else:
|
else:
|
||||||
@@ -283,7 +389,6 @@ def hybrid_retrieve(req: QueryRequest) -> QueryResponse:
|
|||||||
depth, edge_types = _extract_expand_options(req)
|
depth, edge_types = _extract_expand_options(req)
|
||||||
subgraph: ga.Subgraph | None = None
|
subgraph: ga.Subgraph | None = None
|
||||||
if depth and depth > 0:
|
if depth and depth > 0:
|
||||||
# Seeds: stabile IDs aus dem Payload (chunk_id bevorzugt, sonst note_id)
|
|
||||||
seed_ids: List[str] = []
|
seed_ids: List[str] = []
|
||||||
for _pid, _score, payload in hits:
|
for _pid, _score, payload in hits:
|
||||||
key = payload.get("chunk_id") or payload.get("note_id")
|
key = payload.get("chunk_id") or payload.get("note_id")
|
||||||
@@ -294,7 +399,13 @@ def hybrid_retrieve(req: QueryRequest) -> QueryResponse:
|
|||||||
try:
|
try:
|
||||||
subgraph = ga.expand(client, prefix, seed_ids, depth=depth, edge_types=edge_types)
|
subgraph = ga.expand(client, prefix, seed_ids, depth=depth, edge_types=edge_types)
|
||||||
except Exception:
|
except Exception:
|
||||||
# Edge-Expansion ist optional: bei Fehlern weiter ohne Graph-Boni
|
|
||||||
subgraph = None
|
subgraph = None
|
||||||
|
|
||||||
return _build_hits_from_semantic(hits, top_k=top_k, used_mode="hybrid", subgraph=subgraph)
|
# explain Flag durchreichen
|
||||||
|
return _build_hits_from_semantic(
|
||||||
|
hits,
|
||||||
|
top_k=top_k,
|
||||||
|
used_mode="hybrid",
|
||||||
|
subgraph=subgraph,
|
||||||
|
explain=req.explain
|
||||||
|
)
|
||||||
+63
-11
@@ -3,27 +3,27 @@ app/models/dto.py — Pydantic-Modelle (DTOs) für WP-04 Endpunkte
|
|||||||
|
|
||||||
Zweck:
|
Zweck:
|
||||||
Laufzeit-Modelle für FastAPI (Requests/Responses), getrennt von JSON-Schemas.
|
Laufzeit-Modelle für FastAPI (Requests/Responses), getrennt von JSON-Schemas.
|
||||||
Deckt die Graph-/Retriever-Endpunkte ab, ohne bestehende Funktionen zu ändern.
|
Deckt die Graph-/Retriever-Endpunkte ab.
|
||||||
|
Enthält Erweiterungen für WP-04b (Explanation Layer).
|
||||||
|
|
||||||
Kompatibilität:
|
Kompatibilität:
|
||||||
Python 3.12+, Pydantic 2.x, FastAPI 0.110+
|
Python 3.12+, Pydantic 2.x, FastAPI 0.110+
|
||||||
Version:
|
Version:
|
||||||
0.1.0 (Erstanlage für WP-04)
|
0.2.0 (Update für WP-04b Explanation Layer)
|
||||||
Stand:
|
Stand:
|
||||||
2025-10-07
|
2025-12-07
|
||||||
Bezug:
|
Bezug:
|
||||||
- schemas/*.json (Speicherschema für Notes/Chunks/Edges)
|
- schemas/*.json (Speicherschema für Notes/Chunks/Edges)
|
||||||
- WP-04 API-Design (Query- und Graph-Endpunkte)
|
- WP-04 API-Design (Query- und Graph-Endpunkte)
|
||||||
Nutzung:
|
Nutzung:
|
||||||
from app.models.dto import QueryRequest, QueryResponse, GraphResponse
|
from app.models.dto import QueryRequest, QueryResponse, GraphResponse
|
||||||
Änderungsverlauf:
|
|
||||||
0.1.0 (2025-10-07) – Erstanlage.
|
|
||||||
"""
|
"""
|
||||||
|
|
||||||
from __future__ import annotations
|
from __future__ import annotations
|
||||||
from pydantic import BaseModel
|
from pydantic import BaseModel, Field
|
||||||
from typing import List, Literal, Optional, Dict
|
from typing import List, Literal, Optional, Dict, Any
|
||||||
|
|
||||||
EdgeKind = Literal["references", "references_at", "backlink", "next", "prev", "belongs_to"]
|
EdgeKind = Literal["references", "references_at", "backlink", "next", "prev", "belongs_to", "depends_on", "related_to", "similar_to"]
|
||||||
|
|
||||||
|
|
||||||
class NodeDTO(BaseModel):
|
class NodeDTO(BaseModel):
|
||||||
@@ -44,7 +44,7 @@ class NodeDTO(BaseModel):
|
|||||||
class EdgeDTO(BaseModel):
|
class EdgeDTO(BaseModel):
|
||||||
"""Darstellung einer Kante im API-Graph."""
|
"""Darstellung einer Kante im API-Graph."""
|
||||||
id: str
|
id: str
|
||||||
kind: EdgeKind
|
kind: str # String statt Literal, um flexibel für Custom-Types zu bleiben
|
||||||
source: str
|
source: str
|
||||||
target: str
|
target: str
|
||||||
weight: float
|
weight: float
|
||||||
@@ -57,26 +57,78 @@ class QueryRequest(BaseModel):
|
|||||||
- mode: 'semantic' | 'edge' | 'hybrid'
|
- mode: 'semantic' | 'edge' | 'hybrid'
|
||||||
- query: (optional) Freitext; Embedding wird später angebunden
|
- query: (optional) Freitext; Embedding wird später angebunden
|
||||||
- query_vector: (optional) direkter Vektor (384d) für Quick-Tests ohne Embedding
|
- query_vector: (optional) direkter Vektor (384d) für Quick-Tests ohne Embedding
|
||||||
|
- explain: (optional) Fordert detaillierte Erklärungen an (WP-04b)
|
||||||
"""
|
"""
|
||||||
mode: Literal["semantic", "edge", "hybrid"] = "hybrid"
|
mode: Literal["semantic", "edge", "hybrid"] = "hybrid"
|
||||||
query: Optional[str] = None
|
query: Optional[str] = None
|
||||||
query_vector: Optional[List[float]] = None
|
query_vector: Optional[List[float]] = None
|
||||||
top_k: int = 10
|
top_k: int = 10
|
||||||
expand: Dict = {"depth": 1, "edge_types": ["references", "belongs_to", "prev", "next"]}
|
expand: Dict = {"depth": 1, "edge_types": ["references", "belongs_to", "prev", "next", "depends_on", "related_to"]}
|
||||||
filters: Optional[Dict] = None
|
filters: Optional[Dict] = None
|
||||||
|
# Flags zur Steuerung der Rückgabe
|
||||||
ret: Dict = {"with_paths": True, "with_notes": True, "with_chunks": True}
|
ret: Dict = {"with_paths": True, "with_notes": True, "with_chunks": True}
|
||||||
|
# WP-04b: Soll eine Erklärung generiert werden?
|
||||||
|
explain: bool = False
|
||||||
|
|
||||||
|
|
||||||
|
# --- WP-04b Explanation Models ---
|
||||||
|
|
||||||
|
class ScoreBreakdown(BaseModel):
|
||||||
|
"""
|
||||||
|
Aufschlüsselung der Score-Komponenten.
|
||||||
|
Zeigt die gewichteten Beiträge zum Total Score.
|
||||||
|
"""
|
||||||
|
semantic_contribution: float = Field(..., description="W_sem * semantic_score * weight")
|
||||||
|
edge_contribution: float = Field(..., description="W_edge * edge_bonus")
|
||||||
|
centrality_contribution: float = Field(..., description="W_cent * centrality_bonus")
|
||||||
|
|
||||||
|
# Rohwerte für Transparenz
|
||||||
|
raw_semantic: float
|
||||||
|
raw_edge_bonus: float
|
||||||
|
raw_centrality: float
|
||||||
|
node_weight: float = Field(..., description="Typ-Gewicht (retriever_weight)")
|
||||||
|
|
||||||
|
|
||||||
|
class Reason(BaseModel):
|
||||||
|
"""
|
||||||
|
Ein semantischer Grund für das Ranking.
|
||||||
|
z.B. 'Verlinkt von Projekt X', 'Hohe Textähnlichkeit'.
|
||||||
|
"""
|
||||||
|
kind: Literal["semantic", "edge", "type", "centrality"]
|
||||||
|
message: str
|
||||||
|
score_impact: Optional[float] = None
|
||||||
|
details: Optional[Dict[str, Any]] = None
|
||||||
|
|
||||||
|
|
||||||
|
class Explanation(BaseModel):
|
||||||
|
"""
|
||||||
|
Container für alle Erklärungsdaten eines Treffers.
|
||||||
|
"""
|
||||||
|
breakdown: ScoreBreakdown
|
||||||
|
reasons: List[Reason]
|
||||||
|
# Optional: Pfade im Graphen, die zu diesem Treffer geführt haben
|
||||||
|
related_edges: Optional[List[EdgeDTO]] = None
|
||||||
|
|
||||||
|
|
||||||
|
# --- End Explanation Models ---
|
||||||
|
|
||||||
|
|
||||||
class QueryHit(BaseModel):
|
class QueryHit(BaseModel):
|
||||||
"""Einzelnes Trefferobjekt für /query."""
|
"""Einzelnes Trefferobjekt für /query."""
|
||||||
node_id: str
|
node_id: str
|
||||||
note_id: Optional[str]
|
note_id: Optional[str]
|
||||||
|
|
||||||
|
# Flache Scores (Kompatibilität WP-04a)
|
||||||
semantic_score: float
|
semantic_score: float
|
||||||
edge_bonus: float
|
edge_bonus: float
|
||||||
centrality_bonus: float
|
centrality_bonus: float
|
||||||
total_score: float
|
total_score: float
|
||||||
|
|
||||||
paths: Optional[List[List[Dict]]] = None
|
paths: Optional[List[List[Dict]]] = None
|
||||||
source: Optional[Dict] = None
|
source: Optional[Dict] = None
|
||||||
|
|
||||||
|
# WP-04b: Erklärungsobjekt (nur gefüllt, wenn explain=True)
|
||||||
|
explanation: Optional[Explanation] = None
|
||||||
|
|
||||||
|
|
||||||
class QueryResponse(BaseModel):
|
class QueryResponse(BaseModel):
|
||||||
@@ -91,4 +143,4 @@ class GraphResponse(BaseModel):
|
|||||||
center_note_id: str
|
center_note_id: str
|
||||||
nodes: List[NodeDTO]
|
nodes: List[NodeDTO]
|
||||||
edges: List[EdgeDTO]
|
edges: List[EdgeDTO]
|
||||||
stats: Dict[str, int]
|
stats: Dict[str, int]
|
||||||
@@ -0,0 +1,214 @@
|
|||||||
|
# mindnet v2.2 – Knowledge Design Manual
|
||||||
|
**Datei:** `docs/mindnet_knowledge_design_manual_v2.2.md`
|
||||||
|
**Stand:** 2025-12-07
|
||||||
|
**Status:** **FINAL** (Konsolidiert aus WP01–WP04a)
|
||||||
|
**Quellen:** `knowledge_design.md`, `TYPE_REGISTRY_MANUAL.md`, `chunking_strategy.md`, `mindnet_functional_architecture.md`, `WP03/WP04 Hinweise`.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 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. Damit der **Retriever** (die Suchmaschine) und spätere **KI-Agenten** dieses Wissen nutzen können, müssen Notizen einer klaren Struktur folgen.
|
||||||
|
|
||||||
|
### 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
|
||||||
|
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).
|
||||||
|
|
||||||
|
### 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 verknüpft die Notiz mit der Konfiguration in `config/types.yaml`.
|
||||||
|
|
||||||
|
### 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 |
|
||||||
|
| :--- | :--- |
|
||||||
|
| **`concept`** | Fachbegriffe, Theorien, Modelle. Zeitloses Wissen. (z. B. "Vektordatenbank") |
|
||||||
|
| **`project`** | Ein Vorhaben mit Ziel, Dauer und Aufgaben. (z. B. "Aufbau Homelab") |
|
||||||
|
| **`experience`** | Persönliche Erfahrung, Lektion oder Erkenntnis. (z. B. "Learning: Docker Networking") |
|
||||||
|
| **`decision`** | Eine bewusst getroffene Entscheidung inkl. Alternativen und Begründung. (z. B. "ADR-001: Nutzung von Qdrant") |
|
||||||
|
| **`value`** | Ein persönlicher Wert oder ein Prinzip. (z. B. "Datensparsamkeit") |
|
||||||
|
| **`person`** | Eine reale Person (Netzwerk, Autor). |
|
||||||
|
| **`event`** | Ein Ereignis (Konferenz, Meeting). |
|
||||||
|
| **`journal`** | Zeitbezogener Log-Eintrag, Daily Note. |
|
||||||
|
| **`source`** | Externe Quelle (Buch, PDF, Artikel), die exzerpiert wird. |
|
||||||
|
|
||||||
|
### 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).
|
||||||
|
* Ziel: Mindnet soll bei Fragen eher *deine Entscheidungen* und *Projekte* finden als reine Definitionen.
|
||||||
|
2. **`chunk_profile` (Textzerlegung):**
|
||||||
|
* `journal` (short): Wird fein zerlegt, da sich Themen schnell ändern.
|
||||||
|
* `concept` (medium): Standard-Absätze.
|
||||||
|
* `project` (long): Längere Kontext-Fenster, um Zusammenhänge zu wahren.
|
||||||
|
3. **`edge_defaults` (Automatische Vernetzung):**
|
||||||
|
* Mindnet ergänzt automatisch Kanten.
|
||||||
|
* Beispiel: Ein Link in einem `project` wird automatisch als `depends_on` (Abhängigkeit) interpretiert, sofern nicht anders angegeben.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 4. Edges & Referenzen in Notes
|
||||||
|
|
||||||
|
Um aus isolierten Dateien ein **Netzwerk** zu machen, nutzen wir Verlinkungen. Mindnet v2.2 (WP03) bietet hierfür präzise Werkzeuge.
|
||||||
|
|
||||||
|
### 4.1 Wikilinks (Die Basis-Referenz)
|
||||||
|
Der klassische Obsidian-Link.
|
||||||
|
|
||||||
|
Wir nutzen [[Qdrant]] als Vektordatenbank.
|
||||||
|
|
||||||
|
* **Bedeutung:** "Diese Notiz erwähnt Qdrant."
|
||||||
|
* **Edge-Typ:** `references`
|
||||||
|
* **Confidence:** 1.0
|
||||||
|
|
||||||
|
### 4.2 Inline-Relationen (Semantische Verknüpfung)
|
||||||
|
Wenn du ausdrücken willst, **wie** Dinge zusammenhängen. Dies ist essenziell für die Erklärbarkeit ("Warum ist das relevant?").
|
||||||
|
|
||||||
|
Daher [[rel:depends_on Qdrant]].
|
||||||
|
Dieses Konzept ist [[rel:similar_to Pinecone]].
|
||||||
|
|
||||||
|
* **Syntax:** `[[rel:RELATION ZIEL]]`. (Wichtig: Das `rel:` Präfix steht *innerhalb* der Klammer).
|
||||||
|
* **Gültige Relationen:**
|
||||||
|
* `depends_on`: Hängt ab von / Benötigt.
|
||||||
|
* `similar_to`: Ähnelt / Ist vergleichbar mit.
|
||||||
|
* `related_to`: Hat zu tun mit (allgemein).
|
||||||
|
* `caused_by`: Wurde verursacht durch.
|
||||||
|
* `solves`: Löst (Problem).
|
||||||
|
* `implements`: Setzt um (Konzept).
|
||||||
|
* **Nicht unterstützt:** `rel: depends_on [[Ziel]]` (alte Syntax, funktioniert nicht mehr!).
|
||||||
|
|
||||||
|
### 4.3 Callout-Edges (Kuratierte Listen)
|
||||||
|
Für Zusammenfassungen oder "Siehe auch"-Blöcke am Ende einer Notiz, die nicht im Fließtext stehen sollen.
|
||||||
|
|
||||||
|
> [!edge] related_to: [[Vector Embeddings]] [[AI Agents]]
|
||||||
|
|
||||||
|
* **Funktion:** Erzeugt `related_to`-Kanten zu allen genannten Zielen in dieser Zeile.
|
||||||
|
* **Nutzen:** Erlaubt schnelle Listenpflege ohne den Textfluss zu stören.
|
||||||
|
|
||||||
|
### 4.4 Strukturkanten (Automatisch)
|
||||||
|
Diese musst du nicht schreiben, sie entstehen automatisch:
|
||||||
|
* `belongs_to`: Verknüpft jeden Textabschnitt (Chunk) mit seiner Ursprungsnotiz.
|
||||||
|
* `next` / `prev`: Verknüpft Absätze in Lesereihenfolge (ermöglicht Agenten das "Weiterlesen").
|
||||||
|
* `has_part` / `part_of`: (Zukünftig) Basierend auf Ordnerstrukturen.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 5. Best Practices & Beispiele
|
||||||
|
|
||||||
|
### 5.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).
|
||||||
|
|
||||||
|
### 5.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]].
|
||||||
|
|
||||||
|
### 5.3 Typische Anti-Patterns (Bitte vermeiden!)
|
||||||
|
|
||||||
|
1. **Der "Alles"-Zettel:** Eine Notiz "Ideen 2025", die 50 verschiedene Themen enthält.
|
||||||
|
* *Besser:* Atomare Notizen ("Idee A", "Idee B") erstellen und verlinken.
|
||||||
|
2. **Manuelle Gewichtung:** `retriever_weight: 0.9` im Frontmatter setzen.
|
||||||
|
* *Problem:* Wenn du das System tunen willst, musst du hunderte Dateien ändern.
|
||||||
|
* *Besser:* Den `type` korrekt setzen und das Gewicht zentral in `types.yaml` steuern.
|
||||||
|
3. **Link-Wüsten:** Eine Notiz, die nur aus einer Liste von 100 Links besteht ohne Text.
|
||||||
|
* *Problem:* Der Vektor-Sucher findet keinen kontextuellen "Anker" (Text).
|
||||||
|
* *Besser:* Kurze Beschreibung zu jedem Link hinzufügen.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 6. Langfristige Stabilität & Virtual Schema Layer
|
||||||
|
|
||||||
|
Mindnet ist auf Langlebigkeit ausgelegt.
|
||||||
|
|
||||||
|
### 6.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`).
|
||||||
|
|
||||||
|
### 6.2 Was bedeutet das für dich?
|
||||||
|
* Du kannst dich auf den Inhalt konzentrieren.
|
||||||
|
* Wenn wir in Zukunft entscheiden, dass "Projekte" stärker gewichtet werden sollen, ändern wir **eine Zeile** in der Konfiguration, und das gesamte System passt sich beim nächsten Import an.
|
||||||
|
* Deine Notizen bleiben sauber und zukunftssicher.
|
||||||
@@ -0,0 +1,190 @@
|
|||||||
|
# Mindnet v2.2 – Admin Guide
|
||||||
|
**Datei:** `docs/mindnet_admin_guide_v2.2.md`
|
||||||
|
**Stand:** 2025-12-07
|
||||||
|
**Status:** **FINAL** (Konsolidiert WP02–WP04a)
|
||||||
|
**Quellen:** `Handbuch.md`, `mindnet_v2_implementation_playbook.md`, `mindnet_technical_architecture.md`, `Programmplan_V2.2.md`.
|
||||||
|
|
||||||
|
> Dieses Handbuch richtet sich an **Administratoren**. Es beschreibt Installation, Konfiguration, Backup-Strategien, Monitoring und den sicheren Betrieb der Mindnet-Instanz.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 1. Zielgruppe & Scope
|
||||||
|
|
||||||
|
Mindnet ist als **Single-Node System** konzipiert, das lokal (z.B. Laptop) oder auf einem privaten Server (Homelab, Intranet) läuft.
|
||||||
|
Als Admin bist du verantwortlich für:
|
||||||
|
* Die Verfügbarkeit der Dienste (Qdrant, API).
|
||||||
|
* Die Datensicherheit (Backups).
|
||||||
|
* Die Integrität des Imports (Sync zwischen Vault und DB).
|
||||||
|
* Die Governance (wer darf zugreifen).
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 2. Initial Setup
|
||||||
|
|
||||||
|
### 2.1 Systemvoraussetzungen
|
||||||
|
* **OS:** Linux (Ubuntu 22.04+ empfohlen) oder macOS.
|
||||||
|
* **Runtime:** Python 3.10+, Docker (für Qdrant).
|
||||||
|
* **Hardware:**
|
||||||
|
* CPU: 2+ Cores.
|
||||||
|
* RAM: Min. 4GB (abhängig von der Vault-Größe und Qdrant-Index).
|
||||||
|
* Disk: SSD empfohlen für Qdrant-Performance.
|
||||||
|
|
||||||
|
### 2.2 Installation
|
||||||
|
# 1. Repository klonen
|
||||||
|
git clone <repo-url> /opt/mindnet
|
||||||
|
cd /opt/mindnet
|
||||||
|
|
||||||
|
# 2. Umgebung einrichten
|
||||||
|
python3 -m venv .venv
|
||||||
|
source .venv/bin/activate
|
||||||
|
pip install -r requirements.txt
|
||||||
|
|
||||||
|
# 3. Verzeichnisse anlegen
|
||||||
|
mkdir -p logs qdrant_storage
|
||||||
|
|
||||||
|
### 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 Konfiguration (ENV)
|
||||||
|
Erstelle eine `.env` Datei im Root-Verzeichnis. Diese Variablen steuern das Verhalten der Skripte und der API.
|
||||||
|
|
||||||
|
# Qdrant Verbindung
|
||||||
|
QDRANT_URL="http://localhost:6333"
|
||||||
|
QDRANT_API_KEY="" # Leer lassen für lokale Instanzen ohne Auth
|
||||||
|
|
||||||
|
# Mindnet Core Settings
|
||||||
|
COLLECTION_PREFIX="mindnet"
|
||||||
|
MINDNET_TYPES_FILE="./config/types.yaml"
|
||||||
|
MINDNET_RETRIEVER_CONFIG="./config/retriever.yaml"
|
||||||
|
|
||||||
|
# Embedding Settings (Default: all-MiniLM-L6-v2)
|
||||||
|
VECTOR_DIM=384
|
||||||
|
|
||||||
|
# Import-Strategie (Performance vs. Gründlichkeit)
|
||||||
|
# Body: Nur Textänderungen triggern Update (Standard)
|
||||||
|
# Full: Auch Frontmatter-Änderungen (z.B. Tags) triggern Update
|
||||||
|
MINDNET_HASH_COMPARE="Body"
|
||||||
|
MINDNET_HASH_SOURCE="parsed"
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 3. Betrieb im Alltag
|
||||||
|
|
||||||
|
### 3.1 Regelmäßige Importe
|
||||||
|
Der Vault-Zustand sollte regelmäßig (z.B. stündlich per Cronjob oder Trigger) nach Qdrant synchronisiert werden. Das Skript erkennt Änderungen automatisch.
|
||||||
|
|
||||||
|
**Cronjob-Beispiel (stündlich):**
|
||||||
|
0 * * * * cd /opt/mindnet && .venv/bin/python3 -m scripts.import_markdown --vault /path/to/vault --prefix "mindnet" --apply --purge-before-upsert --sync-deletes >> ./logs/import.log 2>&1
|
||||||
|
|
||||||
|
* `--purge-before-upsert`: Wichtig, um Fragmente gelöschter Textstellen zu entfernen.
|
||||||
|
* `--sync-deletes`: Wichtig, um Notizen aus dem Index zu entfernen, die im Vault gelöscht wurden.
|
||||||
|
|
||||||
|
### 3.2 Health-Checks
|
||||||
|
Prüfe regelmäßig, ob die API und der Retriever korrekt arbeiten.
|
||||||
|
|
||||||
|
**API Status Check:**
|
||||||
|
curl -f http://localhost:8000/health || echo "API Down"
|
||||||
|
|
||||||
|
**Logischer Smoke-Test:**
|
||||||
|
Führt eine echte Hybrid-Suche durch und prüft, ob Scores berechnet werden.
|
||||||
|
python3 scripts/test_retriever_smoke.py --mode hybrid
|
||||||
|
|
||||||
|
### 3.3 Umgang mit Fehlern im Importer
|
||||||
|
Falls der Importer abbricht oder Dateien ignoriert:
|
||||||
|
|
||||||
|
1. **Diagnose:** Nutze `scripts/diagnose_changed.py`, um zu sehen, warum eine Datei als "unchanged" gilt.
|
||||||
|
python3 -m scripts.diagnose_changed --vault ./vault --note-id "MeineProblemnote"
|
||||||
|
2. **Schema-Validierung:** Prüfe mit `scripts/payload_dryrun.py`, ob eine spezifische Datei das JSON-Schema verletzt.
|
||||||
|
3. **Erzwingen:** Nutze `touch <filename>` im Vault, um den Zeitstempel zu aktualisieren und Hash-Checks zu umgehen, oder nutze `--force` (Vorsicht: Performance).
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 4. Update-Prozess
|
||||||
|
|
||||||
|
Wenn neue Versionen der Mindnet-Software (z.B. Schema-Updates in WP05) ausgerollt werden:
|
||||||
|
|
||||||
|
1. **Code aktualisieren:**
|
||||||
|
git pull origin main
|
||||||
|
2. **Dependencies prüfen:**
|
||||||
|
pip install -r requirements.txt
|
||||||
|
3. **Schema-Migration:**
|
||||||
|
Mindnet nutzt oft "Rebuild" statt komplexer Migrationen, da der Vault die Source of Truth ist.
|
||||||
|
* Prüfe `CHANGELOG.md` auf "Breaking Changes".
|
||||||
|
* Bei Schema-Änderungen: Führe einen **Full Rebuild** durch (siehe 5.3).
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 5. Backup & Restore
|
||||||
|
|
||||||
|
Datensicherheit ruht auf zwei Säulen: Dem Vault (Original) und Qdrant (Index).
|
||||||
|
|
||||||
|
### 5.1 Vault-Backup (Priorität 1)
|
||||||
|
Der Markdown-Vault ist die **Single Source of Truth**. Er muss klassisch gesichert werden.
|
||||||
|
* **Strategie:** Git-Repository, rsync auf NAS, oder Cloud-Sync.
|
||||||
|
* **Restore:** Einfach Dateien zurückkopieren und Import laufen lassen.
|
||||||
|
|
||||||
|
### 5.2 Qdrant-Snapshots (Priorität 2)
|
||||||
|
Für schnelle Wiederherstellung des Suchindex ohne stundenlangen Re-Import (bei großen Vaults).
|
||||||
|
|
||||||
|
**Backup erstellen (Volume-Level):**
|
||||||
|
docker stop mindnet_qdrant
|
||||||
|
tar -czf qdrant_backup_$(date +%F).tar.gz ./qdrant_storage
|
||||||
|
docker start mindnet_qdrant
|
||||||
|
|
||||||
|
**Alternativ: API-Snapshot (Zero-Downtime):**
|
||||||
|
Siehe Qdrant Dokumentation (Snapshot API).
|
||||||
|
|
||||||
|
**Restore:**
|
||||||
|
1. Container stoppen.
|
||||||
|
2. Inhalt von `qdrant_storage` löschen.
|
||||||
|
3. Backup entpacken.
|
||||||
|
4. Container starten.
|
||||||
|
|
||||||
|
### 5.3 Notfall-Wiederherstellung (Rebuild)
|
||||||
|
Wenn die Datenbank korrupt ist oder Indizes defekt sind, ist der sauberste Weg ein Rebuild:
|
||||||
|
|
||||||
|
# 1. DB komplett leeren (Wipe)
|
||||||
|
python3 -m scripts.reset_qdrant --mode wipe --prefix "mindnet" --yes
|
||||||
|
|
||||||
|
# 2. Alles neu importieren
|
||||||
|
python3 -m scripts.import_markdown --vault /path/to/vault --prefix "mindnet" --apply
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 6. Monitoring & Logging
|
||||||
|
|
||||||
|
### 6.1 Log-Quellen
|
||||||
|
* **Importer:** Schreibt nach STDOUT/STDERR. Sollte im Cronjob in eine Datei (z.B. `/var/log/mindnet_import.log`) umgeleitet werden.
|
||||||
|
* **API (Uvicorn):** Standard Access-Logs.
|
||||||
|
* **Qdrant:** Docker Logs (`docker logs mindnet_qdrant`).
|
||||||
|
|
||||||
|
### 6.2 Wichtige Metriken (Log-Parsing)
|
||||||
|
Achte in den Import-Logs auf folgende Muster:
|
||||||
|
* `edges_created`: Sollte bei neuen Inhalten > 0 sein.
|
||||||
|
* `chunks_created`: Sollte plausibel zur Anzahl neuer/geänderter Notizen sein.
|
||||||
|
* `unresolved_references`: Ein hoher Anstieg deutet auf tote Links oder Tippfehler im Vault hin.
|
||||||
|
* `ERROR` / `WARNING`: Parsing-Fehler (z.B. ungültiges YAML).
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 7. Governance & Sicherheit
|
||||||
|
|
||||||
|
### 7.1 Zugriffsschutz
|
||||||
|
Mindnet hat aktuell **keine integrierte Authentifizierung** (By Design für lokalen Betrieb).
|
||||||
|
* **API:** Muss hinter einem Reverse Proxy (Nginx, Traefik, Caddy) mit Basic Auth oder OAuth laufen, wenn sie im Netzwerk freigegeben wird.
|
||||||
|
* **Qdrant:** Sollte nicht öffentlich erreichbar sein (Firewall auf Port 6333, `127.0.0.1` Bindung).
|
||||||
|
|
||||||
|
### 7.2 Datenschutz & Sichtbarkeit
|
||||||
|
* **Interne Nutzung:** Standardmäßig sind alle Inhalte im Index "internal".
|
||||||
|
* **Trennung:** Wenn du öffentliche und private Daten hast, nutze unterschiedliche `COLLECTION_PREFIX` (z.B. `mindnet_public`, `mindnet_private`) und getrennte Import-Jobs/Vault-Ordner, oder warte auf die WP05-ACL-Implementierung (Filterung auf API-Ebene).
|
||||||
|
|
||||||
|
### 7.3 Typen-Governance
|
||||||
|
Änderungen an der `types.yaml` (z.B. neue Gewichte) wirken global.
|
||||||
|
* **Prozess:** Änderungen sollten getestet werden (Smoke-Test), bevor sie produktiv gehen.
|
||||||
|
* **Review:** Prüfe, ob neue Typen (`type: xyz`) auch Chunking-Profile haben, sonst fallen sie auf Defaults zurück.
|
||||||
@@ -0,0 +1,140 @@
|
|||||||
|
# Mindnet v2.2 – Appendices & Referenzen
|
||||||
|
**Datei:** `docs/mindnet_appendices_v2.2.md`
|
||||||
|
**Stand:** 2025-12-07
|
||||||
|
**Status:** **FINAL** (Konsolidiert aus WP01–WP04a)
|
||||||
|
**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.2). Diese Werte werden beim Import angewendet, sofern im Frontmatter nichts anderes definiert ist.
|
||||||
|
|
||||||
|
| Typ (`type`) | Chunk Profile | Retriever Weight | Edge Defaults (Auto-Kanten) | Beschreibung |
|
||||||
|
| :--- | :--- | :--- | :--- | :--- |
|
||||||
|
| **concept** | `medium` | 0.60 | `references`, `related_to` | Abstrakte Begriffe, Theorien. |
|
||||||
|
| **project** | `long` | 0.97 | `references`, `depends_on` | Aktive Vorhaben. Hohe Priorität. |
|
||||||
|
| **decision** | `long` | 1.00 | `caused_by`, `references` | Entscheidungen (ADRs). Höchste Prio. |
|
||||||
|
| **experience** | `medium` | 0.90 | `derived_from`, `inspired_by` | Persönliche Learnings. |
|
||||||
|
| **journal** | `short` | 0.80 | `related_to` | Zeitgebundene Logs. Fein granular. |
|
||||||
|
| **person** | `short` | 0.50 | `related_to` | Personen-Profile. |
|
||||||
|
| **source** | `long` | 0.50 | *(keine)* | Externe Quellen (Bücher, PDFs). |
|
||||||
|
| **event** | `short` | 0.60 | `related_to` | Meetings, Konferenzen. |
|
||||||
|
| **default** | `medium` | 1.00 | `references` | Fallback, wenn Typ unbekannt. |
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## Anhang B: Edge-Typen & Semantik
|
||||||
|
|
||||||
|
Referenz aller implementierten Kantenarten (`kind`). Die Spalte "Herkunft" zeigt, durch welchen Mechanismus diese Kante primär entsteht.
|
||||||
|
|
||||||
|
| 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". |
|
||||||
|
| `derived_from` | Default (Exp) | Nein | Herkunft. "Erkenntnis stammt aus Quelle X". |
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## Anhang C: Datenmodelle (JSON Payloads)
|
||||||
|
|
||||||
|
Dies sind die Felder, die effektiv in Qdrant gespeichert werden. Dient als Referenz für Entwickler und Debugging (`payload_dryrun`).
|
||||||
|
|
||||||
|
### 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. 'long')
|
||||||
|
"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
|
||||||
|
"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)
|
||||||
|
"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' in v2.2
|
||||||
|
"rule_id": "string (keyword)", // Traceability: 'inline:rel', 'explicit:wikilink'
|
||||||
|
"confidence": "float", // 0.0 - 1.0
|
||||||
|
"note_id": "string (keyword)" // Owner Note ID (für Löschung)
|
||||||
|
}
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 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). |
|
||||||
|
| `MINDNET_TYPES_FILE` | `config/types.yaml` | Pfad zur Typ-Registry. |
|
||||||
|
| `MINDNET_RETRIEVER_CONFIG`| `config/retriever.yaml`| Pfad zur Scoring-Konfiguration. |
|
||||||
|
| `MINDNET_HASH_COMPARE` | `Body` | Vergleichsmodus für Import (`Body`, `Frontmatter`, `Full`). |
|
||||||
|
| `MINDNET_HASH_SOURCE` | `parsed` | Quelle für Hash (`parsed`, `raw`, `file`). |
|
||||||
|
| `MINDNET_HASH_NORMALIZE` | `canonical` | Normalisierung vor Hash (`canonical`, `none`). |
|
||||||
|
| `VECTOR_DIM` | `384` | Dimension der Embeddings (Modellabhängig). |
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## Anhang E: Glossar
|
||||||
|
|
||||||
|
Zentrale Begriffe des Mindnet-Systems.
|
||||||
|
|
||||||
|
* **Callout-Edge:** Eine Kante, die durch einen Obsidian-Callout Block (`> [!edge]`) definiert wird. Dient für Listen.
|
||||||
|
* **Chunking:** Prozess des Zerlegens einer Notiz in kleinere, semantische Einheiten (Chunks).
|
||||||
|
* **Confidence:** Ein Wert (0.0-1.0), der angibt, wie sicher eine Kante ist. Explizite User-Eingaben haben 1.0, Defaults ~0.7.
|
||||||
|
* **Idempotenz:** Eigenschaft des Importers, bei mehrfacher Ausführung das exakt gleiche Ergebnis zu liefern (keine Duplikate).
|
||||||
|
* **Inline-Edge:** Eine Kante, die im Fließtext mittels `[[rel:type Ziel]]` definiert wird. Semantisch sehr stark.
|
||||||
|
* **Provenance:** Die Herkunft einer Information (z.B. "explicit" vs "rule" vs "inference").
|
||||||
|
* **Retriever:** Die Komponente (FastAPI), die Suchanfragen beantwortet und Scores berechnet.
|
||||||
|
* **Rule ID:** Ein String, der genau identifiziert, welche Code-Regel eine Kante erzeugt hat (z.B. `edge_defaults:project:depends_on`).
|
||||||
|
* **Vault:** Der lokale Ordner mit Markdown-Dateien. Die "Single Source of Truth".
|
||||||
|
* **Vector Search:** Suche basierend auf semantischer Ähnlichkeit (Embeddings) statt reiner Stichworte.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## Anhang F: Workpackage Status (v2.2)
|
||||||
|
|
||||||
|
Status der Module gemäß Programmplan.
|
||||||
|
|
||||||
|
| 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 | 🟡 In Arbeit | API liefert Pfade, UI fehlt noch. |
|
||||||
|
| **WP04c**| Feedback Loop | 🔴 Geplant | Logging von User-Feedback. |
|
||||||
|
| **WP05** | Virtual Schema | 🟡 Teilw. | `types.yaml` aktiv, ACL fehlt. |
|
||||||
|
| **WP06** | Self-Healing | 🔴 Geplant | Auto-Fixing von Broken Links. |
|
||||||
|
| **WP08** | Self-Tuning | 🔴 Geplant | Auto-Adjustment der Gewichte. |
|
||||||
@@ -0,0 +1,143 @@
|
|||||||
|
# Mindnet v2.2 – Entwickler-Workflow
|
||||||
|
**Datei:** `DEV_WORKFLOW.md`
|
||||||
|
**Stand:** 2025-12-07
|
||||||
|
|
||||||
|
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 trennen strikt:
|
||||||
|
* **PROD (`~/mindnet`):** Läuft stabil auf `main`. **Port 8001**.
|
||||||
|
* **DEV (`~/mindnet_dev`):** Deine Spielwiese für Branches. **Port 8002**.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 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. **Sicherstellen, dass Git bereit ist:**
|
||||||
|
* Öffne VS Code.
|
||||||
|
* Unten links in der blauen Leiste sollte der aktuelle Branch stehen (z.B. `main`).
|
||||||
|
|
||||||
|
2. **Branch erstellen (WICHTIG):**
|
||||||
|
* Klicke unten links auf den Branch-Namen (z.B. `main`).
|
||||||
|
* Wähle im Menü oben `+ Create new branch...`.
|
||||||
|
* Gib den Namen ein: `feature/was-ich-tue` (z.B. `feature/wp04b-explanation`).
|
||||||
|
* Drücke **Enter**.
|
||||||
|
|
||||||
|
3. **Sicherheits-Check:**
|
||||||
|
* Schau unten links: Steht dort jetzt `feature/wp04b-explanation`?
|
||||||
|
* **Nur wenn dort dein Feature-Branch steht, darfst du Code ändern!** Alles, was du jetzt speicherst, landet in diesem Branch.
|
||||||
|
|
||||||
|
4. **Coden:**
|
||||||
|
* Nimm deine Änderungen vor.
|
||||||
|
|
||||||
|
5. **Sichern & Hochladen:**
|
||||||
|
* Klicke links auf das **Source Control** Icon (Gabel-Symbol).
|
||||||
|
* Gib eine Nachricht ein: "feat: Add explanation layer logic".
|
||||||
|
* Klicke auf **Commit**.
|
||||||
|
* Klicke auf **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, ohne die Produktion zu stören.
|
||||||
|
|
||||||
|
1. **Einloggen:**
|
||||||
|
`ssh user@<BEELINK-IP>`
|
||||||
|
|
||||||
|
2. **In die Werkstatt gehen:**
|
||||||
|
`cd /home/llmadmin/mindnet_dev`
|
||||||
|
|
||||||
|
3. **Code holen:**
|
||||||
|
```bash
|
||||||
|
git fetch
|
||||||
|
git checkout feature/wp04b-explanation
|
||||||
|
git pull
|
||||||
|
```
|
||||||
|
|
||||||
|
4. **Umgebung aktivieren (Venv):**
|
||||||
|
Damit Python die installierten Bibliotheken findet, musst du das Virtual Environment aktivieren:
|
||||||
|
```bash
|
||||||
|
source .venv/bin/activate
|
||||||
|
```
|
||||||
|
*(Dein Prompt sollte jetzt `(.venv) user@...` zeigen)*
|
||||||
|
|
||||||
|
5. **Abhängigkeiten prüfen:**
|
||||||
|
*(Nur nötig, wenn du neue Libraries in `requirements.txt` eingetragen hast)*
|
||||||
|
```bash
|
||||||
|
pip install -r requirements.txt
|
||||||
|
```
|
||||||
|
|
||||||
|
6. **Test-Server starten:**
|
||||||
|
**WICHTIG:** Nutze Port **8002** und das Dev-Prefix!
|
||||||
|
Stelle sicher, dass in `~/mindnet_dev/.env` steht: `COLLECTION_PREFIX="mindnet_dev"`.
|
||||||
|
|
||||||
|
```bash
|
||||||
|
uvicorn app.main:app --host 0.0.0.0 --port 8002
|
||||||
|
```
|
||||||
|
|
||||||
|
7. **Testen:**
|
||||||
|
Prüfe deine Änderung (z.B. Browser auf `http://<BEELINK-IP>:8002/docs` oder Smoke-Test Skript).
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
### Phase 3: Release (Gitea / Raspberry Pi)
|
||||||
|
|
||||||
|
Wenn der Test auf Port 8002 erfolgreich war:
|
||||||
|
|
||||||
|
1. Öffne Gitea im Browser.
|
||||||
|
2. Du solltest einen Hinweis sehen "feature/... had recent pushes".
|
||||||
|
3. Erstelle einen **Pull Request** (Dein Branch -> `main`).
|
||||||
|
4. **Merge** den Pull Request.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
### Phase 4: Deployment (Beelink / `mindnet`)
|
||||||
|
|
||||||
|
Jetzt bringen wir die Änderung in das Live-System (Port 8001).
|
||||||
|
|
||||||
|
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
|
||||||
|
sudo systemctl restart mindnet-api
|
||||||
|
```
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 3. Cheat Sheet: Die wichtigsten Befehle
|
||||||
|
|
||||||
|
| Wo? | Befehl | Was tut es? |
|
||||||
|
| :--- | :--- | :--- |
|
||||||
|
| **VS Code** | `Klick auf Branch-Namen` | Branch erstellen oder wechseln. |
|
||||||
|
| **VS Code** | `Sync Changes` | Lädt Code zu Gitea hoch. |
|
||||||
|
| **Beelink** | `cd ~/mindnet_dev` | Gehe in den Test-Ordner. |
|
||||||
|
| **Beelink** | `source .venv/bin/activate` | **Aktiviert Python-Umgebung.** |
|
||||||
|
| **Beelink** | `git fetch` | "Gibt es neue Branches auf Gitea?" |
|
||||||
|
| **Beelink** | `git checkout <name>` | Wechsle auf einen anderen Branch. |
|
||||||
|
| **Beelink** | `git pull` | Hol den neuesten Stand des aktuellen Branches. |
|
||||||
|
| **Beelink** | `uvicorn ... --port 8002` | Startet Test-Server (Dev). |
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 4. Sicherheitsregeln
|
||||||
|
|
||||||
|
1. **Niemals** in `~/mindnet` (Prod-Ordner) experimentieren oder `git checkout` machen. Dieser Ordner bleibt immer auf `main`.
|
||||||
|
2. **Niemals** beide Umgebungen auf denselben `COLLECTION_PREFIX` zeigen lassen.
|
||||||
|
* Prod `.env`: `COLLECTION_PREFIX="mindnet"`
|
||||||
|
* Dev `.env`: `COLLECTION_PREFIX="mindnet_dev"`
|
||||||
|
3. **Port-Disziplin:**
|
||||||
|
* **PROD:** Port 8001
|
||||||
|
* **DEV:** Port 8002
|
||||||
@@ -0,0 +1,155 @@
|
|||||||
|
# Mindnet v2.2 – Developer Guide
|
||||||
|
**Datei:** `docs/mindnet_developer_guide_v2.2.md`
|
||||||
|
**Stand:** 2025-12-07
|
||||||
|
**Status:** **FINAL** (Konsolidiert WP02–WP04a)
|
||||||
|
**Quellen:** `mindnet_technical_architecture.md`, `Handbuch.md`, `docs_mindnet_retriever.md`, `mindnet_v2_implementation_playbook.md`.
|
||||||
|
|
||||||
|
> **Zielgruppe:** Entwickler:innen.
|
||||||
|
> **Zweck:** Anleitung zum Aufsetzen der Entwicklungsumgebung, Verständnis der Modulstruktur und Durchführung von Tests.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 1. Projektstruktur
|
||||||
|
|
||||||
|
Der Code ist modular in `app` (Logik), `scripts` (CLI) und `config` (Steuerung) getrennt.
|
||||||
|
|
||||||
|
mindnet/
|
||||||
|
├── app/
|
||||||
|
│ ├── core/ # Kernlogik
|
||||||
|
│ │ ├── chunker.py # Text-Zerlegung
|
||||||
|
│ │ ├── derive_edges.py # Edge-Erzeugung (WP03 Logik)
|
||||||
|
│ │ ├── retriever.py # Scoring & Graph-Expansion (WP04 Logik)
|
||||||
|
│ │ ├── qdrant.py # DB-Verbindung
|
||||||
|
│ │ └── ...
|
||||||
|
│ ├── models/ # Pydantic DTOs (Request/Response)
|
||||||
|
│ ├── routers/ # FastAPI Endpoints
|
||||||
|
│ ├── services/ # Externe Dienste (LLM, Embeddings)
|
||||||
|
│ └── main.py # Entrypoint der API
|
||||||
|
├── config/ # YAML-Konfigurationen (Single Source of Truth)
|
||||||
|
│ ├── types.yaml # Import-Regeln
|
||||||
|
│ └── retriever.yaml # Scoring-Regeln
|
||||||
|
├── scripts/ # CLI-Tools (Import, Diagnose, Reset)
|
||||||
|
├── tests/ # Pytest Suite
|
||||||
|
└── vault/ # Dein lokaler Markdown-Content (Git-ignored)
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 2. Lokales Setup (Development)
|
||||||
|
|
||||||
|
### 2.1 Voraussetzungen
|
||||||
|
* **Python:** 3.10 oder höher.
|
||||||
|
* **Docker:** Für Qdrant.
|
||||||
|
* **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
|
||||||
|
pip install -r requirements.txt
|
||||||
|
|
||||||
|
### 2.3 Konfiguration (Environment)
|
||||||
|
Erstelle eine `.env` Datei im Root-Verzeichnis oder exportiere die Variablen.
|
||||||
|
|
||||||
|
# Qdrant Verbindung
|
||||||
|
QDRANT_URL="http://localhost:6333"
|
||||||
|
QDRANT_API_KEY="" # Leer lassen für lokal
|
||||||
|
|
||||||
|
# Mindnet Settings
|
||||||
|
COLLECTION_PREFIX="mindnet_dev"
|
||||||
|
MINDNET_TYPES_FILE="./config/types.yaml"
|
||||||
|
MINDNET_RETRIEVER_CONFIG="./config/retriever.yaml"
|
||||||
|
|
||||||
|
# Hash-Strategie (für Importer-Debugging)
|
||||||
|
MINDNET_HASH_COMPARE="Body"
|
||||||
|
MINDNET_HASH_SOURCE="parsed"
|
||||||
|
|
||||||
|
### 2.4 Dienste starten
|
||||||
|
Starten von Qdrant via Docker:
|
||||||
|
docker run -d --name mindnet_qdrant_dev -p 6333:6333 -p 6334:6334 qdrant/qdrant
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 3. Core-Module & Entwicklung
|
||||||
|
|
||||||
|
### 3.1 Der Importer (`scripts.import_markdown`)
|
||||||
|
Dies ist das komplexeste Modul.
|
||||||
|
* **Einstieg:** `scripts/import_markdown.py` -> `main()`.
|
||||||
|
* **Idempotenz:** Der Importer muss mehrfach laufen können, ohne Duplikate zu erzeugen. Wir nutzen deterministische IDs (UUIDv5) basierend auf Dateipfaden/Titeln.
|
||||||
|
* **Debugging:** Wenn du am Importer arbeitest, nutze `--dry-run` oder `scripts/payload_dryrun.py`, um DB-Schreibvorgänge zu vermeiden.
|
||||||
|
|
||||||
|
### 3.2 Edge-Logik (`app.core.derive_edges`)
|
||||||
|
Hier wird entschieden, welche Kanten entstehen.
|
||||||
|
* **Erweiterung:** Wenn du neue Edge-Regeln (z.B. Regex-Parser) hinzufügst, tue dies hier.
|
||||||
|
* **Rule-ID:** Vergib zwingend eine eindeutige `rule_id` (z.B. `custom:my_rule`), damit die Herkunft nachvollziehbar bleibt.
|
||||||
|
|
||||||
|
### 3.3 Der Retriever (`app.core.retriever`)
|
||||||
|
Hier passiert das Scoring und die Graph-Expansion.
|
||||||
|
* **Gewichtung:** Hardcodiere niemals Gewichte (`0.5` etc.) im Code. Nutze `app.core.config.get_retriever_config()`, um `retriever.yaml` zu lesen.
|
||||||
|
* **Graph-Adapter:** Nutze `graph_adapter.expand()`, um Nachbarn zu laden. Vermeide direkte Qdrant-Point-Queries im Retriever-Code, um die Abstraktion zu wahren.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 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, ob `import_markdown` valide JSON-Objekte erzeugt, ohne in die DB zu schreiben. Essentiell bei Schema-Änderungen.
|
||||||
|
python3 -m scripts.payload_dryrun --vault ./mindnet_v2_test_vault
|
||||||
|
|
||||||
|
* **Edge Checks:** Prüft Graph-Invarianten (z.B. `next` muss reziprok zu `prev` sein).
|
||||||
|
python3 -m scripts.edges_full_check
|
||||||
|
|
||||||
|
### 4.3 Smoke Tests (E2E)
|
||||||
|
Prüfen das laufende System (API) gegen eine echte (lokale) Qdrant-Instanz.
|
||||||
|
# 1. API im Hintergrund starten
|
||||||
|
uvicorn app.main:app --port 8000 &
|
||||||
|
|
||||||
|
# 2. Smoke Test feuern
|
||||||
|
python scripts/test_retriever_smoke.py --query "Test" --mode hybrid --top-k 5
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 5. Guidelines für Erweiterungen
|
||||||
|
|
||||||
|
### 5.1 Neuen Note-Typ hinzufügen
|
||||||
|
* **Nicht im Code!** Bearbeite `config/types.yaml`.
|
||||||
|
* Definiere `chunk_profile` und `retriever_weight`.
|
||||||
|
* Führe einen **Re-Import** durch, damit die Änderungen wirksam werden.
|
||||||
|
|
||||||
|
### 5.2 Schema-Änderungen
|
||||||
|
Wenn du Felder in `mindnet_notes` oder `mindnet_chunks` hinzufügst:
|
||||||
|
1. Passe `app/core/note_payload.py` bzw. `chunk_payload.py` an.
|
||||||
|
2. Aktualisiere `tests/assert_payload_schema.py`.
|
||||||
|
3. Führe `scripts/reset_qdrant.py` (Wipe) aus, um die Indizes neu anzulegen.
|
||||||
|
|
||||||
|
### 5.3 Neue API-Endpunkte
|
||||||
|
* Erstelle einen neuen Router in `app/routers/`.
|
||||||
|
* Nutze Pydantic Models aus `app/models/dto.py` für Request/Response.
|
||||||
|
* Registriere den Router in `app/main.py`.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 6. Nützliche Einzeiler
|
||||||
|
|
||||||
|
**DB komplett zurücksetzen (Vorsicht!):**
|
||||||
|
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
|
||||||
|
|
||||||
|
**Warum wird mein File nicht importiert?**
|
||||||
|
python3 -m scripts.diagnose_changed --vault ./vault --all
|
||||||
@@ -1,19 +1,22 @@
|
|||||||
# Mindnet – Fachliche Architektur (Stand: 2025-11-17)
|
# Mindnet v2.2 – Fachliche Architektur
|
||||||
|
**Datei:** `docs/mindnet_functional_architecture_v2.2.md`
|
||||||
|
**Stand:** 2025-12-07
|
||||||
|
**Status:** **FINAL** (Integrierter Stand WP01–WP04a)
|
||||||
|
|
||||||
> Dieses Dokument beschreibt **was** Mindnet fachlich tut und **warum** – mit Fokus auf die Erzeugung und Nutzung von **Edges** (Kanten) zwischen Notizen/Chunks. Die technische Umsetzung (Module, Flags, Schemas) wird nur dort angerissen, wo es zum Verständnis nötig ist und im technischen Dokument detailliert.
|
> Dieses Dokument beschreibt **was** Mindnet fachlich tut und **warum** – mit Fokus auf die Erzeugung und Nutzung von **Edges** (Kanten) zwischen Notizen/Chunks sowie die Logik des Retrievers. Die technische Umsetzung (Module, Flags, Schemas) wird im technischen Dokument detailliert.
|
||||||
|
|
||||||
---
|
---
|
||||||
|
|
||||||
## 0) Zielbild & Grundprinzip
|
## 0) Zielbild & Grundprinzip
|
||||||
|
|
||||||
Mindnet wandelt Obsidian-Markdown-Notizen in einen **Graph aus Punkten und Kanten** um.
|
Mindnet wandelt Obsidian-Markdown-Notizen in einen **dynamischen Graphen aus Punkten und Kanten** um.
|
||||||
Die drei zentralen Artefakt-Sammlungen lauten:
|
Die drei zentralen Artefakt-Sammlungen lauten:
|
||||||
|
|
||||||
- `mindnet_notes` – genau **eine** Note pro Markdown-Datei (Metadaten & Hashes)
|
- `mindnet_notes` – genau **eine** Note pro Markdown-Datei (Metadaten & Hashes)
|
||||||
- `mindnet_chunks` – semantische Teilstücke einer Note (Fenster/„Chunks“)
|
- `mindnet_chunks` – semantische Teilstücke einer Note (Fenster/„Chunks“)
|
||||||
- `mindnet_edges` – gerichtete Beziehungen zwischen Knoten (Chunks/Notes)
|
- `mindnet_edges` – gerichtete Beziehungen zwischen Knoten (Chunks/Notes)
|
||||||
|
|
||||||
Die Import-Pipeline erzeugt diese Artefakte **deterministisch** und **idempotent** (erneute Läufe überschreiben konsistent statt zu duplizieren). Die Import-Schritte sind: *parse → chunk → edge → upsert*. :contentReference[oaicite:0]{index=0}
|
Die Import-Pipeline erzeugt diese Artefakte **deterministisch** und **idempotent** (erneute Läufe überschreiben konsistent statt zu duplizieren). Die Import-Schritte sind: *parse → chunk → edge → upsert*.
|
||||||
|
|
||||||
---
|
---
|
||||||
|
|
||||||
@@ -21,53 +24,64 @@ Die Import-Pipeline erzeugt diese Artefakte **deterministisch** und **idempotent
|
|||||||
|
|
||||||
### 1.1 Notiz (Note)
|
### 1.1 Notiz (Note)
|
||||||
- Repräsentiert eine fachliche Einheit (z. B. *„Vector DB Basics“*, *„KI-Projekt“*).
|
- Repräsentiert eine fachliche Einheit (z. B. *„Vector DB Basics“*, *„KI-Projekt“*).
|
||||||
- Trägt Eigenschaften (Titel, Typ, Zeitstempel, optionale Policies).
|
- Trägt Eigenschaften (Titel, Typ, Zeitstempel, optionale Policies).
|
||||||
- **Typ** (*type*) steuert u. a. Chunk-Profil und Default-Relationen (siehe §4).
|
- **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. :contentReference[oaicite:1]{index=1}
|
- **retriever_weight** und **chunk_profile** werden systematisch an Note **und** Chunks gespiegelt, damit der Retriever beides nutzen kann.
|
||||||
|
|
||||||
### 1.2 Chunk
|
### 1.2 Chunk
|
||||||
- Ausschnitt/Textfenster aus der Note, als eigenständiger Such-Anker.
|
- Ausschnitt/Textfenster aus der Note, als eigenständiger Such-Anker.
|
||||||
- Jeder Chunk gehört **genau einer** Note.
|
- Jeder Chunk gehört **genau einer** Note.
|
||||||
- Chunks bilden eine Sequenz (1…N) – das ermöglicht *next/prev*.
|
- Chunks bilden eine Sequenz (1…N) – das ermöglicht *next/prev*.
|
||||||
|
- **Neu in v2.2:** Alle Kanten entstehen ausschließlich zwischen Chunks (Scope="chunk"), nie zwischen Notes direkt. Notes dienen nur noch als Metadatencontainer.
|
||||||
|
|
||||||
> **Wichtig:** Chunking-Profile (short/medium/long) kommen aus `types.yaml` (per Note-Typ), können aber lokal überschrieben werden. Die effektiven Werte werden bei der Payload-Erzeugung bestimmt. :contentReference[oaicite:2]{index=2}
|
> **Wichtig:** Chunking-Profile (short/medium/long) 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
|
## 2) Edges – fachliche Typen & Bedeutung
|
||||||
|
|
||||||
Edges kodieren Beziehungen. Sie sind **gerichtet** und werden in `mindnet_edges` gespeichert.
|
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
|
### 2.1 Struktur-Kanten (Das Skelett)
|
||||||
- **belongs_to**: *Chunk → Note* (Zuordnung)
|
- **belongs_to**: *Chunk → Note* (Zuordnung)
|
||||||
- **next / prev**: Kettenbeziehungen zwischen aufeinanderfolgenden Chunks derselben Note
|
- **next / prev**: Kettenbeziehungen zwischen aufeinanderfolgenden Chunks derselben Note.
|
||||||
→ ermöglichen „lineares Weiterlesen“ oder Kontextpfade in Antworten.
|
→ ermöglichen „lineares Weiterlesen“ oder Kontextpfade in Antworten.
|
||||||
Diese Kanten entstehen immer, unabhängig von Inhalten. :contentReference[oaicite:3]{index=3}
|
Diese Kanten entstehen immer, unabhängig von Inhalten.
|
||||||
|
|
||||||
### 2.2 Inhalts-Kanten (explizit)
|
### 2.2 Inhalts-Kanten (explizit)
|
||||||
- **references (chunk-scope)**: aus dem Textfenster des Chunks extrahierte Links.
|
Hier unterscheidet v2.2 präzise zwischen verschiedenen Quellen der Evidenz:
|
||||||
Standardquelle: **Wikilinks** `[[…]]` – einschließlich Varianten `[[id#anchor]]`, `[[id|label]]`.
|
|
||||||
→ Mindnet reduziert robust auf die Ziel-ID (Titel/ID-Normalisierung). :contentReference[oaicite:4]{index=4}
|
|
||||||
- **Explizite Inline-Relationen**: im Fließtext notierte Relationen, z. B.:
|
|
||||||
rel: similar_to [[Vector DB Basics]]
|
|
||||||
→ werden als Relation **similar_to** mit hoher Confidence materialisiert; *rule_id* `inline:rel`.
|
|
||||||
(Diese Form ist besonders kompakt in Obsidian editierbar.)
|
|
||||||
- **Callout-Edges** (optional):
|
|
||||||
> [!edge] related_to: [[Vector DB Basics]] [[Embeddings 101]]
|
|
||||||
→ erzeugt mehrere **related_to**-Kanten aus einer Zeile; *rule_id* `callout:edge`.
|
|
||||||
(Für kuratierte, sichtbare Linklisten am Notizende.)
|
|
||||||
|
|
||||||
> Alle expliziten Quellen (Wikilink, Inline-Rel, Callout) sind **gleichwertige Primärbelege** und werden als *provenance=explicit* geführt. Wo zutreffend, tragen Edges *rule_id* wie `explicit:wikilink`, `inline:rel`, `callout:edge`. :contentReference[oaicite:5]{index=5}
|
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.3 Typ-basierte Default-Kanten (regelbasiert)
|
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.:
|
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"]`
|
- `concept`: `["references","related_to"]`
|
||||||
- `project`: `["references","depends_on"]`
|
- `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.
|
Regel: **Für jede gefundene explizite Referenz** (s. o.) werden **zusätzliche** Edges nach diesen Defaults erzeugt.
|
||||||
Diese Kanten tragen *provenance=rule* und eine **rule_id** der Form
|
Beispiel: Ein *project* mit `edge_defaults=["depends_on"]` erzeugt zu *jedem* explizit referenzierten Ziel **zusätzlich** eine `depends_on`-Kante.
|
||||||
`edge_defaults:{note_type}:{relation}` (z. B. `edge_defaults:project:depends_on`). :contentReference[oaicite:6]{index=6}
|
Diese Kanten tragen *provenance=rule* und eine **rule_id** der Form `edge_defaults:{note_type}:{relation}` sowie eine geringere Confidence (~0.7).
|
||||||
|
|
||||||
---
|
---
|
||||||
|
|
||||||
@@ -75,31 +89,29 @@ Diese Kanten tragen *provenance=rule* und eine **rule_id** der Form
|
|||||||
|
|
||||||
Jede Kante hat mindestens:
|
Jede Kante hat mindestens:
|
||||||
|
|
||||||
- `kind` – Beziehungsart *(belongs_to, next, prev, references, related_to, depends_on, similar_to, …)*
|
- `kind` – Beziehungsart *(belongs_to, next, prev, references, related_to, depends_on, similar_to, …)*
|
||||||
- `scope` – `"chunk"` (Standard) oder `"note"` (optional für Backlinks/Note-Scope)
|
- `scope` – `"chunk"` (Standard in v2.2)
|
||||||
- `source_id`, `target_id` – Quell-/Ziel-Knoten (Chunk- oder Note-ID)
|
- `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; dient der schnellen Löschung/Filterung)
|
- `note_id` – **Owner-Note** (die Note, aus der die Kante stammt)
|
||||||
|
|
||||||
Erweiterte/abgeleitete Felder (V2-Superset):
|
Erweiterte/abgeleitete Felder (WP03 Superset):
|
||||||
|
|
||||||
- `provenance` – `"explicit"` (Wikilink/Inline/Callout) oder `"rule"` (Typ-Defaults)
|
- `provenance` – `"explicit"` (Wikilink/Inline/Callout) oder `"rule"` (Typ-Defaults)
|
||||||
- `rule_id` – maschinenlesbare Regelquelle, z. B.
|
- `rule_id` – maschinenlesbare Regelquelle (z.B. `inline:rel`, `edge_defaults:project:depends_on`)
|
||||||
- `explicit:wikilink`, `inline:rel`, `callout:edge`
|
- `confidence` – 0.0–1.0; Heuristik zur Gewichtung im Scoring.
|
||||||
- `edge_defaults:{note_type}:{relation}`
|
|
||||||
- `confidence` – 0.0–1.0; Heuristik, z. B. `1.0` für Wikilinks/Backlinks, `0.95` für `inline:rel`, `0.7` für Typ-Defaults.
|
|
||||||
|
|
||||||
**Dedup-Schlüssel** (fachlich): Gleichlautende `(source_id, target_id, kind, scope, rule_id)` werden nicht mehrfach geschrieben. :contentReference[oaicite:7]{index=7}
|
**Dedup-Schlüssel** (fachlich): Gleichlautende `(source_id, target_id, kind, scope, rule_id)` werden nicht mehrfach geschrieben.
|
||||||
|
|
||||||
---
|
---
|
||||||
|
|
||||||
## 4) Typ-Registry (`config/types.yaml`)
|
## 4) Typ-Registry (`config/types.yaml`)
|
||||||
|
|
||||||
### 4.1 Zweck
|
### 4.1 Zweck
|
||||||
- Steuert **Chunking-Profile** (`short|medium|long`) **pro Typ**
|
- Steuert **Chunking-Profile** (`short|medium|long`) **pro Typ**
|
||||||
- Liefert **retriever_weight** (Note-/Chunk-Gewichtung im Ranking) **pro Typ**
|
- Liefert **retriever_weight** (Note-/Chunk-Gewichtung im Ranking) **pro Typ**
|
||||||
- Definiert **edge_defaults** je Typ (s. o.)
|
- Definiert **edge_defaults** je Typ (s. o.)
|
||||||
|
|
||||||
Der Importer lädt die Registry aus `MINDNET_TYPES_FILE` oder nutzt Fallbacks. **Frontmatter-Overrides** (z. B. `retriever_weight`) werden respektiert; am Ende schreibt der Importer die **effektiven** Werte zuverlässig in Note- und Chunk-Payload. :contentReference[oaicite:8]{index=8}
|
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)
|
### 4.2 Beispiel (auslieferungsnah)
|
||||||
version: 1.0
|
version: 1.0
|
||||||
@@ -107,185 +119,117 @@ Der Importer lädt die Registry aus `MINDNET_TYPES_FILE` oder nutzt Fallbacks. *
|
|||||||
concept:
|
concept:
|
||||||
chunk_profile: medium
|
chunk_profile: medium
|
||||||
edge_defaults: ["references", "related_to"]
|
edge_defaults: ["references", "related_to"]
|
||||||
retriever_weight: 0.35
|
retriever_weight: 0.60
|
||||||
project:
|
project:
|
||||||
chunk_profile: long
|
chunk_profile: long
|
||||||
edge_defaults: ["references", "depends_on"]
|
edge_defaults: ["references", "depends_on"]
|
||||||
retriever_weight: 0.97
|
retriever_weight: 0.97
|
||||||
profile:
|
|
||||||
chunk_profile: long
|
|
||||||
edge_defaults: ["references", "depends_on"]
|
|
||||||
retriever_weight: 0.66
|
|
||||||
|
|
||||||
**Auflösung im Importer**
|
**Auflösung im Importer**
|
||||||
- `effective_chunk_profile(note_type, registry)` → `"short|medium|long"|None`
|
- `effective_chunk_profile(note_type, registry)` → `"short|medium|long"|None`
|
||||||
- `effective_retriever_weight(note_type, registry)` → `float|None`
|
- `effective_retriever_weight(note_type, registry)` → `float|None`
|
||||||
- Ergebnis wird in `note_payload` **und** `chunk_payloads` gespiegelt. :contentReference[oaicite:9]{index=9}
|
- Ergebnis wird in `note_payload` **und** `chunk_payloads` gespiegelt.
|
||||||
|
|
||||||
---
|
---
|
||||||
|
|
||||||
## 5) Wie entstehen Edges aus Markdown?
|
## 5) Der Retriever (Funktionaler Layer)
|
||||||
|
|
||||||
### 5.1 Quelle „Wikilinks“ (Primärfall)
|
Der Retriever ist in v2.2 der zentrale Zugangspunkt zum Wissen. Er realisiert die **Hybride Suche**.
|
||||||
- Parser extrahiert alle `[[…]]` (Label/Anker werden auf die Ziel-ID reduziert).
|
|
||||||
- Pro Fund entsteht **eine** `references`-Kante (Chunk-Scope).
|
|
||||||
- Zusätzlich: Typ-Defaults (z. B. `depends_on`, `related_to`) pro Ziel. :contentReference[oaicite:10]{index=10}
|
|
||||||
|
|
||||||
### 5.2 Quelle „Inline-Relation“ (Optional, kompakt)
|
### 5.1 Scoring-Modell
|
||||||
- Im Fließtext markierte Relation, z. B.:
|
Die Relevanz eines Treffers ergibt sich nicht mehr nur aus Textähnlichkeit, sondern aus einer gewichteten Formel:
|
||||||
rel: similar_to [[Vector DB Basics]]
|
|
||||||
- Erzeugt `similar_to`-Kanten; *rule_id* `inline:rel`; `confidence≈0.95`.
|
|
||||||
- Geeignet für sparsame, gut lesbare Referenzierung. (Erfassung in der Chunk-Window-Analyse.) :contentReference[oaicite:11]{index=11}
|
|
||||||
|
|
||||||
### 5.3 Quelle „Callout-Edges“ (Optional, kuratiert)
|
total_score =
|
||||||
- Klar sichtbare, redaktionell gepflegte Liste am Ende einer Note:
|
semantic_weight * semantic_score
|
||||||
> [!edge] related_to: [[Vector DB Basics]] [[Embeddings 101]]
|
+ edge_weight * edge_bonus
|
||||||
- Erzeugt je Ziel eine `related_to`-Kante; *rule_id* `callout:edge`.
|
+ centrality_weight * centrality_bonus
|
||||||
- Eignet sich für „Leselisten“ und „Siehe auch“. (Zählung als *callout_total* in Reports, wo vorhanden.) :contentReference[oaicite:12]{index=12}
|
+ type_weight * retriever_weight
|
||||||
|
|
||||||
### 5.4 Struktur-Kanten
|
* **semantic_score:** Vektorähnlichkeit (Qdrant).
|
||||||
- `belongs_to` pro Chunk
|
* **retriever_weight:** Wichtigkeit des Typs (z.B. Projekte > Quellen).
|
||||||
- `next/prev` aus Nachbarbezug (aus Chunk-Sequenz/Neighbors) :contentReference[oaicite:13]{index=13}
|
* **edge_bonus:** Belohnung für Chunks, die im Kontext der Anfrage stark vernetzt sind (unter Berücksichtigung der *confidence*).
|
||||||
|
* **centrality_bonus:** Belohnung für Knoten, die zentrale Hubs im lokalen Graphen darstellen.
|
||||||
|
|
||||||
> **Hinweis zu Note-Scope:** Optional können zusätzlich Note-weite *references/backlinks* aus der Gesamtheit aller Chunk-Funde abgeleitet werden (Konfig-Flag/ENV). Das ist für globale Graph-Analysen nützlich, aber im Retrieval seltener erforderlich. :contentReference[oaicite:14]{index=14}
|
### 5.2 Erklärbarkeit (Explainability)
|
||||||
|
Der Retriever liefert **Begründungspfade**. Er gibt nicht nur Text zurück, sondern:
|
||||||
|
* `score_breakdown`: Warum ist dieser Chunk oben? (War es der Text oder der Graph?)
|
||||||
|
* `paths`: Über welche Kanten wurde dieser Chunk gefunden? (z.B. "Gefunden via `depends_on` von deiner aktuellen Projekt-Notiz").
|
||||||
|
|
||||||
---
|
---
|
||||||
|
|
||||||
## 6) Confidence & Provenance – wozu?
|
## 6) Confidence & Provenance – wozu?
|
||||||
|
|
||||||
Der Retriever kann Edges gewichten:
|
Der Retriever kann Edges gewichten:
|
||||||
- **provenance**: *explicit* > *rule*
|
- **provenance**: *explicit* > *rule*
|
||||||
- **confidence**: numerische Feinsteuerung (z. B. Inline-Relation etwas höher, Defaults etwas niedriger)
|
- **confidence**: numerische Feinsteuerung
|
||||||
- **retriever_weight (Note/Chunk)**: skaliert die Relevanz des gesamten Knotens
|
- **retriever_weight (Note/Chunk)**: skaliert die Relevanz des gesamten Knotens
|
||||||
|
|
||||||
Eine typische Gewichtung (konfigurierbar) ist:
|
Eine typische Gewichtung (konfigurierbar in `retriever.yaml`) ist:
|
||||||
explicit: 1.0, rule: 0.8, default_resolved: 0.6, default: 0.2
|
`explicit: 1.0`, `rule: 0.8`. Damit bevorzugt der Graph **kuratiertes Wissen** (explizit notierte Links) vor „erweiterten“ Default-Ableitungen.
|
||||||
Damit bevorzugt der Graph **kuratiertes Wissen** (explizit notierte Links) vor „erweiterten“ Default-Ableitungen. :contentReference[oaicite:15]{index=15}
|
|
||||||
|
|
||||||
---
|
---
|
||||||
|
|
||||||
## 7) Semantik ausgewählter `kind`-Werte
|
## 7) Semantik ausgewählter `kind`-Werte
|
||||||
|
|
||||||
- `references` – „Nutzt/erwähnt“; neutral, aber stützend für Kontext.
|
- `references` – „Nutzt/erwähnt“; neutral, aber stützend für Kontext.
|
||||||
- `related_to` – Ähnlichkeit/Verwandtschaft (symmetrisch interpretierbar).
|
- `related_to` – Ähnlichkeit/Verwandtschaft (symmetrisch interpretierbar).
|
||||||
- `similar_to` – noch engere Ähnlichkeit; oft aus Inline-Rel (bewusst gesetzt).
|
- `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“).
|
- `depends_on` – fachliche Abhängigkeit (z. B. „Projekt X hängt von Y ab“).
|
||||||
- `belongs_to`, `next`, `prev` – Struktur.
|
- `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 (z. B. Query-Zeit-Expansion), um Redundanz im Vault zu vermeiden. :contentReference[oaicite:16]{index=16}
|
> Symmetrische Relationen (z. B. `related_to`, `similar_to`) können **explizit** nur einseitig notiert sein, aber im Retriever beidseitig interpretiert werden.
|
||||||
|
|
||||||
---
|
---
|
||||||
|
|
||||||
## 8) Frontmatter-Eigenschaften – Rolle & Empfehlung
|
## 8) Frontmatter-Eigenschaften – Rolle & Empfehlung
|
||||||
|
|
||||||
Frontmatter-Eigenschaften (Properties) bleiben **minimiert**:
|
Frontmatter-Eigenschaften (Properties) bleiben **minimiert**:
|
||||||
- **type** – steuert Typ-Defaults via Registry (Pflicht für differenziertes Verhalten).
|
- **type** – steuert Typ-Defaults via Registry (Pflicht für differenziertes Verhalten).
|
||||||
- **retriever_weight** *(optional)* – kann typbasierte Defaults überschreiben.
|
- **tags** – für klassische Filterung.
|
||||||
- **chunk_profile** *(optional)* – kann typbasierte Defaults überschreiben.
|
- **retriever_weight / chunk_profile** – Sollten **nicht** manuell gesetzt werden (Best Practice: `types.yaml` nutzen).
|
||||||
- **links** *(optional, Bestandskompatibilität)* – wenn vorhanden (z. B. `depends_on: …`), können sie als explizite Kanten materialisiert werden; die Pflege in freiem Text (Inline/Callout) ist jedoch **benutzerfreundlicher** und weniger fehleranfällig.
|
- **links** – Veraltet. Bitte Links primär über Text (Wikilink/Inline/Callout) pflegen.
|
||||||
|
|
||||||
Empfehlung: **Links primär über Text (Wikilink/Inline/Callout) pflegen**, nicht als Properties. Die Registry regelt Standards; Properties dienen nur gezielten Ausnahmen. :contentReference[oaicite:17]{index=17}
|
|
||||||
|
|
||||||
---
|
---
|
||||||
|
|
||||||
## 9) Lösch-/Update-Garantien (Idempotenz)
|
## 9) Lösch-/Update-Garantien (Idempotenz)
|
||||||
|
|
||||||
- Jede Note hat einen stabilen **note_id** (Frontmatter/Hash).
|
- 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.
|
- 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.
|
||||||
- Es gibt Abkürzungen für „fehlertolerante Rebuilds“: *Existenz-Checks* statt Full-Scan. :contentReference[oaicite:18]{index=18}
|
- Die Import-Skripte unterstützen Modi wie `--purge-before-upsert` und `--sync-deletes`, um den Graph sauber zu halten.
|
||||||
|
|
||||||
---
|
---
|
||||||
|
|
||||||
## 10) Beispiel – Von Markdown zu Kanten
|
## 10) Beispiel – Von Markdown zu Kanten (v2.2)
|
||||||
|
|
||||||
**Markdown (Auszug)**
|
**Markdown (Auszug)**
|
||||||
# Relations Showcase
|
# Relations Showcase
|
||||||
…
|
…
|
||||||
rel: similar_to [[Vector DB Basics]]
|
Wir nutzen [[rel:depends_on Qdrant Vektordatenbank]] für die Suche.
|
||||||
…
|
…
|
||||||
[[Embeddings 101]]
|
Siehe auch: [[Embeddings 101]]
|
||||||
|
|
||||||
> [!edge] related_to: [[Vector DB Basics]] [[Embeddings 101]]
|
> [!edge] related_to: [[Vector DB Basics]]
|
||||||
|
|
||||||
**Ergebnis (fachlich)**
|
**Ergebnis (fachlich)**
|
||||||
- `references(Chunk→Vector DB Basics)` + `references(Chunk→Embeddings 101)`
|
1. `depends_on(Chunk→Qdrant)` mit `rule_id=inline:rel`, `confidence≈0.95`.
|
||||||
- `similar_to(Chunk→Vector DB Basics)` mit `rule_id=inline:rel`, `confidence≈0.95`
|
2. `references(Chunk→Embeddings 101)` mit `rule_id=explicit:wikilink`, `confidence=1.0`.
|
||||||
- `related_to(Chunk→Vector DB Basics)` und `related_to(Chunk→Embeddings 101)`
|
3. `related_to(Chunk→Vector DB Basics)` via Callout; `rule_id=callout:edge`, `confidence≈0.90`.
|
||||||
via Callout; `rule_id=callout:edge`
|
4. **Typ-Defaults:** Falls die Note vom Typ `project` ist, entstehen zusätzlich `depends_on`-Kanten zu den Zielen aus (2) und (3).
|
||||||
- Zusätzliche **Typ-Defaults** je Quell-Typ, z. B. `edge_defaults:concept:related_to` → weitere `related_to`-Kanten
|
|
||||||
|
|
||||||
*Strukturkanten* (`belongs_to`, `next/prev`) fallen wie üblich an. (Die tatsächlichen Zähllogiken erscheinen im Import-Report/Smoke-Tests.) :contentReference[oaicite:19]{index=19}
|
|
||||||
|
|
||||||
---
|
---
|
||||||
|
|
||||||
## 11) Abfrage-Implikationen (fachlich)
|
## 11) Qualitäts- und Testkriterien (fachlich)
|
||||||
|
|
||||||
Retriever und Query-Layer berücksichtigen:
|
- **Keine Duplikate** gleicher `(src, relation, dst)` in der Collectionsicht (Dedup).
|
||||||
1) **Knoten-Gewicht** (`retriever_weight`) aus Typ/Property (Note & Chunk).
|
- **Explizite Links** werden vollständig materialisiert (*explicit_total*).
|
||||||
2) **Edge-Provenance/Confidence** – explizit > regelbasiert; höhere Confidence bevorzugt.
|
- **Typ-Defaults** ergänzen, aber überdecken nicht.
|
||||||
3) **Edge-Topologie** – z. B. 1-Hop-Nachbarschaft, Sequenzpfade (`next/prev`), Backlinks (optional).
|
- **Retriever Smoke-Test:** Ein Query muss plausible Scores liefern, die den Einfluss von `edge_bonus` zeigen.
|
||||||
4) **Policy-Filter** – Privacy, Tags, Created usw. via Payload-Indizes.
|
|
||||||
|
|
||||||
Die Abfrage kann so z. B. Ergebnisse bevorzugen, die **explizit** in einem *Projekt* als `depends_on` genannt sind – und nur nachrangig solche, die „typbedingt“ (`edge_defaults`) ähnlich/abhängig sind. :contentReference[oaicite:20]{index=20}
|
|
||||||
|
|
||||||
---
|
---
|
||||||
|
|
||||||
## 12) Qualitäts- und Testkriterien (fachlich)
|
## 12) Referenzen (Projektdateien & Leitlinien)
|
||||||
|
|
||||||
- **Keine Duplikate** gleicher `(src, relation, dst)` in der Collectionsicht (Dedup).
|
- Import-Pipeline & Registry-Auflösung: `scripts/import_markdown.py`.
|
||||||
- **Explizite Links** werden vollständig materialisiert (*explicit_total*).
|
- Kantenbildung (V2-Logic): `app/core/derive_edges.py`.
|
||||||
- **Typ-Defaults** ergänzen, aber überdecken nicht – Counts bleiben plausibel (*defaults_total*).
|
- Typ-Registry: `config/types.yaml` & `TYPE_REGISTRY_MANUAL.md`.
|
||||||
- **Inline/Callout** werden separat quantifiziert (*inline_total*, *callout_total*), damit Redaktionen ihre Pflegewirkung beobachten können. :contentReference[oaicite:21]{index=21}
|
- Retriever-Scoring: `app/core/retriever.py` & `wp04_retriever_scoring.md`.
|
||||||
|
|
||||||
---
|
|
||||||
|
|
||||||
## 13) Praxisempfehlungen für den Vault
|
|
||||||
|
|
||||||
1) **Wikilinks** überall, wo eine inhaltliche Nennung stattfindet.
|
|
||||||
2) Für **gezielte Relationen** (Ähnlichkeit/Abhängigkeit) kurze **Inline-Rel**-Zeilen; z. B.:
|
|
||||||
rel: similar_to [[X]]
|
|
||||||
rel: related_to [[Y]] [[Z]]
|
|
||||||
3) Am Notizende **Callout-Edges** für kuratierte Überblicksblöcke:
|
|
||||||
> [!edge] related_to: [[X]] [[Y]]
|
|
||||||
4) **Properties** schlank halten: mindestens `type`, optional `retriever_weight`/`chunk_profile`.
|
|
||||||
5) **types.yaml** pflegen (zentrale Governance): *Welche Typen gibt es? Welche Default-Relationen sind fachlich sinnvoll?*
|
|
||||||
6) **Regelmäßige Smoke-Tests/Reports** prüfen die Kanten-Counts und Provenance-Verteilung. :contentReference[oaicite:22]{index=22}
|
|
||||||
|
|
||||||
---
|
|
||||||
|
|
||||||
## 14) Referenzen (Projektdateien & Leitlinien)
|
|
||||||
|
|
||||||
- Import-Pipeline & Registry-Auflösung (Importer, Flags, Idempotenz): `scripts/import_markdown.py`. :contentReference[oaicite:23]{index=23}
|
|
||||||
- Robuste Kantenbildung (Wikilinks, Struktur, optionale Note-Scope): `app/core/derive_edges.py` (v1.4+). :contentReference[oaicite:24]{index=24}
|
|
||||||
- V2-Edge-Superset (Provenance, rule_id, Confidence, Typ-Defaults): `app/core/edges.py` (v2.0+). :contentReference[oaicite:25]{index=25}
|
|
||||||
- Typ-Registry laden/auflösen (Fallbacks, Effektivwerte): Import-Helper / *Type-Registry*-Hilfsfunktionen. :contentReference[oaicite:26]{index=26}
|
|
||||||
- Test-/Playbook-Leitplanken (Policies, KPIs, Roadmap): *Implementation Playbook*. :contentReference[oaicite:27]{index=27}
|
|
||||||
|
|
||||||
---
|
|
||||||
|
|
||||||
## 15) Anhang – Mini-Beispiel einer Projekt-Note (verkürzt)
|
|
||||||
|
|
||||||
---
|
|
||||||
id: 20251110-ki-trainerassistent-projekt-56d2aa
|
|
||||||
title: KI Trainerassistent (Projekt)
|
|
||||||
type: project
|
|
||||||
retriever_weight: 1.0 # optional Override
|
|
||||||
chunk_profile: default # optional Override
|
|
||||||
---
|
|
||||||
|
|
||||||
# KI Trainerassistent (Projekt)
|
|
||||||
|
|
||||||
Wir nutzen [[Qdrant Vektordatenbank]] und [[Ollama LLM]] …
|
|
||||||
|
|
||||||
rel: depends_on [[Qdrant Vektordatenbank]]
|
|
||||||
rel: related_to [[Ollama LLM]]
|
|
||||||
|
|
||||||
> [!edge] depends_on: [[Qdrant Vektordatenbank]]
|
|
||||||
> [!edge] related_to: [[Ollama LLM]]
|
|
||||||
|
|
||||||
*Erwartung*:
|
|
||||||
- `references` (Wikilinks) auf **beide** Ziele
|
|
||||||
- `depends_on` & `related_to` via **Inline** und **Callout** (provenance=`explicit`, rule_id `inline:rel`/`callout:edge`)
|
|
||||||
- Zusätzlich **Typ-Defaults** aus `types.yaml` für `project` (z. B. weitere `depends_on`) – provenance=`rule`, `rule_id=edge_defaults:project:depends_on`. :contentReference[oaicite:28]{index=28}
|
|
||||||
|
|
||||||
---
|
|
||||||
@@ -1,699 +1,215 @@
|
|||||||
# Mindnet – Technische Architektur (V2, Stand: 2025-11-xx)
|
# Mindnet v2.2 – Technische Architektur
|
||||||
|
**Datei:** `docs/mindnet_technical_architecture_v2.2.md`
|
||||||
|
**Stand:** 2025-12-07
|
||||||
|
**Status:** **FINAL** (Integrierter Stand WP01–WP04a)
|
||||||
|
**Quellen:** `mindnet_technical_architecture.md`, `chunking_strategy.md`, `Handbuch.md`, `wp04_retriever_scoring.md`, `Überarbeitungshinweise_WP03.md`, `Überarbeitungshinweise_WP04.md`.
|
||||||
|
|
||||||
> **Ziel dieses Dokuments:**
|
> **Ziel dieses Dokuments:**
|
||||||
> Vollständige, konsolidierte Beschreibung der aktuellen technischen Architektur von **Mindnet V2** – insbesondere der Verarbeitung von Markdown-Notizen, des Chunkings, der Kantenableitung (Edges) inkl. `rule_id` / `confidence` und der Speicherung in Qdrant.
|
> Vollständige, konsolidierte Beschreibung der aktuellen technischen Architektur von **Mindnet v2.2**. Es definiert die Datenstrukturen in Qdrant, die Verarbeitungspipelines (Importer, Chunker, Edges) und die Retrieval-Logik. Es bildet den **aktuellen Implementierungsstand** ab.
|
||||||
> Das Dokument bildet den **aktuellen Implementierungsstand** ab, nicht mehr gültige Annahmen sind bereinigt, neue Konzepte (Typ-Defaults, Inline-Relationen, Edges-Schema) sind integriert.
|
|
||||||
|
|
||||||
---
|
---
|
||||||
|
|
||||||
## 1. Systemüberblick
|
## 1. Systemüberblick
|
||||||
|
|
||||||
### 1.1 Zielbild
|
### 1.1 Architektur-Zielbild
|
||||||
|
|
||||||
Mindnet ist ein **persönliches Wissensnetz**. Technisch bedeutet das:
|
Mindnet ist ein **persönliches Wissensnetz**. Technisch bedeutet das:
|
||||||
|
1. **Source:** Markdown-Notizen in einem Vault (Obsidian-kompatibel).
|
||||||
|
2. **Pipeline:** Ein Python-Importer transformiert diese in **Notes**, **Chunks** und **Edges**.
|
||||||
|
3. **Storage:** Speicherung in **Qdrant** (Vektor-Datenbank) in drei getrennten Collections.
|
||||||
|
4. **Service:** Eine FastAPI-Anwendung stellt Endpunkte für **Semantische** und **Hybride Suche** bereit.
|
||||||
|
|
||||||
- Markdown-Notizen in einem Vault (Obsidian-kompatibel) werden
|
Das System arbeitet **deterministisch** (stabile IDs) und ist **konfigurationsgetrieben** (`types.yaml`, `retriever.yaml`).
|
||||||
- geparst (Frontmatter + Body),
|
|
||||||
- in **Notes**, **Chunks** und **Edges** überführt,
|
|
||||||
- in **Qdrant** als drei Collections abgelegt:
|
|
||||||
- `<prefix>_notes`
|
|
||||||
- `<prefix>_chunks`
|
|
||||||
- `<prefix>_edges`.
|
|
||||||
|
|
||||||
- Das System ist so konzipiert, dass es:
|
### 1.2 Verzeichnisstruktur & Komponenten
|
||||||
- **deterministisch** arbeitet (IDs, Chunks, Kanten),
|
Die Codebasis ist modular aufgebaut.
|
||||||
- über `types.yaml` **konfigurierbar** ist,
|
|
||||||
- später von einem LLM-basieren Agenten als **Graph-Retriever** genutzt werden kann.
|
/mindnet/
|
||||||
|
├── app/
|
||||||
|
│ ├── main.py # FastAPI Einstiegspunkt
|
||||||
|
│ ├── core/
|
||||||
|
│ │ ├── 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 # Text-Zerlegung (Profiling)
|
||||||
|
│ │ ├── edges.py # Edge-Datenstrukturen
|
||||||
|
│ │ ├── derive_edges.py # Logik der Kantenableitung (WP03)
|
||||||
|
│ │ └── retriever.py # Scoring & Graph-Expansion (WP04)
|
||||||
|
│ ├── models/ # Pydantic DTOs (QueryRequest, etc.)
|
||||||
|
│ └── routers/ # API Routen
|
||||||
|
├── config/
|
||||||
|
│ ├── types.yaml # Typ-Definitionen (Import-Zeit)
|
||||||
|
│ └── retriever.yaml # Scoring-Gewichte (Laufzeit)
|
||||||
|
├── scripts/
|
||||||
|
│ ├── import_markdown.py # Haupt-Importer CLI
|
||||||
|
│ ├── payload_dryrun.py # Diagnose: JSON-Generierung ohne DB
|
||||||
|
│ └── edges_full_check.py # Diagnose: Graph-Integrität
|
||||||
|
└── tests/ # Pytest Suite
|
||||||
|
|
||||||
---
|
---
|
||||||
|
|
||||||
### 1.2 Verzeichnisstruktur (Server)
|
## 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.
|
||||||
|
* **Schema (Payload):**
|
||||||
|
|
||||||
|
| Feld | Datentyp | Beschreibung |
|
||||||
|
| :--- | :--- | :--- |
|
||||||
|
| `chunk_id` | Keyword | Deterministisch: `{note_id}#c{index:02d}`. |
|
||||||
|
| `note_id` | Keyword | Referenz zur Note. |
|
||||||
|
| `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 |
|
||||||
|
|
||||||
/home/llmadmin/mindnet/:
|
|
||||||
|
|
||||||
- **/app**
|
|
||||||
- `main.py` – FastAPI-App / Einstieg
|
|
||||||
- **/app/core**
|
|
||||||
- `qdrant.py` – QdrantConfig, Client-Factory, Collection-Management
|
|
||||||
- `qdrant_points.py` – Upserts / Deletes / Queries auf Punktebene
|
|
||||||
- `note_payload.py` – Bau von Note-Payloads
|
|
||||||
- `chunk_payload.py` – Bau von Chunk-Payloads
|
|
||||||
- `chunker.py` – Chunking-Logik
|
|
||||||
- `edges.py` – Datenstruktur & Hilfsfunktionen für Edges
|
|
||||||
- `derive_edges.py` – Ableitung von Edges aus Text und Typen
|
|
||||||
- **/app/models**
|
|
||||||
- `dto.py` – DTOs für API / Services
|
|
||||||
- **/app/routers**
|
|
||||||
- `qdrant_router.py` – API-Layer Richtung Qdrant
|
|
||||||
- **/app/services**
|
|
||||||
- `llm_ollama.py` – Anbindung an Ollama-LLM
|
|
||||||
- `embeddings_client.py` – Embedding-Service (z. B. Ollama / lokaler Dienst)
|
|
||||||
- **/config**
|
|
||||||
- `types.yaml` – Typdefinitionen inkl. Chunk-Profilen und Edge-Defaults
|
|
||||||
- **/scripts**
|
|
||||||
- `import_markdown.py` – Hauptimporter für Vault
|
|
||||||
- `reset_qdrant.py` – Collections löschen/neu anlegen (inkl. Indizes)
|
|
||||||
- `setup_mindnet_collections.py` – Collection-Setup (historisch / Hilfsskript)
|
|
||||||
- diverse Diagnose- und Testskripte, z. B.
|
|
||||||
- `payload_dryrun.py`
|
|
||||||
- `edges_full_check.py`
|
|
||||||
- **/tests**
|
|
||||||
- `test_edges_smoke.py` – einfache Edge-Smoke-Tests
|
|
||||||
- `test_edges_all.py` – umfassendere Checks (Counts, Plausibilität)
|
|
||||||
- `ensure_indexes_and_show.py`, `assert_payload_schema.py` – Schema/Index-Checks
|
|
||||||
- **/vault**
|
|
||||||
- produktives Vault (Obsidian)
|
|
||||||
- **/mindnet_v2_test_vault**
|
|
||||||
- Test-Vault für V2-Funktionen (Chunking, Edges, Typ-Defaults)
|
|
||||||
|
|
||||||
---
|
---
|
||||||
|
|
||||||
## 2. Datenmodell & Collections
|
## 3. Konfiguration
|
||||||
|
|
||||||
### 2.1 Note, Chunk, Edge – Begriffe
|
Die Logik ist ausgelagert in YAML-Dateien.
|
||||||
|
|
||||||
- **Note**
|
|
||||||
Entspricht einer Markdown-Datei mit YAML-Frontmatter (`id`, `title`, `type`, …).
|
|
||||||
In Qdrant als ein Punkt in `<prefix>_notes`.
|
|
||||||
|
|
||||||
- **Chunk**
|
|
||||||
Ein Abschnitt einer Note (z. B. Absatz, Überschrifts-Block, Sliding Window).
|
|
||||||
In Qdrant als Punkt in `<prefix>_chunks`.
|
|
||||||
|
|
||||||
- **Edge**
|
|
||||||
Eine gerichtete Kante, die eine Beziehung zwischen:
|
|
||||||
- zwei Chunks,
|
|
||||||
- Chunk ↔ Note,
|
|
||||||
- oder (konzeptionell) Note ↔ Note beschreibt.
|
|
||||||
Gespeichert in `<prefix>_edges`.
|
|
||||||
|
|
||||||
---
|
|
||||||
|
|
||||||
### 2.2 Qdrant Collections (Stand V2)
|
|
||||||
|
|
||||||
**Namenskonvention:**
|
|
||||||
Prefix aus ENV (`COLLECTION_PREFIX`, z. B. `mindnet`):
|
|
||||||
|
|
||||||
- `mindnet_notes`
|
|
||||||
- `mindnet_chunks`
|
|
||||||
- `mindnet_edges`
|
|
||||||
|
|
||||||
Die Collections werden über:
|
|
||||||
|
|
||||||
```bash
|
|
||||||
python3 -m scripts.reset_qdrant --mode wipe --prefix "$COLLECTION_PREFIX"
|
|
||||||
```
|
|
||||||
|
|
||||||
**vollständig neu angelegt**, inkl. Payload-Indizes (Details in 6.1).
|
|
||||||
|
|
||||||
---
|
|
||||||
|
|
||||||
### 2.3 Notes – Payload & Felder
|
|
||||||
|
|
||||||
Minimale, indexierte Felder (Auszug, Schema laut `diag_payload_indexes`):
|
|
||||||
|
|
||||||
- `note_id` (keyword) – stabile Note-ID (Frontmatter `id`)
|
|
||||||
- `title` (text) – Notiz-Titel
|
|
||||||
- `type` (keyword) – logischer Typ (z. B. `concept`, `project`, `profile`, `journal`, `source`)
|
|
||||||
- `tags` (keyword[]) – Tags aus Frontmatter
|
|
||||||
- `updated` (integer) – Zeitstempel (z. B. `YYYYMMDDHHMMSS` oder epoch; Implementierungsdetail)
|
|
||||||
|
|
||||||
Weitere Felder (nicht alle indexiert, aber im Payload vorhanden):
|
|
||||||
|
|
||||||
- `retriever_weight` (float) – wie stark diese Note/Chunks im Retrieval gewichtet werden
|
|
||||||
- `chunk_profile` (string) – Name des verwendeten Chunk-Profils
|
|
||||||
- `edge_defaults` (string[]) – Liste von Default-Relationen pro Typ (z. B. `["references","related_to"]`)
|
|
||||||
- `confidentiality`, `visibility`, weitere Metadaten aus Frontmatter
|
|
||||||
|
|
||||||
Diese Felder werden in `app/core/note_payload.py` aus Frontmatter + `types.yaml` konstruiert.
|
|
||||||
|
|
||||||
---
|
|
||||||
|
|
||||||
### 2.4 Chunks – Payload & Felder
|
|
||||||
|
|
||||||
Indexierte Kernfelder:
|
|
||||||
|
|
||||||
- `note_id` (keyword) – Referenz auf die übergeordnete Note
|
|
||||||
- `chunk_id` (keyword) – deterministische Chunk-ID:
|
|
||||||
`"{note_id}#c{index:02d}"` (z. B. `20251110-ollama-llm-9f0a12#c02`)
|
|
||||||
- `index` (integer) – 0-basiert; Position in der Note
|
|
||||||
- `type` (keyword) – Note-Typ (vom Note geerbt)
|
|
||||||
- `tags` (keyword[]) – Tags (vom Note geerbt)
|
|
||||||
|
|
||||||
Weitere wichtige Payload-Felder:
|
|
||||||
|
|
||||||
- `ord` (integer) – 1-basiertes Pendant zu `index` (für menschliche Lesbarkeit)
|
|
||||||
- `text` (string) – eigentlicher Chunk-Text (ggf. gereinigt/normalisiert)
|
|
||||||
- `window` (string) – Kontext-Fenster (z. B. Chunk ± Nachbarn)
|
|
||||||
- `retriever_weight` (float) – gültiger Wert aus `types.yaml` (oder Default)
|
|
||||||
- `chunk_profile` (string) – verwendetes Profil, z. B. `short`, `medium`, `long`, `by_heading`
|
|
||||||
- `neighbors_prev` (string[]) – Liste von `chunk_id`s direkter Vorgänger (i. d. R. 0 oder 1 ID)
|
|
||||||
- `neighbors_next` (string[]) – Liste von `chunk_id`s direkter Nachfolger
|
|
||||||
|
|
||||||
Die Konstruktion erfolgt in `app/core/chunk_payload.py` auf Basis der Chunks aus `chunker.py` und der aufgelösten Typ-Defaults.
|
|
||||||
|
|
||||||
---
|
|
||||||
|
|
||||||
### 2.5 Edges – Payload & Felder
|
|
||||||
|
|
||||||
Indexierte Felder:
|
|
||||||
|
|
||||||
- `note_id` (keyword) – Note, zu der der **Quell-Chunk** gehört
|
|
||||||
- `source_id` (keyword) – i. d. R. `chunk_id` des Quell-Chunks (z. B. `2025…#c00`)
|
|
||||||
- `target_id` (keyword) – Zielobjekt (z. B.:
|
|
||||||
- `chunk_id` eines anderen Chunks
|
|
||||||
- Note-Titel (`"Embeddings 101"`) bei **konzeptionellen Referenzen**
|
|
||||||
- `kind` (keyword) – Kantenart:
|
|
||||||
- Struktur: `belongs_to`, `next`, `prev`
|
|
||||||
- Explizit: `references`
|
|
||||||
- Inline: z. B. `similar_to`, `depends_on`, `related_to`
|
|
||||||
- Typ-Defaults: ebenfalls z. B. `depends_on`, `related_to` (aus `edge_defaults`)
|
|
||||||
- `scope` (keyword) – aktuell immer `"chunk"` (Kante wird auf Chunk-Ebene geführt)
|
|
||||||
- `chunk_id` (keyword) – `chunk_id` des Quell-Chunks
|
|
||||||
|
|
||||||
Weitere Payload-Felder:
|
|
||||||
|
|
||||||
- `rule_id` (string) – Herkunftsregel:
|
|
||||||
- Struktur:
|
|
||||||
- `structure:belongs_to`
|
|
||||||
- `structure:next`
|
|
||||||
- `structure:prev`
|
|
||||||
- Explizite Wiki-Links:
|
|
||||||
- `explicit:wikilink`
|
|
||||||
- Inline-Relationen:
|
|
||||||
- `inline:rel`
|
|
||||||
- Typ-Defaults aus `types.yaml`:
|
|
||||||
- `edge_defaults:<type>:<relation>`
|
|
||||||
z. B. `edge_defaults:concept:related_to`
|
|
||||||
- `confidence` (float) – Stärke / Vertrauensgrad:
|
|
||||||
- Struktur-Kanten: `1.0`
|
|
||||||
- Explizite Wiki-Links: `1.0`
|
|
||||||
- Inline-Relationen (`[[rel:… …]]`): z. B. `0.95`
|
|
||||||
- Typ-Defaults: z. B. `0.7`
|
|
||||||
|
|
||||||
Edges werden in `app/core/derive_edges.py` erzeugt und in `mindnet_edges` gespeichert.
|
|
||||||
|
|
||||||
---
|
|
||||||
|
|
||||||
## 3. Typ-Konfiguration (`config/types.yaml`)
|
|
||||||
|
|
||||||
### 3.1 Struktur des Files
|
|
||||||
|
|
||||||
`types.yaml` (vereinfachtes Beispiel):
|
|
||||||
|
|
||||||
|
### 3.1 Typ-Registry (`config/types.yaml`)
|
||||||
|
Steuert den Import-Prozess.
|
||||||
|
* **Priorität:** Frontmatter > Pfad > Default.
|
||||||
|
* **Inhalt:**
|
||||||
```yaml
|
```yaml
|
||||||
version: 1.0
|
|
||||||
default:
|
|
||||||
retriever_weight: 1.0
|
|
||||||
chunk_profile: default
|
|
||||||
|
|
||||||
types:
|
types:
|
||||||
concept:
|
concept:
|
||||||
chunk_profile: medium
|
chunk_profile: medium
|
||||||
edge_defaults: ["references", "related_to"]
|
edge_defaults: ["references", "related_to"]
|
||||||
retriever_weight: 0.35
|
retriever_weight: 0.60
|
||||||
|
|
||||||
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: long
|
|
||||||
edge_defaults: ["references", "depends_on"]
|
|
||||||
retriever_weight: 0.97
|
|
||||||
|
|
||||||
profile:
|
|
||||||
chunk_profile: long
|
|
||||||
edge_defaults: ["references", "depends_on"]
|
|
||||||
retriever_weight: 0.66
|
|
||||||
```
|
```
|
||||||
|
|
||||||
### 3.2 Typauflösung – Reihenfolge der Prioritäten
|
### 3.2 Retriever-Config (`config/retriever.yaml`)
|
||||||
|
Steuert das Scoring zur Laufzeit (WP04a).
|
||||||
Für eine Note mit `type` und optionalen Frontmatter Feldern `retriever_weight`, `chunk_profile` gilt aktuell:
|
* **Inhalt:**
|
||||||
|
```yaml
|
||||||
1. **Typ-spezifische Defaults** aus `types.yaml`:
|
scoring:
|
||||||
- `retriever_weight` ← `types.<type>.retriever_weight` (falls vorhanden)
|
semantic_weight: 1.0
|
||||||
- `chunk_profile` ← `types.<type>.chunk_profile` (falls vorhanden)
|
edge_weight: 0.7
|
||||||
2. **Globaler Default** `default` in `types.yaml`, falls Typ-Eintrag fehlt.
|
centrality_weight: 0.5
|
||||||
3. **Frontmatter `retriever_weight` / `chunk_profile`** werden aktuell *nicht* mehr als Konfigurationsebene verwendet, sondern eher als historische Relikte. (Dies kann zukünftig wieder aktiviert werden, ist aber im aktuellen Stand bewusst abgeschaltet zugunsten klarer, zentraler Konfiguration über `types.yaml`.)
|
```
|
||||||
|
|
||||||
Das Ergebnis dieser Auflösung wird im Payload als:
|
|
||||||
|
|
||||||
- `note_payload["retriever_weight"]`
|
|
||||||
- `note_payload["chunk_profile"]`
|
|
||||||
|
|
||||||
gesetzt und **1:1 an alle Chunks vererbt**.
|
|
||||||
|
|
||||||
---
|
---
|
||||||
|
|
||||||
## 4. Import-Pipeline (Markdown → Qdrant)
|
## 4. Import-Pipeline (Markdown → Qdrant)
|
||||||
|
|
||||||
### 4.1 Runbook
|
Das Skript `scripts/import_markdown.py` orchestriert den Prozess.
|
||||||
|
|
||||||
Standard-Import (mit Purge-Before-Upsert):
|
### 4.1 Verarbeitungsschritte
|
||||||
|
|
||||||
```bash
|
1. **Discovery & Parsing:**
|
||||||
export COLLECTION_PREFIX=mindnet
|
* Einlesen der `.md` Dateien. Hash-Vergleich (Body/Frontmatter) zur Erkennung von Änderungen.
|
||||||
export MINDNET_TYPES_FILE="$(pwd)/config/types.yaml"
|
2. **Typauflösung:**
|
||||||
|
* Laden der `types.yaml`. Bestimmen des effektiven Typs und der `edge_defaults`.
|
||||||
python3 -m scripts.import_markdown \
|
3. **Chunking:**
|
||||||
--vault ./mindnet_v2_test_vault \
|
* Zerlegung via `chunker.py` basierend auf `chunk_profile` (z.B. `by_heading`, `short`, `long`).
|
||||||
--apply \
|
* Trennung von `text` (Kern) und `window` (Embedding-Kontext).
|
||||||
--purge-before-upsert \
|
4. **Kantenableitung (Edge Derivation):**
|
||||||
--prefix "$COLLECTION_PREFIX"
|
Die `derive_edges.py` erzeugt Kanten in strikter Reihenfolge:
|
||||||
```
|
1. **Inline-Edges:** `[[rel:depends_on X]]` → `kind=depends_on`, `rule_id=inline:rel`, `conf=0.95`.
|
||||||
|
2. **Callout-Edges:** `> [!edge] related_to: [[X]]` → `kind=related_to`, `rule_id=callout:edge`, `conf=0.90`.
|
||||||
Nur Sync-Deletes (entfernte Dateien in Qdrant aufräumen):
|
3. **Explizite Referenzen:** `[[X]]` → `kind=references`, `rule_id=explicit:wikilink`, `conf=1.0`.
|
||||||
|
4. **Typ-Defaults:** Für jede Referenz werden Zusatzkanten gemäß `edge_defaults` erzeugt (z.B. `project` -> `depends_on`). `rule_id=edge_defaults:...`, `conf=0.7`.
|
||||||
```bash
|
5. **Struktur:** `belongs_to`, `next`, `prev` (automatisch).
|
||||||
python3 -m scripts.import_markdown \
|
5. **Upsert:**
|
||||||
--vault ./mindnet_v2_test_vault \
|
* Schreiben in Qdrant. Nutzung von `--purge-before-upsert` für saubere Updates.
|
||||||
--sync-deletes \
|
|
||||||
--apply \
|
|
||||||
--prefix "$COLLECTION_PREFIX"
|
|
||||||
```
|
|
||||||
|
|
||||||
---
|
---
|
||||||
|
|
||||||
### 4.2 Verarbeitungsschritte
|
## 5. Retriever-Architektur & Scoring
|
||||||
|
|
||||||
**1. Discovery & Parsing**
|
Der Retriever (`app/core/retriever.py`) realisiert die Logik hinter `/query`.
|
||||||
|
|
||||||
- `import_markdown.py` traversiert das Vault‐Verzeichnis.
|
### 5.1 Betriebsmodi
|
||||||
- Für jede `.md`:
|
* **Semantic:** Reine Vektorsuche. Schnell.
|
||||||
- YAML-Frontmatter extrahieren (id, title, type, created, updated, tags, …).
|
* **Hybrid:** Vektorsuche + Graph-Expansion (Tiefe N) + Re-Ranking.
|
||||||
- Body (Markdown) als String.
|
|
||||||
|
|
||||||
**2. Typauflösung & Payload-Bau (Note)**
|
### 5.2 Scoring-Formel (WP04a)
|
||||||
|
Die Relevanzberechnung ist nun eine gewichtete Summe:
|
||||||
|
|
||||||
- Laden & Auflösen von `types.yaml` (über ENV `MINDNET_TYPES_FILE` oder Default `./config/types.yaml`).
|
$$
|
||||||
- Bestimmung des effektiven Typs (`type` aus Frontmatter; ggf. Fallback).
|
TotalScore = (W_{sem} \cdot S_{sem} \cdot \max(W_{type}, 0)) + (W_{edge} \cdot B_{edge}) + (W_{cent} \cdot B_{cent})
|
||||||
- Anwendung der Typdefaults:
|
$$
|
||||||
- `retriever_weight` und `chunk_profile` werden aus `types.yaml` gelesen.
|
|
||||||
- Konstruktion des Note-Payloads via `make_note_payload` (in `note_payload.py`):
|
|
||||||
- Felder wie `note_id`, `title`, `type`, `tags`, `updated`, `retriever_weight`, `chunk_profile`, `edge_defaults`, …
|
|
||||||
|
|
||||||
**3. Chunking**
|
* **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`.
|
||||||
|
|
||||||
- Übergabe des Note-Bodies + `chunk_profile` an `chunker.py`.
|
### 5.3 Graph-Expansion
|
||||||
- `chunker.py` nutzt `chunk_config.py`, das definierte Profile bereitstellt, z. B.:
|
Der Hybrid-Modus lädt dynamisch die Nachbarschaft der Top-K Vektor-Treffer ("Seeds") über `graph_adapter.expand`. Dies baut einen temporären `NetworkX`-Graphen im Speicher, auf dem Boni berechnet werden.
|
||||||
|
|
||||||
```python
|
|
||||||
CHUNK_PROFILES = {
|
|
||||||
"short": {"max_tokens": 128, "overlap": 32},
|
|
||||||
"medium": {"max_tokens": 256, "overlap": 64},
|
|
||||||
"long": {"max_tokens": 512, "overlap": 128},
|
|
||||||
"by_heading": {"strategy": "by_heading", "max_chars": 2000},
|
|
||||||
"default": {"max_tokens": 256, "overlap": 64},
|
|
||||||
}
|
|
||||||
```
|
|
||||||
|
|
||||||
- Ergebnis: Liste geordneter Chunks mit:
|
|
||||||
- `chunk_id` (`note_id#cXX`),
|
|
||||||
- `index` (0..N-1),
|
|
||||||
- `ord` (1..N),
|
|
||||||
- `text`,
|
|
||||||
- `window` (inkl. Nachbartexte),
|
|
||||||
- `neighbors_prev` / `neighbors_next`.
|
|
||||||
|
|
||||||
**4. Chunk-Payloads**
|
|
||||||
|
|
||||||
- In `chunk_payload.py` werden für jeden Chunk die Payloads gebaut:
|
|
||||||
- Vererbung von `note_id`, `type`, `tags`, `retriever_weight`, `chunk_profile`.
|
|
||||||
- Setzen von `index`, `ord`, `neighbors_prev`, `neighbors_next`.
|
|
||||||
- Persistieren von `text` und `window`.
|
|
||||||
|
|
||||||
**5. Kantenableitung (Edges)**
|
|
||||||
|
|
||||||
- `derive_edges.py` wird mit Note + Chunks + Typinformationen aufgerufen.
|
|
||||||
- Es entstehen mehrere Gruppen von Kanten:
|
|
||||||
1. **Struktur-Kanten**:
|
|
||||||
- `belongs_to`: Chunk → Note
|
|
||||||
- `next`: Chunk[i] → Chunk[i+1]
|
|
||||||
- `prev`: Chunk[i] → Chunk[i-1]
|
|
||||||
2. **Explizite Kanten aus Text**:
|
|
||||||
- Wiki-Links: `[[Target Title]]` → `kind="references"`, `rule_id="explicit:wikilink"`, `confidence=1.0`.
|
|
||||||
- Inline-Relationen: `[[rel:depends_on Embeddings 101]]`:
|
|
||||||
- `kind="depends_on"`
|
|
||||||
- `rule_id="inline:rel"`
|
|
||||||
- `confidence≈0.95`
|
|
||||||
- `target_id="Embeddings 101"` (Titel, nicht ID – Auflösung erfolgt später im Agenten).
|
|
||||||
3. **Typ-basierte Defaults (`edge_defaults`)**:
|
|
||||||
- Aus `types.yaml` je `type`: Liste von Relations-Kinds, z. B.:
|
|
||||||
- `concept.edge_defaults = ["references","related_to"]`
|
|
||||||
- `project.edge_defaults = ["references","depends_on"]`
|
|
||||||
- Für jede explizite Referenz Quelle→Ziel (z. B. `references`, `similar_to`) werden **zusätzliche Kanten** erzeugt, z. B.:
|
|
||||||
- `edge_defaults:project:depends_on`
|
|
||||||
- `edge_defaults:concept:related_to`
|
|
||||||
- `confidence≈0.7`.
|
|
||||||
4. **Deduplication**:
|
|
||||||
- Alle Kanten werden in einem Set anhand eines Keys wie
|
|
||||||
- `(kind, scope, source_id, target_id, rule_id)`
|
|
||||||
dedupliziert (idempotent).
|
|
||||||
|
|
||||||
**6. Upsert nach Qdrant**
|
|
||||||
|
|
||||||
- Punkte (Notes, Chunks, Edges) werden via `qdrant_points.py` in die entsprechenden Collections upserted.
|
|
||||||
- Option `--purge-before-upsert` sorgt dafür, dass alte Punkte mit denselben IDs entfernt werden, bevor neue geschrieben werden (stabiler Reimport).
|
|
||||||
- `--sync-deletes` entfernt Punkte, deren zugehörige Dateien im Vault nicht mehr existieren.
|
|
||||||
|
|
||||||
---
|
---
|
||||||
|
|
||||||
## 5. Edges im Detail – Semantik & Regeln
|
## 6. Indizes & Performance
|
||||||
|
|
||||||
### 5.1 Struktur-Kanten
|
Damit Qdrant performant bleibt, sind Payload-Indizes essenziell.
|
||||||
|
|
||||||
Erzeugt für **jede Note** mit >0 Chunks:
|
**Erforderliche Indizes:**
|
||||||
|
* **Notes:** `note_id`, `type`, `tags`.
|
||||||
|
* **Chunks:** `note_id`, `chunk_id`.
|
||||||
|
* **Edges:** `source_id`, `target_id`, `kind`, `scope`, `note_id`.
|
||||||
|
|
||||||
- **belongs_to**
|
Validierung erfolgt über `tests/ensure_indexes_and_show.py`.
|
||||||
- pro Chunk genau eine Kante:
|
|
||||||
- `source_id = chunk_id`
|
|
||||||
- `target_id = note_id` *oder* (konzeptionell) ein Note-Identifikator
|
|
||||||
- `kind = "belongs_to"`
|
|
||||||
- `scope = "chunk"`
|
|
||||||
- `rule_id = "structure:belongs_to"`
|
|
||||||
- `confidence = 1.0`
|
|
||||||
- **next / prev**
|
|
||||||
- für Index i (`0..N-2`):
|
|
||||||
- `next`: `chunk_i → chunk_{i+1}`
|
|
||||||
- `prev`: `chunk_{i+1} → chunk_i`
|
|
||||||
- `kind = "next"` bzw. `"prev"`
|
|
||||||
- `scope = "chunk"`
|
|
||||||
- `rule_id = "structure:next"` / `"structure:prev"`
|
|
||||||
- `confidence = 1.0`
|
|
||||||
|
|
||||||
Tests (`tests.test_edges_smoke` / `tests.test_edges_all`) stellen sicher:
|
|
||||||
|
|
||||||
- `belongs_to` == `#chunks`
|
|
||||||
- `next` == `prev` == `#chunks - 1`
|
|
||||||
- keine Duplikate der Strukturkanten.
|
|
||||||
|
|
||||||
---
|
---
|
||||||
|
|
||||||
### 5.2 Explizite Wiki-Links (`[[Target Title]]`)
|
## 7. Offene Punkte / Known Limitations
|
||||||
|
|
||||||
- Parser in `derive_edges.py` sucht im Chunk-Text nach Mustern:
|
1. **Multi-Target Inline-Relations:**
|
||||||
- `[[Some Page]]` (kein `rel:` Präfix)
|
* `rel: similar_to [[A]] [[B]]` wird aktuell parser-seitig nicht unterstützt.
|
||||||
- Erzeugt Kanten:
|
* Workaround: Zwei separate Inline-Links `[[rel:similar_to A]] [[rel:similar_to B]]`.
|
||||||
- `kind = "references"`
|
2. **Unresolved Targets:**
|
||||||
- `scope = "chunk"`
|
* Kanten zu Notizen, die noch nicht existieren, werden mit `target_id="Titel"` angelegt.
|
||||||
- `source_id = chunk_id`
|
* Heilung durch `scripts/resolve_unresolved_references.py` möglich.
|
||||||
- `target_id = "<Titel aus dem Link>"` (z. B. `"Vector DB Basics"`)
|
3. **Vektor-Konfiguration für Edges:**
|
||||||
- `rule_id = "explicit:wikilink"`
|
* `mindnet_edges` hat aktuell keine Vektoren (`vectors = null`). Eine semantische Suche *auf Kanten* ist noch nicht möglich.
|
||||||
- `confidence = 1.0`
|
|
||||||
|
|
||||||
Diese Kanten bilden das **explizite Referenznetz** des Nutzers ab (Obsidian-typische Wikilinks).
|
|
||||||
|
|
||||||
---
|
|
||||||
|
|
||||||
### 5.3 Inline-Relationen (`[[rel:… …]]`)
|
|
||||||
|
|
||||||
Aktuell **implementiert und funktional** ist folgende Form:
|
|
||||||
|
|
||||||
- **Format (aktuell unterstützt):**
|
|
||||||
|
|
||||||
```md
|
|
||||||
[[rel:depends_on Embeddings 101]]
|
|
||||||
[[rel:similar_to Vector DB Basics]]
|
|
||||||
[[rel:related_to Qdrant Vektordatenbank]]
|
|
||||||
```
|
|
||||||
|
|
||||||
- Parsing-Strategie:
|
|
||||||
- Link-Inhalt wird gesplittet:
|
|
||||||
- Erster Token: `rel:depends_on`
|
|
||||||
- Rest: Zielbezeichnung (`Embeddings 101`)
|
|
||||||
- `kind` wird aus dem Teil `depends_on` extrahiert (z. B. `similar_to`, `related_to`).
|
|
||||||
- `target_id` wird aus dem Rest (meist ein Titel) abgeleitet.
|
|
||||||
|
|
||||||
- Ergebnis-Kante:
|
|
||||||
- `kind = "<Relation aus rel:…>"`
|
|
||||||
- `scope = "chunk"`
|
|
||||||
- `source_id = chunk_id`
|
|
||||||
- `target_id = "<Ziel-Titel>"`
|
|
||||||
- `rule_id = "inline:rel"`
|
|
||||||
- `confidence ≈ 0.95`
|
|
||||||
|
|
||||||
- **Nicht unterstützt (Stand jetzt):**
|
|
||||||
|
|
||||||
```md
|
|
||||||
rel: depends_on [[Embeddings 101]] [[Vector DB Basics]]
|
|
||||||
```
|
|
||||||
|
|
||||||
Diese Syntax wird derzeit **nicht** erkannt.
|
|
||||||
Multi-Target-Inline-Relationen (`rel: similar_to [[A]] [[B]]`) sind ein **offener Task**.
|
|
||||||
|
|
||||||
---
|
|
||||||
|
|
||||||
### 5.4 Typ-basierte Default-Edges (`edge_defaults`)
|
|
||||||
|
|
||||||
Zweck:
|
|
||||||
|
|
||||||
- Für bestimmte Typen (vor allem `concept`, `project`, `profile`) sollen zusätzliche Kanten automatisch ergänzt werden, um das **Semantiknetz zu verdichten**, ohne dass der Nutzer jede Relation explizit pflegen muss.
|
|
||||||
|
|
||||||
Konfiguration:
|
|
||||||
|
|
||||||
- In `types.yaml` definiert, z. B.:
|
|
||||||
|
|
||||||
```yaml
|
|
||||||
types:
|
|
||||||
concept:
|
|
||||||
edge_defaults: ["references", "related_to"]
|
|
||||||
project:
|
|
||||||
edge_defaults: ["references", "depends_on"]
|
|
||||||
```
|
|
||||||
|
|
||||||
Aktuelle Implementierung:
|
|
||||||
|
|
||||||
- Für jede **explizite** Referenz (Wiki-Link oder Inline-Relation) von Chunk → Ziel:
|
|
||||||
- `kind="references"` (Wiki) oder die Inline-Relation (`depends_on`, `similar_to`, …)
|
|
||||||
- Auf Basis des Note-Typs (`type`) wird pro Default-Relation eine zusätzliche Kante erzeugt:
|
|
||||||
|
|
||||||
Beispiel:
|
|
||||||
|
|
||||||
- Note-Typ: `project`
|
|
||||||
- `edge_defaults: ["references","depends_on"]`
|
|
||||||
- Explizit: `references` von `Edge Index` → `Embeddings 101`
|
|
||||||
- Abgeleitete Kanten:
|
|
||||||
- `kind="references"`, `rule_id="edge_defaults:project:references"`, `confidence=0.7`
|
|
||||||
- `kind="depends_on"`, `rule_id="edge_defaults:project:depends_on"`, `confidence=0.7`
|
|
||||||
|
|
||||||
- Symmetrische Kanten:
|
|
||||||
- Für einige Relations-Typen (z. B. `related_to`) wird zusätzlich eine **spiegelbildliche** Kante Ziel → Quelle erzeugt.
|
|
||||||
- Dies erklärt in Tests z. B. Paare wie:
|
|
||||||
- `related_to (Source=Ollama LLM, Target=Qdrant Vektordatenbank)`
|
|
||||||
- `related_to (Source=Qdrant Vektordatenbank, Target=Ollama LLM)`
|
|
||||||
|
|
||||||
- Deduplication:
|
|
||||||
- Es wird verhindert, dass mehrfach identische Kanten geschrieben werden.
|
|
||||||
- Schlüssel: `(kind, scope, source_id, target_id, rule_id)`.
|
|
||||||
|
|
||||||
---
|
|
||||||
|
|
||||||
### 5.5 `rule_id` & `confidence` – Bedeutung
|
|
||||||
|
|
||||||
**`rule_id`** kodiert **Herkunft** und **Regel**, z. B.:
|
|
||||||
|
|
||||||
- `structure:belongs_to`, `structure:next`, `structure:prev`
|
|
||||||
- `explicit:wikilink`
|
|
||||||
- `inline:rel`
|
|
||||||
- `edge_defaults:<type>:<relation>`
|
|
||||||
|
|
||||||
**`confidence`** dient als späterer Gewichtungsfaktor im Retrieval / Ranking:
|
|
||||||
|
|
||||||
- `1.0` → harte Struktur- oder explizite Kante (vom Nutzer direkt gesetzt)
|
|
||||||
- `0.95` → Inline-Relation (stark, aber nicht so „hart“ wie die reine Referenz)
|
|
||||||
- `0.7` → Typ-Default-Edges (abgeleitete Hypothesen aus Typwissen)
|
|
||||||
|
|
||||||
Ein künftiger LLM-Agent kann daraus z. B.:
|
|
||||||
|
|
||||||
- Kanten mit hoher `confidence` priorisieren,
|
|
||||||
- Default-Edges als schwächere Hinweise betrachten,
|
|
||||||
- Inline-Relationen gezielt als semantische Aussagen über die Beziehung interpretieren.
|
|
||||||
|
|
||||||
---
|
|
||||||
|
|
||||||
## 6. Qdrant-Schema & Indizes
|
|
||||||
|
|
||||||
### 6.1 Erstellung & Indizes
|
|
||||||
|
|
||||||
Die Erstellung erfolgt über:
|
|
||||||
|
|
||||||
```bash
|
|
||||||
python3 -m scripts.reset_qdrant --mode wipe --prefix "$COLLECTION_PREFIX"
|
|
||||||
```
|
|
||||||
|
|
||||||
Intern:
|
|
||||||
|
|
||||||
- `qdrant.py` / `setup_mindnet_collections.py`:
|
|
||||||
- Collections anlegen, ggf. mit Vektor-Konfiguration (Single-Vector; Named-Vectors sind vorbereitet aber optional).
|
|
||||||
- `ensure_payload_indexes()`:
|
|
||||||
- Legt für jede Collection die relevanten Payload-Indizes an.
|
|
||||||
|
|
||||||
Verifizierbar durch:
|
|
||||||
|
|
||||||
```bash
|
|
||||||
python3 -m tests.ensure_indexes_and_show
|
|
||||||
```
|
|
||||||
|
|
||||||
Beispielauszug (bereits real so gesehen):
|
|
||||||
|
|
||||||
- **mindnet_notes**
|
|
||||||
|
|
||||||
```json
|
|
||||||
{
|
|
||||||
"tags": { "data_type": "keyword", "points": 8 },
|
|
||||||
"note_id":{ "data_type": "keyword", "points": 8 },
|
|
||||||
"title": { "data_type": "text", "points": 8 },
|
|
||||||
"updated":{ "data_type": "integer", "points": 0 },
|
|
||||||
"type": { "data_type": "keyword", "points": 8 }
|
|
||||||
}
|
|
||||||
```
|
|
||||||
|
|
||||||
- **mindnet_chunks**
|
|
||||||
|
|
||||||
```json
|
|
||||||
{
|
|
||||||
"note_id": { "data_type": "keyword", "points": 44 },
|
|
||||||
"chunk_id":{ "data_type": "keyword", "points": 44 },
|
|
||||||
"index": { "data_type": "integer", "points": 44 },
|
|
||||||
"type": { "data_type": "keyword", "points": 44 },
|
|
||||||
"tags": { "data_type": "keyword", "points": 44 }
|
|
||||||
}
|
|
||||||
```
|
|
||||||
|
|
||||||
- **mindnet_edges**
|
|
||||||
|
|
||||||
```json
|
|
||||||
{
|
|
||||||
"scope": { "data_type": "keyword", "points": 135 },
|
|
||||||
"kind": { "data_type": "keyword", "points": 135 },
|
|
||||||
"chunk_id":{ "data_type": "keyword", "points": 135 },
|
|
||||||
"target_id":{ "data_type": "keyword", "points": 135 },
|
|
||||||
"note_id": { "data_type": "keyword", "points": 135 },
|
|
||||||
"source_id":{ "data_type": "keyword", "points": 135 }
|
|
||||||
}
|
|
||||||
```
|
|
||||||
|
|
||||||
### 6.2 Schema-Validierung
|
|
||||||
|
|
||||||
`tests/assert_payload_schema.py` prüft:
|
|
||||||
|
|
||||||
- ob die Minimalfelder (`note_id`, `type`, `title`, `updated`, `tags` etc.) vorhanden sind,
|
|
||||||
- berichtet fehlende Felder.
|
|
||||||
|
|
||||||
Nach Korrektur der Indexanlage sollte:
|
|
||||||
|
|
||||||
- `ok = true` sein, bzw. zumindest alle Kernfelder unter `present` geführt werden.
|
|
||||||
(Im aktuellen Stand werden sie als Indizes geführt; Qdrant speichert zusätzliche Felder ohne explizite Schema-Zeile, was technisch unproblematisch ist.)
|
|
||||||
|
|
||||||
---
|
|
||||||
|
|
||||||
## 7. Nutzung im Retrieval (Ausblick)
|
|
||||||
|
|
||||||
### 7.1 Typbewusstes Chunk-Retrieval
|
|
||||||
|
|
||||||
Ein typischer Query-Pfad eines LLM-Agents:
|
|
||||||
|
|
||||||
1. Query → Embedding
|
|
||||||
2. Suche in `mindnet_chunks` mit Filter, z. B.:
|
|
||||||
|
|
||||||
```python
|
|
||||||
f = rest.Filter(
|
|
||||||
must=[
|
|
||||||
rest.FieldCondition(key="type", match=rest.MatchValue(value="concept")),
|
|
||||||
rest.FieldCondition(key="tags", match=rest.MatchAny(any=["ki","ollama"]))
|
|
||||||
]
|
|
||||||
)
|
|
||||||
```
|
|
||||||
|
|
||||||
3. Treffer werden nach:
|
|
||||||
- Vektor-Score,
|
|
||||||
- `retriever_weight`,
|
|
||||||
- ggf. Edges (z. B. Projekte mit `depends_on` → Konzepte) gewichtet.
|
|
||||||
|
|
||||||
### 7.2 Graph-orientierte Navigation
|
|
||||||
|
|
||||||
Basierend auf `mindnet_edges` kann der Agent:
|
|
||||||
|
|
||||||
- ausgehend von einem relevanten Chunk:
|
|
||||||
- Struktur-Kanten (`next`, `prev`) zur Kontextvergrößerung nutzen,
|
|
||||||
- `references` / `depends_on` / `related_to` interpretieren,
|
|
||||||
- `edge_defaults` als semantische Ausdehnung (z. B. von `project` zu seinen `concept`-Bausteinen) nutzen.
|
|
||||||
|
|
||||||
Die Bedeutung der Kanten ist dabei durch `rule_id` und `confidence` klar nachvollziehbar.
|
|
||||||
|
|
||||||
---
|
|
||||||
|
|
||||||
## 8. Offene Punkte / Known Limitations
|
|
||||||
|
|
||||||
1. **Multi-Target Inline-Relationen**
|
|
||||||
Syntax wie:
|
|
||||||
|
|
||||||
```md
|
|
||||||
[[rel:similar_to Vector DB Basics]] [[rel:similar_to Embeddings 101]]
|
|
||||||
```
|
|
||||||
funktioniert (zwei separate Inline-Links).
|
|
||||||
**Nicht** unterstützt (Stand jetzt):
|
|
||||||
|
|
||||||
```md
|
|
||||||
[[rel:similar_to Vector DB Basics]] [[Embeddings 101]]
|
|
||||||
rel: similar_to [[Vector DB Basics]] [[Embeddings 101]]
|
|
||||||
```
|
|
||||||
|
|
||||||
→ Offener Task: Parser erweitern, um mehrere Ziele in einer Inline-Relation zu unterstützen.
|
|
||||||
|
|
||||||
2. **Callout-Edges (`[!edge]`)**
|
|
||||||
- Konzeptionell vorgesehen, z. B.:
|
|
||||||
|
|
||||||
```md
|
|
||||||
> [!edge] related_to: [[Vector DB Basics]]
|
|
||||||
```
|
|
||||||
|
|
||||||
- Im aktuellen Implementierungsstand werden Callouts entweder:
|
|
||||||
- gar nicht, oder
|
|
||||||
- nur teilweise verarbeitet (in den aktuellen Test-Runs war `callout_total = 0`).
|
|
||||||
→ Offener Task: Callout-Parser robust implementieren und mit Tests absichern.
|
|
||||||
|
|
||||||
3. **Frontmatter-Overrides für `retriever_weight` / `chunk_profile`**
|
|
||||||
- Aktuell **nicht** wirksam.
|
|
||||||
- Typdefaults aus `types.yaml` sind der **Single Source of Truth**.
|
|
||||||
- Später können kontrollierte Overrides (z. B. für Sonderfälle) eingeführt werden.
|
|
||||||
|
|
||||||
4. **Vektor-Konfiguration für Edges**
|
|
||||||
- `mindnet_edges` wird derzeit ohne Vektoren betrieben (`vectors = null`).
|
|
||||||
- Später könnte z. B. eine semantische Repräsentation von Kanten eingeführt werden (z. B. Embedding von `(source_chunk_text + relation + target_title)`).
|
|
||||||
|
|
||||||
---
|
|
||||||
|
|
||||||
## 9. Zusammenfassung
|
|
||||||
|
|
||||||
- Die Mindnet-V2-Architektur implementiert einen **dreistufigen Speicher**:
|
|
||||||
- Notes (`mindnet_notes`),
|
|
||||||
- Chunks (`mindnet_chunks`),
|
|
||||||
- Edges (`mindnet_edges`).
|
|
||||||
|
|
||||||
- **`types.yaml`** steuert:
|
|
||||||
- `retriever_weight` und `chunk_profile` je Typ (inkl. Default),
|
|
||||||
- `edge_defaults` je Typ (automatische Relations-Ableitung).
|
|
||||||
|
|
||||||
- Das **Chunking** ist profilbasiert (short/medium/long/by_heading) und deterministisch.
|
|
||||||
|
|
||||||
- Die **Kantenableitung** in `derive_edges.py` erzeugt:
|
|
||||||
- strukturelle Kanten (belongs_to / next / prev),
|
|
||||||
- explizite Kanten aus Wiki-Links (`[[Target]]`),
|
|
||||||
- semantische Inline-Relationen (`[[rel:depends_on Target]]`),
|
|
||||||
- typbasierte Default-Kanten (z. B. `edge_defaults:project:depends_on`).
|
|
||||||
|
|
||||||
- `rule_id` und `confidence` machen die Herkunft jeder Kante transparent und ermöglichen später eine **gewichtete Auswertung** durch LLM-basierte Agenten.
|
|
||||||
|
|
||||||
- Qdrant-Collections und Payload-Indizes sind konsistent eingerichtet und durch Tests verifiziert.
|
|
||||||
|
|
||||||
Dieses Dokument bildet damit das aktuelle technische Gesamtbild von Mindnet V2 ab, inkl. aller relevanten Mechanismen rund um Typen, Chunking, Edges und Qdrant-Schema.
|
|
||||||
|
|
||||||
@@ -0,0 +1,191 @@
|
|||||||
|
# mindnet v2.2 – Pipeline Playbook
|
||||||
|
**Datei:** `docs/mindnet_pipeline_playbook_v2.2.md`
|
||||||
|
**Stand:** 2025-12-07
|
||||||
|
**Status:** **FINAL** (Konsolidiert aus WP02, WP03, WP04a)
|
||||||
|
**Quellen:** `mindnet_v2_implementation_playbook.md`, `Handbuch.md`, `chunking_strategy.md`, `docs_mindnet_retriever.md`, `wp04_retriever_scoring.md`.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 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 und wie der Retriever konfiguriert und betrieben wird.
|
||||||
|
|
||||||
|
**Zielgruppe:** Dev/Ops, Tech-Leads.
|
||||||
|
**Scope:**
|
||||||
|
* **Ist-Stand (WP01–WP04a):** Markdown-Import, Chunking, Edge-Erzeugung, Hybrider Retriever.
|
||||||
|
* **Roadmap (Ausblick):** Self-Healing (WP06), Feedback-Loops (WP08).
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 2. Die Import-Pipeline (Runbook)
|
||||||
|
|
||||||
|
Der Import ist der kritischste Prozess. Er muss **deterministisch** und **idempotent** sein. Wir nutzen `scripts/import_markdown.py` als zentralen Entrypoint.
|
||||||
|
|
||||||
|
### 2.1 Der 12-Schritte-Prozess
|
||||||
|
Gemäß WP03-Spezifikation läuft der Import intern wie folgt ab:
|
||||||
|
|
||||||
|
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.
|
||||||
|
6. **Inline-Kanten finden:** Parsing von `[[rel:...]]` im Fließtext.
|
||||||
|
7. **Callout-Kanten finden:** Parsing von `> [!edge]` Blöcken.
|
||||||
|
8. **Default-Edges erzeugen:** Anwendung der `edge_defaults` aus der Typ-Registry.
|
||||||
|
9. **Strukturkanten erzeugen:** `belongs_to` (Chunk->Note), `next`/`prev` (Sequenz).
|
||||||
|
10. **Chunks upserten:** Schreiben in Qdrant (`mindnet_chunks`).
|
||||||
|
11. **Edges upserten:** Schreiben in Qdrant (`mindnet_edges`).
|
||||||
|
12. **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)
|
||||||
|
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 Full Rebuild (Clean Slate)
|
||||||
|
Notwendig bei Änderungen an `types.yaml` (z.B. neue Chunk-Größen) oder Embedding-Modellen.
|
||||||
|
|
||||||
|
# 1. Qdrant Collections löschen und neu anlegen (Wipe inkl. Schema)
|
||||||
|
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
|
||||||
|
|
||||||
|
### 2.4 Baseline-Builds & Hashing
|
||||||
|
Um unnötige Updates zu vermeiden, nutzt der Importer Hashes.
|
||||||
|
* **ENV `MINDNET_HASH_COMPARE`:** Steuert, was verglichen wird.
|
||||||
|
* `Body`: Nur Textänderungen triggern Update (Standard).
|
||||||
|
* `Full`: Auch Frontmatter-Änderungen (z.B. Tags) triggern Update.
|
||||||
|
* **Flag `--baseline-modes`:** Berechnet Hashes für alle Modi vor, um spätere Wechsel der Strategie ohne Massen-Update zu ermöglichen.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 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):
|
||||||
|
* `short`: Max 128 Tokens (z.B. für Logs, Chats).
|
||||||
|
* `medium`: Max 256 Tokens (z.B. für Konzepte).
|
||||||
|
* `long`: Max 512 Tokens (z.B. für Essays, Projekte).
|
||||||
|
* `by_heading`: Trennt strikt an Überschriften.
|
||||||
|
|
||||||
|
### 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.2 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** | Default | *(via types.yaml)* | `edge_defaults:...` | ~0.70 |
|
||||||
|
| **5** | Struktur | *(automatisch)* | `structure:...` | 1.00 |
|
||||||
|
|
||||||
|
### 4.2 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 & Scoring
|
||||||
|
|
||||||
|
Der Retriever (`app/core/retriever.py`) kombiniert Signale zur Laufzeit.
|
||||||
|
|
||||||
|
### 5.1 Konfiguration (`retriever.yaml`)
|
||||||
|
Diese Datei steuert das Ranking. Änderungen wirken sofort (API-Neustart).
|
||||||
|
|
||||||
|
scoring:
|
||||||
|
semantic_weight: 1.0 # Vektor-Ähnlichkeit
|
||||||
|
edge_weight: 0.7 # Graph-Dichte Bonus
|
||||||
|
centrality_weight: 0.5 # Zentralitäts-Bonus
|
||||||
|
|
||||||
|
### 5.2 Scoring-Formel
|
||||||
|
total_score =
|
||||||
|
semantic_weight * semantic_score
|
||||||
|
+ edge_weight * edge_bonus
|
||||||
|
+ centrality_weight * centrality_bonus
|
||||||
|
+ type_weight * retriever_weight
|
||||||
|
|
||||||
|
* `retriever_weight`: Kommt aus dem Note-Payload (via `types.yaml`).
|
||||||
|
* `edge_bonus`: Summe der `confidence` aller relevanten Kanten im Subgraph.
|
||||||
|
|
||||||
|
### 5.3 Hybrider Modus
|
||||||
|
Der Request muss `mode="hybrid"` und `expand.depth > 0` setzen, damit der Graph genutzt wird.
|
||||||
|
* **Expand:** Lädt Nachbarn der Vektor-Treffer.
|
||||||
|
* **Re-Rank:** Berechnet Boni auf diesem lokalen Graphen.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 6. Quality Gates & Tests
|
||||||
|
|
||||||
|
Diese Tests garantieren die Stabilität der Pipeline.
|
||||||
|
|
||||||
|
### 6.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; keine verwaisten Kanten).
|
||||||
|
|
||||||
|
python3 -m scripts.edges_full_check
|
||||||
|
|
||||||
|
3. **Unit Tests:**
|
||||||
|
|
||||||
|
pytest tests/test_retriever_basic.py tests/test_retriever_edges.py
|
||||||
|
|
||||||
|
### 6.2 Smoke-Test (E2E)
|
||||||
|
Prüft am laufenden System, ob Semantik und Graph funktionieren.
|
||||||
|
|
||||||
|
python scripts/test_retriever_smoke.py \
|
||||||
|
--query "mindnet" \
|
||||||
|
--mode hybrid \
|
||||||
|
--expand-depth 1 \
|
||||||
|
--top-k 5
|
||||||
|
|
||||||
|
### 6.3 Roundtrip-Test (Datenverlust-Check)
|
||||||
|
Exportiert Qdrant zurück nach Markdown und vergleicht mit Original.
|
||||||
|
|
||||||
|
python3 -m scripts.export_markdown --out ./_export
|
||||||
|
python3 tests/compare_vaults.py --src ./vault --dst ./_export --focus body
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 7. Ausblick & Roadmap
|
||||||
|
|
||||||
|
### 7.1 Self-Healing (WP06)
|
||||||
|
Geplant: Automatisierte Jobs, die `unresolved` Referenzen periodisch prüfen und heilen, wenn die Ziel-Note erstellt wurde. Aktuell manuell via `scripts/resolve_unresolved_references.py`.
|
||||||
|
|
||||||
|
### 7.2 Feedback-Logging (WP04c/WP08)
|
||||||
|
Geplant: Speicherung von User-Feedback zu Suchergebnissen, um `retriever.yaml` Gewichte mittelfristig automatisch zu justieren ("Self-Tuning").
|
||||||
@@ -0,0 +1,114 @@
|
|||||||
|
# Mindnet v2.2 – User Guide
|
||||||
|
**Datei:** `docs/mindnet_user_guide_v2.2.md`
|
||||||
|
**Stand:** 2025-12-07
|
||||||
|
**Status:** **FINAL** (Konsolidiert WP01–WP04a)
|
||||||
|
**Quellen:** `knowledge_design.md`, `wp04_retriever_scoring.md`, `Programmplan_V2.2.md`, `Handbuch.md`.
|
||||||
|
|
||||||
|
> **Willkommen bei Mindnet.**
|
||||||
|
> Dies ist dein persönliches Wissensnetzwerk. Im Gegensatz zu einer normalen Suche (wie Google Drive oder Spotlight), die nur Texte findet, "denkt" Mindnet mit. Dieser Guide zeigt dir, wie du das System nutzt.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 1. Was Mindnet für dich tut
|
||||||
|
|
||||||
|
Mindnet ist ein **assoziatives Gedächtnis**. Es verbindet deine Notizen zu einem Graphen.
|
||||||
|
|
||||||
|
### 1.1 Mehr als nur Stichworte
|
||||||
|
Wenn du nach "Projekt Alpha" suchst, findet Mindnet nicht nur das Dokument mit diesem Titel. Es findet auch:
|
||||||
|
* **Abhängigkeiten:** "Technologie X wird benötigt" (weil sie verlinkt ist).
|
||||||
|
* **Entscheidungen:** "Warum nutzen wir X?" (weil eine Decision-Note existiert).
|
||||||
|
* **Ähnliches:** "Projekt Beta war ähnlich" (weil es strukturell verwandt ist).
|
||||||
|
|
||||||
|
### 1.2 Dein KI-Zwilling (Vision)
|
||||||
|
Mindnet speichert nicht nur Fakten, sondern deine **Perspektive**. Durch die Gewichtung von Typen (z.B. "Prinzipien sind wichtiger als Quellen") lernt das System, Antworten so zu priorisieren, wie du es tun würdest.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 2. Gute Fragen an Mindnet stellen
|
||||||
|
|
||||||
|
Mindnet nutzt eine **Hybride Suche**. Das heißt, es schaut auf deine Worte (Semantik) und auf das Netzwerk (Graph).
|
||||||
|
|
||||||
|
### 2.1 Frage-Muster
|
||||||
|
Um gute Antworten zu erhalten, formuliere deine Anfragen präzise:
|
||||||
|
|
||||||
|
* **Faktensuche:** "Wie installiere ich Qdrant?"
|
||||||
|
* *Mindnet sucht:* Chunks mit technischer Anleitung. Hier gewinnt oft die reine Text-Ähnlichkeit.
|
||||||
|
* **Zusammenhänge:** "Womit hängt Projekt Alpha zusammen?"
|
||||||
|
* *Mindnet sucht:* Den Projekt-Knoten und folgt den Kanten (`depends_on`, `related_to`). Hier gewinnt der Graph.
|
||||||
|
* **Entscheidungen:** "Warum nutzen wir Vektordatenbanken?"
|
||||||
|
* *Mindnet sucht:* Notizen vom Typ `decision` oder `principle`. Hier gewinnt das Typ-Gewicht (`retriever_weight`).
|
||||||
|
|
||||||
|
### 2.2 Tipps für bessere Ergebnisse
|
||||||
|
1. **Nutze deine Sprache:** Verwende die Begriffe, die du auch in deinen Notizen benutzt hast.
|
||||||
|
2. **Kontext geben:** Statt nur "Qdrant" zu tippen (was alles finden würde), frage "Qdrant Setup für Mindnet", um den Kontext einzuschränken.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 3. Ergebnisse interpretieren
|
||||||
|
|
||||||
|
Wenn Mindnet antwortet, siehst du oft mehr als nur Text. Du siehst eine **Begründung**.
|
||||||
|
|
||||||
|
### 3.1 Der Score (Warum ist das hier oben?)
|
||||||
|
Mindnet berechnet für jeden Treffer einen `total_score`. Dieser ist keine Magie, sondern Mathematik:
|
||||||
|
|
||||||
|
Score = (Text-Treffer) + (Wichtigkeit) + (Vernetzung)
|
||||||
|
|
||||||
|
* **Text-Treffer (Semantik):** Wie gut passen die Worte?
|
||||||
|
* **Wichtigkeit (Typ):** Ist die Quelle eine zentrale `decision` (hoch gewichtet) oder nur eine `source` (niedrig)? Ein Treffer in einer Entscheidung schlägt oft einen Treffer in einem Buch-Exzerpt.
|
||||||
|
* **Vernetzung (Edge Bonus):** Wird dieser Inhalt oft von anderen wichtigen Projekten referenziert? Ein "zentraler" Knoten wird bevorzugt.
|
||||||
|
|
||||||
|
### 3.2 Pfade (Der Kontext)
|
||||||
|
Oft zeigt Mindnet im Hintergrund (Explainability):
|
||||||
|
*"Gefunden via: Projekt Alpha -> depends_on -> Vektordatenbank"*
|
||||||
|
|
||||||
|
Das bedeutet: Dieser Treffer ist relevant, weil er eine **Abhängigkeit** deines aktuellen Projekts ist, auch wenn deine Suchworte vielleicht nicht exakt passen. Das ist der Moment, in dem Mindnet "mitdenkt".
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 4. Neues Wissen beisteuern (Authoring)
|
||||||
|
|
||||||
|
Mindnet lebt von deinem Input. Du musst kein Techniker sein, um gutes Wissen zu designen. Du schreibst einfach Markdown.
|
||||||
|
|
||||||
|
### 4.1 Die Goldene Regel: "Verlinke semantisch"
|
||||||
|
Statt einfach nur `[[Link]]` zu schreiben, versuche zu sagen, *wie* es zusammenhängt. Das hilft dem Retriever später, den "Pfad" zu finden.
|
||||||
|
|
||||||
|
* Hängt es davon ab? -> `[[rel:depends_on Ziel]]`
|
||||||
|
* Ist es ähnlich? -> `[[rel:similar_to Ziel]]`
|
||||||
|
* Ist es eine Folge davon? -> `[[rel:caused_by Ziel]]`
|
||||||
|
|
||||||
|
### 4.2 Struktur hilft dem Chunker
|
||||||
|
Mindnet zerlegt deinen Text in Häppchen ("Chunks"). Hilf dabei:
|
||||||
|
* Verwende **Überschriften** (##), um Themen zu trennen.
|
||||||
|
* Schreibe **Absätze**, die einen Gedanken fassen.
|
||||||
|
* Vermeide endlose Textwüsten.
|
||||||
|
|
||||||
|
### 4.3 Typen nutzen
|
||||||
|
Setze im Frontmatter deiner Notizen den richtigen Typ.
|
||||||
|
* `type: project` -> Mindnet weiß: Das hat Aufgaben und Abhängigkeiten.
|
||||||
|
* `type: decision` -> Mindnet weiß: Das ist wichtig und begründet Dinge.
|
||||||
|
* `type: journal` -> Mindnet weiß: Das ist zeitgebunden und weniger wichtig für Grundsatzfragen.
|
||||||
|
|
||||||
|
**Beispiel:**
|
||||||
|
---
|
||||||
|
title: Entscheidung für Python
|
||||||
|
type: decision
|
||||||
|
---
|
||||||
|
Wir nutzen Python, weil es [[rel:solves AI Library Requirements]].
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 5. Feedback & Lernen
|
||||||
|
|
||||||
|
Mindnet wird schlauer, wenn du es pflegst.
|
||||||
|
|
||||||
|
### 5.1 Ergebnis fehlt?
|
||||||
|
* Existiert die Notiz im Vault?
|
||||||
|
* Ist sie isoliert (keine Links)? Isolierte Notizen haben keinen Graph-Bonus und werden schlechter gefunden. **Verlinke sie!**
|
||||||
|
* Ist der Typ `source`? Dann ist das Gewicht niedrig (0.5). Wenn es deine eigene Meinung ist, ändere den Typ auf `concept` oder `experience`.
|
||||||
|
|
||||||
|
### 5.2 Falsches Ergebnis?
|
||||||
|
* Ist die Notiz veraltet? Setze `status: archived` (wenn du Filter konfiguriert hast) oder lösche sie.
|
||||||
|
* Wird ein Begriff falsch verstanden? Füge Synonyme oder eine Definition hinzu.
|
||||||
|
|
||||||
|
### 5.3 Ausblick (Roadmap)
|
||||||
|
In Zukunft (WP08) wirst du Ergebnisse direkt mit "Daumen hoch/runter" bewerten können. Mindnet passt dann seine Gewichte (`retriever.yaml`) automatisch an, um deine Präferenzen zu lernen.
|
||||||
+35
-10
@@ -1,10 +1,35 @@
|
|||||||
fastapi
|
# --- API Server ---
|
||||||
uvicorn[standard]
|
fastapi>=0.116.1
|
||||||
qdrant-client
|
uvicorn[standard]>=0.35.0
|
||||||
pydantic>=2
|
# httpx wird oft für Tests benötigt
|
||||||
sentence-transformers
|
httpx>=0.28.1
|
||||||
torch
|
|
||||||
python-frontmatter
|
# --- Datenbank ---
|
||||||
tqdm
|
qdrant-client>=1.15.1
|
||||||
requests
|
|
||||||
numpy
|
# --- Datenmodelle & Validierung ---
|
||||||
|
pydantic>=2.11.7
|
||||||
|
numpy>=2.3.2
|
||||||
|
|
||||||
|
# --- Markdown & Parsing (Hier fehlten Pakete!) ---
|
||||||
|
python-frontmatter>=1.1.0
|
||||||
|
# WICHTIG: Das fehlte und verursachte den Fehler
|
||||||
|
markdown-it-py>=3.0.0
|
||||||
|
# WICHTIG: Für types.yaml und retriever.yaml
|
||||||
|
PyYAML>=6.0.2
|
||||||
|
python-slugify>=8.0.4
|
||||||
|
|
||||||
|
# --- KI & Embeddings ---
|
||||||
|
sentence-transformers>=5.1.0
|
||||||
|
# Torch wird meist durch sentence-transformers geholt,
|
||||||
|
# aber wir listen es explizit für Stabilität
|
||||||
|
torch>=2.0.0
|
||||||
|
|
||||||
|
# --- Utilities ---
|
||||||
|
# WICHTIG: Damit .env Dateien gelesen werden
|
||||||
|
python-dotenv>=1.1.1
|
||||||
|
requests>=2.32.5
|
||||||
|
tqdm>=4.67.1
|
||||||
|
|
||||||
|
# --- Testing ---
|
||||||
|
pytest>=8.4.2
|
||||||
@@ -0,0 +1,67 @@
|
|||||||
|
import argparse
|
||||||
|
import requests
|
||||||
|
import json
|
||||||
|
import sys
|
||||||
|
|
||||||
|
def main():
|
||||||
|
parser = argparse.ArgumentParser(description="Testet die Explanation-Funktion des Retrievers.")
|
||||||
|
parser.add_argument("--url", default="http://localhost:8002/query", help="URL zum Query Endpoint")
|
||||||
|
parser.add_argument("--query", default="mindnet", help="Suchbegriff")
|
||||||
|
args = parser.parse_args()
|
||||||
|
|
||||||
|
payload = {
|
||||||
|
"mode": "hybrid",
|
||||||
|
"query": args.query,
|
||||||
|
"top_k": 1,
|
||||||
|
"explain": True, # Das neue Flag aus WP-04b
|
||||||
|
"expand": {
|
||||||
|
"depth": 1,
|
||||||
|
"edge_types": ["references", "belongs_to", "depends_on", "related_to"]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
print(f"--- Sende Request an {args.url} ---")
|
||||||
|
try:
|
||||||
|
r = requests.post(args.url, json=payload)
|
||||||
|
r.raise_for_status()
|
||||||
|
data = r.json()
|
||||||
|
except Exception as e:
|
||||||
|
print(f"FEHLER: {e}")
|
||||||
|
sys.exit(1)
|
||||||
|
|
||||||
|
hits = data.get("results", [])
|
||||||
|
if not hits:
|
||||||
|
print("Keine Treffer gefunden.")
|
||||||
|
return
|
||||||
|
|
||||||
|
top_hit = hits[0]
|
||||||
|
print(f"\nTop Treffer: {top_hit.get('node_id')}")
|
||||||
|
print(f"Total Score: {top_hit.get('total_score'):.4f}")
|
||||||
|
|
||||||
|
# Explanation prüfen
|
||||||
|
expl = top_hit.get("explanation")
|
||||||
|
if not expl:
|
||||||
|
print("\n[FAIL] Keine 'explanation' im Response erhalten!")
|
||||||
|
sys.exit(1)
|
||||||
|
|
||||||
|
print("\n--- EXPLANATION LAYER ---")
|
||||||
|
|
||||||
|
bd = expl.get("breakdown", {})
|
||||||
|
print(f"Breakdown:")
|
||||||
|
print(f" Semantic Contribution: {bd.get('semantic_contribution', 0):.4f}")
|
||||||
|
print(f" Edge Contribution: {bd.get('edge_contribution', 0):.4f}")
|
||||||
|
print(f" Centrality Contribution: {bd.get('centrality_contribution', 0):.4f}")
|
||||||
|
print(f" Typ-Gewicht: {bd.get('node_weight', 0):.2f}")
|
||||||
|
|
||||||
|
print("\nReasons:")
|
||||||
|
for reason in expl.get("reasons", []):
|
||||||
|
kind = reason.get("kind", "").upper()
|
||||||
|
msg = reason.get("message", "")
|
||||||
|
impact = reason.get("score_impact")
|
||||||
|
impact_str = f" ({impact:+.4f})" if impact is not None else ""
|
||||||
|
print(f" [{kind}] {msg}{impact_str}")
|
||||||
|
|
||||||
|
print("\n[SUCCESS] Explanation Layer antwortet korrekt.")
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
main()
|
||||||
Reference in new issue
Block a user