Compare commits

...
Author SHA1 Message Date
Lars 27497fd6be Merge pull request 'Feat: WP-04b Explanation Layer' (#1) from WP04b into main
Deploy mindnet to llm-node / deploy (push) Successful in 3s
Reviewed-on: #1
2025-12-07 18:31:37 +01:00
Lars 466ce3ca82 angepasster retriever 2025-12-07 16:57:01 +01:00
Lars 8b5af5ec65 dto 2025-12-07 16:50:32 +01:00
Lars 34cbc0c0eb Erste Version des WP04b 2025-12-07 16:32:02 +01:00
Lars 52ff4bbff5 OK
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-12-07 16:20:16 +01:00
Lars 9e7104e362 Neue Dokumentationsdateien
Deploy mindnet to llm-node / deploy (push) Successful in 6s
2025-12-07 15:49:44 +01:00
Lars 882ae5368f test
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-12-07 12:43:20 +01:00
Lars 12a424ce23 docs/appendix.md hinzugefügt
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-12-07 12:15:52 +01:00
Lars c3230761e8 docs/user_guide.md hinzugefügt
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-12-07 12:13:21 +01:00
Lars f5104008c2 docs/admin_guide.md hinzugefügt
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-12-07 12:11:51 +01:00
Lars 013e8c6d0c docs/developer_guide.md hinzugefügt
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-12-07 12:09:43 +01:00
Lars 603bba533b docs/pipeline_playbook.md hinzugefügt
Deploy mindnet to llm-node / deploy (push) Successful in 4s
2025-12-07 12:07:03 +01:00
Lars e202a8d88b docs/mindnet_technical_architecture.md aktualisiert
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-12-07 11:59:05 +01:00
Lars c56a31c6bc docs/Knowledge_Design_Manual.md hinzugefügt
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-12-07 11:52:09 +01:00
Lars b73b18bf9a docs/mindnet_functional_architecture.md aktualisiert
Deploy mindnet to llm-node / deploy (push) Successful in 4s
2025-12-07 11:38:25 +01:00
Lars 0f351252b2 Programmmanagement/Überarbeitungshinweise_WP04.md hinzugefügt
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-12-06 18:32:45 +01:00
Lars d7d7411fa0 Programmmanagement/Überarbeitungshinweise_WP03.md hinzugefügt
Deploy mindnet to llm-node / deploy (push) Successful in 4s
2025-12-06 18:30:08 +01:00
Lars 45af7f074c Programmmanagement/Dokumentationsrahmenplan.md hinzugefügt
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-12-06 12:48:16 +01:00
Lars 70ab118612 Programmmanagement/Programmplan_V2.2.md aktualisiert
Deploy mindnet to llm-node / deploy (push) Successful in 4s
2025-12-06 10:35:27 +01:00
Lars ba0cdea9d0 Programmmanagement/Programmplan_V2.1.md aktualisiert
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-12-05 20:39:46 +01:00
Lars 09500ff764 Programmmanagement/Programmplan_V2.1 hinzugefügt
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-12-05 20:39:04 +01:00
Lars b29ce4a0a6 scripts/health_check_mindnet.py aktualisiert
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-12-05 12:12:30 +01:00
Lars 311e598b69 scripts/health_check_mindnet.py hinzugefügt
Deploy mindnet to llm-node / deploy (push) Successful in 4s
2025-12-04 21:03:24 +01:00
Lars 413dca770c docs/wp04_retriever_scoring.md hinzugefügt
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-12-04 20:38:00 +01:00
Lars 9d9239b11e app/core/retriever.py aktualisiert
Deploy mindnet to llm-node / deploy (push) Successful in 4s
2025-12-04 15:55:39 +01:00
Lars a571c41c61 app/core/retriever.py aktualisiert
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-12-04 15:43:32 +01:00
Lars ba1fab9dcf config/retriever.yaml aktualisiert
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-12-04 15:43:00 +01:00
Lars 5dc9c13a71 tests/diag_subgraph_for_note.py hinzugefügt
Deploy mindnet to llm-node / deploy (push) Successful in 4s
2025-12-04 13:52:18 +01:00
Lars 70821bae5a tests/diag_edges_for_note.py aktualisiert
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-12-04 13:42:14 +01:00
Lars 486abf82dd tests/diag_edges_for_note.py hinzugefügt
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-12-04 13:37:42 +01:00
Lars 19afe3af33 config/types.yaml aktualisiert
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-12-04 13:35:04 +01:00
Lars 113042b7f4 config/types.yaml aktualisiert
Deploy mindnet to llm-node / deploy (push) Successful in 2s
2025-12-04 12:38:20 +01:00
Lars f8eebd91cb app/core/note_payload.py aktualisiert
Deploy mindnet to llm-node / deploy (push) Successful in 4s
2025-12-04 12:37:31 +01:00
Lars 00297fc354 app/core/note_payload.py aktualisiert
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-12-04 12:11:51 +01:00
Lars 5baac082f9 app/core/graph_adapter.py aktualisiert
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-12-04 11:52:18 +01:00
Lars 611b0aa54e app/core/retriever.py aktualisiert
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-12-04 11:35:53 +01:00
Lars 110f0dbcf5 app/core/retriever.py aktualisiert
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-12-04 11:16:33 +01:00
Lars 1688cf0a1e app/core/graph_adapter.py aktualisiert
Deploy mindnet to llm-node / deploy (push) Successful in 4s
2025-12-04 11:16:03 +01:00
Lars 13b7c8858a app/core/graph_adapter.py aktualisiert
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-12-03 18:40:06 +01:00
Lars b8b6f243d1 Dateien nach "app/core" hochladen
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-12-03 18:27:06 +01:00
Lars eaa6e805ce Dateien nach "config" hochladen
Deploy mindnet to llm-node / deploy (push) Successful in 5s
2025-12-03 18:26:18 +01:00
Lars 05dbb21c58 Dateien nach "tests" hochladen
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-12-03 14:44:45 +01:00
Lars f1f4358dee app/core/note_payload.py aktualisiert
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-12-03 14:27:09 +01:00
Lars 3374c41f07 Dateien nach "docs" hochladen
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-12-03 12:07:42 +01:00
Lars 95affe87e5 Dateien nach "tests" hochladen
Deploy mindnet to llm-node / deploy (push) Successful in 5s
2025-12-03 12:07:29 +01:00
Lars 5e86398fcd Dateien nach "app/core" hochladen
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-12-03 12:03:37 +01:00
Lars 844f0cbe42 Dateien nach "tests" hochladen
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-12-03 12:03:22 +01:00
Lars 4d5d7847e5 Dateien nach "tests" hochladen
Deploy mindnet to llm-node / deploy (push) Successful in 2s
2025-12-03 10:39:24 +01:00
Lars 06795feed6 Dateien nach "app/core" hochladen
Deploy mindnet to llm-node / deploy (push) Successful in 4s
2025-12-03 10:39:11 +01:00
Lars a4548a7ee1 Dateien nach "app/core" hochladen
Deploy mindnet to llm-node / deploy (push) Successful in 4s
2025-12-03 10:35:28 +01:00
Lars 42216865e2 app/core/retriever.py aktualisiert
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-12-02 17:37:06 +01:00
Lars e48bdb2401 tests/test_retriever_basic.py hinzugefügt
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-12-02 17:32:40 +01:00
Lars c67eb4b2f3 app/core/retriever.py aktualisiert
Deploy mindnet to llm-node / deploy (push) Successful in 6s
2025-12-02 17:31:49 +01:00
Lars fafa74b0b8 docs/mindnet_v2_implementation_playbook.md aktualisiert
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-11-18 11:19:22 +01:00
Lars 049a39aba3 docs/mindnet_technical_architecture.md aktualisiert
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-11-18 10:38:03 +01:00
Lars cd26430a61 Dateien nach "app/core" hochladen
Deploy mindnet to llm-node / deploy (push) Successful in 4s
2025-11-18 07:52:39 +01:00
Lars aab010ff17 app/core/derive_edges.py aktualisiert
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-11-18 07:50:46 +01:00
Lars 9a7bc32051 Dateien nach "app/core" hochladen
Deploy mindnet to llm-node / deploy (push) Successful in 4s
2025-11-17 21:55:41 +01:00
Lars bfdd8ac6be app/core/derive_edges.py aktualisiert
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-11-17 21:53:49 +01:00
Lars 018669fb87 Dateien nach "app/core" hochladen
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-11-17 21:44:03 +01:00
Lars fb2de78d62 Dateien nach "app/core" hochladen
Deploy mindnet to llm-node / deploy (push) Successful in 4s
2025-11-17 21:42:26 +01:00
Lars 7e8d6c1954 app/core/derive_edges.py aktualisiert
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-11-17 21:38:44 +01:00
Lars d21230c6c3 Dateien nach "app/core" hochladen
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-11-17 21:24:22 +01:00
Lars 4e98d5bfa1 Dateien nach "app/core" hochladen
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-11-17 21:23:49 +01:00
Lars 8998269377 app/core/derive_edges.py aktualisiert
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-11-17 21:16:35 +01:00
Lars 6e9a227ad2 app/core/derive_edges.py aktualisiert
Deploy mindnet to llm-node / deploy (push) Successful in 4s
2025-11-17 21:05:36 +01:00
Lars 4e7506da5a config/types.yaml aktualisiert
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-11-17 19:37:56 +01:00
Lars 06ad93c77c config/types.yaml aktualisiert
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-11-17 19:36:56 +01:00
Lars 0bb7b34259 docs/mindnet_functional_architecture.md aktualisiert
Deploy mindnet to llm-node / deploy (push) Successful in 4s
2025-11-17 18:46:39 +01:00
Lars 859c17b49d tests/test_edges_all.py aktualisiert
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-11-17 16:37:23 +01:00
Lars 46b26c9624 scripts/edges_full_check.py aktualisiert
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-11-17 16:37:00 +01:00
Lars fd215c18e4 app/core/derive_edges.py aktualisiert
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-11-17 16:27:40 +01:00
Lars efa3afc7dc Dateien nach "app/core" hochladen
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-11-17 16:18:10 +01:00
Lars e03dd66051 app/core/derive_edges.py aktualisiert
Deploy mindnet to llm-node / deploy (push) Successful in 5s
2025-11-17 16:14:57 +01:00
Lars 3476fe5fae tests/test_edges_smoke.py aktualisiert
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-11-17 16:04:57 +01:00
Lars 3e08c8347e scripts/edges_full_check.py aktualisiert
Deploy mindnet to llm-node / deploy (push) Successful in 4s
2025-11-17 16:04:21 +01:00
Lars c691123d2d config/types.yaml aktualisiert
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-11-17 15:58:34 +01:00
Lars a4b81535e8 Dateien nach "app/core" hochladen
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-11-17 15:53:38 +01:00
Lars a898cf4b65 Dateien nach "app/core" hochladen
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-11-17 15:52:23 +01:00
Lars 10009a0a43 Dateien nach "app/core" hochladen
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-11-17 15:49:39 +01:00
Lars 4dfe47ff99 Dateien nach "app/core" hochladen
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-11-17 15:48:12 +01:00
Lars bd997e61d6 app/core/derive_edges.py aktualisiert
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-11-17 15:46:56 +01:00
Lars 23d0670126 app/core/derive_edges.py aktualisiert
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-11-17 15:39:18 +01:00
Lars 12c600edbe scripts/edges_full_check.py aktualisiert
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-11-17 15:31:58 +01:00
Lars e4115e705e tests/test_edges_all.py aktualisiert
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-11-17 15:31:36 +01:00
Lars 0cbc4a2d72 tests/test_edges_all.py hinzugefügt
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-11-17 15:17:29 +01:00
Lars cea6d35729 scripts/edges_full_check.py hinzugefügt
Deploy mindnet to llm-node / deploy (push) Successful in 4s
2025-11-17 15:17:02 +01:00
Lars 4c56918d8a app/core/derive_edges.py aktualisiert
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-11-17 13:06:29 +01:00
Lars f17263417e app/core/note_payload.py aktualisiert
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-11-17 12:21:59 +01:00
Lars 6f0b463489 app/core/derive_edges.py aktualisiert
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-11-17 12:21:28 +01:00
Lars 28c01caa1a tests/test_edges_defaults_smoke.py aktualisiert
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-11-17 11:10:00 +01:00
Lars 95b59e9b0a app/core/derive_edges.py aktualisiert
Deploy mindnet to llm-node / deploy (push) Successful in 2s
2025-11-17 11:09:05 +01:00
Lars bc967f1f6e tests/test_edges_defaults_smoke.py hinzugefügt
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-11-17 10:58:15 +01:00
Lars 4228b8a74f app/core/derive_edges.py aktualisiert
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-11-17 10:57:30 +01:00
41 changed files with 6778 additions and 1036 deletions

No files matched your search

+3
View File
@@ -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.
+772
View File
@@ -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 Änderungs­erkennung.
**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 Änderungs­erkennung (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 Änderungs­erkennung 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
+4
View File
@@ -33,3 +33,7 @@ python3 scripts/import_markdown.py --vault /path/to/Obsidian
- `POST /qdrant/query` → semantic search over chunks with optional filters
See `scripts/quick_test.sh` for a runnable example.
>Anmerkung:
Diese Datei ist veraltet
+353 -38
View File
@@ -2,27 +2,45 @@
# -*- coding: utf-8 -*-
"""
Modul: app/core/derive_edges.py
Version: 1.4.0
Robuste Kantenbildung für mindnet (Notes/Chunks):
- belongs_to (chunk -> note)
- next / prev (chunk-Kette)
- references (chunk-scope) aus Chunk.window/text
- optional references/backlink (note-scope)
Wichtig: Wikilinks werden mit der Parser-Funktion `extract_wikilinks` extrahiert,
damit Varianten wie [[id#anchor]] oder [[id|label]] korrekt auf 'id' reduziert werden.
Zweck:
- Bewahrt bestehende Edgelogik (belongs_to, prev/next, references, backlink)
- Ergänzt typenbasierte Default-Kanten (edge_defaults aus config/types.yaml)
- Unterstützt "typed inline relations":
* [[rel:KIND | Target]]
* [[rel:KIND Target]]
* rel: KIND [[Target]]
- Unterstützt Obsidian-Callouts:
* > [!edge] KIND: [[Target]] [[Target2]] ...
Kompatibilität:
- build_edges_for_note(...) Signatur unverändert
- rule_id Werte:
* structure:belongs_to
* structure:order
* explicit:wikilink
* inline:rel
* callout:edge
* edge_defaults:<type>:<relation>
* derived:backlink
"""
from __future__ import annotations
from typing import Dict, List, Optional, Iterable
import os
import re
from typing import Iterable, List, Optional, Tuple, Set, Dict
# Parser-Extraktion für saubere Wikilinks
from app.core.parser import extract_wikilinks
try:
import yaml # optional, nur für types.yaml
except Exception: # pragma: no cover
yaml = None
# --------------------------------------------------------------------------- #
# Utilities
# --------------------------------------------------------------------------- #
def _get(d: dict, *keys, default=None):
for k in keys:
if k in d and d[k] is not None:
if isinstance(d, dict) and k in d and d[k] is not None:
return d[k]
return default
@@ -36,8 +54,8 @@ def _chunk_text_for_refs(chunk: dict) -> str:
or ""
)
def _dedupe(seq: Iterable[str]) -> List[str]:
seen = set()
def _dedupe_seq(seq: Iterable[str]) -> List[str]:
seen: Set[str] = set()
out: List[str] = []
for s in seq:
if s not in seen:
@@ -48,15 +66,177 @@ def _dedupe(seq: Iterable[str]) -> List[str]:
def _edge(kind: str, scope: str, source_id: str, target_id: str, note_id: str, extra: Optional[dict] = None) -> dict:
pl = {
"kind": kind,
"scope": scope, # "chunk" | "note"
"relation": kind, # Alias (v2)
"scope": scope, # "chunk" | "note"
"source_id": source_id,
"target_id": target_id,
"note_id": note_id, # Träger/Quelle der Kante (aktuelle Note)
"note_id": note_id, # Träger-Note der Kante
}
if extra:
pl.update(extra)
return pl
def _mk_edge_id(kind: str, s: str, t: str, scope: str, rule_id: Optional[str] = None) -> str:
base = f"{kind}:{s}->{t}#{scope}"
if rule_id:
base += f"|{rule_id}"
try:
import hashlib
return hashlib.blake2s(base.encode("utf-8"), digest_size=12).hexdigest()
except Exception: # pragma: no cover
return base
# --------------------------------------------------------------------------- #
# Typen-Registry (types.yaml)
# --------------------------------------------------------------------------- #
def _env(n: str, default: Optional[str] = None) -> str:
v = os.getenv(n)
return v if v is not None else (default or "")
def _load_types_registry() -> dict:
"""Lädt die YAML-Registry aus MINDNET_TYPES_FILE oder ./config/types.yaml"""
p = _env("MINDNET_TYPES_FILE", "./config/types.yaml")
if not os.path.isfile(p) or yaml is None:
return {}
try:
with open(p, "r", encoding="utf-8") as f:
data = yaml.safe_load(f) or {}
return data
except Exception:
return {}
def _get_types_map(reg: dict) -> dict:
if isinstance(reg, dict) and isinstance(reg.get("types"), dict):
return reg["types"]
return reg if isinstance(reg, dict) else {}
def _edge_defaults_for(note_type: Optional[str], reg: dict) -> List[str]:
"""
Liefert die edge_defaults-Liste für den gegebenen Notiztyp.
Fallback-Reihenfolge:
1) reg['types'][note_type]['edge_defaults']
2) reg['defaults']['edge_defaults'] (oder 'default'/'global')
3) []
"""
types_map = _get_types_map(reg)
if note_type and isinstance(types_map, dict):
t = types_map.get(note_type)
if isinstance(t, dict) and isinstance(t.get("edge_defaults"), list):
return [str(x) for x in t["edge_defaults"] if isinstance(x, str)]
for key in ("defaults", "default", "global"):
v = reg.get(key)
if isinstance(v, dict) and isinstance(v.get("edge_defaults"), list):
return [str(x) for x in v["edge_defaults"] if isinstance(x, str)]
return []
# --------------------------------------------------------------------------- #
# Parser für Links / Relationen
# --------------------------------------------------------------------------- #
# Normale Wikilinks (Fallback)
_WIKILINK_RE = re.compile(r"\[\[(?:[^\|\]]+\|)?([a-zA-Z0-9_\-#:. ]+)\]\]")
# Getypte Inline-Relationen:
# [[rel:KIND | Target]]
# [[rel:KIND Target]]
_REL_PIPE = re.compile(r"\[\[\s*rel:(?P<kind>[a-z_]+)\s*\|\s*(?P<target>[^\]]+?)\s*\]\]", re.IGNORECASE)
_REL_SPACE = re.compile(r"\[\[\s*rel:(?P<kind>[a-z_]+)\s+(?P<target>[^\]]+?)\s*\]\]", re.IGNORECASE)
# rel: KIND [[Target]] (reines Textmuster)
_REL_TEXT = re.compile(r"rel\s*:\s*(?P<kind>[a-z_]+)\s*\[\[\s*(?P<target>[^\]]+?)\s*\]\]", re.IGNORECASE)
def _extract_typed_relations(text: str) -> Tuple[List[Tuple[str,str]], str]:
"""
Gibt Liste (kind, target) zurück und den Text mit entfernten getypten Relation-Links,
damit die generische Wikilink-Erkennung sie nicht doppelt zählt.
Unterstützt drei Varianten:
- [[rel:KIND | Target]]
- [[rel:KIND Target]]
- rel: KIND [[Target]]
"""
pairs: List[Tuple[str,str]] = []
def _collect(m):
k = (m.group("kind") or "").strip().lower()
t = (m.group("target") or "").strip()
if k and t:
pairs.append((k, t))
return "" # Link entfernen
text = _REL_PIPE.sub(_collect, text)
text = _REL_SPACE.sub(_collect, text)
text = _REL_TEXT.sub(_collect, text)
return pairs, text
# Obsidian Callout Parser
_CALLOUT_START = re.compile(r"^\s*>\s*\[!edge\]\s*(.*)$", re.IGNORECASE)
_REL_LINE = re.compile(r"^(?P<kind>[a-z_]+)\s*:\s*(?P<targets>.+?)\s*$", re.IGNORECASE)
_WIKILINKS_IN_LINE = re.compile(r"\[\[([^\]]+)\]\]")
def _extract_callout_relations(text: str) -> Tuple[List[Tuple[str,str]], str]:
"""
Findet [!edge]-Callouts und extrahiert (kind, target). Entfernt den gesamten
Callout-Block aus dem Text (damit Wikilinks daraus nicht zusätzlich als
"references" gezählt werden).
"""
if not text:
return [], text
lines = text.splitlines()
out_pairs: List[Tuple[str,str]] = []
keep_lines: List[str] = []
i = 0
while i < len(lines):
m = _CALLOUT_START.match(lines[i])
if not m:
keep_lines.append(lines[i])
i += 1
continue
block_lines: List[str] = []
first_rest = m.group(1) or ""
if first_rest.strip():
block_lines.append(first_rest)
i += 1
while i < len(lines) and lines[i].lstrip().startswith('>'):
block_lines.append(lines[i].lstrip()[1:].lstrip())
i += 1
for bl in block_lines:
mrel = _REL_LINE.match(bl)
if not mrel:
continue
kind = (mrel.group("kind") or "").strip().lower()
targets = mrel.group("targets") or ""
found = _WIKILINKS_IN_LINE.findall(targets)
if found:
for t in found:
t = t.strip()
if t:
out_pairs.append((kind, t))
else:
for raw in re.split(r"[,;]", targets):
t = raw.strip()
if t:
out_pairs.append((kind, t))
# Callout wird NICHT in keep_lines übernommen
continue
remainder = "\n".join(keep_lines)
return out_pairs, remainder
def _extract_wikilinks(text: str) -> List[str]:
ids: List[str] = []
for m in _WIKILINK_RE.finditer(text or ""):
ids.append(m.group(1).strip())
return ids
# --------------------------------------------------------------------------- #
# Hauptfunktion
# --------------------------------------------------------------------------- #
def build_edges_for_note(
note_id: str,
chunks: List[dict],
@@ -68,53 +248,188 @@ def build_edges_for_note(
- belongs_to: für jeden Chunk (chunk -> note)
- next / prev: zwischen aufeinanderfolgenden Chunks
- references: pro Chunk aus window/text
- references: pro Chunk aus window/text (via Wikilinks)
- typed inline relations: [[rel:KIND | Target]] / [[rel:KIND Target]] / rel: KIND [[Target]]
- Obsidian Callouts: > [!edge] KIND: [[Target]] [[Target2]]
- optional note-scope references/backlinks: dedupliziert über alle Chunk-Funde + note_level_references
- typenbasierte Default-Kanten (edge_defaults) je gefundener Referenz
"""
edges: List[dict] = []
# belongs_to
# Note-Typ (aus erstem Chunk erwartet)
note_type = None
if chunks:
note_type = _get(chunks[0], "type")
# 1) belongs_to
for ch in chunks:
cid = _get(ch, "chunk_id", "id")
if not cid:
continue
edges.append(_edge("belongs_to", "chunk", cid, note_id, note_id, {"chunk_id": cid}))
edges.append(_edge("belongs_to", "chunk", cid, note_id, note_id, {
"chunk_id": cid,
"edge_id": _mk_edge_id("belongs_to", cid, note_id, "chunk", "structure:belongs_to"),
"provenance": "rule",
"rule_id": "structure:belongs_to",
"confidence": 1.0,
}))
# next/prev
# 2) next / prev
for i in range(len(chunks) - 1):
a, b = chunks[i], chunks[i + 1]
a_id = _get(a, "chunk_id", "id")
b_id = _get(b, "chunk_id", "id")
if not a_id or not b_id:
continue
edges.append(_edge("next", "chunk", a_id, b_id, note_id, {"chunk_id": a_id}))
edges.append(_edge("prev", "chunk", b_id, a_id, note_id, {"chunk_id": b_id}))
edges.append(_edge("next", "chunk", a_id, b_id, note_id, {
"chunk_id": a_id,
"edge_id": _mk_edge_id("next", a_id, b_id, "chunk", "structure:order"),
"provenance": "rule",
"rule_id": "structure:order",
"confidence": 0.95,
}))
edges.append(_edge("prev", "chunk", b_id, a_id, note_id, {
"chunk_id": b_id,
"edge_id": _mk_edge_id("prev", b_id, a_id, "chunk", "structure:order"),
"provenance": "rule",
"rule_id": "structure:order",
"confidence": 0.95,
}))
# references (chunk-scope) – Links aus window bevorzugen (Overlap-fest)
# 3) references + typed inline + callouts + defaults (chunk-scope)
reg = _load_types_registry()
defaults = _edge_defaults_for(note_type, reg)
refs_all: List[str] = []
for ch in chunks:
cid = _get(ch, "chunk_id", "id")
if not cid:
continue
txt = _chunk_text_for_refs(ch)
refs = extract_wikilinks(txt) # Parser-Logik
raw = _chunk_text_for_refs(ch)
# 3a) typed inline relations
typed, remainder = _extract_typed_relations(raw)
for kind, target in typed:
kind = kind.strip().lower()
if not kind or not target:
continue
edges.append(_edge(kind, "chunk", cid, target, note_id, {
"chunk_id": cid,
"edge_id": _mk_edge_id(kind, cid, target, "chunk", "inline:rel"),
"provenance": "explicit",
"rule_id": "inline:rel",
"confidence": 0.95,
}))
if kind in {"related_to", "similar_to"}:
edges.append(_edge(kind, "chunk", target, cid, note_id, {
"chunk_id": cid,
"edge_id": _mk_edge_id(kind, target, cid, "chunk", "inline:rel"),
"provenance": "explicit",
"rule_id": "inline:rel",
"confidence": 0.95,
}))
# 3b) callouts
call_pairs, remainder2 = _extract_callout_relations(remainder)
for kind, target in call_pairs:
k = (kind or "").strip().lower()
if not k or not target:
continue
edges.append(_edge(k, "chunk", cid, target, note_id, {
"chunk_id": cid,
"edge_id": _mk_edge_id(k, cid, target, "chunk", "callout:edge"),
"provenance": "explicit",
"rule_id": "callout:edge",
"confidence": 0.95,
}))
if k in {"related_to", "similar_to"}:
edges.append(_edge(k, "chunk", target, cid, note_id, {
"chunk_id": cid,
"edge_id": _mk_edge_id(k, target, cid, "chunk", "callout:edge"),
"provenance": "explicit",
"rule_id": "callout:edge",
"confidence": 0.95,
}))
# 3c) generische Wikilinks → references (+ defaults je Ref)
refs = _extract_wikilinks(remainder2)
for r in refs:
edges.append(_edge("references", "chunk", cid, r, note_id, {"chunk_id": cid, "ref_text": r}))
edges.append(_edge("references", "chunk", cid, r, note_id, {
"chunk_id": cid,
"ref_text": r,
"edge_id": _mk_edge_id("references", cid, r, "chunk", "explicit:wikilink"),
"provenance": "explicit",
"rule_id": "explicit:wikilink",
"confidence": 1.0,
}))
for rel in defaults:
if rel == "references":
continue
edges.append(_edge(rel, "chunk", cid, r, note_id, {
"chunk_id": cid,
"edge_id": _mk_edge_id(rel, cid, r, "chunk", f"edge_defaults:{note_type}:{rel}"),
"provenance": "rule",
"rule_id": f"edge_defaults:{note_type}:{rel}",
"confidence": 0.7,
}))
if rel in {"related_to", "similar_to"}:
edges.append(_edge(rel, "chunk", r, cid, note_id, {
"chunk_id": cid,
"edge_id": _mk_edge_id(rel, r, cid, "chunk", f"edge_defaults:{note_type}:{rel}"),
"provenance": "rule",
"rule_id": f"edge_defaults:{note_type}:{rel}",
"confidence": 0.7,
}))
refs_all.extend(refs)
# optional: note-scope references/backlinks
# 4) optional note-scope refs/backlinks (+ defaults)
if include_note_scope_refs:
refs_note = refs_all[:]
refs_note = list(refs_all or [])
if note_level_references:
refs_note.extend([r for r in note_level_references if isinstance(r, str) and r])
refs_note = _dedupe(refs_note)
refs_note = _dedupe_seq(refs_note)
for r in refs_note:
edges.append(_edge("references", "note", note_id, r, note_id))
edges.append(_edge("backlink", "note", r, note_id, note_id))
edges.append(_edge("references", "note", note_id, r, note_id, {
"edge_id": _mk_edge_id("references", note_id, r, "note", "explicit:note_scope"),
"provenance": "explicit",
"rule_id": "explicit:note_scope",
"confidence": 1.0,
}))
edges.append(_edge("backlink", "note", r, note_id, note_id, {
"edge_id": _mk_edge_id("backlink", r, note_id, "note", "derived:backlink"),
"provenance": "rule",
"rule_id": "derived:backlink",
"confidence": 0.9,
}))
for rel in defaults:
if rel == "references":
continue
edges.append(_edge(rel, "note", note_id, r, note_id, {
"edge_id": _mk_edge_id(rel, note_id, r, "note", f"edge_defaults:{note_type}:{rel}"),
"provenance": "rule",
"rule_id": f"edge_defaults:{note_type}:{rel}",
"confidence": 0.7,
}))
if rel in {"related_to", "similar_to"}:
edges.append(_edge(rel, "note", r, note_id, note_id, {
"edge_id": _mk_edge_id(rel, r, note_id, "note", f"edge_defaults:{note_type}:{rel}"),
"provenance": "rule",
"rule_id": f"edge_defaults:{note_type}:{rel}",
"confidence": 0.7,
}))
# Dedupe (Schlüssel: kind,source_id,target_id,scope)
dedup = {}
# 5) De-Dupe (source_id, target_id, relation, rule_id)
seen: Set[Tuple[str,str,str,str]] = set()
out: List[dict] = []
for e in edges:
k = (e["kind"], e["source_id"], e["target_id"], e.get("scope", ""))
dedup[k] = e
return list(dedup.values())
s = str(e.get("source_id") or "")
t = str(e.get("target_id") or "")
rel = str(e.get("relation") or e.get("kind") or "edge")
rule = str(e.get("rule_id") or "")
key = (s, t, rel, rule)
if key in seen:
continue
seen.add(key)
out.append(e)
return out
+210 -46
View File
@@ -1,92 +1,256 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
app/core/graph_adapter.py — Adjazenzaufbau & Subgraph-Expansion (WP-04)
app/core/graph_adapter.py — Adjazenzaufbau & Subgraph-Expansion
Zweck:
Baut aus Qdrant-Edges (Collection: *_edges) einen leichten In-Memory-Graph
und liefert Edge-basierte Kennzahlen (In-Degree, Out-Degree, edge_bonus).
Baut aus Qdrant-Edges (Collection: *_edges) einen leichten In-Memory-Graph.
Kompatibilität:
Python 3.12+, qdrant-client 1.x
- WP-04a: Liefert Scores (edge_bonus, centrality).
- WP-04b: Liefert jetzt auch Struktur-Daten für Erklärungen (Reverse-Lookup).
Version:
0.1.0 (Erstanlage)
Stand:
2025-10-07
Bezug:
- WP-04 Edge-Gewichtungen und Heuristiken
- app/core/qdrant_points.py (get_edges_for_sources)
Nutzung:
from app.core.graph_adapter import expand
Änderungsverlauf:
0.1.0 (2025-10-07) – Erstanlage.
0.4.0 (Update für WP-04b: Reverse Adjacency für Explainability)
"""
from __future__ import annotations
from typing import Dict, List, Optional, DefaultDict
from collections import defaultdict
from qdrant_client import QdrantClient
from app.core.qdrant_points import get_edges_for_sources
EDGE_BASE_WEIGHTS = {
"references": 0.20,
"belongs_to": 0.10,
"next": 0.06,
"prev": 0.06,
"backlink": 0.04,
"references_at": 0.08,
from typing import Dict, List, Optional, DefaultDict, Any
from collections import defaultdict
from qdrant_client import QdrantClient
from qdrant_client.http import models as rest
from app.core.qdrant import collection_names
# Legacy-Import Fallback
try: # pragma: no cover
from app.core.qdrant_points import get_edges_for_sources # type: ignore
except Exception: # pragma: no cover
get_edges_for_sources = None # type: ignore
# Basisgewichte je Edge-Typ (WP-04a Config)
EDGE_BASE_WEIGHTS: Dict[str, float] = {
# Struktur
"belongs_to": 0.10,
"next": 0.06,
"prev": 0.06,
"backlink": 0.04,
"references_at": 0.08,
# Wissen
"references": 0.20,
"depends_on": 0.18,
"related_to": 0.15,
"similar_to": 0.12,
}
class Subgraph:
"""Leichtgewichtiger Subgraph mit Adjazenzlisten & einfachen Kennzahlen."""
def _edge_weight(pl: Dict) -> float:
"""Berechnet das effektive Edge-Gewicht aus kind + confidence."""
kind = pl.get("kind", "edge")
base = EDGE_BASE_WEIGHTS.get(kind, 0.0)
def __init__(self):
conf_raw = pl.get("confidence", None)
try:
conf = float(conf_raw) if conf_raw is not None else None
except Exception:
conf = None
if conf is None:
return base
if conf < 0.0: conf = 0.0
if conf > 1.0: conf = 1.0
return base * conf
def _fetch_edges(
client: QdrantClient,
prefix: str,
seeds: List[str],
edge_types: Optional[List[str]] = None,
limit: int = 2048,
) -> List[Dict]:
"""
Holt Edges direkt aus der *_edges Collection.
Filter: source_id IN seeds OR target_id IN seeds OR note_id IN seeds
"""
if not seeds or limit <= 0:
return []
_, _, edges_col = collection_names(prefix)
seed_conditions = []
for field in ("source_id", "target_id", "note_id"):
for s in seeds:
seed_conditions.append(
rest.FieldCondition(key=field, match=rest.MatchValue(value=str(s)))
)
seeds_filter = rest.Filter(should=seed_conditions) if seed_conditions else None
type_filter = None
if edge_types:
type_conds = [
rest.FieldCondition(key="kind", match=rest.MatchValue(value=str(k)))
for k in edge_types
]
type_filter = rest.Filter(should=type_conds)
must = []
if seeds_filter: must.append(seeds_filter)
if type_filter: must.append(type_filter)
flt = rest.Filter(must=must) if must else None
pts, _ = client.scroll(
collection_name=edges_col,
scroll_filter=flt,
limit=limit,
with_payload=True,
with_vectors=False,
)
out: List[Dict] = []
for p in pts or []:
pl = dict(p.payload or {})
if pl:
out.append(pl)
return out
class Subgraph:
"""Leichtgewichtiger Subgraph mit Adjazenzlisten & Kennzahlen."""
def __init__(self) -> None:
# Forward: source -> [targets]
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.out_degree: DefaultDict[str, int] = defaultdict(int)
def add_edge(self, e: Dict):
src = e["source"]; tgt = e["target"]; kind = e["kind"]
def add_edge(self, e: Dict) -> None:
"""
Fügt eine Kante hinzu und aktualisiert Forward/Reverse Indizes.
e muss enthalten: source, target, kind, weight.
"""
src = e.get("source")
tgt = e.get("target")
kind = e.get("kind")
weight = e.get("weight", EDGE_BASE_WEIGHTS.get(kind, 0.0))
self.adj[src].append({"target": tgt, "kind": kind, "weight": weight})
owner = e.get("note_id")
if not src or not tgt:
return
# 1. Primäre Adjazenz (Forward)
edge_data = {"target": tgt, "kind": kind, "weight": weight}
self.adj[src].append(edge_data)
self.out_degree[src] += 1
self.in_degree[tgt] += 1
# 2. Reverse Adjazenz (Neu für Explanation)
# Wir speichern, woher die Kante kam.
rev_data = {"source": src, "kind": kind, "weight": weight}
self.reverse_adj[tgt].append(rev_data)
# 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:
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:
"""Summe der ausgehenden Kantengewichte (Hub-Score)."""
return sum(edge["weight"] for edge in self.adj.get(node_id, []))
def edge_bonus(self, node_id: str) -> float:
"""API für Retriever (WP-04a Kompatibilität)."""
return self.aggregate_edge_bonus(node_id)
def centrality_bonus(self, node_id: str) -> float:
"""Log-gedämpfte Zentralität (In-Degree)."""
import math
# Log-gedämpfter Bonus, hart begrenzt
return min(math.log1p(self.in_degree.get(node_id, 0)) / 10.0, 0.15)
indeg = self.in_degree.get(node_id, 0)
if indeg <= 0:
return 0.0
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(client: QdrantClient, prefix: str, seeds: List[str],
depth: int = 1, edge_types: Optional[List[str]] = None) -> Subgraph:
def expand(
client: QdrantClient,
prefix: str,
seeds: List[str],
depth: int = 1,
edge_types: Optional[List[str]] = None,
) -> Subgraph:
"""
Expandiert ab Seeds entlang von Edges (bis depth), optional gefiltert nach Typen.
Seeds sind stabile payload-IDs (z. B. note_id, chunk_id).
Expandiert ab Seeds entlang von Edges (bis `depth`).
"""
sg = Subgraph()
frontier = set(seeds)
visited = set()
for _ in range(max(depth, 0)):
max_depth = max(depth, 0)
for _ in range(max_depth):
if not frontier:
break
edges = get_edges_for_sources(client, prefix, list(frontier), edge_types=edge_types, limit=2048)
edges_payloads = _fetch_edges(
client=client,
prefix=prefix,
seeds=list(frontier),
edge_types=edge_types,
limit=2048,
)
next_frontier = set()
for pl in edges:
for pl in edges_payloads:
src = pl.get("source_id")
tgt = pl.get("target_id")
# Skip invalid edges
if not src or not tgt:
continue
e = {
"source": pl.get("source_id"),
"target": pl.get("target_id"),
"source": src,
"target": tgt,
"kind": pl.get("kind", "edge"),
"weight": pl.get("weight", EDGE_BASE_WEIGHTS.get(pl.get("kind", "edge"), 0.0)),
"weight": _edge_weight(pl),
"note_id": pl.get("note_id"),
}
sg.add_edge(e)
if e["target"]:
next_frontier.add(e["target"])
# Nur weitersuchen, wenn Target noch nicht besucht
if tgt and tgt not in visited:
next_frontier.add(tgt)
visited |= frontier
frontier = next_frontier - visited
return sg
return sg
+196 -129
View File
@@ -1,159 +1,226 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
app/core/note_payload.py (Mindnet V2 — types.yaml authoritative)
- retriever_weight und chunk_profile werden aus config/types.yaml gelesen.
- Reihenfolge: types.<type> > defaults.* > Fallbacks (1.0 / "default").
- Frontmatter-Overrides für diese beiden Felder werden bewusst IGNORIERT.
- edge_defaults (falls in types.yaml definiert) werden in die Note-Payload gespiegelt.
- MINDNET_TYPES_FILE kann absoluten Pfad liefern, sonst ./config/types.yaml.
Modul: app/core/note_payload.py
Version: 2.0.0
Zweck
-----
Erzeugt ein robustes Note-Payload. Werte wie `retriever_weight`, `chunk_profile`
und `edge_defaults` werden in folgender Priorität bestimmt:
1) Frontmatter (Note)
2) Typ-Registry (config/types.yaml: types.<type>.*)
3) Registry-Defaults (config/types.yaml: defaults.*)
4) ENV-Defaults (MINDNET_DEFAULT_RETRIEVER_WEIGHT / MINDNET_DEFAULT_CHUNK_PROFILE)
"""
from __future__ import annotations
from typing import Any, Dict, Optional, List
import os, yaml, hashlib, datetime
# ----------------------- helpers -----------------------
from typing import Any, Dict, Tuple, Optional
import os
import json
import pathlib
def _env(n: str, d: Optional[str]=None) -> str:
v = os.getenv(n)
return v if v is not None else (d or "")
try:
import yaml # type: ignore
except Exception:
yaml = None
def _load_types() -> dict:
p = _env("MINDNET_TYPES_FILE", "./config/types.yaml")
# ---------------------------------------------------------------------------
# Helper
# ---------------------------------------------------------------------------
def _as_dict(x) -> Dict[str, Any]:
"""Versucht, ein ParsedMarkdown-ähnliches Objekt in ein Dict zu überführen."""
if isinstance(x, dict):
return dict(x)
out: Dict[str, Any] = {}
# bekannte Attribute übernehmen, sofern vorhanden
for attr in (
"frontmatter",
"body",
"id",
"note_id",
"title",
"path",
"tags",
"type",
"created",
"modified",
"date",
):
if hasattr(x, attr):
val = getattr(x, attr)
if val is not None:
out[attr] = val
# Fallback: wenn immer noch leer, raw speichern
if not out:
out["raw"] = str(x)
return out
def _pick_args(*args, **kwargs) -> Tuple[Optional[str], Optional[dict]]:
"""Extrahiert optionale Zusatzargumente wie path und types_cfg."""
path = kwargs.get("path") or (args[0] if args else None)
types_cfg = kwargs.get("types_cfg") or kwargs.get("types") or None
return path, types_cfg
def _env_float(name: str, default: float) -> float:
"""Liest einen Float-Wert aus der Umgebung, mit robustem Fallback."""
try:
with open(p, "r", encoding="utf-8") as f:
return yaml.safe_load(f) or {}
return float(os.environ.get(name, default))
except Exception:
return default
def _ensure_list(x) -> list:
"""Garantiert eine String-Liste."""
if x is None:
return []
if isinstance(x, list):
return [str(i) for i in x]
if isinstance(x, (set, tuple)):
return [str(i) for i in x]
return [str(x)]
# ---------------------------------------------------------------------------
# Type-Registry laden
# ---------------------------------------------------------------------------
def _load_types_config(explicit_cfg: Optional[dict] = None) -> dict:
"""Lädt die Type-Registry aus YAML/JSON oder nutzt ein explizit übergebenes Dict."""
if explicit_cfg and isinstance(explicit_cfg, dict):
return explicit_cfg
path = os.getenv("MINDNET_TYPES_FILE") or "./config/types.yaml"
if not os.path.isfile(path) or yaml is None:
return {}
try:
with open(path, "r", encoding="utf-8") as f:
data = yaml.safe_load(f) or {}
return data if isinstance(data, dict) else {}
except Exception:
return {}
def _get_types_map(reg: dict) -> dict:
if isinstance(reg, dict) and isinstance(reg.get("types"), dict):
return reg["types"]
return reg if isinstance(reg, dict) else {}
def _get_defaults(reg: dict) -> dict:
if isinstance(reg, dict) and isinstance(reg.get("defaults"), dict):
return reg["defaults"]
# alias "global" erlaubt
if isinstance(reg, dict) and isinstance(reg.get("global"), dict):
return reg["global"]
def _cfg_for_type(note_type: str, reg: dict) -> dict:
"""Liefert die Konfiguration für einen konkreten Notiztyp aus der Registry."""
if not isinstance(reg, dict):
return {}
types = reg.get("types") if isinstance(reg.get("types"), dict) else reg
return types.get(note_type, {}) if isinstance(types, dict) else {}
def _cfg_defaults(reg: dict) -> dict:
"""Liefert den Default-Block aus der Registry (defaults/global)."""
if not isinstance(reg, dict):
return {}
for key in ("defaults", "default", "global"):
v = reg.get(key)
if isinstance(v, dict):
return v
return {}
def _resolve_chunk_profile(note_type: str, reg: dict) -> str:
types = _get_types_map(reg)
if isinstance(types, dict):
t = types.get(note_type, {})
if isinstance(t, dict) and isinstance(t.get("chunk_profile"), str):
return t["chunk_profile"]
defs = _get_defaults(reg)
if isinstance(defs, dict) and isinstance(defs.get("chunk_profile"), str):
return defs["chunk_profile"]
return "default"
def _as_float(x: Any) -> Optional[float]:
# ---------------------------------------------------------------------------
# Haupt-API
# ---------------------------------------------------------------------------
def make_note_payload(note: Any, *args, **kwargs) -> Dict[str, Any]:
"""
Baut das Note-Payload für mindnet_notes auf.
Erwartete Felder im Payload:
- note_id: stabile ID aus Frontmatter (id) oder Note-Objekt
- title: Titel der Notiz
- type: Notiztyp (z. B. concept, project, journal, ...)
- path: Pfad im Vault
- retriever_weight: effektives Gewicht für den Retriever
- chunk_profile: Profil für Chunking (short|medium|long|default|...)
- edge_defaults: Liste von Kanten-Typen, die als Defaults gelten
"""
n = _as_dict(note)
path_arg, types_cfg_explicit = _pick_args(*args, **kwargs)
reg = _load_types_config(types_cfg_explicit)
fm = n.get("frontmatter") or {}
fm_type = fm.get("type") or n.get("type") or "concept"
note_type = str(fm_type)
cfg_type = _cfg_for_type(note_type, reg)
cfg_def = _cfg_defaults(reg)
# --- retriever_weight: Frontmatter > Typ-Config > Registry-Defaults > ENV ---
default_rw = _env_float("MINDNET_DEFAULT_RETRIEVER_WEIGHT", 1.0)
retriever_weight = fm.get("retriever_weight")
if retriever_weight is None:
retriever_weight = cfg_type.get(
"retriever_weight",
cfg_def.get("retriever_weight", default_rw),
)
try:
return float(x)
retriever_weight = float(retriever_weight)
except Exception:
return None
retriever_weight = default_rw
def _resolve_retriever_weight(note_type: str, reg: dict) -> float:
types = _get_types_map(reg)
if isinstance(types, dict):
t = types.get(note_type, {})
if isinstance(t, dict) and (t.get("retriever_weight") is not None):
v = _as_float(t.get("retriever_weight"))
if v is not None:
return float(v)
defs = _get_defaults(reg)
if isinstance(defs, dict) and (defs.get("retriever_weight") is not None):
v = _as_float(defs.get("retriever_weight"))
if v is not None:
return float(v)
return 1.0
# --- chunk_profile: Frontmatter > Typ-Config > Registry-Defaults > ENV ---
chunk_profile = fm.get("chunk_profile")
if chunk_profile is None:
chunk_profile = cfg_type.get(
"chunk_profile",
cfg_def.get(
"chunk_profile",
os.environ.get("MINDNET_DEFAULT_CHUNK_PROFILE", "medium"),
),
)
if not isinstance(chunk_profile, str):
chunk_profile = "medium"
# ------------------- public API -------------------
# --- edge_defaults: Frontmatter > Typ-Config > Registry-Defaults ---
edge_defaults = fm.get("edge_defaults")
if edge_defaults is None:
edge_defaults = cfg_type.get(
"edge_defaults",
cfg_def.get("edge_defaults", []),
)
edge_defaults = _ensure_list(edge_defaults)
def make_note_payload(parsed_note: Any,
*,
vault_root: str,
hash_mode: str = "body",
hash_normalize: str = "canonical",
hash_source: str = "parsed",
file_path: Optional[str] = None) -> Dict[str, Any]:
"""
Erwartet ein Parsed-Objekt mit Attributen:
- frontmatter (dict)
- body (str)
- path (optional)
Liefert Note-Payload mit deterministischer note_id und Typ-Werten aus types.yaml.
"""
fm = (getattr(parsed_note, "frontmatter", None) or {}) if parsed_note else {}
title = fm.get("title") or ""
note_type = fm.get("type") or "concept"
note_id = fm.get("id") or _stable_id_from_path_or_title(file_path or "", title)
tags = fm.get("tags") or []
if isinstance(tags, str):
tags = [tags]
# types.yaml authoritative:
reg = _load_types()
chunk_profile = _resolve_chunk_profile(note_type, reg)
retriever_weight = _resolve_retriever_weight(note_type, reg)
# edge_defaults (falls vorhanden)
edge_defaults = None
types = _get_types_map(reg)
if isinstance(types, dict):
t = types.get(note_type, {})
if isinstance(t, dict) and isinstance(t.get("edge_defaults"), list):
edge_defaults = t["edge_defaults"]
updated = _ts_to_int(fm.get("updated"))
# --- Basis-Metadaten (IDs, Titel, Pfad) ---
note_id = n.get("note_id") or n.get("id") or fm.get("id")
title = n.get("title") or fm.get("title") or ""
path = n.get("path") or path_arg
if isinstance(path, pathlib.Path):
path = str(path)
payload: Dict[str, Any] = {
"note_id": note_id,
"type": note_type,
"title": title,
"tags": tags,
"updated": updated if updated is not None else 0,
"path": file_path or "",
"type": note_type,
"path": path or "",
"retriever_weight": retriever_weight,
"chunk_profile": chunk_profile,
"retriever_weight": float(retriever_weight),
"edge_defaults": edge_defaults,
}
if edge_defaults is not None:
payload["edge_defaults"] = edge_defaults
# Tags / Keywords übernehmen
tags = fm.get("tags") or fm.get("keywords") or n.get("tags")
if tags:
payload["tags"] = _ensure_list(tags)
# Zeitliche Metadaten (sofern vorhanden)
for k in ("created", "modified", "date"):
v = fm.get(k) or n.get(k)
if v:
payload[k] = str(v)
# JSON-Roundtrip zur harten Validierung (ASCII beibehalten)
json.loads(json.dumps(payload, ensure_ascii=False))
return payload
# ------------------- internal utilities -------------------
def _stable_id_from_path_or_title(path: str, title: str) -> str:
base = path or title or ""
if not base:
base = "note"
h = hashlib.sha1(base.encode("utf-8")).hexdigest()[:6]
# title-sourced; in V2 typischerweise durch Frontmatter id ersetzt
return f"auto-{h}"
def _ts_to_int(val: Any) -> Optional[int]:
# akzeptiert YYYY-MM-DD oder epoch int; None bei Fehler
if val is None:
return None
if isinstance(val, int):
return val
if isinstance(val, float):
return int(val)
if isinstance(val, str):
val = val.strip()
# YYYY-MM-DD
try:
dt = datetime.date.fromisoformat(val)
return int(datetime.datetime(dt.year, dt.month, dt.day).timestamp())
except Exception:
pass
# epoch string
try:
return int(val)
except Exception:
return None
return None
+81
View File
@@ -217,3 +217,84 @@ def search_chunks_by_vector(client: QdrantClient, prefix: str, vector: List[floa
for r in res:
out.append((str(r.id), float(r.score), dict(r.payload or {})))
return out
# --- Edge retrieval helper ---
def get_edges_for_sources(
client: QdrantClient,
prefix: str,
source_ids: Iterable[str],
edge_types: Optional[Iterable[str]] = None,
limit: int = 2048,
) -> List[Dict[str, Any]]:
"""Retrieve edge payloads from the <prefix>_edges collection.
Args:
client: QdrantClient instance.
prefix: Mindnet collection prefix (e.g. "mindnet").
source_ids: Iterable of source_id values (typically chunk_ids or note_ids).
edge_types: Optional iterable of edge kinds (e.g. ["references", "depends_on"]). If None,
all kinds are returned.
limit: Maximum number of edge payloads to return.
Returns:
A list of edge payload dicts, e.g.:
{
"note_id": "...",
"chunk_id": "...",
"kind": "references" | "depends_on" | ...,
"scope": "chunk",
"source_id": "...",
"target_id": "...",
"rule_id": "...",
"confidence": 0.7,
...
}
"""
source_ids = list(source_ids)
if not source_ids or limit <= 0:
return []
# Resolve collection name
_, _, edges_col = _names(prefix)
# Build filter: source_id IN source_ids
src_filter = _filter_any("source_id", [str(s) for s in source_ids])
# Optional: kind IN edge_types
kind_filter = None
if edge_types:
kind_filter = _filter_any("kind", [str(k) for k in edge_types])
flt = _merge_filters(src_filter, kind_filter)
out: List[Dict[str, Any]] = []
next_page = None
remaining = int(limit)
# Use paginated scroll API; we don't need vectors, only payloads.
while remaining > 0:
batch_limit = min(256, remaining)
res, next_page = client.scroll(
collection_name=edges_col,
scroll_filter=flt,
limit=batch_limit,
with_payload=True,
with_vectors=False,
offset=next_page,
)
if not res:
break
for r in res:
out.append(dict(r.payload or {}))
remaining -= 1
if remaining <= 0:
break
if next_page is None or remaining <= 0:
break
return out
+389 -99
View File
@@ -1,121 +1,411 @@
"""
app/core/retriever.py — Semantischer/Edge-Aware/Hybrid Retriever (WP-04)
Zweck:
Kandidatenfindung via Vektorsuche in *_chunks, optionale Edge-Expansion
und kombiniertes Ranking zur Rückgabe von Top-K Treffern.
Erweiterung (0.2.0): Text→Embedding, falls kein query_vector übergeben wurde.
Kompatibilität:
Python 3.12+, qdrant-client 1.x
Version:
0.2.0 (Text→Embedding ergänzt; bestehendes Verhalten unverändert)
Stand:
2025-10-07
Bezug:
- app/core/graph_adapter.py (expand)
- app/core/ranking.py (combine_scores)
- app/core/qdrant_points.py (search_chunks_by_vector)
- app/services/embeddings_client.py (embed_text)
- app/models/dto.py (QueryRequest/Response)
Änderungsverlauf:
0.2.0 (2025-10-07) – Text→Embedding (embed_text_if_needed).
0.1.0 (2025-10-07) – Erstanlage.
"""
from __future__ import annotations
import os
import time
from typing import Dict, List, Optional, Tuple
from qdrant_client import QdrantClient
from functools import lru_cache
from typing import Any, Dict, List, Tuple, Iterable, Optional
from app.models.dto import QueryRequest, QueryResponse, QueryHit
from app.core.ranking import combine_scores
from app.core.graph_adapter import expand
from app.core import qdrant_points as qp
from app.config import get_settings
from app.services.embeddings_client import embed_text
from app.models.dto import (
QueryRequest,
QueryResponse,
QueryHit,
Explanation,
ScoreBreakdown,
Reason,
EdgeDTO
)
import app.core.qdrant as qdr
import app.core.qdrant_points as qp
import app.services.embeddings_client as ec
import app.core.graph_adapter as ga
try:
import yaml # type: ignore[import]
except Exception: # pragma: no cover - Fallback, falls PyYAML nicht installiert ist
yaml = None # type: ignore[assignment]
def _vector_from_request(req: QueryRequest) -> List[float]:
@lru_cache
def _get_scoring_weights() -> Tuple[float, float, float]:
"""Liefert (semantic_weight, edge_weight, centrality_weight) für den Retriever.
Priorität:
1. Werte aus config/retriever.yaml (falls vorhanden und gültig).
2. Fallback auf Settings.RETRIEVER_W_* (ENV-basiert).
"""
Query-Vektor bestimmen:
- Falls query_vector gesetzt: unverändert verwenden (Back-compat, Tests).
- Sonst, falls query gesetzt: serverseitig einbetten.
- Andernfalls: Fehler.
settings = get_settings()
sem = float(getattr(settings, "RETRIEVER_W_SEM", 1.0))
edge = float(getattr(settings, "RETRIEVER_W_EDGE", 0.0))
cent = float(getattr(settings, "RETRIEVER_W_CENT", 0.0))
# YAML-Override, falls konfiguriert
config_path = os.getenv("MINDNET_RETRIEVER_CONFIG", "config/retriever.yaml")
if yaml is None:
return sem, edge, cent
try:
if os.path.exists(config_path):
with open(config_path, "r", encoding="utf-8") as f:
data = yaml.safe_load(f) or {}
scoring = data.get("scoring", {}) or {}
sem = float(scoring.get("semantic_weight", sem))
edge = float(scoring.get("edge_weight", edge))
cent = float(scoring.get("centrality_weight", cent))
except Exception:
# Bei Fehlern in der YAML-Konfiguration defensiv auf Defaults zurückfallen
return sem, edge, cent
return sem, edge, cent
def _get_client_and_prefix() -> Tuple[Any, str]:
"""Liefert (QdrantClient, prefix) basierend auf QdrantConfig.from_env()."""
cfg = qdr.QdrantConfig.from_env()
client = qdr.get_client(cfg)
return client, cfg.prefix
def _get_query_vector(req: QueryRequest) -> List[float]:
"""
Liefert den Query-Vektor aus dem Request.
"""
if req.query_vector:
return req.query_vector
if req.query:
return embed_text(req.query)
raise ValueError("query_vector fehlt. Alternativ 'query' (Text) übergeben, wird serverseitig eingebettet.")
return list(req.query_vector)
if not req.query:
raise ValueError("QueryRequest benötigt entweder query oder query_vector")
settings = get_settings()
model_name = settings.MODEL_NAME
try:
return ec.embed_text(req.query, model_name=model_name) # type: ignore[call-arg]
except TypeError:
return ec.embed_text(req.query) # type: ignore[call-arg]
def _semantic_hits(
client: Any,
prefix: str,
vector: List[float],
top_k: int,
filters: Dict[str, Any] | None = None,
) -> List[Tuple[str, float, Dict[str, Any]]]:
"""Führt eine semantische Suche über mindnet_chunks aus und liefert Roh-Treffer."""
flt = filters or None
raw_hits = qp.search_chunks_by_vector(client, prefix, vector, top=top_k, filters=flt)
results: List[Tuple[str, float, Dict[str, Any]]] = []
for pid, score, payload in raw_hits:
results.append((str(pid), float(score), dict(payload or {})))
return results
def _compute_total_score(
semantic_score: float,
payload: Dict[str, Any],
edge_bonus: float = 0.0,
cent_bonus: float = 0.0,
) -> Tuple[float, float, float]:
"""Berechnet total_score aus semantic_score, retriever_weight und Graph-Boni."""
raw_weight = payload.get("retriever_weight", 1.0)
try:
weight = float(raw_weight)
except (TypeError, ValueError):
weight = 1.0
if weight < 0.0:
weight = 0.0
sem_w, edge_w, cent_w = _get_scoring_weights()
total = (sem_w * float(semantic_score) * weight) + (edge_w * edge_bonus) + (cent_w * cent_bonus)
return float(total), float(edge_bonus), float(cent_bonus)
# --- WP-04b Explanation Logic ---
def _build_explanation(
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)
if not expand:
return 0, None
depth = 1
edge_types: List[str] | None = None
if hasattr(expand, "depth") or hasattr(expand, "edge_types"):
depth = int(getattr(expand, "depth", 1) or 1)
types_val = getattr(expand, "edge_types", None)
if types_val:
edge_types = list(types_val)
return depth, edge_types
if isinstance(expand, dict):
if "depth" in expand:
depth = int(expand.get("depth") or 1)
if "edge_types" in expand and expand["edge_types"] is not None:
edge_types = list(expand["edge_types"])
return depth, edge_types
return 0, None
def _build_hits_from_semantic(
hits: Iterable[Tuple[str, float, Dict[str, Any]]],
top_k: int,
used_mode: str,
subgraph: ga.Subgraph | None = None,
explain: bool = False, # WP-04b
) -> QueryResponse:
"""Baut aus Raw-Hits und optionalem Subgraph strukturierte QueryHits.
WP-04b: Wenn explain=True, wird _build_explanation aufgerufen.
"""
t0 = time.time()
enriched: List[Tuple[str, float, Dict[str, Any], float, float, float]] = []
for pid, semantic_score, payload in hits:
edge_bonus = 0.0
cent_bonus = 0.0
node_key = payload.get("chunk_id") or payload.get("note_id")
if subgraph is not None and node_key:
try:
edge_bonus = float(subgraph.edge_bonus(node_key))
except Exception:
edge_bonus = 0.0
try:
cent_bonus = float(subgraph.centrality_bonus(node_key))
except Exception:
cent_bonus = 0.0
total, edge_bonus, cent_bonus = _compute_total_score(
semantic_score,
payload,
edge_bonus=edge_bonus,
cent_bonus=cent_bonus,
)
enriched.append((pid, float(semantic_score), payload, total, edge_bonus, cent_bonus))
# Sortierung nach total_score absteigend
enriched_sorted = sorted(enriched, key=lambda h: h[3], reverse=True)
limited = enriched_sorted[: max(1, top_k)]
results: List[QueryHit] = []
for pid, semantic_score, payload, total, edge_bonus, cent_bonus in limited:
note_id = payload.get("note_id")
path = payload.get("path")
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(
QueryHit(
node_id=str(pid),
note_id=note_id,
semantic_score=float(semantic_score),
edge_bonus=edge_bonus,
centrality_bonus=cent_bonus,
total_score=total,
paths=None,
source={
"path": path,
"section": section,
},
explanation=explanation_obj
)
)
dt = int((time.time() - t0) * 1000)
return QueryResponse(results=results, used_mode=used_mode, latency_ms=dt)
def semantic_retrieve(req: QueryRequest) -> QueryResponse:
"""Nur semantische Kandidaten, keine Edge-Expansion (depth=0)."""
t0 = time.time()
s = get_settings()
client = QdrantClient(url=s.QDRANT_URL, api_key=s.QDRANT_API_KEY)
"""Reiner semantischer Retriever (ohne Edge-Expansion)."""
client, prefix = _get_client_and_prefix()
vector = _get_query_vector(req)
top_k = req.top_k or get_settings().RETRIEVER_TOP_K
q_vec = _vector_from_request(req)
raw_hits = qp.search_chunks_by_vector(client, s.COLLECTION_PREFIX, q_vec, top=req.top_k, filters=req.filters)
results: List[QueryHit] = []
for pid, s_score, payload in raw_hits:
results.append(QueryHit(
node_id=pid,
note_id=payload.get("note_id"),
semantic_score=float(s_score),
edge_bonus=0.0,
centrality_bonus=0.0,
total_score=float(s_score), # un-normalisiert: ok für quick semantic mode
paths=None,
source={"path": payload.get("path"), "section": payload.get("section_title")}
))
dt = int((time.time() - t0) * 1000)
return QueryResponse(results=results, used_mode="semantic", latency_ms=dt)
hits = _semantic_hits(client, prefix, vector, top_k=top_k, filters=req.filters)
# 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:
"""Semantik + Edge-Expansion + kombiniertes Ranking."""
t0 = time.time()
s = get_settings()
client = QdrantClient(url=s.QDRANT_URL, api_key=s.QDRANT_API_KEY)
"""Hybrid-Retriever: semantische Suche + optionale Edge-Expansion."""
client, prefix = _get_client_and_prefix()
q_vec = _vector_from_request(req)
if req.query_vector:
vector = list(req.query_vector)
else:
vector = _get_query_vector(req)
# 1) Semantische Seeds (top_k * 3 für breitere Basis)
raw_hits = qp.search_chunks_by_vector(client, s.COLLECTION_PREFIX, q_vec, top=req.top_k * 3, filters=req.filters)
id2payload = {pid: payload for (pid, _, payload) in raw_hits}
seeds = [pid for (pid, _, _) in raw_hits]
top_k = req.top_k or get_settings().RETRIEVER_TOP_K
# 2) Edge-Expansion
edge_types = req.expand.get("edge_types") if req.expand else None
depth = req.expand.get("depth", 1) if req.expand else 1
sg = expand(client, s.COLLECTION_PREFIX, seeds, depth=depth, edge_types=edge_types)
hits = _semantic_hits(client, prefix, vector, top_k=top_k, filters=req.filters)
edge_bonus_map = {pid: sg.aggregate_edge_bonus(pid) for pid in seeds}
centrality_map = {pid: sg.centrality_bonus(pid) for pid in seeds}
depth, edge_types = _extract_expand_options(req)
subgraph: ga.Subgraph | None = None
if depth and depth > 0:
seed_ids: List[str] = []
for _pid, _score, payload in hits:
key = payload.get("chunk_id") or payload.get("note_id")
if key and key not in seed_ids:
seed_ids.append(key)
# 3) Combined Ranking
scored = combine_scores(
raw_hits, edge_bonus_map, centrality_map,
w_sem=s.RETRIEVER_W_SEM, w_edge=s.RETRIEVER_W_EDGE, w_cent=s.RETRIEVER_W_CENT
)
if seed_ids:
try:
subgraph = ga.expand(client, prefix, seed_ids, depth=depth, edge_types=edge_types)
except Exception:
subgraph = None
# 4) Antwortobjekte (Chunk-Ebene)
results: List[QueryHit] = []
for pid, total, e, c, s_score in scored[: req.top_k]:
payload = id2payload[pid]
results.append(QueryHit(
node_id=pid,
note_id=payload.get("note_id"),
semantic_score=float(s_score),
edge_bonus=float(e),
centrality_bonus=float(c),
total_score=float(total),
paths=None,
source={"path": payload.get("path"), "section": payload.get("section_title")}
))
dt = int((time.time() - t0) * 1000)
return QueryResponse(results=results, used_mode="hybrid", latency_ms=dt)
# explain Flag durchreichen
return _build_hits_from_semantic(
hits,
top_k=top_k,
used_mode="hybrid",
subgraph=subgraph,
explain=req.explain
)
+116
View File
@@ -0,0 +1,116 @@
"""app/core/retriever_config.py
---------------------------------
Zentrale Konfiguration für den mindnet-Retriever (WP-04).
Zweck:
- Lädt config/retriever.yaml (falls vorhanden) oder nutzt sinnvolle Defaults.
- Bietet einen gecachten Zugriff auf die Retriever-Config für
andere Module (z. B. graph_adapter, retriever).
Hinweis zur Weiterentwicklung (Selbstjustierung):
- Die hier definierten Parameter sind so gewählt, dass sie später
durch ein Feedback-/Learning-to-Rank-Modell überschrieben werden
können, ohne die restliche Architektur anzupassen.
"""
from __future__ import annotations
import os
from dataclasses import dataclass
from functools import lru_cache
from pathlib import Path
from typing import Dict
try:
import yaml # type: ignore
except Exception: # pragma: no cover - Fallback, falls PyYAML nicht installiert ist.
yaml = None # type: ignore
@dataclass(frozen=True)
class RetrieverConfig:
semantic_scale: float
edge_scale: float
centrality_scale: float
edge_weights: Dict[str, float]
@lru_cache
def get_retriever_config() -> RetrieverConfig:
"""Lädt die Retriever-Konfiguration (YAML + Defaults).
Reihenfolge:
1. Defaults (sinnvoll gewählte Startwerte).
2. Optional: config/retriever.yaml bzw. Pfad aus ENV
MINDNET_RETRIEVER_CONFIG überschreibt die Defaults.
Die Funktion ist bewusst gecached, da sich die Konfiguration zur
Laufzeit üblicherweise nicht ändert. Für dynamisches Nachladen
könnte der Cache explizit geleert werden.
"""
# 1) Defaults – bewusst konservativ gewählt.
semantic_scale = 1.0
edge_scale = 1.0
centrality_scale = 1.0
edge_weights: Dict[str, float] = {
# Wissens-Kanten
"depends_on": 1.0,
"related_to": 0.7,
"similar_to": 0.7,
"references": 0.5,
# Struktur-Kanten
"belongs_to": 0.2,
"next": 0.1,
"prev": 0.1,
# Sonstige / technische Kanten
"backlink": 0.2,
"references_at": 0.2,
}
# 2) Optional: YAML-Konfiguration laden
cfg_path_env = os.getenv("MINDNET_RETRIEVER_CONFIG")
if cfg_path_env:
cfg_path = Path(cfg_path_env)
else:
# Project-Root = zwei Ebenen über app/core/
cfg_path = Path(__file__).resolve().parents[2] / "config" / "retriever.yaml"
if yaml is not None and cfg_path.exists():
try:
data = yaml.safe_load(cfg_path.read_text(encoding="utf-8")) or {}
except Exception:
data = {}
retr = data.get("retriever") or {}
# Skalenwerte überschreiben, falls angegeben
try:
semantic_scale = float(retr.get("semantic_scale", semantic_scale))
except (TypeError, ValueError):
pass
try:
edge_scale = float(retr.get("edge_scale", edge_scale))
except (TypeError, ValueError):
pass
try:
centrality_scale = float(retr.get("centrality_scale", centrality_scale))
except (TypeError, ValueError):
pass
# Edge-Gewichte je Kanten-Typ
ew_cfg = retr.get("edge_weights") or {}
if isinstance(ew_cfg, dict):
for k, v in ew_cfg.items():
try:
edge_weights[str(k)] = float(v)
except (TypeError, ValueError):
continue
return RetrieverConfig(
semantic_scale=semantic_scale,
edge_scale=edge_scale,
centrality_scale=centrality_scale,
edge_weights=edge_weights,
)
+63 -11
View File
@@ -3,27 +3,27 @@ app/models/dto.py — Pydantic-Modelle (DTOs) für WP-04 Endpunkte
Zweck:
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:
Python 3.12+, Pydantic 2.x, FastAPI 0.110+
Version:
0.1.0 (Erstanlage für WP-04)
0.2.0 (Update für WP-04b Explanation Layer)
Stand:
2025-10-07
2025-12-07
Bezug:
- schemas/*.json (Speicherschema für Notes/Chunks/Edges)
- WP-04 API-Design (Query- und Graph-Endpunkte)
Nutzung:
from app.models.dto import QueryRequest, QueryResponse, GraphResponse
Änderungsverlauf:
0.1.0 (2025-10-07) – Erstanlage.
"""
from __future__ import annotations
from pydantic import BaseModel
from typing import List, Literal, Optional, Dict
from pydantic import BaseModel, Field
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):
@@ -44,7 +44,7 @@ class NodeDTO(BaseModel):
class EdgeDTO(BaseModel):
"""Darstellung einer Kante im API-Graph."""
id: str
kind: EdgeKind
kind: str # String statt Literal, um flexibel für Custom-Types zu bleiben
source: str
target: str
weight: float
@@ -57,26 +57,78 @@ class QueryRequest(BaseModel):
- mode: 'semantic' | 'edge' | 'hybrid'
- query: (optional) Freitext; Embedding wird später angebunden
- 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"
query: Optional[str] = None
query_vector: Optional[List[float]] = None
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
# Flags zur Steuerung der Rückgabe
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):
"""Einzelnes Trefferobjekt für /query."""
node_id: str
note_id: Optional[str]
# Flache Scores (Kompatibilität WP-04a)
semantic_score: float
edge_bonus: float
centrality_bonus: float
total_score: float
paths: Optional[List[List[Dict]]] = None
source: Optional[Dict] = None
# WP-04b: Erklärungsobjekt (nur gefüllt, wenn explain=True)
explanation: Optional[Explanation] = None
class QueryResponse(BaseModel):
@@ -91,4 +143,4 @@ class GraphResponse(BaseModel):
center_note_id: str
nodes: List[NodeDTO]
edges: List[EdgeDTO]
stats: Dict[str, int]
stats: Dict[str, int]
+24
View File
@@ -0,0 +1,24 @@
version: 1.0
scoring:
# W_sem: skaliert den Term (semantic_score * retriever_weight)
# Empfehlung Startwert: 1.0 → Semantik bleibt Hauptsignal
semantic_weight: 1.0
# W_edge: skaliert edge_bonus aus dem Subgraph
# Empfehlung: 0.7 → Graph ist deutlich spürbar, aber überstimmt Semantik nicht komplett
edge_weight: 0.7
# W_cent: skaliert centrality_bonus (Knoten-Zentralität im Subgraph)
# Empfehlung: 0.5 → zentrale Knoten werden bevorzugt, aber moderat
centrality_weight: 0.5
# Optional, für später (aktuell noch nicht ausgewertet, aber als Blaupause):
edge_types:
references: 0.20
depends_on: 0.18
related_to: 0.15
similar_to: 0.12
belongs_to: 0.10
next: 0.06
prev: 0.06
+64 -13
View File
@@ -1,25 +1,76 @@
version: 1.0
defaults:
retriever_weight: 0.1
retriever_weight: 1.0
chunk_profile: default
edge_defaults: [] # Leerliste → keine impliziten Kanten, wenn nicht gesetzt
types:
# Wissensbausteine
concept:
chunk_profile: medium
retriever_weight: 0.60
edge_defaults: ["references", "related_to"]
retriever_weight: 0.35
task:
source:
chunk_profile: short
edge_defaults: ["depends_on", "belongs_to"]
retriever_weight: 0.8
experience:
retriever_weight: 0.50
edge_defaults: [] # Quellen sind i. d. R. Ziel von Kanten, erzeugen selbst keine Default-Kanten
glossary:
chunk_profile: short
retriever_weight: 0.40
edge_defaults: ["related_to"]
# Person & Persönlichkeit
profile: # z. B. "Persönliches Leitbild (Kurzprofil)"
chunk_profile: long
retriever_weight: 0.66
edge_defaults: ["references", "related_to"]
value: # Werte (z. B. "Mut", "Fairness")
chunk_profile: short
retriever_weight: 0.90
edge_defaults: ["related_to"]
principle: # Prinzipien/Leitsätze
chunk_profile: short
retriever_weight: 0.90
edge_defaults: ["related_to", "references"]
experience: # prägende Erlebnisse/Erfahrungen
chunk_profile: medium
edge_defaults: ["derived_from", "inspired_by"]
retriever_weight: 0.9
retriever_weight: 0.90
edge_defaults: ["related_to", "references"]
# Ziele, Entscheidungen, Meilensteine
goal:
chunk_profile: medium
retriever_weight: 0.90
edge_defaults: ["depends_on", "related_to", "references"]
decision:
chunk_profile: short
retriever_weight: 0.90
edge_defaults: ["depends_on", "references", "related_to"] # „Worauf stützte sich die Entscheidung?“
milestone:
chunk_profile: short
retriever_weight: 0.70
edge_defaults: ["related_to", "references"]
# Operativ: Projekte, Aufgaben, Journal
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
edge_defaults: ["references", "depends_on"] # Projekt stützt sich auf Konzepte/Quellen und hängt von Bausteinen ab
task:
chunk_profile: short
retriever_weight: 0.80
edge_defaults: ["depends_on", "references"]
journal:
chunk_profile: medium
retriever_weight: 0.80
edge_defaults: ["references", "related_to"]
+214
View File
@@ -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.
+190
View File
@@ -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.
+140
View File
@@ -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. |
+143
View File
@@ -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
+155
View File
@@ -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
+96
View File
@@ -0,0 +1,96 @@
# mindnet Retriever (WP-04 / Step 4a) – Kurz-Dokumentation
## 1. Überblick
Der Retriever besteht aus:
- **Semantic Retriever** (`semantic_retrieve`)
- **Hybrid Retriever** (`hybrid_retrieve`)
- Qdrant-Backend (`*_chunks`, `*_edges`)
- optionaler Edge-Expansion über `graph_adapter.expand`
Die API nutzt das bestehende `/query`-Endpoint (FastAPI), das `QueryRequest` und `QueryResponse` aus `app.models.dto` verwendet.
## 2. Scoring-Formel
Pro Treffer werden folgende Komponenten geführt:
- `semantic_score` – direkt aus Qdrant (Cosine/Euclidean, je nach Collection)
- `retriever_weight` – aus Chunk-Payload (`types.yaml` / Frontmatter)
- `edge_bonus` – Bonus aus dem Subgraph (z. B. Zahl der eingehenden/ausgehenden Edges, Beziehungstypen)
- `centrality_bonus` – Bonus aus einer einfachen Zentralitäts-Heuristik im Subgraph
Aktuelle Formel (Step 4a):
```text
total_score = semantic_score * max(retriever_weight, 0.0)
+ edge_bonus
+ centrality_bonus
```
Die Sortierung der Ergebnisse erfolgt absteigend nach `total_score`.
## 3. Modi
### 3.1 Semantic Mode
- Funktion: `semantic_retrieve`
- Request-Feld `mode = "semantic"`
- Keine Edge-Expansion, kein Graph-Call.
- Kandidaten nur aus Vektorsuche in `<prefix>_chunks`.
### 3.2 Hybrid Mode
- Funktion: `hybrid_retrieve`
- Request-Feld `mode = "hybrid"`
- Schritte:
1. Semantische Chunk-Suche wie im Semantic Mode
2. Falls `expand.depth > 0` gesetzt ist:
- Seeds = `chunk_id` (Fallback: `note_id`) der Treffer
- Aufruf `graph_adapter.expand(client, prefix, seed_ids, depth, edge_types)`
- Ergebnis-Subgraph liefert `edge_bonus` und `centrality_bonus` pro Node
3. Scores werden nach obiger Formel kombiniert.
## 4. Request-Struktur (JSON)
Beispiel-Hybrid-Request:
```json
{
"mode": "hybrid",
"query": "embeddings und qdrant",
"top_k": 10,
"expand": {
"depth": 1,
"edge_types": ["references", "depends_on"]
}
}
```
Minimaler Semantic-Request:
```json
{
"mode": "semantic",
"query": "karate trainingsplan",
"top_k": 5
}
```
## 5. Smoke-Test
Für einen schnellen End-to-End-Test kann folgendes Skript verwendet werden:
```bash
python scripts/test_retriever_smoke.py --query "karate" --mode hybrid --expand-depth 1 --top-k 5
```
Das Skript ruft `/query` auf, wertet Statuscode und JSON-Antwort aus und zeigt die Scores der Top-K-Treffer an.
## 6. Tests
Die wichtigsten Tests für den Retriever sind:
- `tests/test_retriever_basic.py` – Basisfunktion (Semantic + Hybrid)
- `tests/test_retriever_weight.py` – Einfluss von `retriever_weight` auf das Ranking
- `tests/test_retriever_edges.py` – Einfluss von Edge-/Centrality-Boni im Hybrid-Modus
+189 -146
View File
@@ -1,192 +1,235 @@
# Mindnet – Fachliche Architektur
**Version:** 2.0 • **Datum:** 2025-11-09 • **Autor:** Fachkonzept (gemeinsam mit Owner)
# 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 sowie die Logik des Retrievers. Die technische Umsetzung (Module, Flags, Schemas) wird im technischen Dokument detailliert.
---
## 0. Zweck dieses Dokuments
Dieses Dokument beschreibt **Fachdomäne, Funktionsräume, Prozesse und Regeln** von *mindnet*. Es ergänzt die technische Architektur und macht die ursprünglichen Ziele, Designentscheidungen, Anti‑Patterns und Umsetzungsstrategien explizit nachvollziehbar.
## 0) Zielbild & Grundprinzip
Mindnet wandelt Obsidian-Markdown-Notizen in einen **dynamischen Graphen aus Punkten und Kanten** um.
Die drei zentralen Artefakt-Sammlungen lauten:
- `mindnet_notes` – genau **eine** Note pro Markdown-Datei (Metadaten & Hashes)
- `mindnet_chunks` – semantische Teilstücke einer Note (Fenster/„Chunks“)
- `mindnet_edges` – gerichtete Beziehungen zwischen Knoten (Chunks/Notes)
Die Import-Pipeline erzeugt diese Artefakte **deterministisch** und **idempotent** (erneute Läufe überschreiben konsistent statt zu duplizieren). Die Import-Schritte sind: *parse → chunk → edge → upsert*.
---
## 1. Vision & Leitplanken
- **Essenz bewahren:** Entscheidungen, Erlebnisse, Werte, Prinzipien und Konditionierungen so strukturieren, dass sie später erklärbar rekonstruiert werden können.
- **Antworten im eigenen Stil:** Ergebnisse sollen die Persönlichkeit des Owners widerspiegeln (Sprache: **Deutsch**).
- **Vertraulichkeit:** Aktuell einheitlich, aber mit **Stufen** (public/internal/sensitive) erweiterbar.
- **Zeitliche Priorisierung:** Standard: jüngere Inhalte leichter gewichten; Ausnahmen konfigurierbar.
- **Lokal zuerst**, später skalierbar.
## 1) Notizen & Chunks (fachliche Perspektive)
### 1.1 Notiz (Note)
- Repräsentiert eine fachliche Einheit (z. B. *„Vector DB Basics“*, *„KI-Projekt“*).
- Trägt Eigenschaften (Titel, Typ, Zeitstempel, optionale Policies).
- **Typ** (*type*) steuert u. a. Chunk-Profil und Default-Relationen (siehe §4).
- **retriever_weight** und **chunk_profile** werden systematisch an Note **und** Chunks gespiegelt, damit der Retriever beides nutzen kann.
### 1.2 Chunk
- Ausschnitt/Textfenster aus der Note, als eigenständiger Such-Anker.
- Jeder Chunk gehört **genau einer** Note.
- Chunks bilden eine Sequenz (1…N) – das ermöglicht *next/prev*.
- **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.
---
## 2. Fachliches Datenmodell
### 2.1 Kernobjekte
- **Note**: Eintrag im Wissensnetz (z. B. Konzept, Projekt, Erfahrung, Ereignis, Aufgabe).
- **Chunk**: semantischer Abschnitt einer Note (Antwortbaustein).
- **Edge**: gerichtete Beziehung zwischen Notes/Chunks (mit Typ, Gewicht, Quelle).
- **Run**: Importlauf (Audit).
- **Config**: aktive Regel‑ und Typkonfigurationen.
## 2) Edges – fachliche Typen & Bedeutung
### 2.2 Typen & Semantik (Auszug)
- `concept`: Begriff/These/Prinzip.
- `experience`: Erlebnis/Beobachtung (zeitlich verankert).
- `project`: Vorhaben mit Zielen/Abhängigkeiten.
- `task`: Arbeitseinheit.
- (erweiterbar: `event`, `decision`, `person`, `place`, `quote` …)
Edges kodieren Beziehungen. Sie sind **gerichtet** und werden in `mindnet_edges` gespeichert. Die Erzeugung folgt einer strengen Priorität: **Inline > Callout > Defaults > Struktur**.
### 2.3 Relationen (fachlich)
- `references`: verweist inhaltlich auf …
- `related_to`: thematische Nähe/Assoziation.
- `depends_on`: fachliche/kausale Abhängigkeit.
- `belongs_to`: Zugehörigkeit (Teil‑von, Kapitel‑zu).
- `derived_from`: abgeleitet (z. B. Schluss aus Erfahrung).
- `inspired_by`: Impuls/Idee aus Quelle.
- `supports` / `contradicts`: argumentative Beziehung.
### 2.1 Struktur-Kanten (Das Skelett)
- **belongs_to**: *Chunk → Note* (Zuordnung)
- **next / prev**: Kettenbeziehungen zwischen aufeinanderfolgenden Chunks derselben Note.
→ ermöglichen „lineares Weiterlesen“ oder Kontextpfade in Antworten.
Diese Kanten entstehen immer, unabhängig von Inhalten.
### 2.2 Inhalts-Kanten (explizit)
Hier unterscheidet v2.2 präzise zwischen verschiedenen Quellen der Evidenz:
1. **Explizite Inline-Relationen (Höchste Priorität):**
Im Fließtext notierte, semantisch qualifizierte Relationen.
* Syntax: `[[rel:depends_on Embeddings 101]]`
* Fachliche Aussage: "Hängt ab von", "Ähnlich zu".
* *rule_id*: `inline:rel`
* *confidence*: ~0.95
2. **Callout-Edges (Kuratierte Listen):**
Redaktionell gepflegte Listen am Ende einer Notiz (z.B. "Siehe auch").
* Syntax: `> [!edge] related_to: [[Vector DB Basics]]`
* *rule_id*: `callout:edge`
* *confidence*: ~0.90
3. **Wikilinks (Standard-Referenzen):**
Der klassische Obsidian-Link.
* Syntax: `[[Vector DB Basics]]`
* Typ: `references`
* *rule_id*: `explicit:wikilink`
* *confidence*: 1.0
> Alle expliziten Quellen (Wikilink, Inline-Rel, Callout) sind **Primärbelege**.
### 2.3 Typ-basierte Default-Kanten (Regelbasiert)
Jede Note hat einen *Typ* (z. B. `concept`, `project`, `profile`). In `config/types.yaml` definieren wir pro Typ **edge_defaults**, z. B.:
- `concept`: `["references","related_to"]`
- `project`: `["references","depends_on"]`
Regel: **Für jede gefundene explizite Referenz** (s. o.) werden **zusätzliche** Edges nach diesen Defaults erzeugt.
Beispiel: Ein *project* mit `edge_defaults=["depends_on"]` erzeugt zu *jedem* explizit referenzierten Ziel **zusätzlich** eine `depends_on`-Kante.
Diese Kanten tragen *provenance=rule* und eine **rule_id** der Form `edge_defaults:{note_type}:{relation}` sowie eine geringere Confidence (~0.7).
---
## 3. Funktionsräume
1. **Kurativer Raum**
- Schreiben/Überarbeiten von Notizen (Obsidian Templates, Frontmatter‑Guides).
- Plausibilisierung: Pflichtfelder, Dublettencheck, Warnungen (z. B. fehlende Relationen).
## 3) Edge-Payload – Felder & Semantik
2. **Graphischer Raum**
- Relationen setzen (declared), Vorschläge prüfen (inferred).
- Subgraph‑Explorer je Frage/Entscheidung.
Jede Kante hat mindestens:
3. **Antwort‑Raum**
- Query‑Typen: *Faktenabruf*, *Erlebnisbasiert erklären*, *Planung/Entscheidung begründen*.
- Erklärpfad: Chunks → Kanten → Zeitfaktoren → Typgewichte.
- `kind` – Beziehungsart *(belongs_to, next, prev, references, related_to, depends_on, similar_to, …)*
- `scope` – `"chunk"` (Standard in v2.2)
- `source_id`, `target_id` – Quell-/Ziel-Knoten (Chunk-IDs oder Note-Titel bei unresolved Targets)
- `note_id` – **Owner-Note** (die Note, aus der die Kante stammt)
4. **Governance‑Raum**
- Sichtbarkeit/ACL, Qualitätsflags, Review‑Queues.
- Versionsjournal, Import‑Runs, Config‑Historie.
Erweiterte/abgeleitete Felder (WP03 Superset):
- `provenance` – `"explicit"` (Wikilink/Inline/Callout) oder `"rule"` (Typ-Defaults)
- `rule_id` – maschinenlesbare Regelquelle (z.B. `inline:rel`, `edge_defaults:project:depends_on`)
- `confidence` – 0.0–1.0; Heuristik zur Gewichtung im Scoring.
**Dedup-Schlüssel** (fachlich): Gleichlautende `(source_id, target_id, kind, scope, rule_id)` werden nicht mehrfach geschrieben.
---
## 4. Fachliche Regeln
### 4.1 Frontmatter‑Schema (Mindeststandard)
```yaml
id: "{deterministic}"
title: "…"
type: "concept|experience|project|task|…"
created: "YYYY-MM-DD"
modified: "YYYY-MM-DD"
visibility: "internal" # default
retriever_weight: null # optional override
chunk_profile: null # optional override
tags: ["…"]
edge_hints:
- relation: references
target: "note-id-or-path"
- relation: depends_on
target: "…"
```
## 4) Typ-Registry (`config/types.yaml`)
### 4.2 Typregeln (aus types.yaml)
- `chunk_profile`, `retriever_weight`, `edge_defaults` werden je Typ **automatisch** angewandt.
- Aus `edge_defaults` abgeleitete Kanten werden **persistiert** (`source='rule'`).
### 4.1 Zweck
- Steuert **Chunking-Profile** (`short|medium|long`) **pro Typ**
- Liefert **retriever_weight** (Note-/Chunk-Gewichtung im Ranking) **pro Typ**
- Definiert **edge_defaults** je Typ (s. o.)
### 4.3 Zeitgewichtung
- Default: **Exponential Decay** mit globalem λ; Override per `time_weight_override` möglich.
- Erlebnisse (`experience`) erhalten standardmäßig leicht höheren **Base‑Impact** im Score, um Persönlichkeit abzubilden.
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.4 Qualitätsregeln
- Jede Note soll **mind. eine Relation** besitzen.
- **Konflikte** (contradicts) werden nicht gefiltert, sondern sichtbar gemacht (mit Hinweis).
- **Sichtbarkeit**: Antworten aus `sensitive` nur bei expliziter Freigabe.
### 4.2 Beispiel (auslieferungsnah)
version: 1.0
types:
concept:
chunk_profile: medium
edge_defaults: ["references", "related_to"]
retriever_weight: 0.60
project:
chunk_profile: long
edge_defaults: ["references", "depends_on"]
retriever_weight: 0.97
**Auflösung im Importer**
- `effective_chunk_profile(note_type, registry)` → `"short|medium|long"|None`
- `effective_retriever_weight(note_type, registry)` → `float|None`
- Ergebnis wird in `note_payload` **und** `chunk_payloads` gespiegelt.
---
## 5. Use Cases (repräsentativ)
1. **„Warum habe ich 2019 X entschieden?“**
- Abfrage auf `decision` + temporale Nachbarschaft zu `experience`/`principle`.
- Ausgabe mit Erklärpfad: *Erlebnis → Prinzip → Projekt → Entscheidung*.
## 5) Der Retriever (Funktionaler Layer)
2. **„Plane ein Trainingsprogramm“**
- Query kombiniert Konzepte/Erfahrungen/Projekte → Graph‑Walk + Typgewichtung, priorisiert jüngere Erkenntnisse.
Der Retriever ist in v2.2 der zentrale Zugangspunkt zum Wissen. Er realisiert die **Hybride Suche**.
3. **„Welche Ereignisse haben mein Leitbild geprägt?“**
- Subgraph über `derived_from`/`inspired_by` Ketten + Zeitachsen‑Visualisierung.
### 5.1 Scoring-Modell
Die Relevanz eines Treffers ergibt sich nicht mehr nur aus Textähnlichkeit, sondern aus einer gewichteten Formel:
total_score =
semantic_weight * semantic_score
+ edge_weight * edge_bonus
+ centrality_weight * centrality_bonus
+ type_weight * retriever_weight
* **semantic_score:** Vektorähnlichkeit (Qdrant).
* **retriever_weight:** Wichtigkeit des Typs (z.B. Projekte > Quellen).
* **edge_bonus:** Belohnung für Chunks, die im Kontext der Anfrage stark vernetzt sind (unter Berücksichtigung der *confidence*).
* **centrality_bonus:** Belohnung für Knoten, die zentrale Hubs im lokalen Graphen darstellen.
### 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. Anti‑Patterns (vermeiden)
- **Edges ohne Relation** („Dot‑Kanten“) – verhindern jede sinnvolle Auswertung.
- **Nur Vektor‑Suche** ohne Graph / Zeitfaktor – verfälscht Persönlichkeit.
- **Freies Tag‑Chaos** ohne Typregeln – mindert Reproduzierbarkeit.
- **Heimliche Workarounds** (z. B. Felder mit Mehrdeutigkeit) – erschweren spätere Automatisierung.
## 6) Confidence & Provenance – wozu?
Der Retriever kann Edges gewichten:
- **provenance**: *explicit* > *rule*
- **confidence**: numerische Feinsteuerung
- **retriever_weight (Note/Chunk)**: skaliert die Relevanz des gesamten Knotens
Eine typische Gewichtung (konfigurierbar in `retriever.yaml`) ist:
`explicit: 1.0`, `rule: 0.8`. Damit bevorzugt der Graph **kuratiertes Wissen** (explizit notierte Links) vor „erweiterten“ Default-Ableitungen.
---
## 7. Umsetzungsstrategie & Roadmap
### Phase 1 (Jetzt)
- Pflicht‑Frontmatter, deterministische IDs, Ingestion v2 (Chunks/Edges **persistiert**).
- types.yaml + retrieval.yaml live‑fähig; Import‑Run‑Audit.
- Tests (Parser/Chunker/Edge‑Rules), Regression auf Chunk‑Mengen.
## 7) Semantik ausgewählter `kind`-Werte
### Phase 2
- Hybrid‑Retrieval mit Graph‑Boosts, Explain‑Traces in API.
- Subgraph‑Explorer, Governance‑Views (Review‑Queues).
- `references` – „Nutzt/erwähnt“; neutral, aber stützend für Kontext.
- `related_to` – Ähnlichkeit/Verwandtschaft (symmetrisch interpretierbar).
- `similar_to` – noch engere Ähnlichkeit; oft aus Inline-Rel (bewusst gesetzt).
- `depends_on` – fachliche Abhängigkeit (z. B. „Projekt X hängt von Y ab“).
- `belongs_to`, `next`, `prev` – Struktur.
### Phase 3
- ML‑gestützte Edge‑Vorschläge, temporale Graphanalysen, Reasoning‑Chains.
- ACL/Sharing‑Modelle, Export/Archiv‑Pipelines.
> Symmetrische Relationen (z. B. `related_to`, `similar_to`) können **explizit** nur einseitig notiert sein, aber im Retriever beidseitig interpretiert werden.
---
## 8. Beispiel‑Konfigurationen
### 8.1 types.yaml (Beispiel – wie technisch)
```yaml
version: 1.0
types:
concept:
chunk_profile: medium
edge_defaults: ["references", "related_to"]
retriever_weight: 0.33
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.95
```
## 8) Frontmatter-Eigenschaften – Rolle & Empfehlung
### 8.2 retrieval.yaml
```yaml
relation_weights:
references: 1.0
related_to: 0.6
depends_on: 1.2
belongs_to: 0.8
derived_from: 1.1
inspired_by: 0.8
supports: 1.0
contradicts: -0.9
mixing:
alpha: 0.45
beta: 0.25
gamma: 0.20
delta: 0.07
epsilon: 0.03
time_decay:
lambda: 0.0025
```
Frontmatter-Eigenschaften (Properties) bleiben **minimiert**:
- **type** – steuert Typ-Defaults via Registry (Pflicht für differenziertes Verhalten).
- **tags** – für klassische Filterung.
- **retriever_weight / chunk_profile** – Sollten **nicht** manuell gesetzt werden (Best Practice: `types.yaml` nutzen).
- **links** – Veraltet. Bitte Links primär über Text (Wikilink/Inline/Callout) pflegen.
---
## 9. Governance & Nachvollziehbarkeit
- **Decision Log** (ADR‑ähnlich): jedes Regel‑/Schema‑Update mit Begründung.
- **Import‑Protokolle** versioniert, inkl. geänderter Dateien, Chunk‑/Edge‑Zahlen.
- **Explainability Standard** in jeder Antwort.
## 9) Lösch-/Update-Garantien (Idempotenz)
- Jede Note hat einen stabilen **note_id** (Frontmatter/Hash).
- Vor einem Upsert können *alte Chunks/Edges einer Note* gefiltert gelöscht werden (`note_id`-Filter) – das hält Collections sauber bei Re-Imports.
- Die Import-Skripte unterstützen Modi wie `--purge-before-upsert` und `--sync-deletes`, um den Graph sauber zu halten.
---
## Anhang A: Glossar
- **Chunk‑Profil**: Regelset zur Textteilung.
- **Rule‑Edge**: automatisch erzeugte Kante auf Basis von Typregeln.
- **Declared Edge**: explizit gesetzte Kante aus der Quelle.
## 10) Beispiel – Von Markdown zu Kanten (v2.2)
**Markdown (Auszug)**
# Relations Showcase
…
Wir nutzen [[rel:depends_on Qdrant Vektordatenbank]] für die Suche.
…
Siehe auch: [[Embeddings 101]]
> [!edge] related_to: [[Vector DB Basics]]
**Ergebnis (fachlich)**
1. `depends_on(Chunk→Qdrant)` mit `rule_id=inline:rel`, `confidence≈0.95`.
2. `references(Chunk→Embeddings 101)` mit `rule_id=explicit:wikilink`, `confidence=1.0`.
3. `related_to(Chunk→Vector DB Basics)` via Callout; `rule_id=callout:edge`, `confidence≈0.90`.
4. **Typ-Defaults:** Falls die Note vom Typ `project` ist, entstehen zusätzlich `depends_on`-Kanten zu den Zielen aus (2) und (3).
---
## 11) Qualitäts- und Testkriterien (fachlich)
- **Keine Duplikate** gleicher `(src, relation, dst)` in der Collectionsicht (Dedup).
- **Explizite Links** werden vollständig materialisiert (*explicit_total*).
- **Typ-Defaults** ergänzen, aber überdecken nicht.
- **Retriever Smoke-Test:** Ein Query muss plausible Scores liefern, die den Einfluss von `edge_bonus` zeigen.
---
## 12) Referenzen (Projektdateien & Leitlinien)
- Import-Pipeline & Registry-Auflösung: `scripts/import_markdown.py`.
- Kantenbildung (V2-Logic): `app/core/derive_edges.py`.
- Typ-Registry: `config/types.yaml` & `TYPE_REGISTRY_MANUAL.md`.
- Retriever-Scoring: `app/core/retriever.py` & `wp04_retriever_scoring.md`.
+170 -429
View File
@@ -1,474 +1,215 @@
# Mindnet – Technische Architektur
**Version:** 2.0 • **Datum:** 2025-11-09 • **Autor:** Systemarchitektur (gemeinsam mit Owner)
# 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:**
> 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.
---
## 0. Zweck dieses Dokuments
Dieses Dokument beschreibt die **technische Architektur** von *mindnet* so präzise, dass ein erfahrener Engineer sie 1:1 implementieren kann. Es konsolidiert die bisherigen Überlegungen, eliminiert redundante/unklare Passagen und ergänzt fehlende Details (Datenmodell, Indizes, Import‑Pipelines, Scoring, Erklärbarkeit, Skalierung, Betrieb). Gültige Inhalte aus früheren Fassungen bleiben erhalten (siehe **Anhang A: Originalinhalt**).
## 1. Systemüberblick
> **Kernziele:**
> - Persönliches Wissensnetz mit langlebiger Semantik (Notizen, Erlebnisse, Entscheidungen).
> - Antworten, die **erklärbar** auf Erfahrungen, Konditionierung und Persönlichkeit beruhen.
> - **Konfigurierbare Regeln** (Zeitgewichtung, Relationstypen, Typ‑Profile).
> - **Lokal** betreibbar, später **skalierbar** (on‑prem → Rechenzentrum/Cloud).
> - **Deterministisch**, idempotent, auditierbar.
### 1.1 Architektur-Zielbild
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.
Das System arbeitet **deterministisch** (stabile IDs) und ist **konfigurationsgetrieben** (`types.yaml`, `retriever.yaml`).
### 1.2 Verzeichnisstruktur & Komponenten
Die Codebasis ist modular aufgebaut.
/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. Systemkontext (High Level)
- **Quellen:** Obsidian‑Vault (Markdown + Frontmatter), künftig MediaWiki/HTML/PDF/E-Mail/Images.
- **Ingestion:** Validator → Parser → Chunker (Profile) → Embedding → Graph‑& Payload‑Indexierung.
- **Speicher:** Qdrant als Vektorstore + Payload (JSON), ergänzt um Dateimetadaten.
- **APIs:** FastAPI (Read/Write), Tools (mindnet_query, mindnet_subgraph), n8n‑Glue.
- **Retrieval/Reasoning:** Hybrid (Vektor + Keyword + Graph‑Walk) mit konfigurierbaren Scoring‑Regeln und **Erklärpfad**.
- **Ops:** Deterministische IDs, Versions/Provenance‑Felder, Observability, Tests.
## 2. Datenmodell & Collections (Qdrant)
---
Das Datenmodell verteilt sich auf drei Collections, definiert durch `COLLECTION_PREFIX` (Standard: `mindnet`).
## 2. Zielarchitektur (Komponenten)
### 2.1 Ingestion Layer
1. **Frontmatter‑Validator**
- Erzwingt Pflichtfelder: `id`, `title`, `type`, `created`, `modified`
- Optionale Felder: `tags`, `visibility`, `relevance`, `time_weight_override`, `retriever_weight`, `chunk_profile`, `sources`, `aliases`, `edge_hints`.
- Validiert `type` gegen **types.yaml** (Konfiguration).
### 2.1 Notes Collection (`<prefix>_notes`)
Repräsentiert die Metadaten einer Datei.
* **Zweck:** Filterung, Metadaten-Haltung, Vererbung von Eigenschaften an Chunks.
* **Schema (Payload):**
2. **Parser**
- Extrahiert: reinen Text, Überschriften, Querverweise (`[[Note]]`, Markdown‑Links), Zitate/Quellen.
- Normalisiert Unicode, trennt Codeblöcke, Zitate, Aufzählungen.
| 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 |
3. **Chunker** (profilgesteuert)
- Profile: `short` (~300–500 Token), `medium` (~700–1000), `long` (~1200–1600).
- Regeln: Absatz‑, Überschriften‑, semantische Grenzen, Überschneidung ~10–15% für Kontextkohärenz.
- Chunk‑Header speichert: `{note_id, path, type, idx, section_hierarchy, tokens, chunk_profile}`.
4. **Embedding**
- Standard: MiniLM‑384d (lokal über Ollama/TEI), konfigurierbar (`embedding.model`, `dim`).
- Persistiert Vektor + **Payload**.
5. **Edge‑Builder**
- **Declared Edges**: aus expliziten Links/Referenzen in der Quelle.
- **Inferred Edges (Rules)**: aus `types.yaml.edge_defaults` **und** Heuristiken (z. B. Abschnittstitel „Bezug“, „siehe auch“).
- Beide Ebenen als **Edges** persistiert mit `source='declared' | 'rule'`, **kein bloßer Dot‑Marker**.
### 2.2 Chunks Collection (`<prefix>_chunks`)
Die atomaren Sucheinheiten.
* **Zweck:** Vektorsuche (Embeddings), Granulares Ergebnis.
* **Schema (Payload):**
### 2.2 Storage Layer (Qdrant)
**Collections (empfohlen):**
- `mindnet_notes` (1 Vektor je Note, optional)
- `mindnet_chunks` (**primärer Suchraum**)
- `mindnet_edges` (Graph als Payload‑Dokumente)
- `mindnet_runs` (Import‑Läufe, Audit/Provenance)
- `mindnet_configs` (aktive Konfigurationen, z. B. `types.yaml` Schnappschuss)
| 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. |
**Beispiel‑Schemas:**
```yaml
# mindnet_chunks.payload
id: string # deterministic (UUIDv5 über prefix+path+idx)
note_id: string # FK mindnet_notes.id
type: string # z. B. concept|task|experience|project|event …
title: string
path: string # Pfad im Vault
collection: string # Präfix/Namespace
created: string # ISO‑Datum
modified: string # ISO‑Datum
chunk_idx: int
chunk_profile: string # short|medium|long
retriever_weight: float # aus types.yaml oder Note‑Override
time_weight: float # berechnet (Decay) oder Override
section: string # Überschrift/Gliederung
text: string # Rohtext des Chunks
tokens: int
hash: string # content_hash (idempotent)
visibility: string # public|internal|sensitive
source: { # Provenance
repo: string|null,
path: string,
commit: string|null,
import_run_id: string
}
```
```yaml
# mindnet_edges.payload
id: string # deterministic (UUIDv5 über src_id + dst_id + relation + source)
src_id: string # id (Note ODER Chunk)
dst_id: string # id (Note ODER Chunk)
src_kind: string # note|chunk
dst_kind: string # note|chunk
relation: string # references|related_to|depends_on|belongs_to|derived_from|inspired_by|mentions|contradicts|supports …
weight: float # Standard 1.0; typenspezifische Offsets möglich
source: string # declared|rule|ml
evidence: string|null # Textausschnitt/Link der Ableitung
created: string
import_run_id: string
visibility: string
```
### 2.3 Edges Collection (`<prefix>_edges`)
Gerichtete Kanten. Massiv erweitert in WP03 für Provenienz-Tracking.
* **Zweck:** Graph-Traversal, Kontext-Anreicherung.
* **Schema (Payload):**
**Indizes (Qdrant):**
- Vektorindex auf `mindnet_chunks` (HNSW)
- Payload‑Indizes:
- `type` (keyword), `visibility` (keyword), `created/modified` (datetime), `note_id` (keyword)
- optional: **Full‑Text** auf `text` (Qdrant payload text index) für Hybrid‑Suche
| 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 |
### 2.3 Retrieval & Scoring
**Hybrid‑Pipeline (empfohlen):**
1. **Lexikalische Kandidaten** (FTS auf `text`, `title`, `aliases`) – k_l.
2. **Vektor‑Kandidaten** (ANN auf Embeddings) – k_v.
3. **Graph‑Expansion**: 1–2 Hops über `mindnet_edges` mit relation‑spezifischen Boosts.
4. **Re‑Ranking** (finale Score):
- `S = α·sim + β·kw + γ·G + δ·time_decay + ε·type_weight + ζ·recency_boost_overrides`
- `type_weight` = `retriever_weight` aus **types.yaml** oder Note‑Override.
- `time_decay` = `exp(−λ·age_days)`; λ global/konfigurierbar; Override per Frontmatter möglich.
- **Erklärbarkeit:** Speichere die Summanden + Top‑Edges als **evidence** im Query‑Log.
**Relation‑Gewichte (Defaultvorschlag):**
```yaml
relation_weights:
references: 1.0
related_to: 0.6
depends_on: 1.2
belongs_to: 0.8
derived_from: 1.1
inspired_by: 0.8
supports: 1.0
contradicts: -0.9
```
### 2.4 Konfiguration (types.yaml + config.yaml)
```yaml
version: 1.0
types:
concept: { chunk_profile: medium, edge_defaults: [references, related_to], retriever_weight: 0.33 }
task: { chunk_profile: short, edge_defaults: [depends_on, belongs_to], retriever_weight: 0.80 }
experience: { chunk_profile: medium, edge_defaults: [derived_from, inspired_by],retriever_weight: 0.90 }
project: { chunk_profile: long, edge_defaults: [references, depends_on], retriever_weight: 0.95 }
retrieval:
alpha: 0.45 # sim
beta: 0.25 # keyword
gamma: 0.20 # graph
delta: 0.07 # time decay
epsilon: 0.03 # type weight
time_decay:
lambda: 0.0025 # ~ Halbwertzeit ≈ 277 Tage
visibility_defaults: public
```
### 2.5 Determinismus, Versionierung, Idempotenz
- **IDs:** UUIDv5 über `{collection_prefix}:{path}:{chunk_idx}` (Chunks) bzw. `{collection_prefix}:{path}` (Notes).
- **content_hash:** SHA256 über normalisierte Inhalte (Unicode NFC, Whitespace‑Policy, Überschriften‑Normalisierung).
- **Import‑Lauf (`mindnet_runs`)**: `{run_id, started_at, finished_at, config_hash, files_seen, files_changed, errors}`.
- **Idempotenz:** nur `changed` bei `content_hash`‑Abweichung.
### 2.6 Erklärbarkeit (Audit Trail)
- Jede Antwort liefert: Top‑Chunks, Summanden des Scores, **angetretene Kanten** inkl. Relation & Gewicht, Zeitfaktor.
- Persistiere Query‑Logs (optional): `{query, filters, topk, decision_trace, timestamp}`.
### 2.7 Sicherheit & Datenschutz
- **visibility**: `public|internal|sensitive`, Query‑Filter standardmäßig `internal`.
- Optionale **ACL**‑Schicht: Nutzer/Gruppen, Freigabe je Note/Chunk/Edge.
- **Redaktions‑Flags**: `needs_review`, `draft`, `private_journal` (werden standardmäßig ausgeschlossen).
### 2.8 Skalierung & Betrieb
- **Shards/Replicas** (Qdrant): 1/1 lokal; 2/2 in DC/Cloud.
- **Snapshots/Backups**: Qdrant Snapshot + Vault‑Repo Snapshot (rsync/borg).
- **Observability**: Prometheus‑Exporter (API Latenz, Import‑Dauer, Chunks/Edges pro Lauf), strukturierte Logs (JSON).
- **Tests**: deterministische Golden‑Files für Parser/Chunker; Contract‑Tests für API; Offline‑Eval für Retrieval.
---
## 3. Implementierungsleitfaden (konkret)
### 3.1 Collections anlegen (Qdrant)
- `mindnet_chunks(dim=384, distance=cosine)`
- `mindnet_notes(dim=384, distance=cosine)` (optional, falls Note‑Level‑Suche gewünscht)
- `mindnet_edges(dim=0)` (reiner Payload‑Store; kein Vektor)
- Payload‑Indizes: siehe 2.2
### 3.2 Import‑Pipeline (CLI)
1. **Scan** Vault → valide Dateien.
2. **Make Note Payload** (inkl. Typ‑Regeln; `retriever_weight`/`chunk_profile` aus **types.yaml**, Override per Frontmatter).
3. **Chunken** gemäß Profil + `chunk_idx`.
4. **Edges bauen**: declared + rule‑inferred (duplizierte Kanten per ID‑Determinismus verhindern).
5. **Upsert**: Notes → Chunks → Edges (in dieser Reihenfolge).
6. **Run‑Record** und **Config‑Schnappschuss** persistieren.
### 3.3 Query‑API (FastAPI)
- `POST /query`: text, filters({visibility, types, date_range}), topk, graph_hops, `explain=true`.
- `GET /subgraph/{id}`: Nachbarschaft, Relation‑Filter, Depth.
- `POST /admin/reindex` / `POST /admin/import`.
### 3.4 Konfigurierbarkeit
- `types.yaml` heiß ladbar (mit Versionsstempel); bei Änderung → `config_hash` & reimport optional.
- `retrieval.yaml` für Gewichte, Relation‑Boosts, Zeitdecay.
---
## 4. Migrations‑ und Qualitätsregeln
- **Keine Workarounds**, die Semantik zerstören (z. B. „Dot‑Edge“ ohne Relation).
- **Explizite Kantenpersistenz**: *jede* Regelkante wird als `source='rule'` gespeichert.
- **Chunk‑Zahl**: Profiltreue sicherstellen; Regressionstest (z. B. 171 ➝ 59 = **Fehler** oder Profiländerung dokumentieren).
- **Provenance Pflicht**: `import_run_id` in Chunks/Edges setzen.
---
## 5. Offene Erweiterungen (vordenken)
- **ML‑Edge‑Inference** (NER, Coref, TEI‑Reranking).
- **Reasoning‑Graph** (Motivationsketten: Kindheitserlebnis → Prinzip → Entscheidung).
- **Citations‑Fabric** (autom. Quellenkonsolidierung).
- **Temporale Graphabfragen** (Edges mit Zeitintervallen).
---
## Anhang A: Originalinhalt (unverändert, falls vorhanden)
Der vollständige Originaltext aus `knowledge_design.md` bleibt hier als Referenz erhalten, damit keine implizite Aussage verloren geht.
---
# mindnet – Knowledge Design
**Version:** 1.4.0 (aktualisiert 2025-10-06)
## 3. Konfiguration
## 1. Gesamtziel und Systemverständnis
Die Logik ist ausgelagert in YAML-Dateien.
**mindnet** ist ein lokales Wissensnetzwerk, das alle meine Notizen, Projekte, Gedanken, Erfahrungen und Pläne als Markdown-Dateien speichert, automatisch importiert, semantisch in **Chunks** zerlegt und als **Graph-Struktur in Qdrant** ablegt.
Es ist die Grundlage für ein agentenfähiges, lokal betriebenes LLM-System, das meine Daten verknüpft, abfragt und erweitert.
### 3.1 Typ-Registry (`config/types.yaml`)
Steuert den Import-Prozess.
* **Priorität:** Frontmatter > Pfad > Default.
* **Inhalt:**
```yaml
types:
concept:
chunk_profile: medium
edge_defaults: ["references", "related_to"]
retriever_weight: 0.60
```
**Zentrale Ziele**
- Vollständige Repräsentation persönlichen Wissens in strukturierter, maschinenlesbarer Form
- Reproduzierbare Verarbeitung: Import → Chunking → Embedding → Edges → Graph
- Verlustfreie Roundtrip-Fähigkeit (Import ⇄ Export)
- Erweiterbarkeit für Agenten, RAG-Retriever und semantische Suche
**Prinzipien**
- **Deterministisch:** IDs, Hashes und Edges wiederholbar
- **Portabel:** Markdown + YAML
- **Robust:** fehlertoleranter Parser
- **Idempotent:** keine Duplikate bei Re-Import
- **Erweiterbar:** neue Typen und Edge-Arten ohne Migration
### 3.2 Retriever-Config (`config/retriever.yaml`)
Steuert das Scoring zur Laufzeit (WP04a).
* **Inhalt:**
```yaml
scoring:
semantic_weight: 1.0
edge_weight: 0.7
centrality_weight: 0.5
```
---
## 2. YAML-Frontmatter-Schema
## 4. Import-Pipeline (Markdown → Qdrant)
| Feld | Typ | Beschreibung |
|-------|-----|--------------|
| `title` | string | Menschlich lesbarer Titel |
| `id` | string | Eindeutige Note-ID (Slug) |
| `type` | enum | `concept`, `thought`, `experience`, `task`, `project`, `journal`, `person`, `meeting`, `milestone` |
| `status` | enum | `draft`, `active`, `done`, `archived` |
| `created` | date | ISO-Datum |
| `updated` | date | Letzte Änderung |
| `area` | string | Themen- oder Lebensbereich |
| `project` | string | Zugehöriges Projekt |
| `tags` | list | Strukturierte Tags (`area/…`, `topic/…`) |
| `depends_on` | list | IDs anderer Notizen |
| `assigned_to` | list | Beteiligte Personen |
| `embedding_exclude` | bool | Falls `true`, keine Embeddings |
| `hash_mode` | enum | Hash-Modus beim Import (`body`, `frontmatter`, `full`) |
| `priority` | enum/int | 1–5 oder `low` / `med` / `high` |
| `effort_min`, `due` | int/date | Aufwand / Termin |
| `aliases` | list | Alternative IDs |
| `lang` | string | ISO-Sprachcode |
| `source` | string | Herkunft / Referenzquelle |
Das Skript `scripts/import_markdown.py` orchestriert den Prozess.
**Pflichtfelder:** `title`, `id`, `type`, `status`, `created`
**Optionale Felder:** alle übrigen
### 4.1 Verarbeitungsschritte
1. **Discovery & Parsing:**
* Einlesen der `.md` Dateien. Hash-Vergleich (Body/Frontmatter) zur Erkennung von Änderungen.
2. **Typauflösung:**
* Laden der `types.yaml`. Bestimmen des effektiven Typs und der `edge_defaults`.
3. **Chunking:**
* Zerlegung via `chunker.py` basierend auf `chunk_profile` (z.B. `by_heading`, `short`, `long`).
* Trennung von `text` (Kern) und `window` (Embedding-Kontext).
4. **Kantenableitung (Edge Derivation):**
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`.
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`.
5. **Struktur:** `belongs_to`, `next`, `prev` (automatisch).
5. **Upsert:**
* Schreiben in Qdrant. Nutzung von `--purge-before-upsert` für saubere Updates.
---
## 3. Dateinamen und Ordner
## 5. Retriever-Architektur & Scoring
- Format: `YYYY-MM-DD_title.md` oder `slug.md`
- Strukturierte Ordner:
- `10_thoughts/`, `20_concepts/`, `30_projects/`, `40_experiences/`, …
- Alle Pfade relativ; Unterstriche statt Leerzeichen
Der Retriever (`app/core/retriever.py`) realisiert die Logik hinter `/query`.
### 5.1 Betriebsmodi
* **Semantic:** Reine Vektorsuche. Schnell.
* **Hybrid:** Vektorsuche + Graph-Expansion (Tiefe N) + Re-Ranking.
### 5.2 Scoring-Formel (WP04a)
Die Relevanzberechnung ist nun eine gewichtete Summe:
$$
TotalScore = (W_{sem} \cdot S_{sem} \cdot \max(W_{type}, 0)) + (W_{edge} \cdot B_{edge}) + (W_{cent} \cdot B_{cent})
$$
* **Komponenten:**
* $S_{sem}$: Semantic Score (Cosine Similarity).
* $W_{type}$: `retriever_weight` (aus Note/Chunk Payload).
* $B_{edge}$: Edge-Bonus (Summe der Konfidenzen eingehender relevanter Kanten).
* $B_{cent}$: Centrality-Bonus (im lokalen Subgraphen).
* **Gewichte ($W$):** Stammen aus `retriever.yaml`.
### 5.3 Graph-Expansion
Der Hybrid-Modus lädt dynamisch die Nachbarschaft der Top-K Vektor-Treffer ("Seeds") über `graph_adapter.expand`. Dies baut einen temporären `NetworkX`-Graphen im Speicher, auf dem Boni berechnet werden.
---
## 4. Link- und Edge-Design
## 6. Indizes & Performance
**Verlinkungen**
- Wikilinks: `[[note-id]]` oder `[[Titel|note-id]]`
- Automatische Edges aus Text und Frontmatter
Damit Qdrant performant bleibt, sind Payload-Indizes essenziell.
**Edge-Typen in Qdrant**
**Erforderliche Indizes:**
* **Notes:** `note_id`, `type`, `tags`.
* **Chunks:** `note_id`, `chunk_id`.
* **Edges:** `source_id`, `target_id`, `kind`, `scope`, `note_id`.
| Typ | Bedeutung | Quelle | Scope |
|------|------------|--------|--------|
| `belongs_to` | Chunk → Note | intern | chunk |
| `prev` / `next` | Reihenfolge | intern | chunk |
| `references` | explizite Wikilinks | Text | chunk |
| `backlink` | Gegenkante zu `references` | abgeleitet | note |
| `depends_on` | YAML-Abhängigkeiten | YAML | note |
| `assigned_to` | YAML-Zuweisung | YAML | note |
| `unresolved` | Ziel fehlt (Stub) | abgeleitet | chunk |
**Edge-Schlüssel**
- `source_id`, `target_id`, `kind`, `scope`, `note_id`
- Dedup-Schlüssel: Kombination aus `(kind, source_id, target_id, scope)`
Validierung erfolgt über `tests/ensure_indexes_and_show.py`.
---
## 5. Chunking-Modell
## 7. Offene Punkte / Known Limitations
**Chunk-Datenstruktur**
| Feld | Beschreibung |
|-------|---------------|
| `note_id` | Zugehörige Note |
| `chunk_index` | Laufende Nummer |
| `text` | Originalabschnitt |
| `window` | Text + Overlap links/rechts |
| `overlap_left` | Länge des linken Overlaps |
| `overlap_right` | Länge des rechten Overlaps |
| `embedding` | 384-dimensionaler Vektor |
| `tokens` | Tokenanzahl (optional) |
**Chunking-Regeln (aus `chunking_strategy.md`)**
- Trennung nach Absätzen, Überschriften, Listen, Tabellen
- Token-Zielgröße 350–500 (max 600)
- Overlap: 30–40 % für semantische Kohärenz
- Overlap wird in `window` integriert, sodass `text ≠ window`
---
## 6. Hash-Strategie und Änderungsverfolgung
**Zweck:** Nur bei realer Inhaltsänderung re-indexieren
| Umgebungsvariable | Beschreibung |
|--------------------|--------------|
| `MINDNET_HASH_COMPARE` | Vergleichsquelle (`Body`, `Full`, `Frontmatter`) |
| `MINDNET_HASH_SOURCE` | Rohtext vs. geparst (`raw` / `parsed`) |
| `MINDNET_HASH_NORMALIZE` | Normalisierung (`canonical` / `none`) |
**Basismodi**
- `body` → Nur Textkörper
- `frontmatter` → Nur Metadaten
- `full` → Kombination
- Hash = SHA-256(canonicalized_input)
Bei Änderung: Re-Import, neue Embeddings, Edges werden aktualisiert.
---
## 7. Qdrant-Speicherstruktur
| Collection | Inhalt | Primärfelder | Embedding |
|-------------|---------|---------------|------------|
| `mindnet_notes` | Notes mit Fulltext & Hash | `note_id` | optional |
| `mindnet_chunks` | Chunks mit Text, Window, Embedding | `chunk_id`, `note_id` | 384 d |
| `mindnet_edges` | Graphkanten | `edge_id`, `source_id`, `target_id` | — |
**Upsert-Strategie**
- Idempotente UUIDv5-IDs
- Keine Duplikate durch deterministische Signaturen
- `purge-before-upsert` zur Bereinigung
**Indizes**
- notes: `note_id`, `hash_signature`
- chunks: `note_id`, `chunk_index`
- edges: `(kind, source_id, target_id, scope)`
---
## 8. Fehler-Toleranz und Parser-Robustheit
- UTF-8 mit Fallback: ersetzt ungültige Bytes (`errors="replace"`)
- Ignoriert Nullbytes, BOM, exotische Zeilenenden
- Erkennt defekte oder leere YAML-Header und überspringt sie
- Logt Problemfälle (`read_markdown failed`, `make_note_payload returned non-dict`)
- Bei Fehlern: Import → warn → continue
---
## 9. Tests & Validierung
**Integrationstests**
- Roundtrip: Import → Export → Compare (`compare_vaults.py`)
- Chunk-Integrität: `verify_chunks_integrity.py`
- Hash-Audit: `hash_reporter.py`
- Window-Vergleich: `check_chunks_window_vs_text.py`
**Erwartete Ergebnisse**
- Alle Notes werden erkannt
- `window ≠ text` bei > 60 % der Chunks
- Roundtrip-Vergleich liefert „OK“
- Edge-Anzahl entspricht Modell (belongs_to = #Chunks, next/prev ≈ #Chunks – 1)
---
## 10. Export & Roundtrip-Verhalten
- `export_markdown.py` erzeugt identische Markdown-Dateien
- Schreibt YAML + Body in korrekter Reihenfolge
- Roundtrip-Prüfung (`compare_vaults.py`) validiert:
- vollständigen Body
- unveränderte Hash-Signatur
- gleiche Chunkzahl
---
## 11. Graph-Schicht und WP-04-Integration
- Qdrant fungiert als Graph-Backend
- `graph/service.py` (WP-04): stellt API für Mehrhop-Abfragen bereit
- Unterstützt:
- `expand(note_id, hops=2)`
- `resolve_unresolved()`
- `neighbors(kind=…)`
- Grundlage für spätere **Retriever-Funktionen** (LLM / Agenten)
---
## 12. Agenten- und LLM-Integration
**Retriever-Pipeline**
1. Suche top-k Chunks (cosine distance)
2. Erweiterung um Edges (`references`, `backlinks`)
3. Kontext-Assembling via `window`-Text
4. Prompt-Generierung
**Agent-Use-Cases**
- Automatisches Tagging (`type`, `status`)
- Vorschläge für neue Edges
- Auflösen von `unresolved`-Referenzen
- Auto-Import externer Quellen (MediaWiki, PDFs, Webseiten)
---
## 13. Erweiterbarkeit
- Neue Edge-Typen: `inspired_by`, `relates_to`, `contradicts`
- Neue Note-Typen: `decision`, `resource`, `recommendation`
- Embedding-Engines austauschbar (MiniLM → LaBSE → E5)
- Versionierte Chunking-Strategien (`chunk_config.py`)
---
## 14. Qualitätssicherung und Best Practices
- Validierung vor Upsert
- Keine Leer-Chunks
- Vollständige Metadaten in Notes
- Tests in `tests/` automatisch ausführbar (`run_e2e_roundtrip.sh`)
- Ergebnis: „Roundtrip OK“ und `verify_chunks_integrity` = OK
---
## 15. Änderungsverlauf
**v1.4.0 (2025-10-06)**
- Neu: `window` vs `text` Feld in `mindnet_chunks`
- Neu: Hash-Modi (`body`, `frontmatter`, `full`) mit Env-Steuerung
- Neu: Baseline-Modus für Vergleich
- Parser → fehlertolerant (UTF-8 replace)
- Roundtrip-Test vollständig integriert
- Graph-Service und Mehrhop-Abfragen (WP-04-Vorbereitung)
- `purge-before-upsert` und `--note-scope-refs` Parameter ergänzt
**v1.3.0 (2025-09-09)**
- Hash-Normalisierung und Edge-Scope
- Roundtrip-Tests, Agenten-Integration
**v1.2.0 (2025-09-02)**
- Grundstruktur des Knowledge-Designs
---
1. **Multi-Target Inline-Relations:**
* `rel: similar_to [[A]] [[B]]` wird aktuell parser-seitig nicht unterstützt.
* Workaround: Zwei separate Inline-Links `[[rel:similar_to A]] [[rel:similar_to B]]`.
2. **Unresolved Targets:**
* Kanten zu Notizen, die noch nicht existieren, werden mit `target_id="Titel"` angelegt.
* Heilung durch `scripts/resolve_unresolved_references.py` möglich.
3. **Vektor-Konfiguration für Edges:**
* `mindnet_edges` hat aktuell keine Vektoren (`vectors = null`). Eine semantische Suche *auf Kanten* ist noch nicht möglich.
+42 -1
View File
@@ -19,6 +19,31 @@
> **Warum so?** Qdrant‑Payload‑Indizes/Filter → schnelle, erklärbare Selektionen; Snapshots → betriebssicheres Rollback; OTel → Nachvollziehbarkeit; YAML/JSON‑Schema → Validierbarkeit & Stabilität.
### 0.1 Aktueller Implementierungsstand (2025-11-18)
- Es existiert eine produktive mindnet-Instanz mit den Collections:
- `${prefix}_notes`
- `${prefix}_chunks`
- `${prefix}_edges`
- Import-Pipeline:
- `scripts/import_markdown.py` erzeugt Notes, Chunks und Edges vollständig.
- `types.yaml` definiert per Note-Typ:
- `retriever_weight`
- `chunk_profile`
- `edge_defaults` (z. B. `depends_on`, `related_to`).
- Edges:
- Strukturkanten: `belongs_to`, `next`, `prev`
- Explizite Kanten aus Wikilinks: `kind="references"`, `rule_id="explicit:wikilink"`
- Typbasierte Default-Kanten aus `edge_defaults`: `rule_id="edge_defaults:<type>:<relation>"`
- Inline-Kanten im Format `[[rel:<relation> <Zielnote>]]` mit `rule_id="inline:rel"`
- alle Edges tragen eine `confidence` im Bereich `[0,1]` als Hinweis für spätere Ranking-Logiken.
- Tests:
- `tests/test_edges_smoke.py`, `tests/test_edges_all.py` und `scripts/edges_full_check.py` validieren Counts, Konsistenz (`belongs_to == chunks`, `next/prev`-Ketten, keine Duplikate) und Provenienz-Zählungen (`explicit`, `defaults`, `inline`, `structure`).
- Offene Punkte:
- Mehrere Ziele in einer Inline-Relation (`rel: similar_to [[A]] [[B]]`) sind noch nicht implementiert.
- Retrieval-Service nutzt die neuen Edges und Weights bisher nur teilweise; ein edge-bewusster Retriever ist als nächster Schritt geplant.
---
## 1) Datenmodelle (Schemata, v2)
@@ -196,10 +221,15 @@ rule_sets:
- CI‑Job: `make schema-validate` (jsonschema).
- **Abnahme:** Validator grün auf 3 Gold‑Notizen.
### Step 2 – Qdrant v2‑Collections
### Step 2 – Qdrant v2‑Collections (Optional)
- Anlegen der 3 v2‑Collections + Payload‑Indizes.
- **Abnahme:** Filter‑Query liefert erwartbare Ergebnisse.
### Step 2a – Edge-Pipeline v1 stabilisieren (ERLEDIGT)
- Ziel: Vollständige Generierung von Struktur-, expliziten, typbasierten und Inline-Kanten in den bestehenden Collections `${prefix}_notes`, `${prefix}_chunks`, `${prefix}_edges`.
- Status: Implementiert und durch `tests/test_edges_smoke.py`, `tests/test_edges_all.py` und `scripts/edges_full_check.py` verifiziert.
### Step 3 – Chunker v2
- Implementierung & Flag `--chunker v2`.
- **Abnahme:** Chunk‑Counts ~ alt (≈171 ± 15 %), semantische Schnitte.
@@ -208,6 +238,17 @@ rule_sets:
- Reihenfolge & `provenance` strikt umsetzen, `default_resolved` integrieren.
- **Abnahme:** erwartete Relationensätze auf Gold‑Notizen, keine Duplikate.
### Step 4a – Edge-bewusster Retriever
- Implementiere einen Retrieval-Service, der:
- Chunks über Vektor-Suche aus `${prefix}_chunks` holt,
- dazu passende Nachbar-Chunks (`next/prev`) und typrelevante Notizen (`edge_defaults`, Inline-Relationen, Wikilinks) über `${prefix}_edges` ergänzt,
- `retriever_weight` und `confidence` beim Scoring berücksichtigt.
- Liefere einen API-Endpoint `/mindnet/query` mit einem einfachen JSON-Response (Chunks + Begründung).
- Akzeptanz:
- mindestens ein Testfall mit dem Relations-Showcase-Vault,
- sichtbarer Einfluss von `edge_defaults` und Inline-Relationen auf die Ergebnisliste.
### Step 5 – Importer‑Pipeline v2
- `--schema v2` Side‑by‑Side; Batch‑Upserts; vollständige Payloads; Recency‑Boost Konfig **nur** in Policy.
- **Abnahme:** Dry‑Run/Apply‑Parität, Reports, Telemetrie‑Ereignisse sichtbar.
+191
View File
@@ -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").
+114
View File
@@ -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.
+260
View File
@@ -0,0 +1,260 @@
# WP-04 / Step 4a – Retriever Scoring & Konfiguration
Dieses Dokument beschreibt den aktuellen Stand (2025-11-30) der Scoring-Logik des mindnet-Retrievers in WP-04 / Step 4a.
Es dient als Referenz für:
- Nachvollziehbarkeit des Rankings
- Konfiguration und Feintuning (ohne Codeänderungen)
- spätere Automatisierung / „Selbstjustierung“ des Retrievers
---
## 1. Überblick
Der Retriever kombiniert drei Signalquellen zu einem einheitlichen Score:
1. **Semantik** – Vektorsuche über `mindnet_chunks`
2. **Typ-Gewichtung** – `retriever_weight` pro Note/Chunk (aus `types.yaml`)
3. **Graph-Boni** – `edge_bonus` und `centrality_bonus` aus dem Subgraph (Edges)
Die Berechnung erfolgt in `app/core/retriever.py` und ist über `config/retriever.yaml` konfigurierbar.
Die API stellt die Funktionalität über den `/query`-Endpoint (FastAPI) bereit.
---
## 2. Datenbasis (Kurzüberblick)
### 2.1 Notes (`<prefix>_notes`)
Relevante Felder:
- note_id: keyword
- title: text
- type: keyword
- retriever_weight: float
- chunk_profile: keyword
- edge_defaults: keyword[]
- tags: keyword[]
- path: text
- fulltext: text
### 2.2 Chunks (`<prefix>_chunks`)
Relevante Felder:
- note_id: keyword
- chunk_id: keyword
- text: text
- window: text
- retriever_weight: float
- type: keyword
- path: text
- section: text
- neighbors_prev / neighbors_next
- chunk_profile: keyword
### 2.3 Edges (`<prefix>_edges`)
Relevante Felder:
- kind: keyword
- source_id: keyword
- target_id: keyword
- note_id: keyword
- confidence: float
- rule_id, provenance, edge_id, scope, relation, ref_text
Edges stammen stets aus der Import-/Edge-Pipeline (WP-03) und bilden die graphbasierte Grundlage des Retrievers.
---
## 3. Scoring-Formel (Retriever)
### 3.1 Eingangsgrößen
Für jeden Treffer gelten:
semantic_score – aus der Vektorsuche (Qdrant)
retriever_weight – typabhängiges Gewicht (aus types.yaml)
edge_bonus – aggregierter Graph-Bonus
centrality_bonus – Zentralitätsbonus aus dem Subgraph
### 3.2 Globale Gewichte (aus retriever.yaml)
Datei: `config/retriever.yaml`
Beispiel:
version: 1.0
scoring:
semantic_weight: 1.0 # W_sem
edge_weight: 0.7 # W_edge
centrality_weight: 0.5 # W_cent
Falls diese Datei fehlt, greifen ENV-basierte Defaults (`RETRIEVER_W_*`).
### 3.3 Formel
total_score =
W_sem * semantic_score * max(retriever_weight, 0.0)
+ W_edge * edge_bonus
+ W_cent * centrality_bonus
Bemerkungen:
- Negative `retriever_weight` werden abgefangen.
- Die rohen `edge_bonus` und `centrality_bonus` werden im API-/Smoke-Output angezeigt.
- Die Gewichte aus `retriever.yaml` beeinflussen **nur den total_score**, nicht die Anzeige.
---
## 4. Konfigurationsdateien
### 4.1 Typen-Registry (`types.yaml`)
Beispielauszug:
defaults:
retriever_weight: 1.0
chunk_profile: default
types:
types:
concept:
retriever_weight: 0.60
edge_defaults: ["references", "related_to"]
project:
retriever_weight: 0.97
edge_defaults: ["references", "depends_on"]
journal:
retriever_weight: 0.80
edge_defaults: ["references", "related_to"]
source:
retriever_weight: 0.50
edge_defaults: []
Diese Werte bestimmen, wie wichtig eine Note/Chunk **prinzipiell** für den Retriever ist.
### 4.2 Retriever-Konfiguration (`retriever.yaml`)
Beispiel:
version: 1.0
scoring:
semantic_weight: 1.0
edge_weight: 0.7
centrality_weight: 0.5
# Blueprint für spätere Edge-Feinsteuerung:
edge_types:
references: 0.20
depends_on: 0.18
related_to: 0.15
similar_to: 0.12
belongs_to: 0.10
next: 0.06
prev: 0.06
Die Datei befindet sich standardmäßig unter `config/retriever.yaml`.
Override per ENV:
MINDNET_RETRIEVER_CONFIG=/pfad/zur/datei.yaml
### 4.3 Aktive Gewichte auslesen
python - << 'PY'
from app.core.retriever import _get_scoring_weights
print(_get_scoring_weights())
PY
Beispielausgabe:
(1.0, 0.7, 0.5)
---
## 5. Betriebsmodi
### 5.1 Semantikmodus (semantic)
Ablauf:
- Query-Vektor über embed_text()
- Qdrant-Suche über mindnet_chunks
- kein Subgraph → edge_bonus = centrality = 0
- total_score = W_sem * semantic_score * retriever_weight
### 5.2 Hybridmodus (hybrid)
Ablauf:
- Semantik wie oben
- falls expand.depth > 0:
- Subgraph-Berechnung über ga.expand()
- Ermittlung von edge_bonus und centrality_bonus
- total_score = kombinierte Formel aus Semantik + Graph
---
## 6. Tests
### Ausführung (Unit & Integration)
pytest tests/test_retriever_basic.py \
tests/test_retriever_weight.py \
tests/test_retriever_edges.py
pytest tests/test_query_unit.py \
tests/test_query_text_embed_unit.py
Tests decken ab:
- Semantiktreffer
- Typ-Gewichte
- Edge-Boni
- Hybridmodus / FastAPI-Endpunkt
### Smoke-Test
python tests/test_retriever_smoke.py \
--url "http://127.0.0.1:8001/query" \
--query "embeddings" \
--mode hybrid \
--expand-depth 1 \
--top-k 5
Beispielausgabe:
[1] note_id=...retriever-design
total=1.5054 (semantic=0.4038 edge=1.5910 centrality=0.0000)
Interpretation:
- `semantic`, `edge`, `centrality` = Rohwerte
- `total` = skaliert mit `retriever.yaml`
---
## 7. Betriebs-Hinweise
### 7.1 Änderung der Gewichte
- retriever.yaml anpassen
- FastAPI/uvicorn neu starten
- Smoke-Test prüfen
### 7.2 Zielbild WP-04
Der jetzige Stand ermöglicht:
- transparente, konfigurierbare Score-Berechnung
- Kombination aus Semantik, Typwissen und Graphstruktur
- spätere agentenbasierte Selbstjustierung
- alternative Profile (z. B. „mehr Semantik“, „mehr Graph“)
Dieses Dokument dient als stabile Referenz für Entwickler, Tests und spätere Automatisierungsschritte.
+35 -10
View File
@@ -1,10 +1,35 @@
fastapi
uvicorn[standard]
qdrant-client
pydantic>=2
sentence-transformers
torch
python-frontmatter
tqdm
requests
numpy
# --- API Server ---
fastapi>=0.116.1
uvicorn[standard]>=0.35.0
# httpx wird oft für Tests benötigt
httpx>=0.28.1
# --- Datenbank ---
qdrant-client>=1.15.1
# --- 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
+163
View File
@@ -0,0 +1,163 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
scripts/edges_full_check.py
Zählt und validiert Kanten in Qdrant. Erkennt folgende Rule-Gruppen:
- explicit_total: rule_id startswith "explicit:" (z.B. explicit:wikilink, explicit:note_scope)
- callout_total: rule_id == "callout:edge"
- inline_total: rule_id startswith "inline:" (z.B. inline:rel)
- defaults_total: rule_id startswith "edge_defaults:"
- structure: rule_id in {"structure:belongs_to","structure:order"}
Gibt zusätzlich:
- edges_by_kind (aggregiert)
- notes/chunks/edges Anzahlen
- multi_callout_detected: True, falls ein Chunk mehrere Callout-Ziele der gleichen Relation enthält
- per_note_checks: belongs_to == chunks, next == prev == (chunks-1)
"""
from __future__ import annotations
import json
from collections import Counter, defaultdict
from typing import Dict, Any, List, Tuple
from app.core.qdrant import QdrantConfig, get_client
from qdrant_client.http import models as rest
def _count_collection_points(client, name: str) -> int:
try:
res = client.count(collection_name=name, exact=True)
return res.count or 0
except Exception:
return 0
def _scroll_all(client, collection: str) -> List[Any]:
pts_all = []
offset = None
while True:
pts, offset = client.scroll(
collection_name=collection,
with_payload=True,
with_vectors=False,
limit=2048,
offset=offset,
)
pts_all.extend(pts or [])
if offset is None:
break
return pts_all
def _rule_group(rule_id: str) -> str:
if not rule_id:
return "unknown"
if rule_id == "callout:edge":
return "callout"
if rule_id.startswith("inline:"): # <—— wichtig für "inline:rel"
return "inline"
if rule_id.startswith("edge_defaults:"):
return "defaults"
if rule_id.startswith("explicit:"):
return "explicit"
if rule_id in ("structure:belongs_to", "structure:order"):
return "structure"
return "other"
def main() -> None:
cfg = QdrantConfig.from_env()
client = get_client(cfg)
col_notes = f"{cfg.prefix}_notes"
col_chunks = f"{cfg.prefix}_chunks"
col_edges = f"{cfg.prefix}_edges"
# High-level counts
notes_n = _count_collection_points(client, col_notes)
chunks_n = _count_collection_points(client, col_chunks)
edges_pts = _scroll_all(client, col_edges)
edges_n = len(edges_pts)
# By kind / by rule group
by_kind = Counter()
group_counts = Counter()
callout_buckets: Dict[Tuple[str, str], int] = defaultdict(int) # (chunk_id, kind) -> n targets
per_note = defaultdict(lambda: {"chunks": 0, "belongs_to": 0, "next": 0, "prev": 0})
# Für per_note checks: chunks pro note_id aus mindnet_chunks laden
chunks_pts = _scroll_all(client, col_chunks)
chunks_by_note = Counter([p.payload.get("note_id") for p in chunks_pts if p.payload])
for p in edges_pts:
pl = p.payload or {}
kind = str(pl.get("kind") or pl.get("relation") or "edge")
rule_id = str(pl.get("rule_id") or "")
note_id = str(pl.get("note_id") or "")
chunk_id = str(pl.get("chunk_id") or "")
by_kind[kind] += 1
group = _rule_group(rule_id)
group_counts[group] += 1
# Multi-Callout-Erkennung: mehrere callout-Edges gleicher Relation aus demselben Chunk
if group == "callout" and chunk_id and kind:
callout_buckets[(chunk_id, kind)] += 1
# Per-note Strukturchecks
if note_id:
if kind == "belongs_to":
per_note[note_id]["belongs_to"] += 1
elif kind == "next":
per_note[note_id]["next"] += 1
elif kind == "prev":
per_note[note_id]["prev"] += 1
# set chunks count for per_note
for n_id, c in chunks_by_note.items():
per_note[n_id]["chunks"] = c
# final checks per note
per_note_checks = {}
for n_id, stats in per_note.items():
c = stats.get("chunks", 0)
bt = stats.get("belongs_to", 0)
nx = stats.get("next", 0)
pv = stats.get("prev", 0)
per_note_checks[n_id] = {
"chunks": c,
"belongs_to": bt,
"next": nx,
"prev": pv,
"checks": {
"belongs_to_equals_chunks": (bt == c),
"next_prev_match": (nx == pv == max(c - 1, 0)),
},
}
multi_callout_detected = any(v > 1 for v in callout_buckets.values())
out = {
"prefix": cfg.prefix,
"counts": {
"notes": notes_n,
"chunks": chunks_n,
"edges": edges_n,
"edges_by_kind": dict(by_kind),
"explicit_total": group_counts.get("explicit", 0),
"defaults_total": group_counts.get("defaults", 0),
"callout_total": group_counts.get("callout", 0),
"inline_total": group_counts.get("inline", 0),
"structure_total": group_counts.get("structure", 0),
},
"per_note_checks": per_note_checks,
"multi_callout_detected": bool(multi_callout_detected),
"has_duplicates": False, # dedupe passiert beim Upsert
}
print(json.dumps(out, ensure_ascii=False, indent=2))
if __name__ == "__main__":
main()
+340
View File
@@ -0,0 +1,340 @@
#!/usr/bin/env python3
"""
scripts/health_check_mindnet.py
Health-Check für den mindnet-Retriever-/Query-Endpoint.
Funktion:
- Führt POST-Requests auf /query in verschiedenen Modi aus (standard: semantic + hybrid).
- Prüft Status-Code, JSON-Struktur und Anzahl der Treffer.
- Kennzeichnet Probleme als:
- status="ok"
- status="warning" (z.B. Timeout)
- status="error" (harte Fehler wie HTTP-Fehler, JSON-Fehler etc.)
Exit-Code:
- Default (tolerant):
- overall_status = "ok" (inkl. warnings) → Exit-Code 0
- overall_status = "error" → Exit-Code 1
- Mit --strict:
- warnings werden wie errors behandelt → Exit-Code 1
Beispiele:
python scripts/health_check_mindnet.py \
--url http://127.0.0.1:8001/query \
--query "embeddings" \
--top-k 3
python scripts/health_check_mindnet.py \
--url http://127.0.0.1:8001/query \
--query "embeddings" \
--top-k 3 \
--timeout 15 \
--modes hybrid
# Strenger Modus (warnings → Exit-Code 1)
python scripts/health_check_mindnet.py --strict
"""
from __future__ import annotations
import argparse
import json
import socket
import sys
import time
import urllib.error
import urllib.request
from typing import Any, Dict, List
def _post_query(
url: str,
mode: str,
query: str,
top_k: int,
timeout: float,
) -> Dict[str, Any]:
"""
Führt einen POST auf den /query-Endpoint aus und gibt das dekodierte JSON zurück.
Raises:
urllib.error.URLError, urllib.error.HTTPError, RuntimeError
"""
payload = {
"mode": mode,
"query": query,
"top_k": top_k,
"expand": {
"depth": 1 if mode == "hybrid" else 0,
"edge_types": ["references", "belongs_to", "prev", "next"],
},
"ret": {
"with_paths": True,
"with_notes": True,
"with_chunks": True,
},
}
data = json.dumps(payload).encode("utf-8")
req = urllib.request.Request(
url=url,
data=data,
headers={"Content-Type": "application/json"},
method="POST",
)
start = time.monotonic()
with urllib.request.urlopen(req, timeout=timeout) as resp:
status_code = resp.getcode()
body = resp.read().decode("utf-8")
end = time.monotonic()
latency_ms = int((end - start) * 1000)
if status_code != 200:
raise RuntimeError(f"HTTP {status_code}: {body}")
try:
doc = json.loads(body)
except json.JSONDecodeError as exc:
raise RuntimeError(f"Antwort ist kein gültiges JSON: {exc}") from exc
if not isinstance(doc, dict):
raise RuntimeError("Antwort ist kein JSON-Objekt")
doc["_latency_ms"] = latency_ms
return doc
def _validate_response(
mode: str,
doc: Dict[str, Any],
min_results: int,
) -> Dict[str, Any]:
"""
Prüft die wichtigsten Invarianten des Query-Responses.
Rückgabe-Format:
{
"status": "ok" | "warning" | "error",
"message": str,
"latency_ms": int,
"used_mode": str,
"result_count": int
}
"""
latency_ms = int(doc.get("_latency_ms", -1))
used_mode = str(doc.get("used_mode", "unknown"))
results = doc.get("results", [])
if not isinstance(results, list):
return {
"status": "error",
"message": "results ist kein Array",
"latency_ms": latency_ms,
"used_mode": used_mode,
"result_count": -1,
}
result_count = len(results)
if result_count < min_results:
# Zu wenige Ergebnisse sind aus Sicht eines Health-Checks eher ein Error,
# da die Retrieval-Qualität nicht gewährleistet ist.
return {
"status": "error",
"message": f"zu wenige Ergebnisse: {result_count} < {min_results}",
"latency_ms": latency_ms,
"used_mode": used_mode,
"result_count": result_count,
}
sample_msg = "OK"
if result_count > 0:
first = results[0]
if not isinstance(first, dict):
sample_msg = "first result ist kein Objekt"
else:
# einfache Plausibilitätschecks (nur Zugriff, kein strikter Typcheck)
_ = first.get("note_id")
_ = first.get("chunk_id")
_ = first.get("total_score")
status = "ok" if sample_msg == "OK" else "warning"
return {
"status": status,
"message": sample_msg,
"latency_ms": latency_ms,
"used_mode": used_mode,
"result_count": result_count,
}
def run_health_check(
url: str,
query: str,
top_k: int,
timeout: float,
modes: List[str],
min_results: int,
) -> Dict[str, Any]:
"""
Führt den Health-Check für die angegebenen Modi aus.
"""
report: Dict[str, Any] = {
"url": url,
"query": query,
"top_k": top_k,
"timeout_s": timeout,
"checks": [],
"overall_status": "ok", # wird unten ggf. auf warning oder error gesetzt
}
overall_status = "ok"
for mode in modes:
entry: Dict[str, Any] = {
"mode": mode,
"status": "error",
"message": "",
}
try:
doc = _post_query(url=url, mode=mode, query=query, top_k=top_k, timeout=timeout)
validation = _validate_response(mode=mode, doc=doc, min_results=min_results)
entry.update(validation)
except urllib.error.HTTPError as exc:
entry["status"] = "error"
entry["message"] = f"HTTP-Fehler: {exc}"
entry["latency_ms"] = -1
entry["used_mode"] = mode
entry["result_count"] = -1
except urllib.error.URLError as exc:
# URLError kann u.a. socket.timeout enthalten.
lat = -1
entry["latency_ms"] = lat
entry["used_mode"] = mode
entry["result_count"] = -1
if isinstance(exc.reason, socket.timeout):
entry["status"] = "warning"
entry["message"] = f"Timeout (URLError/socket.timeout): {exc}"
else:
entry["status"] = "error"
entry["message"] = f"HTTP/Netzwerkfehler: {exc}"
except socket.timeout as exc:
# Direkter Timeout (falls nicht in URLError verpackt)
entry["status"] = "warning"
entry["message"] = f"Timeout (socket.timeout): {exc}"
entry["latency_ms"] = -1
entry["used_mode"] = mode
entry["result_count"] = -1
except Exception as exc: # noqa: BLE001
entry["status"] = "error"
entry["message"] = f"unerwarteter Fehler: {exc}"
entry["latency_ms"] = -1
entry["used_mode"] = mode
entry["result_count"] = -1
# overall_status bestimmen:
# - error > warning > ok
if entry["status"] == "error":
overall_status = "error"
elif entry["status"] == "warning" and overall_status == "ok":
overall_status = "warning"
report["checks"].append(entry)
report["overall_status"] = overall_status
return report
def parse_args(argv: List[str]) -> argparse.Namespace:
parser = argparse.ArgumentParser(
description="Health-Check für mindnet /query-Retriever",
)
parser.add_argument(
"--url",
default="http://127.0.0.1:8001/query",
help="Vollständige URL des /query-Endpunkts (Default: %(default)s)",
)
parser.add_argument(
"--query",
default="embeddings",
help="Test-Query für den Health-Check (Default: %(default)s)",
)
parser.add_argument(
"--top-k",
type=int,
default=3,
help="Top-K für die Testabfrage (Default: %(default)s)",
)
parser.add_argument(
"--timeout",
type=float,
default=5.0,
help="Timeout in Sekunden pro Request (Default: %(default)s)",
)
parser.add_argument(
"--modes",
nargs="+",
default=["semantic", "hybrid"],
help="Zu prüfende Modi (Default: semantic hybrid)",
)
parser.add_argument(
"--min-results",
type=int,
default=1,
help="Minimale Anzahl erwarteter Ergebnisse (Default: %(default)s)",
)
parser.add_argument(
"--strict",
action="store_true",
help="Warnings als Fehler behandeln (overall_status=warning führt zu Exit-Code 1)",
)
return parser.parse_args(argv)
def main(argv: List[str]) -> int:
args = parse_args(argv)
report = run_health_check(
url=args.url,
query=args.query,
top_k=args.top_k,
timeout=args.timeout,
modes=args.modes,
min_results=args.min_results,
)
overall = report.get("overall_status", "error")
# Menschlich lesbare Zusammenfassung:
print(f"mindnet health: {overall}")
for c in report["checks"]:
mode = c.get("mode")
status = c.get("status")
latency = c.get("latency_ms")
result_count = c.get("result_count")
msg = c.get("message", "")
print(f" - {mode}: {status} (latency={latency} ms, results={result_count}) {msg}")
# JSON-Ausgabe (z.B. für n8n):
print(json.dumps(report, ensure_ascii=False))
if args.strict:
# strict: warning wird wie error behandelt
return 0 if overall == "ok" else 1
else:
# tolerant: nur echte errors führen zu Exit-Code 1
return 0 if overall in ("ok", "warning") else 1
if __name__ == "__main__":
raise SystemExit(main(sys.argv[1:]))
+104
View File
@@ -0,0 +1,104 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Kleine Diagnosehilfe für mindnet_edges.
Nutzung (aus Projektwurzel):
(.venv) python tests/diag_edges_for_note.py \
--note-id 20251130-relshow-embeddings-101
Optional:
--prefix mindnet
Ziel:
- Zeigt alle Edges aus der Collection <prefix>_edges,
die sich auf die angegebene note_id beziehen:
* note_id == NOTE
* oder source_id == NOTE
* oder target_id == NOTE
"""
from __future__ import annotations
import argparse
import os
import sys
from typing import List
# Projekt-Root (Ordner mit "app/") zum sys.path hinzufügen,
# damit "import app.core.qdrant" funktioniert, auch wenn das Script
# direkt aus tests/ gestartet wird.
THIS_DIR = os.path.dirname(os.path.abspath(__file__))
PROJECT_ROOT = os.path.dirname(THIS_DIR)
if PROJECT_ROOT not in sys.path:
sys.path.insert(0, PROJECT_ROOT)
from qdrant_client.http import models as rest # type: ignore
from app.core.qdrant import QdrantConfig, get_client, collection_names
def fetch_edges_for_note(note_id: str, prefix: str | None, limit: int = 512) -> List[dict]:
cfg = QdrantConfig.from_env()
if prefix:
cfg.prefix = prefix
client = get_client(cfg)
_, _, edges_col = collection_names(cfg.prefix)
conditions = []
for field in ("note_id", "source_id", "target_id"):
conditions.append(
rest.FieldCondition(
key=field,
match=rest.MatchValue(value=str(note_id)),
)
)
flt = rest.Filter(
should=conditions,
)
points, _ = client.scroll(
collection_name=edges_col,
scroll_filter=flt,
with_payload=True,
with_vectors=False,
limit=limit,
)
out: List[dict] = []
for p in points or []:
pl = dict(p.payload or {})
if pl:
out.append(pl)
return out
def main() -> None:
parser = argparse.ArgumentParser()
parser.add_argument("--note-id", required=True, help="Note-ID, z. B. 20251130-relshow-embeddings-101")
parser.add_argument("--prefix", default=None, help="Qdrant-Prefix (Default: aus ENV/QdrantConfig)")
args = parser.parse_args()
note_id = args.note_id
prefix = args.prefix
edges = fetch_edges_for_note(note_id, prefix)
print(f"Prefix: {prefix or '(aus ENV)'}")
print(f"Note-ID: {note_id}")
print(f"Gefundene Edges: {len(edges)}")
print("-" * 60)
for i, e in enumerate(edges, start=1):
print(f"[{i}] kind={e.get('kind')} confidence={e.get('confidence')}")
print(f" note_id = {e.get('note_id')}")
print(f" source_id= {e.get('source_id')}")
print(f" target_id= {e.get('target_id')}")
print()
if __name__ == "__main__":
main()
+120
View File
@@ -0,0 +1,120 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Diagnose für den Graph-Adapter (Subgraph) in mindnet.
Nutzung (aus Projektwurzel):
(.venv) python tests/diag_subgraph_for_note.py \
--note-id 20251130-relshow-embeddings-101 \
--depth 1
Optional:
--prefix mindnet
--edge-type references --edge-type related_to ...
Ziel:
- Ruft app.core.graph_adapter.expand(...) für eine gegebene note_id auf.
- Gibt edge_bonus und centrality_bonus für diese note_id aus.
- Zeigt zusätzlich einige Nachbarn und deren Boni.
"""
from __future__ import annotations
import argparse
import os
import sys
from typing import List, Optional, Tuple
# sys.path anpassen, damit "import app...." aus tests/ funktioniert
THIS_DIR = os.path.dirname(os.path.abspath(__file__))
PROJECT_ROOT = os.path.dirname(THIS_DIR)
if PROJECT_ROOT not in sys.path:
sys.path.insert(0, PROJECT_ROOT)
from app.core.qdrant import QdrantConfig, get_client # type: ignore
import app.core.graph_adapter as ga # type: ignore
def build_subgraph_for_note(
note_id: str,
prefix: Optional[str],
depth: int,
edge_types: Optional[List[str]] = None,
) -> Tuple[ga.Subgraph, str]:
cfg = QdrantConfig.from_env()
if prefix:
cfg.prefix = prefix
client = get_client(cfg)
sg = ga.expand(client, cfg.prefix, [note_id], depth=depth, edge_types=edge_types)
return sg, cfg.prefix
def main() -> None:
parser = argparse.ArgumentParser()
parser.add_argument(
"--note-id",
required=True,
help="Note-ID, z. B. 20251130-relshow-embeddings-101",
)
parser.add_argument(
"--depth",
type=int,
default=1,
help="Expansionstiefe (Default: 1)",
)
parser.add_argument(
"--prefix",
default=None,
help="Qdrant-Prefix (Default: aus ENV/QdrantConfig)",
)
parser.add_argument(
"--edge-type",
action="append",
default=None,
help="Edge-Typ-Filter (kann mehrfach angegeben werden), z. B. --edge-type references",
)
args = parser.parse_args()
note_id = args.note_id
depth = max(0, int(args.depth))
prefix = args.prefix
edge_types = args.edge_type
sg, eff_prefix = build_subgraph_for_note(note_id, prefix, depth, edge_types=edge_types)
print(f"Prefix: {eff_prefix}")
print(f"Note-ID (Seed): {note_id}")
print(f"Depth: {depth}")
print(f"Edge-Types-Filter: {edge_types or '(keiner)'}")
print("-" * 60)
# Boni für die Seed-Note
eb = sg.edge_bonus(note_id)
cb = sg.centrality_bonus(note_id)
print(f"edge_bonus({note_id}) = {eb:.4f}")
print(f"centrality_bonus({note_id}) = {cb:.4f}")
print("-" * 60)
# Ein paar weitere Knoten anzeigen (falls vorhanden)
print("Beispiele weiterer Knoten mit Boni (max. 10):")
printed = 0
for node, edges in sg.adj.items():
if node == note_id:
continue
if printed >= 10:
break
eb2 = sg.edge_bonus(node)
cb2 = sg.centrality_bonus(node)
print(f"- node={node}")
print(f" edge_bonus={eb2:.4f} centrality={cb2:.4f}")
printed += 1
if printed == 0:
print("(keine weiteren Knoten im Subgraph registriert)")
if __name__ == "__main__":
main()
+122
View File
@@ -0,0 +1,122 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
scripts/test_retriever_smoke.py - einfacher Smoke-Test für den mindnet-Retriever
Zweck:
- Startet eine Query gegen die laufende FastAPI-Instanz
- Prüft, ob der /query-Endpunkt antwortet und sinnvolle Treffer liefert
- Gibt Top-K-Ergebnisse inkl. Scores auf stdout aus
Verwendung:
1) Stelle sicher, dass der mindnet-Service läuft, z. B.:
uvicorn app.main:create_app --factory --reload
2) Führe dieses Skript aus:
python scripts/test_retriever_smoke.py --query "karate" --mode hybrid
3) Optional:
python scripts/test_retriever_smoke.py --query "embeddings" --mode semantic --top-k 5
Hinweis:
- Standard-URL ist http://127.0.0.1:8000
- Endpoint ist /query (bestehender Router), der QueryRequest erwartet
"""
from __future__ import annotations
import argparse
import json
import sys
from typing import Any, Dict
import requests
def _build_payload(args: argparse.Namespace) -> Dict[str, Any]:
payload: Dict[str, Any] = {
"mode": args.mode,
"query": args.query,
"top_k": args.top_k,
}
if args.expand_depth is not None and args.expand_depth > 0:
expand: Dict[str, Any] = {"depth": args.expand_depth}
if args.expand_edge_types:
expand["edge_types"] = args.expand_edge_types
payload["expand"] = expand
return payload
def main(argv: list[str] | None = None) -> int:
parser = argparse.ArgumentParser(description="Smoke-Test für mindnet-Retriever (/query)")
parser.add_argument("--url", default="http://127.0.0.1:8000/query", help="Basis-URL des Query-Endpunkts")
parser.add_argument("--query", required=True, help="Text-Query für den Retriever")
parser.add_argument("--mode", choices=["semantic", "hybrid"], default="hybrid", help="Retrieval-Modus")
parser.add_argument("--top-k", type=int, default=5, help="Anzahl der gewünschten Treffer")
parser.add_argument("--expand-depth", type=int, default=0, help="Edge-Expansionstiefe (nur hybrid)")
parser.add_argument(
"--expand-edge-types",
nargs="*",
default=None,
help="Liste von Edge-Typen für die Expansion (z. B. references depends_on)",
)
args = parser.parse_args(argv)
payload = _build_payload(args)
try:
resp = requests.post(args.url, json=payload, timeout=10)
except Exception as exc: # pragma: no cover - Netzwerkfehler
print(f"[ERROR] HTTP-Request fehlgeschlagen: {exc}", file=sys.stderr)
return 1
if resp.status_code != 200:
print(f"[ERROR] Unerwarteter Statuscode: {resp.status_code}", file=sys.stderr)
print(resp.text, file=sys.stderr)
return 1
try:
data = resp.json()
except Exception as exc: # pragma: no cover - JSON-Fehler
print(f"[ERROR] Antwort ist kein gültiges JSON: {exc}", file=sys.stderr)
print(resp.text, file=sys.stderr)
return 1
print("=== mindnet Retriever Smoke-Test ===")
print(f"URL: {args.url}")
print(f"Mode: {args.mode}")
print(f"Query: {args.query!r}")
print(f"Top-K: {args.top_k}")
print()
results = data.get("results") or []
used_mode = data.get("used_mode")
latency_ms = data.get("latency_ms")
print(f"used_mode = {used_mode}, latency = {latency_ms} ms")
print(f"Treffer insgesamt: {len(results)}")
print()
for i, hit in enumerate(results, start=1):
note_id = hit.get("note_id")
node_id = hit.get("node_id")
total = hit.get("total_score")
sem = hit.get("semantic_score")
edge_bonus = hit.get("edge_bonus")
cent_bonus = hit.get("centrality_bonus")
src = hit.get("source") or {}
path = src.get("path")
section = src.get("section")
print(f"[{i}] note_id={note_id} node_id={node_id}")
print(f" total={total:.4f} (semantic={sem:.4f} edge={edge_bonus:.4f} centrality={cent_bonus:.4f})")
if path or section:
print(f" source: {path or '-'} :: {section or '-'}")
print()
return 0
if __name__ == "__main__": # pragma: no cover
raise SystemExit(main())
+116
View File
@@ -0,0 +1,116 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
tests/test_edges_all.py
Ein knapper Integrationscheck:
- Es existieren Notes/Chunks/Edges
- Inline-Edges (rule_id startswith "inline:") werden erkannt
- Callout-Edges (rule_id == "callout:edge") werden erkannt
- Defaults (rule_id startswith "edge_defaults:") werden erkannt
- Strukturkanten stimmen (belongs_to == chunks; next == prev == chunks-1)
"""
from __future__ import annotations
import json
from collections import Counter, defaultdict
from typing import Dict, Any, List, Tuple
from app.core.qdrant import QdrantConfig, get_client
def _scroll_all(client, collection: str):
pts_all = []
offset = None
while True:
pts, offset = client.scroll(
collection_name=collection,
with_payload=True,
with_vectors=False,
limit=2048,
offset=offset,
)
pts_all.extend(pts or [])
if offset is None:
break
return pts_all
def _rule_group(rule_id: str) -> str:
if not rule_id:
return "unknown"
if rule_id == "callout:edge":
return "callout"
if rule_id.startswith("inline:"): # <—— wichtig für inline:rel
return "inline"
if rule_id.startswith("edge_defaults:"):
return "defaults"
if rule_id.startswith("explicit:"):
return "explicit"
if rule_id in ("structure:belongs_to", "structure:order"):
return "structure"
return "other"
def main() -> None:
cfg = QdrantConfig.from_env()
client = get_client(cfg)
col_notes = f"{cfg.prefix}_notes"
col_chunks = f"{cfg.prefix}_chunks"
col_edges = f"{cfg.prefix}_edges"
notes_n = client.count(collection_name=col_notes, exact=True).count
chunks_pts = _scroll_all(client, col_chunks)
edges_pts = _scroll_all(client, col_edges)
ok = True
# Basisbedingungen
if notes_n == 0 or len(chunks_pts) == 0 or len(edges_pts) == 0:
ok = False
# Gruppen zählen
g = Counter(_rule_group((p.payload or {}).get("rule_id", "")) for p in edges_pts)
structure = g.get("structure", 0)
explicit = g.get("explicit", 0)
inline = g.get("inline", 0)
callout = g.get("callout", 0)
defaults = g.get("defaults", 0)
if structure == 0:
ok = False
# mindestens eine der expliziten Varianten vorhanden
if (explicit + inline + callout) == 0:
ok = False
# defaults dürfen 0 sein, wenn types.yaml keine edge_defaults liefert – daher nur Info
# per-note checks
chunks_by_note = Counter([p.payload.get("note_id") for p in chunks_pts if p.payload])
belongs = Counter(
(p.payload or {}).get("note_id")
for p in edges_pts
if (p.payload or {}).get("kind") == "belongs_to"
)
nxt = Counter(
(p.payload or {}).get("note_id")
for p in edges_pts
if (p.payload or {}).get("kind") == "next"
)
prv = Counter(
(p.payload or {}).get("note_id")
for p in edges_pts
if (p.payload or {}).get("kind") == "prev"
)
for n_id, c in chunks_by_note.items():
if belongs.get(n_id, 0) != c:
ok = False
if (nxt.get(n_id, 0) != max(c - 1, 0)) or (prv.get(n_id, 0) != max(c - 1, 0)):
ok = False
print(json.dumps({"ok": ok, "notes_checked": len(chunks_by_note)}, ensure_ascii=False))
if __name__ == "__main__":
main()
+25
View File
@@ -0,0 +1,25 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
tests/test_edges_defaults_smoke.py
Aggregiert Edges je Relation (kind) in Qdrant zur schnellen Sichtprüfung.
Zeigt, ob typenbasierte edge_defaults-Relationen (z. B. depends_on/related_to) auftauchen.
"""
from __future__ import annotations
from collections import Counter
import json
from app.core.qdrant import QdrantConfig, get_client
def main():
cfg = QdrantConfig.from_env()
cl = get_client(cfg)
col = f"{cfg.prefix}_edges"
pts, _ = cl.scroll(collection_name=col, with_payload=True, with_vectors=False, limit=10000)
by_rel = Counter()
for p in pts:
rel = p.payload.get("kind") or p.payload.get("relation") or "edge"
by_rel[rel] += 1
print(json.dumps({"prefix": cfg.prefix, "relations": dict(by_rel)}, ensure_ascii=False))
if __name__ == "__main__":
main()
+107 -114
View File
@@ -1,140 +1,133 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
scripts/test_edges_smoke.py — Progressive Ausgabe
Prüft edge-Integrität je Note mit Live-Ausgabe:
- belongs_to == #Chunks
- next == prev == max(#Chunks-1,0)
- Duplikat-Edges (Key: (kind,source_id,target_id,scope)) == 0
- Zählt references (chunk/note), backlink
Optionen:
--max-notes N : prüft nur die ersten N Notizen
--limit L : Scroll-Limit pro Anfrage (Default 256)
--flush : jede Zeile sofort flushen
"""
from __future__ import annotations
import os, sys, json, argparse
from typing import Dict, Any, List, Tuple, Set
import json
import os
from collections import Counter, defaultdict
from qdrant_client.http import models as rest
from app.core.qdrant import QdrantConfig, get_client
def collections(prefix: str) -> Tuple[str, str, str]:
return f"{prefix}_notes", f"{prefix}_chunks", f"{prefix}_edges"
def scroll_iter(client, collection: str, filt: rest.Filter | None, with_payload: bool, limit: int):
def _rel(pl: dict) -> str:
return pl.get("relation") or pl.get("kind") or "edge"
def _scroll(client, col):
pts = []
next_page = None
while True:
pts, next_page = client.scroll(
collection_name=collection,
scroll_filter=filt,
with_payload=with_payload,
res, next_page = client.scroll(
collection_name=col,
with_payload=True,
with_vectors=False,
limit=limit,
limit=1024,
offset=next_page,
)
if not pts:
break
for p in pts:
yield p
pts.extend(res)
if next_page is None:
break
return pts
def list_notes(client, prefix: str, limit: int, max_notes: int | None) -> List[Dict[str, Any]]:
notes_col, _, _ = collections(prefix)
out: List[Dict[str, Any]] = []
for p in scroll_iter(client, notes_col, None, True, limit):
pl = p.payload or {}
nid = pl.get("note_id") or pl.get("id")
if nid:
out.append({"note_id": nid, "title": pl.get("title"), "type": pl.get("type")})
if max_notes is not None and len(out) >= max_notes:
break
return out
def count_chunks_for_note(client, prefix: str, note_id: str, limit: int) -> int:
_, chunks_col, _ = collections(prefix)
f = rest.Filter(must=[rest.FieldCondition(key="note_id", match=rest.MatchValue(value=note_id))])
return sum(1 for _ in scroll_iter(client, chunks_col, f, False, limit))
def fetch_edges_for_note(client, prefix: str, note_id: str, limit: int) -> List[Dict[str, Any]]:
_, _, edges_col = collections(prefix)
f = rest.Filter(must=[rest.FieldCondition(key="note_id", match=rest.MatchValue(value=note_id))])
return [p.payload or {} for p in scroll_iter(client, edges_col, f, True, limit)]
def main():
ap = argparse.ArgumentParser()
ap.add_argument("--max-notes", type=int)
ap.add_argument("--limit", type=int, default=256)
ap.add_argument("--flush", action="store_true")
args = ap.parse_args()
cfg = QdrantConfig.from_env()
client = get_client(cfg)
prefix = os.environ.get("COLLECTION_PREFIX", cfg.prefix)
notes = list_notes(client, cfg.prefix, args.limit, args.max_notes)
total = {"notes": 0, "chunks": 0, "belongs_to": 0, "next": 0, "prev": 0, "refs_chunk": 0, "refs_note": 0, "backlink": 0, "dup_edges": 0}
cols = {
"notes": f"{prefix}_notes",
"chunks": f"{prefix}_chunks",
"edges": f"{prefix}_edges",
}
for n in notes:
nid = n["note_id"]
total["notes"] += 1
chunk_count = count_chunks_for_note(client, cfg.prefix, nid, args.limit)
total["chunks"] += chunk_count
edges = fetch_edges_for_note(client, cfg.prefix, nid, args.limit)
by_kind = {}
keys: Set[tuple] = set()
dup_count = 0
refs_chunk = 0
refs_note = 0
backlink = 0
for e in edges:
k = e.get("kind")
by_kind[k] = by_kind.get(k, 0) + 1
t = (e.get("kind"), e.get("source_id"), e.get("target_id"), e.get("scope"))
if t in keys:
dup_count += 1
else:
keys.add(t)
if k == "references" and e.get("scope") == "chunk":
refs_chunk += 1
if k == "references" and e.get("scope") == "note":
refs_note += 1
if k == "backlink":
backlink += 1
total["belongs_to"] += by_kind.get("belongs_to", 0)
total["next"] += by_kind.get("next", 0)
total["prev"] += by_kind.get("prev", 0)
total["refs_chunk"] += refs_chunk
total["refs_note"] += refs_note
total["backlink"] += backlink
total["dup_edges"] += dup_count
ok_bt = (by_kind.get("belongs_to", 0) == chunk_count)
ok_seq = (by_kind.get("next", 0) == max(chunk_count - 1, 0) and by_kind.get("prev", 0) == max(chunk_count - 1, 0))
ok_dup = (dup_count == 0)
line = {
"note_id": nid,
"title": n.get("title"),
"type": n.get("type"),
"chunks": chunk_count,
"edges_by_kind": by_kind,
"checks": {
"belongs_to_equals_chunks": ok_bt,
"next_prev_match": ok_seq,
"no_duplicate_edges": ok_dup,
# Index: notes -> title/type
notes_meta = {}
for p in _scroll(client, cols["notes"]):
pl = p.payload or {}
nid = pl.get("note_id")
if nid:
notes_meta[nid] = {
"title": pl.get("title", ""),
"type": pl.get("type", ""),
}
}
print(json.dumps(line, ensure_ascii=False))
if args.flush:
sys.stdout.flush()
print(json.dumps({"prefix": cfg.prefix, "summary": total}, ensure_ascii=False))
# chunks je note
chunks_by_note = defaultdict(int)
for p in _scroll(client, cols["chunks"]):
pl = p.payload or {}
nid = pl.get("note_id")
if nid:
chunks_by_note[nid] += 1
# edges je note
edges_by_note = defaultdict(list)
edges_all = _scroll(client, cols["edges"])
for p in edges_all:
pl = p.payload or {}
nid = pl.get("note_id")
if nid:
edges_by_note[nid].append(pl)
# pro note ausgeben
summary_edges = Counter()
total_chunks = 0
for nid in sorted(notes_meta.keys()):
meta = notes_meta[nid]
chunks = chunks_by_note.get(nid, 0)
total_chunks += chunks
kinds = Counter(_rel(pl) for pl in edges_by_note[nid])
summary_edges.update(kinds)
row = {
"note_id": nid,
"title": meta["title"],
"type": meta["type"],
"chunks": chunks,
"edges_by_kind": dict(kinds),
"checks": {
"belongs_to_equals_chunks": (kinds.get("belongs_to", 0) == chunks),
"next_prev_match": (kinds.get("next", 0) == kinds.get("prev", 0) == max(0, chunks - 1)),
"no_duplicate_edges": _no_dupes(edges_by_note[nid]),
},
}
print(json.dumps(row, ensure_ascii=False))
# Gesamtsummary
total_notes = len(notes_meta)
out = {
"prefix": prefix,
"summary": {
"notes": total_notes,
"chunks": total_chunks,
"belongs_to": summary_edges.get("belongs_to", 0),
"next": summary_edges.get("next", 0),
"prev": summary_edges.get("prev", 0),
"refs_chunk": summary_edges.get("references", 0),
"refs_note": summary_edges.get("references_note", 0),
"backlink": summary_edges.get("backlink", 0),
"dup_edges": 0, # per-Note geprüft
},
}
print(json.dumps(out, ensure_ascii=False))
def _no_dupes(pls):
seen = set()
for pl in pls:
key = (
str(pl.get("source_id") or ""),
str(pl.get("target_id") or ""),
str(pl.get("relation") or pl.get("kind") or ""),
str(pl.get("rule_id") or ""),
)
if key in seen:
return False
seen.add(key)
return True
if __name__ == "__main__":
main()
+67
View File
@@ -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()
+64
View File
@@ -0,0 +1,64 @@
from app.core import retriever as r
from app.models.dto import QueryRequest
import app.core.qdrant as qdr
import app.core.qdrant_points as qp
import app.services.embeddings_client as ec
class _DummyClient:
"""Minimaler Platzhalter für QdrantClient in Unit-Tests."""
pass
def _fake_get_client(cfg):
return _DummyClient()
def _fake_embed_text(text: str):
# Liefert stabilen Vektor; Größe ist für diesen Test egal,
# da search_chunks_by_vector ebenfalls gefaked wird.
return [0.0] * 16
def _fake_search_chunks_by_vector(client, prefix, vector, top=10, filters=None):
# einfache Hitliste in absteigender Score-Reihenfolge
return [
("chunk:1", 0.9, {"note_id": "note:1", "path": "a.md", "section_title": "S1"}),
("chunk:2", 0.7, {"note_id": "note:2", "path": "b.md", "section_title": "S2"}),
("chunk:3", 0.4, {"note_id": "note:3", "path": "c.md", "section_title": "S3"}),
]
def test_semantic_retrieve_basic(monkeypatch):
# Qdrant- und Embedding-Aufrufe faken
monkeypatch.setattr(qdr, "get_client", _fake_get_client)
monkeypatch.setattr(ec, "embed_text", _fake_embed_text)
monkeypatch.setattr(qp, "search_chunks_by_vector", _fake_search_chunks_by_vector)
req = QueryRequest(mode="semantic", query="karate trainingsplan", top_k=2)
resp = r.semantic_retrieve(req)
assert resp.used_mode == "semantic"
assert len(resp.results) == 2
# Scores absteigend sortiert
scores = [h.total_score for h in resp.results]
assert scores[0] >= scores[1]
# Korrekte Zuordnung von note_id und Quelle
assert resp.results[0].note_id == "note:1"
assert resp.results[0].source["path"] == "a.md"
def test_hybrid_retrieve_basic(monkeypatch):
# Qdrant- und Embedding-Aufrufe faken
monkeypatch.setattr(qdr, "get_client", _fake_get_client)
monkeypatch.setattr(qp, "search_chunks_by_vector", _fake_search_chunks_by_vector)
# Im Hybrid-Modus arbeiten wir im Step-1-Stand nur mit query_vector
req = QueryRequest(mode="hybrid", query_vector=[0.0] * 16, top_k=2)
resp = r.hybrid_retrieve(req)
assert resp.used_mode == "hybrid"
assert len(resp.results) == 2
scores = [h.total_score for h in resp.results]
assert scores[0] >= scores[1]
+74
View File
@@ -0,0 +1,74 @@
from app.core import retriever as r
from app.models.dto import QueryRequest
import app.core.qdrant as qdr
import app.core.qdrant_points as qp
import app.core.graph_adapter as ga
import app.services.embeddings_client as ec
class _DummyClient:
pass
def _fake_get_client(cfg):
return _DummyClient()
def _fake_embed_text(text: str):
# Dimension ist egal, da wir search_chunks_by_vector faken
return [0.0] * 384
def _fake_search_chunks_by_vector(client, prefix, vector, top=10, filters=None):
# Drei Treffer mit identischem semantic_score und retriever_weight,
# aber unterschiedlichen Graph-Boni
return [
("chunk:1", 0.8, {"note_id": "note:1", "chunk_id": "c1", "path": "a.md", "section_title": "S1"}),
("chunk:2", 0.8, {"note_id": "note:2", "chunk_id": "c2", "path": "b.md", "section_title": "S2"}),
("chunk:3", 0.8, {"note_id": "note:3", "chunk_id": "c3", "path": "c.md", "section_title": "S3"}),
]
class _DummySubgraph:
def __init__(self, edge_scores, cent_scores):
self._edge = edge_scores
self._cent = cent_scores
def edge_bonus(self, node_id: str) -> float:
return self._edge.get(node_id, 0.0)
def centrality_bonus(self, node_id: str) -> float:
return self._cent.get(node_id, 0.0)
def _fake_expand(client, prefix, seeds, depth=1, edge_types=None):
# Wir gewichten c2 > c1 > c3
edge_scores = {"c1": 0.1, "c2": 0.5, "c3": 0.0}
cent_scores = {"c1": 0.05, "c2": 0.2, "c3": 0.0}
return _DummySubgraph(edge_scores, cent_scores)
def test_hybrid_retrieve_uses_edge_scores(monkeypatch):
# Qdrant-Client, Embeddings, Chunk-Suche und Graph-Expansion faken
monkeypatch.setattr(qdr, "get_client", _fake_get_client)
monkeypatch.setattr(ec, "embed_text", _fake_embed_text)
monkeypatch.setattr(qp, "search_chunks_by_vector", _fake_search_chunks_by_vector)
monkeypatch.setattr(ga, "expand", _fake_expand)
# expand.depth > 0 triggern, edge_types sind hier egal
req = QueryRequest(mode="hybrid", query="karate", top_k=3, expand={"depth": 1, "edge_types": ["references"]})
resp = r.hybrid_retrieve(req)
assert len(resp.results) == 3
# Da alle semantic_scores und retriever_weight gleich sind,
# bestimmt die Summe aus edge_bonus + centrality_bonus das Ranking.
first = resp.results[0]
second = resp.results[1]
third = resp.results[2]
assert first.note_id == "note:2" # c2 hat höchste Graph-Boni
assert second.note_id == "note:1"
assert third.note_id == "note:3"
assert first.total_score > second.total_score > third.total_score
+120
View File
@@ -0,0 +1,120 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
#
# test_retriever_smoke.py – End-to-End Smoke-Test für den mindnet Retriever
#
# Dieser Smoke-Test ist für manuelle End-to-End-Tests gedacht.
# Er wird NICHT automatisch von pytest ausgeführt.
#
# Empfohlener Speicherort: tests/test_retriever_smoke.py
#
# Aufrufbeispiele:
#
# python tests/test_retriever_smoke.py --query "embeddings" --mode semantic
#
# python tests/test_retriever_smoke.py \
# --query "embeddings" \
# --mode hybrid \
# --expand-depth 1 \
# --expand-edge-types references depends_on
#
from __future__ import annotations
import argparse
import sys
from typing import Any, Dict
import requests
def _build_payload(args: argparse.Namespace) -> Dict[str, Any]:
payload: Dict[str, Any] = {
"mode": args.mode,
"query": args.query,
"top_k": args.top_k,
}
if args.expand_depth is not None and args.expand_depth > 0:
expand: Dict[str, Any] = {"depth": args.expand_depth}
if args.expand_edge_types:
expand["edge_types"] = args.expand_edge_types
payload["expand"] = expand
return payload
def main(argv: list[str] | None = None) -> int:
parser = argparse.ArgumentParser(description="Smoke-Test für mindnet-Retriever (/query)")
parser.add_argument("--url", default="http://127.0.0.1:8000/query", help="URL des Query-Endpunkts")
parser.add_argument("--query", required=True, help="Text-Query")
parser.add_argument("--mode", choices=["semantic", "hybrid"], default="hybrid")
parser.add_argument("--top-k", type=int, default=5)
parser.add_argument("--expand-depth", type=int, default=0)
parser.add_argument(
"--expand-edge-types",
nargs="*",
default=None,
help="Edge-Typen (z. B. references depends_on)",
)
args = parser.parse_args(argv)
payload = _build_payload(args)
try:
resp = requests.post(args.url, json=payload, timeout=10)
except Exception as exc:
print(f"[ERROR] HTTP-Request fehlgeschlagen: {exc}", file=sys.stderr)
return 1
if resp.status_code != 200:
print(f"[ERROR] Statuscode: {resp.status_code}", file=sys.stderr)
print(resp.text, file=sys.stderr)
return 1
try:
data = resp.json()
except Exception:
print("[ERROR] Ungültiges JSON:", resp.text, file=sys.stderr)
return 1
print("=== mindnet Retriever Smoke-Test ===")
print(f"URL: {args.url}")
print(f"Mode: {args.mode}")
print(f"Query: {args.query!r}")
print(f"Top-K: {args.top_k}")
print()
results = data.get("results") or []
print(f"used_mode: {data.get('used_mode')}")
print(f"latency: {data.get('latency_ms')} ms")
print(f"Treffer: {len(results)}")
print()
for i, hit in enumerate(results, start=1):
nid = hit.get("note_id")
cid = hit.get("node_id")
tot = hit.get("total_score")
sem = hit.get("semantic_score")
edge = hit.get("edge_bonus")
cen = hit.get("centrality_bonus")
src = hit.get("source") or {}
path = src.get("path")
sec = src.get("section")
print(f"[{i}] note_id={nid} node_id={cid}")
try:
print(
f" total={float(tot):.4f} "
f"(semantic={float(sem):.4f} edge={float(edge):.4f} centrality={float(cen):.4f})"
)
except Exception:
print(f" total={tot}, semantic={sem}, edge={edge}, centrality={cen}")
if path or sec:
print(f" source: {path or '-'} :: {sec or '-'}")
print()
return 0
if __name__ == "__main__":
raise SystemExit(main())
+48
View File
@@ -0,0 +1,48 @@
from app.core import retriever as r
from app.models.dto import QueryRequest
import app.core.qdrant as qdr
import app.core.qdrant_points as qp
import app.services.embeddings_client as ec
class _DummyClient:
pass
def _fake_get_client(cfg):
return _DummyClient()
def _fake_embed_text(text: str):
# Dimension egal, da wir search_chunks_by_vector faken
return [0.0] * 384
def _fake_search_chunks_by_vector_weights(client, prefix, vector, top=10, filters=None):
# Zwei Treffer mit unterschiedlichem retriever_weight
return [
("chunk:low", 0.9, {"note_id": "note:low", "path": "low.md", "section_title": "S1", "retriever_weight": 0.2}),
("chunk:high", 0.8, {"note_id": "note:high", "path": "high.md", "section_title": "S2", "retriever_weight": 1.5}),
]
def test_retriever_weight_influences_ranking(monkeypatch):
# Konfiguration: Qdrant & Embedding faken
monkeypatch.setattr(qdr, "get_client", _fake_get_client)
monkeypatch.setattr(ec, "embed_text", _fake_embed_text)
monkeypatch.setattr(qp, "search_chunks_by_vector", _fake_search_chunks_by_vector_weights)
req = QueryRequest(mode="semantic", query="karate", top_k=2)
resp = r.semantic_retrieve(req)
assert len(resp.results) == 2
first = resp.results[0]
second = resp.results[1]
# Semantic Scores: 0.9 (low), 0.8 (high)
# Total Scores: 0.9 * 0.2 = 0.18 vs. 0.8 * 1.5 = 1.2 -> high sollte oben liegen
assert first.note_id == "note:high"
assert second.note_id == "note:low"
assert first.total_score > second.total_score