Compare commits

...
Author SHA1 Message Date
Lars 62aa24a4bc Merge pull request 'WP07' (#7) from WP07 into main
Deploy mindnet to llm-node / deploy (push) Successful in 3s
Reviewed-on: #7
# Feature: Interview Assistent & Draft Editor (WP-07 + WP-10a)

**PR Typ:** Feature
**Version:** v2.4.0
**Status:** ✅ Tested & Documented

## 📝 Zusammenfassung
Dieser Merge transformiert Mindnet von einem reinen RAG-System (Lesen) in ein **Co-Creation-System (Schreiben)**.
Implementiert wurden der **One-Shot Interview Modus**, der auf Basis von User-Prompts strukturierte Markdown-Entwürfe generiert, sowie ein **Frontend-Editor**, um diese Entwürfe zu finalisieren und herunterzuladen.

## 🛠 Technische Änderungen

### Backend (WP-07)
* **`app/routers/chat.py`**:
    * Neue Logikweiche für Intent `INTERVIEW` (kein RAG-Retrieval).
    * Implementierung von `_detect_target_type` (Keyword-Matching für Schemas).
    * Dynamische Injektion von Pflichtfeldern in den Prompt.
* **`config/decision_engine.yaml`**:
    * Neuer Intent `INTERVIEW` definiert.
    * **Late Binding Schemas:** Definition der Pflichtfelder für `project`, `decision`, `goal`, etc.
* **`config/prompts.yaml`**:
    * Neues `interview_template` mit "One-Shot Extraction" Logik und striktem Markdown-Output-Format.

### Frontend (WP-10a)
* **`app/frontend/ui.py`**:
    * Neues Widget `render_draft_editor`: Erkennt Drafts und rendert `st.text_area`.
    * **Sanitizer:** `normalize_meta_and_body` repariert halluzinierte YAML-Header des LLMs.
    * Export-Funktion (Download als `.md`).

### Dokumentation (WP-14)
* Update auf **v2.4.0** für alle Core-Docs (`Overview`, `Tech Arch`, `User Guide`, `Admin Guide`).
* Aktualisierung `Programmplan_V2.2.md` (WP-07/10a auf Grün).

## ✅ Test-Coverage
* [x] Intent `INTERVIEW` wird via Keywords ("neues projekt") erkannt.
* [x] One-Shot Extractor liefert validen Markdown-Codeblock.
* [x] UI rendert Editor statt Chat-Blase.
* [x] Sanitizer fängt falsche YAML-Keys (z.B. 'situation') ab und schiebt sie in den Body.
2025-12-10 18:57:14 +01:00
Lars f2de556c16 dokumentation 2025-12-10 18:55:38 +01:00
Lars 67d865d373 ui und prompt 2025-12-10 18:13:35 +01:00
Lars 5c0a36c9ea Debug 2 2025-12-10 17:43:03 +01:00
Lars f50ae4c934 debug mode gui 2025-12-10 17:35:21 +01:00
Lars 1fefc538ac UI Work 2025-12-10 17:14:51 +01:00
Lars a520b62d08 spezial UI für das Bearbeiten von MD 2025-12-10 16:55:56 +01:00
Lars 1063c94f5d UI Anpasung für WP07 2025-12-10 16:41:21 +01:00
Lars 954e21ca81 anpassung one shot 2025-12-10 16:16:51 +01:00
Lars fd39211801 neuer prompt 2025-12-10 14:12:53 +01:00
Lars ff23ce6f00 testscript 2025-12-10 14:03:07 +01:00
Lars 86464cec11 erster Entwurf WP07 2025-12-10 13:48:13 +01:00
Lars ba57e8b43f Merge pull request 'WP10' (#6) from WP10 into main
Deploy mindnet to llm-node / deploy (push) Successful in 12s
Reviewed-on: #6
# Merge Request: WP-10 (Chat Interface & Frontend Architecture)

**Branch:** `feature/WP10-chat-interface` → `main`
**Status:** ✅ Ready for Merge
**Version Bump:** v2.3.1 → v2.3.2

## Zusammenfassung
Dieser Merge führt das **Web-Frontend (Streamlit)** ein. Damit wird Mindnet von einer reinen Terminal-Applikation zu einem interaktiven System mit grafischer Benutzeroberfläche.
Das Frontend visualisiert die Entscheidungen der **Decision Engine** (WP-06) und ermöglicht strukturiertes Feedback für das zukünftige **Self-Tuning** (WP-08).

## 🚀 Neue Features (User Perspective)
* **Web Chat UI:** ChatGPT-ähnliches Interface mit persistenter History.
* **Intent Visualisierung:** Badges zeigen an, in welchem Modus (FACT, DECISION, EMPATHY) das System antwortet und *warum* (Keyword vs. LLM).
* **Transparent Sources:** Verwendete Quellen werden als expandierbare Karten unter der Antwort angezeigt, inkl. "Why"-Erklärung.
* **Feedback Loop:**
    * **Global (Antwort):** 1-5 Sterne Rating.
    * **Granular (Quellen):** Faces-Rating (Mapped auf Score 1-5) für spezifische Chunks.

## 🛠️ Technische Änderungen (Backend/Infra)
* **Neue Komponente:** `app/frontend/ui.py` (Streamlit App).
* **Dependencies:** `streamlit` zu `requirements.txt` hinzugefügt.
* **Deployment:** Konfiguration für getrennte Services in Prod und Dev:
    * **PROD:** Backend `:8001` ↔ Frontend `:8501`
    * **DEV:** Backend `:8002` ↔ Frontend `:8502`
* **Logging:** Integration der Feedback-Logik in `data/logs/feedback.jsonl`.

## ⚠️ Deployment Hinweise
Nach dem Merge müssen auf dem Server folgende Schritte ausgeführt werden:

1.  **Dependencies:** `pip install -r requirements.txt` (für Streamlit).
2.  **Systemd:** Neue Service-Files für die UI anlegen (`mindnet-ui-prod.service`).
3.  **Firewall:** Port `8501` (Prod) und `8502` (Dev) in `ufw` freigeben.

## Checkliste
- [x] UI startet und verbindet sich mit API.
- [x] Chat-Flow (Request/Response) funktioniert.
- [x] Intent-Badge zeigt korrekte Source an.
- [x] Feedback wird in `feedback.jsonl` geschrieben.
- [x] Dokumentation (Admin Guide, User Guide, Arch) ist aktualisiert.
2025-12-10 10:29:10 +01:00
Lars be406d230f Dokumentation WP10 2025-12-10 10:26:44 +01:00
Lars 38abde8516 Gui Anpassung. 2025-12-09 23:16:28 +01:00
Lars 9bb6566419 kleine Änderungen 2025-12-09 23:12:07 +01:00
Lars 2acaf3c060 vorbereitung UI für WP07 2025-12-09 23:05:28 +01:00
Lars ec33163d98 verbessertes Feedback 2025-12-09 22:43:38 +01:00
Lars 2d0913cf3b Feedback UI 2025-12-09 22:27:56 +01:00
Lars 76ea8e3350 Update für Feedback Loop 2025-12-09 22:07:58 +01:00
Lars bbc1e589f5 Nutzung von .env für Timeout 2025-12-09 19:00:39 +01:00
Lars 987e297c07 Erste Version Wp10 2025-12-09 18:44:26 +01:00
Lars 046aa2cf48 Merge pull request 'WP06a' (#5) from WP06a into main
Deploy mindnet to llm-node / deploy (push) Successful in 4s
Reviewed-on: #5
fix(wp06a): Fix API Payload-Enrichment & CPU Timeouts

Stabilisierungspatch für die Decision Engine (Post-WP06).

**Bugfixes & Verbesserungen:**
- **FIX:** API (Retriever) liefert nun `payload`-Daten im `QueryHit` zurück. Behebt "Typ: unknown" Fehler in Clients/Tests.
- **FIX:** Test-Skript (`test_wp06_decision.py`) prüft nun robust auf `payload` oder `source` und zeigt Intent-Source an.
- **FIX:** Timeout für LLM-Inference in `.env` konfigurierbar gemacht (`MINDNET_LLM_TIMEOUT`) und Default für Tests auf 300s erhöht (Cold-Start Protection).
- **CHORE:** DTOs erweitert um `intent_source` für besseres Tracing (Keyword vs. LLM).
- **DOCS:** Technische Architektur und Appendices aktualisiert (Chunk-Schema enthält nun explizit `type`).

**Version Bump:** v2.3.1 -> v2.3.2
2025-12-09 18:25:36 +01:00
Lars 0bc0e66a85 Dokumentation angepasst 2025-12-09 18:22:15 +01:00
Lars 2310633de3 payload durchreichen bis zum chat 2025-12-09 18:11:25 +01:00
Lars bd36d78025 neue Test 2025-12-09 18:02:21 +01:00
Lars d2270fafdd testscript für WP06 korrigiert
Deploy mindnet to llm-node / deploy (push) Successful in 4s
2025-12-09 17:45:08 +01:00
Lars 86faf5b8f0 Merge pull request 'WP06' (#4) from WP06 into main
Deploy mindnet to llm-node / deploy (push) Successful in 3s
feat(wp06): Release v2.3.1 - Decision Engine & Hybrid Intent Router

Abschluss von WP-06: Transformation des Chatbots zum strategischen Partner.

Hauptänderungen:
- Feature: Hybrid Intent Router implementiert (Fast Path: Keywords / Slow Path: LLM-Fallback).
- Feature: Strategic Retrieval (Injektion von [VALUE], [GOAL], [EXPERIENCE] basierend auf Intent).
- Feature: Multi-Persona Support (Berater, Empathischer Spiegel, Coder, Bibliothekar).
- Config: Late Binding Logik komplett in `config/decision_engine.yaml` ausgelagert.
- Tech: LLM-Service erweitert um konfigurierbaren Timeout (CPU-Inference Support) und Raw-Generation Mode.
- Docs: Vollständige Aktualisierung der Kern-Dokumentation (Architektur, Playbooks, Guides) auf v2.3.1.

Version Bump: 2.3.0 -> 2.3.1
2025-12-09 17:14:52 +01:00
Lars 902f26ee95 WP06 Dokumentation 2025-12-09 17:11:03 +01:00
Lars ea9fe1a6ed neues Testscript 2025-12-09 15:14:38 +01:00
Lars 6c2074166c verbessertes Prompt, und chat-Router optimiert 2025-12-09 13:50:18 +01:00
Lars bd44af2b68 korrektur zu besseren Analyse 2025-12-09 13:37:26 +01:00
Lars 972cd0dfac neues Testscript 2025-12-09 13:22:34 +01:00
Lars 9cc16bb220 fehlerkorrektzur Hybrid chat 2025-12-09 13:14:24 +01:00
Lars 03594424a1 Hybrider Chat (mit und ohne LLM Einordung des Intents) 2025-12-09 13:08:04 +01:00
Lars 97985371ca neue engine mit mehreren typen 2025-12-09 09:58:35 +01:00
Lars 3c5c01998f Parametrisierung und testscript 2025-12-08 19:41:32 +01:00
Lars 2fa24cb1bd Konfiguierbare Entscheidungen 2025-12-08 19:36:12 +01:00
Lars 0304bae9f4 Port richtig gesetz 2025-12-08 19:03:06 +01:00
Lars ac6d34731a Merge branch 'WP06' of http://192.168.2.144:3000/Lars/mindnet into WP06 2025-12-08 19:00:49 +01:00
Lars be5ad7e080 test 2025-12-08 19:00:42 +01:00
Lars 32128c06c1 docs/pipeline_playbook.md aktualisiert 2025-12-08 18:50:54 +01:00
Lars 07b7f419de Erste Version WP06 2025-12-08 18:48:24 +01:00
Lars 4d6fce2d93 TOC
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-12-08 18:01:35 +01:00
Lars b398168b1f docs/mindnet_functional_architecture.md aktualisiert
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-12-08 17:58:28 +01:00
Lars 6b397fea2e docs/mindnet_functional_architecture.md aktualisiert
Deploy mindnet to llm-node / deploy (push) Successful in 4s
2025-12-08 17:57:51 +01:00
Lars d20386e0a7 Toc
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-12-08 17:55:24 +01:00
Lars fcb90db2d0 docs/mindnet_functional_architecture.md aktualisiert
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-12-08 17:47:28 +01:00
Lars 5d8e96372f docs/developer_guide.md aktualisiert
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-12-08 17:39:01 +01:00
Lars 0d1a98279e docs/developer_guide.md aktualisiert
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-12-08 17:33:46 +01:00
Lars 73641abf8a config/retriever.yaml aktualisiert
Deploy mindnet to llm-node / deploy (push) Successful in 4s
2025-12-08 17:25:43 +01:00
Lars a4873b3d45 docs/mindnet_functional_architecture.md aktualisiert
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-12-08 16:52:22 +01:00
Lars 4f171e5245 Merge pull request 'WP05' (#3) from WP05 into main
Deploy mindnet to llm-node / deploy (push) Successful in 5s
Reviewed-on: #3
2025-12-08 16:17:48 +01:00
Lars d48b671314 Dokumentation aktualisiert 2025-12-08 16:14:52 +01:00
Lars b9d73af062 Update zum Prompt 2025-12-08 14:33:34 +01:00
Lars 21904e62ee go 2025-12-08 14:27:17 +01:00
Lars f9af30b195 Frage in test_chat_wp05 angepasst 2025-12-08 13:45:04 +01:00
Lars 531e3790b3 persönlichkeitsupdate 2025-12-08 13:39:16 +01:00
Lars 7745b71832 debug raus . aktualisierte chats 2025-12-08 11:15:16 +01:00
Lars b39663408c debug 2025-12-08 11:09:52 +01:00
Lars 9c4696e9d5 Inhalte werden ans LLM übergeben 2025-12-08 11:06:29 +01:00
Lars cf5e53f341 anderes LLm und timeout erhöht 2025-12-08 10:52:57 +01:00
Lars e512f768ff wechsel des LLM (--> Mistral") 2025-12-08 10:45:28 +01:00
Lars c3ef65d069 retriever.py mit neuer Wrapper Klasse 2025-12-08 10:39:35 +01:00
Lars 90f0be6baf erste Version WP05 2025-12-08 10:32:57 +01:00
Lars eba51eba0f docs/dev_workflow.md aktualisiert
Deploy mindnet to llm-node / deploy (push) Successful in 3s
2025-12-08 10:10:48 +01:00
37 changed files with 3155 additions and 928 deletions

No files matched your search

+159 -81
View File
@@ -1,21 +1,57 @@
# mindnet v2.2 — Programmplan # mindnet v2.2 — Programmplan
**Version:** 2.2.1 (Post-WP04 Update) **Version:** 2.4.0 (Inkl. WP-07 Interview & WP-10a Draft Editor)
**Stand:** 2025-12-07 **Stand:** 2025-12-10
**Status:** Aktiv **Status:** Aktiv
---
- [mindnet v2.2 — Programmplan](#mindnet-v22--programmplan)
- [1. Programmauftrag](#1-programmauftrag)
- [2. Vision](#2-vision)
- [3. Programmziele](#3-programmziele)
- [3.1 Kurzfristig (Abgeschlossen / Laufend)](#31-kurzfristig-abgeschlossen--laufend)
- [3.2 Mittelfristig (Nächste Schritte)](#32-mittelfristig-nächste-schritte)
- [3.3 Langfristig](#33-langfristig)
- [4. Architekturprinzipien](#4-architekturprinzipien)
- [5. Programmstruktur (Phasenmodell)](#5-programmstruktur-phasenmodell)
- [6. Workpackages – detaillierte Übersicht](#6-workpackages--detaillierte-übersicht)
- [Legende Aufwand / Komplexität](#legende-aufwand--komplexität)
- [WP-01 – Wissensdesign (abgeschlossen)](#wp-01--wissensdesign-abgeschlossen)
- [WP-02 – Chunking \& Hash-Strategie (abgeschlossen)](#wp-02--chunking--hash-strategie-abgeschlossen)
- [WP-03 – Import-Pipeline \& Edge-System v2 (abgeschlossen)](#wp-03--import-pipeline--edge-system-v2-abgeschlossen)
- [WP-04a – Retriever \& Graph-Scoring (abgeschlossen)](#wp-04a--retriever--graph-scoring-abgeschlossen)
- [WP-04b – Explanation Layer ("Why-Layer") (abgeschlossen)](#wp-04b--explanation-layer-why-layer-abgeschlossen)
- [WP-04c – Feedback Logging \& Bewertungsdaten (abgeschlossen)](#wp-04c--feedback-logging--bewertungsdaten-abgeschlossen)
- [WP-05 – Persönlichkeitsmodell \& RAG-Chat (abgeschlossen)](#wp-05--persönlichkeitsmodell--rag-chat-abgeschlossen)
- [WP-05b – Advanced Chat (Optional)](#wp-05b--advanced-chat-optional)
- [WP-06 – Decision Engine \& Hybrid Router (abgeschlossen)](#wp-06--decision-engine--hybrid-router-abgeschlossen)
- [WP-07 – Interview-Assistent (abgeschlossen)](#wp-07--interview-assistent-abgeschlossen)
- [WP-08 – Self-Tuning v1/v2 (geplant)](#wp-08--self-tuning-v1v2-geplant)
- [WP-09 – Vault-Onboarding \& Migration (geplant)](#wp-09--vault-onboarding--migration-geplant)
- [WP-10 – Chat-Interface \& Writeback (abgeschlossen)](#wp-10--chat-interface--writeback-abgeschlossen)
- [WP-10a – GUI Evolution: Draft Editor (abgeschlossen)](#wp-10a--gui-evolution-draft-editor-abgeschlossen)
- [WP-11 – Knowledge-Builder \& Vernetzungs-Assistent (geplant)](#wp-11--knowledge-builder--vernetzungs-assistent-geplant)
- [WP-12 – Knowledge Rewriter (Soft Mode, geplant)](#wp-12--knowledge-rewriter-soft-mode-geplant)
- [WP-13 – MCP-Integration \& Agenten-Layer (geplant)](#wp-13--mcp-integration--agenten-layer-geplant)
- [WP-14 – Review / Refactoring / Dokumentation (geplant)](#wp-14--review--refactoring--dokumentation-geplant)
- [7. Abhängigkeiten (vereinfacht, aktualisiert)](#7-abhängigkeiten-vereinfacht-aktualisiert)
- [8. Laufzeit- \& Komplexitätsindikatoren (aktualisiert)](#8-laufzeit---komplexitätsindikatoren-aktualisiert)
- [9. Programmfortschritt (Ampel, aktualisiert)](#9-programmfortschritt-ampel-aktualisiert)
- [10. Governance \& Versionierung](#10-governance--versionierung)
- [11. Executive Summary](#11-executive-summary)
--- ---
## 1. Programmauftrag ## 1. Programmauftrag
mindnet v2.2 entwickelt ein persönliches, wachsendes KI-Gedächtnis, das: mindnet v2.4 entwickelt ein persönliches, wachsendes KI-Gedächtnis, das:
- Wissen, Erfahrungen, Werte und Entscheidungen speichert, - Wissen, Erfahrungen, Werte und Entscheidungen speichert,
- diese Informationen semantisch verknüpft und rekonstruierbar macht, - diese Informationen semantisch verknüpft und rekonstruierbar macht,
- einen KI-Zwilling aufbaut, der ähnlich argumentiert, entscheidet und reflektiert wie du, - einen KI-Zwilling aufbaut, der ähnlich argumentiert, entscheidet und reflektiert wie du,
- über mehrere Kanäle gefüttert wird: - über mehrere Kanäle gefüttert wird:
- Obsidian-Markdown (primäre Quelle), - Obsidian-Markdown (primäre Quelle),
- Chat-basierter Agent (mindnet-Assistent), - Chat-basierter Agent (Decision Engine & RAG-Chat aktiv),
- später: Interview-Assistent (strukturierte Dialogerfassung), - **Interview-Assistent (One-Shot Extraction aktiv)**,
- automatisch neue Zusammenhänge erkennt und vernetzt (Edges, Typen, Hinweise), - automatisch neue Zusammenhänge erkennt und vernetzt (Edges, Typen, Hinweise),
- sich durch Rückmeldungen (Feedback) selbst verbessert (Self-Tuning). - sich durch Rückmeldungen (Feedback) selbst verbessert (Self-Tuning).
@@ -31,7 +67,7 @@ Langfristig soll mindnet als **digitales Gegenüber** funktionieren, das:
mindnet ist **kein statisches Wissensarchiv**, sondern ein **lebendes, lernendes Gedächtnismodell** mit Fokus auf: mindnet ist **kein statisches Wissensarchiv**, sondern ein **lebendes, lernendes Gedächtnismodell** mit Fokus auf:
- persönliche Perspektive, - persönliche Perspektive,
- erklärbare Begründungspfade, - erklärbare Begründungspfade (Why-Layer),
- kontinuierliche Erweiterbarkeit, - kontinuierliche Erweiterbarkeit,
- robuste technische Basis (lokal, nachvollziehbar, versioniert). - robuste technische Basis (lokal, nachvollziehbar, versioniert).
@@ -44,13 +80,13 @@ mindnet ist **kein statisches Wissensarchiv**, sondern ein **lebendes, lernendes
Kernprinzipien der Vision: Kernprinzipien der Vision:
- **Erklärbarkeit:** - **Erklärbarkeit:**
Jede Antwort muss über Edges, Scores, Werte-Bezüge und Herkunftsnotizen begründbar sein. Jede Antwort muss über Edges, Scores, Werte-Bezüge und Herkunftsnotizen begründbar sein. Das System kann Entscheidungen auf zugrundeliegende `[DECISION]`-Notizen zurückführen.
- **Wachstum:** - **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. 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):** - **Flexibilität (Late Binding):**
Semantik wird überwiegend in Konfiguration (z. B. `types.yaml`, Policies, Knowledge-Design) festgelegt, nicht in jeder einzelnen Markdown-Datei. Semantik wird überwiegend in Konfiguration (z. B. `types.yaml`, `prompts.yaml`, `decision_engine.yaml`) festgelegt. Die Persönlichkeit entsteht durch das Config-Design, nicht durch Hardcoding.
- **Autonomie & Self-Healing:** - **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. 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.
@@ -59,7 +95,7 @@ Kernprinzipien der Vision:
Feedback zu Antworten (gut/schlecht, relevant/nicht relevant) fließt in Score-Gewichte, Policies und ggf. Edge-Struktur ein. Feedback zu Antworten (gut/schlecht, relevant/nicht relevant) fließt in Score-Gewichte, Policies und ggf. Edge-Struktur ein.
- **Persönlichkeit:** - **Persönlichkeit:**
Entscheidungen werden wert- und erfahrungsbasiert begründet; mittelfristig entsteht ein Persönlichkeitsmodell, das den KI-Zwilling trägt. Entscheidungen werden wert- und erfahrungsbasiert begründet; das System agiert als KI-Zwilling durch Nutzung lokaler LLMs (z.B. Phi-3/Mistral) und eines Intent-Routers.
- **Incremental Growth:** - **Incremental Growth:**
Das System muss mit wenigen, heterogenen Notizen starten und sich fortlaufend verdichten können – ohne Retro-Massenmigrationen im Vault. Das System muss mit wenigen, heterogenen Notizen starten und sich fortlaufend verdichten können – ohne Retro-Massenmigrationen im Vault.
@@ -68,32 +104,30 @@ Kernprinzipien der Vision:
## 3. Programmziele ## 3. Programmziele
### 3.1 Kurzfristig (nächste Monate) ### 3.1 Kurzfristig (Abgeschlossen / Laufend)
- Automatische Sammlung von Wissen aus Markdown-Vault und ersten Chat-Dialogen. - Automatische Sammlung von Wissen aus Markdown-Vault.
- Aufbau eines stabilen Graph-Speichers in Qdrant (`*_notes`, `*_chunks`, `*_edges`). - Aufbau eines stabilen Graph-Speichers in Qdrant (`*_notes`, `*_chunks`, `*_edges`).
- Semantischer und graphbasierter Retriever (WP-04a abgeschlossen). - Semantischer und graphbasierter Retriever (WP-04a abgeschlossen).
- **Erklärbarkeit:** Why-Layer liefert Begründungen zu Treffern (WP-04b abgeschlossen). - **Erklärbarkeit:** Why-Layer liefert Begründungen zu Treffern (WP-04b abgeschlossen).
- **Feedback-Loop:** Systematisches Logging von Suche und Bewertung (WP-04c abgeschlossen). - **Feedback-Loop:** Systematisches Logging von Suche und Bewertung (WP-04c abgeschlossen).
- **RAG-Chat:** KI antwortet in natürlicher Sprache auf Basis von Wissen und Persönlichkeit (WP-05 abgeschlossen).
- **Decision Engine:** System erkennt Intent (Fakt vs. Entscheidung) und wägt Werte ab (WP-06 abgeschlossen).
- **Multi-Persona:** System wechselt den Tonfall (Empathisch vs. Analytisch) situativ (WP-06 abgeschlossen).
- **Chat Interface:** Web-basiertes Frontend (Streamlit) für einfache Interaktion und Feedback-Gabe (WP-10 abgeschlossen).
- **Interview-Assistent (WP-07):** One-Shot Extraction von Notizen ("Neues Projekt anlegen") ist live.
- Technische Basis: FastAPI, Qdrant, Ollama (Local LLM), Streamlit.
- Automatisierte Erkennung von Beziehungen: - Automatisierte Erkennung von Beziehungen:
- Wikilinks, Inline-Relationen, Callout-Edges, Typ-Defaults. - Wikilinks, Inline-Relationen, Callout-Edges, Typ-Defaults.
- Schrittweises Lernen über Feedback (Score-Tuning, noch „manuell“ konfiguriert).
- „Mitwachsendes“ Schema ohne Obsidian-Umstrukturierungen: - „Mitwachsendes“ Schema ohne Obsidian-Umstrukturierungen:
- Neues Wissen kann sofort erfasst werden, - Neues Wissen kann sofort erfasst werden,
- bestehende Notizen bleiben gültig (Virtual Schema Layer). - 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 ### 3.2 Mittelfristig (Nächste Schritte)
- Persönlichkeitsprofil wird stabil erkannt und für Antworten genutzt (Typen, Werte-Notizen, Entscheidungsnotizen). - **Self-Tuning (WP-08):** Optimierung der Gewichte in `retriever.yaml` basierend auf dem gesammelten Feedback.
- **RAG-Chat:** KI antwortet in natürlicher Sprache auf Basis von Wissen und Persönlichkeit (WP-05). - **Knowledge-Builder (WP-11):** Assistent zur Analyse und Vernetzung manuell erstellter Notizen.
- Why-Layer: KI-Assistenz für Entscheidungen mit nachvollziehbarer Argumentation. - Agenten können über MCP-Tools (`mindnet_query`, `mindnet_chat`) auf mindnet zugreifen.
- 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 ### 3.3 Langfristig
@@ -112,54 +146,53 @@ Kernprinzipien der Vision:
Die folgenden Prinzipien steuern alle Workpackages und Entscheidungen: Die folgenden Prinzipien steuern alle Workpackages und Entscheidungen:
1. **Late Binding (späte Semantik)** 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. - Struktur und Interpretation werden in Konfigurationen (z. B. `types.yaml`, `prompts.yaml`, `decision_engine.yaml`) definiert, nicht direkt in den Vault-Dateien.
- Erlaubt spätere Anpassungen ohne manuelle Massenänderungen. - Die "Persönlichkeit" des Chats ist ein Prompt-Template, kein Code.
2. **Virtual Schema Layer** 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`). - Typen, Regeln, Policies, Edge-Defaults werden im Schema-Layer beschrieben.
- Markdown-Dateien benötigen nur minimale, robuste Angaben (Titel, Typ, optionale Properties). - Markdown-Dateien benötigen nur minimale, robuste Angaben (Titel, Typ, optionale Properties).
3. **Self-Healing Graph** 3. **Self-Healing Graph**
- Der Graph wird regelmäßig analysiert (Edges, Centrality, fehlende Links). - Der Graph wird regelmäßig analysiert (Edges, Centrality, fehlende Links).
- Automatisierte Jobs ergänzen fehlende Kanten (ähnliche Inhalte, typisierte Standardbeziehungen, Backlinks). - Automatisierte Jobs ergänzen fehlende Kanten.
4. **Deterministische IDs** 4. **Deterministische IDs**
- Notes, Chunks und Edges erhalten stabile IDs (z. B. UUIDv5, deterministische `note_id`/`chunk_id`/`edge_id`). - Notes, Chunks und Edges erhalten stabile IDs (z. B. UUIDv5).
- Der Graph ist jederzeit wiederaufbaubar (Import-Pipeline idempotent). - Der Graph ist jederzeit wiederaufbaubar (Import-Pipeline idempotent).
5. **Full Explainability** 5. **Full Explainability & Context Enrichment**
- Jeder Score, jede Beziehung, jeder Vorschlag muss über: - Jeder Score, jede Beziehung muss nachvollziehbar sein.
- Edges, - Dem LLM werden Metadaten (`[DECISION]`, `[PROJECT]`) injiziert, um Halluzinationen zu vermeiden und logische Schlüsse zu ermöglichen.
- Scoring-Komponenten (Semantik, Typ, Edge-Bonus, Centrality),
- Provenienz (Notizen, Chunks, rule_id, confidence) nachvollziehbar sein.
6. **Persistence First** 6. **Persistence First**
- Obsidian bleibt die primäre Quelle der Wahrheit. - 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). - mindnet ergänzt, schlägt Änderungen vor, schreibt aber nur kontrolliert.
7. **Minimalinvasives Schreiben** 7. **Minimalinvasives Schreiben**
- Automatische Veränderungen an Markdown-Dateien erfolgen ausschließlich nach expliziter Zustimmung. - 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** 8. **Incremental Growth & Early Value**
- Das System muss bereits mit wenigen Notizen und einem kleinen Vault sinnvolle Antworten liefern (Retrieval-MVP). - Das System muss bereits mit wenigen Notizen und einem kleinen Vault sinnvolle Antworten liefern.
- 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.
- Feedback-Mechanismen werden früh eingeführt, auch wenn sie anfangs noch nicht vollautomatisch ausgewertet werden.
9. **Observability & Testbarkeit** 9. **Observability & Testbarkeit**
- Jeder Importlauf, jede Retriever-Anfrage und jede Policy-Änderung soll prüfbar sein (Logs, Traces, Tests, Reports). - Jeder Importlauf, jede Retriever-Anfrage und jede Policy-Änderung soll prüfbar sein.
10. **Local First & Privacy**
- Nutzung lokaler LLMs (Ollama/Phi-3) für Inference. Keine Daten verlassen den Server.
--- ---
## 5. Programmstruktur (Phasenmodell) ## 5. Programmstruktur (Phasenmodell)
Phase A – Fundament & Import Phase A – Fundament & Import (Fertig)
Phase B – Semantik, Graph & Lernen Phase B – Semantik, Graph & Lernen (Fertig)
Phase C – Persönlichkeitsmodell & KI-Zwilling Phase C – Persönlichkeitsmodell & KI-Zwilling (Fertig)
Phase D – Agenten, MCP & Interaktion Phase D – Agenten, MCP & Interaktion (Aktiv)
Phase E – Review, Refactoring, Dokumentation Phase E – Review, Refactoring, Dokumentation
Alle Workpackages sind einer Phase zugeordnet. WP-01 bis WP-04c sind bereits erfolgreich abgeschlossen. Alle Workpackages sind einer Phase zugeordnet. WP-01 bis WP-07 und WP-10/10a sind erfolgreich abgeschlossen.
--- ---
@@ -236,7 +269,7 @@ Aufbau eines hybriden Retrievers, der Semantik, Typwissen und Graph-Informatione
### WP-04b – Explanation Layer ("Why-Layer") (abgeschlossen) ### WP-04b – Explanation Layer ("Why-Layer") (abgeschlossen)
**Phase:** B **Phase:** B
**Status:** 🟢 abgeschlossen (Neu) **Status:** 🟢 abgeschlossen
**Ziel:** **Ziel:**
Treffererklärungen liefern, die verständlich machen, warum ein Ergebnis gewählt wurde. Treffererklärungen liefern, die verständlich machen, warum ein Ergebnis gewählt wurde.
@@ -251,7 +284,7 @@ Treffererklärungen liefern, die verständlich machen, warum ein Ergebnis gewäh
### WP-04c – Feedback Logging & Bewertungsdaten (abgeschlossen) ### WP-04c – Feedback Logging & Bewertungsdaten (abgeschlossen)
**Phase:** B **Phase:** B
**Status:** 🟢 abgeschlossen (Neu) **Status:** 🟢 abgeschlossen
**Ziel:** **Ziel:**
Grundlage für Self-Tuning schaffen durch systematisches Logging. Grundlage für Self-Tuning schaffen durch systematisches Logging.
@@ -264,19 +297,19 @@ Grundlage für Self-Tuning schaffen durch systematisches Logging.
--- ---
### WP-05 – Persönlichkeitsmodell & RAG-Chat (Startbereit) ### WP-05 – Persönlichkeitsmodell & RAG-Chat (abgeschlossen)
**Phase:** C **Phase:** C
**Status:** 🟡 geplant (Nächster Schritt) **Status:** 🟢 abgeschlossen
**Ziel:** **Ziel:**
Aufbau eines RAG-Systems, das nicht nur sucht, sondern in natürlicher Sprache antwortet und dabei eine definierte Persönlichkeit (Werte, Prinzipien) einnimmt. Aufbau eines RAG-Systems, das in natürlicher Sprache antwortet und Kontext versteht.
**Umfang:** **Erreichte Ergebnisse:**
- **Config:** `config/prompts.yaml` für System-Prompts, Werte und RAG-Templates. - **Infrastruktur:** Integration von Ollama (Phi-3 Mini) in den Service-Layer.
- **Service:** `llm_service.py` für Text-Generierung (Ollama-Anbindung). - **Router:** `/chat` Endpoint mit "Hybrid Retrieval Enforcement".
- **Router:** `/chat` Endpoint (Kontext-Assembly -> Prompt -> LLM). - **Context Enrichment:** Injection von Metadaten (`[TYPE]`, `[SCORE]`) in den Prompt, damit kleine Modelle (SLMs) komplexe Zusammenhänge ("Warum?") verstehen.
- **Persönlichkeit:** Definition von "Mindnet" als KI-Zwilling (Stil, Haltung). - **Config:** `prompts.yaml` steuert System-Prompt und RAG-Template.
**Aufwand / Komplexität:** **Aufwand / Komplexität:**
- Aufwand: Mittel - Aufwand: Mittel
@@ -284,18 +317,34 @@ Aufbau eines RAG-Systems, das nicht nur sucht, sondern in natürlicher Sprache a
--- ---
### WP-06 – Decision Engine (geplant) ### WP-05b – Advanced Chat (Optional)
**Phase:** C **Phase:** C
**Status:** 🟡 geplant **Status:** ⚪ optional
**Ziel:** **Ziel:**
Entscheidungsunterstützung auf Basis von Wissen, Persönlichkeit und Zielen – inklusive nachvollziehbarer Begründung. Erweiterung des Chats um Gedächtnis (History) und einfache Tools.
**Umfang:** **Umfang:**
- Identifikation typischer Entscheidungssituationen. - Implementierung von `ChatHistory` (vergangene Nachrichten in den Kontext).
- Integration von fachlichem Wissen, Erfahrungen und Persönlichkeitsmodell. - Einfache Tool-Nutzung (z.B. "Suche in Web").
- Ableitung von Entscheidungs-Templates / Heuristiken.
---
### WP-06 – Decision Engine & Hybrid Router (abgeschlossen)
**Phase:** C
**Status:** 🟢 abgeschlossen
**Ziel:**
Transformation vom reinen Wissens-Abrufer zum strategischen Entscheidungspartner durch Intent-Erkennung.
**Erreichte Ergebnisse:**
- **Hybrid Intent Router:** Kombination aus schnellem Keyword-Matching und intelligentem LLM-Fallback zur Erkennung der Absicht (`DECISION`, `EMPATHY`, `FACT`, `CODING`).
- **Strategic Retrieval:** Gezieltes Nachladen von Werten (`value`), Zielen (`goal`) oder Erfahrungen (`experience`) basierend auf dem Intent.
- **Multi-Persona:** Dynamische Anpassung des Tonfalls (Berater vs. Spiegel vs. Techniker) durch `prompts.yaml`.
- **Late Binding:** Vollständige Konfiguration via `decision_engine.yaml`.
- **Robustheit:** Konfigurierbare Timeouts für CPU-Inference.
**Aufwand / Komplexität:** **Aufwand / Komplexität:**
- Aufwand: Mittel - Aufwand: Mittel
@@ -303,17 +352,18 @@ Entscheidungsunterstützung auf Basis von Wissen, Persönlichkeit und Zielen –
--- ---
### WP-07 – Interview-Assistent (geplant) ### WP-07 – Interview-Assistent (abgeschlossen)
**Phase:** C **Phase:** C/D
**Status:** 🟡 geplant **Status:** 🟢 abgeschlossen
**Ziel:** **Ziel:**
Dialogbasierter Erfassungs-Assistent, der strukturierte Interviews führt und daraus konsistente Markdown-Notizen generiert. Dialogbasierter Erfassungs-Assistent, der strukturierte Interviews führt und daraus konsistente Markdown-Notizen generiert.
**Umfang:** **Erreichte Ergebnisse:**
- Design von Interview-Flows. - **One-Shot Extractor:** Extrahiert Notiz-Inhalte aus einem Prompt.
- Konvertierung von Dialogtranskripten in typisierte Notes. - **Schema Injection:** Typspezifische Pflichtfelder (Late Binding).
- **Draft Generator:** Liefert validen Markdown-Codeblock mit `status: draft`.
**Aufwand / Komplexität:** **Aufwand / Komplexität:**
- Aufwand: Niedrig/Mittel - Aufwand: Niedrig/Mittel
@@ -324,7 +374,7 @@ Dialogbasierter Erfassungs-Assistent, der strukturierte Interviews führt und da
### WP-08 – Self-Tuning v1/v2 (geplant) ### WP-08 – Self-Tuning v1/v2 (geplant)
**Phase:** B/C **Phase:** B/C
**Status:** 🟡 geplant **Status:** 🟡 geplant (Nächster Fokus)
**Ziel:** **Ziel:**
Aufbau eines Self-Tuning-Mechanismus, der auf Basis von Feedback-Daten (WP-04c) Vorschläge für Retriever- und Policy-Anpassungen macht. Aufbau eines Self-Tuning-Mechanismus, der auf Basis von Feedback-Daten (WP-04c) Vorschläge für Retriever- und Policy-Anpassungen macht.
@@ -357,17 +407,20 @@ Sicherstellen, dass bestehende und neue Obsidian-Vaults schrittweise in mindnet
--- ---
### WP-10 – Chat-Interface & Writeback (geplant) ### WP-10 – Chat-Interface & Writeback (abgeschlossen)
**Phase:** D **Phase:** D
**Status:** 🟡 geplant **Status:** 🟢 abgeschlossen
**Ziel:** **Ziel:**
Chat-basierter mindnet-Agent, der sowohl Fragen beantwortet als auch neue Notizen erzeugen/aktualisieren kann (Writeback Richtung Vault). Ablösung der Terminal-Interaktion durch ein grafisches Interface.
**Umfang:** **Erreichte Ergebnisse:**
- Chat-Frontend. - **Tech-Stack:** Streamlit Frontend (`app/frontend/ui.py`).
- Funktionen für Q&A sowie Vorschlag neuer Notes/Edges. - **Funktionen:** Chat-Verlauf, Visualisierung von Intents und Quellen (Expander).
- **Feedback:** Globales Rating (Sterne) und granulare Quellen-Bewertung (Faces).
- **Writeback:** Mockup-Interface für neue Einträge (Vorbereitung WP-07).
- **Deployment:** Systemd-Services für Prod (8501) und Dev (8502).
**Aufwand / Komplexität:** **Aufwand / Komplexität:**
- Aufwand: Hoch - Aufwand: Hoch
@@ -375,6 +428,25 @@ Chat-basierter mindnet-Agent, der sowohl Fragen beantwortet als auch neue Notize
--- ---
### WP-10a – GUI Evolution: Draft Editor (abgeschlossen)
**Phase:** D
**Status:** 🟢 abgeschlossen
**Ziel:**
Anpassung der GUI an komplexe Interaktionsmuster, die durch den Interview-Assistenten und Knowledge-Builder entstehen.
**Erreichte Ergebnisse:**
- **Draft Editor:** Interaktive `st.text_area` für generierte Entwürfe.
- **Sanitizer:** `normalize_meta_and_body` zur Korrektur von LLM-Fehlern.
- **Download/Copy:** Export-Funktionen für Markdown.
**Aufwand / Komplexität:**
- Aufwand: Mittel
- Komplexität: Mittel
---
### WP-11 – Knowledge-Builder & Vernetzungs-Assistent (geplant) ### WP-11 – Knowledge-Builder & Vernetzungs-Assistent (geplant)
**Phase:** D **Phase:** D
@@ -439,6 +511,7 @@ Aufräumen, dokumentieren, stabilisieren – insbesondere für Onboarding Dritte
WP01 → WP02 → WP03 → WP04a WP01 → WP02 → WP03 → WP04a
WP04a → WP04b → WP04c → WP08 WP04a → WP04b → WP04c → WP08
WP03 → WP05 → WP06 → WP07 WP03 → WP05 → WP06 → WP07
WP07 → WP10a
WP03 → WP09 WP03 → WP09
WP01/WP03 → WP10 → WP11 → WP12 WP01/WP03 → WP10 → WP11 → WP12
WP03/WP04 → WP13 WP03/WP04 → WP13
@@ -458,6 +531,7 @@ Aufräumen, dokumentieren, stabilisieren – insbesondere für Onboarding Dritte
| WP08 | Hoch | Hoch | | WP08 | Hoch | Hoch |
| WP09 | Mittel | Niedrig/Mittel | | WP09 | Mittel | Niedrig/Mittel |
| WP10 | Hoch | Hoch | | WP10 | Hoch | Hoch |
| WP10a | Mittel | Mittel |
| WP11 | Hoch | Hoch | | WP11 | Hoch | Hoch |
| WP12 | Niedrig/Mittel | Mittel | | WP12 | Niedrig/Mittel | Mittel |
| WP13 | Mittel | Mittel | | WP13 | Mittel | Mittel |
@@ -475,12 +549,14 @@ Aufräumen, dokumentieren, stabilisieren – insbesondere für Onboarding Dritte
| WP04a | 🟢 | | WP04a | 🟢 |
| WP04b | 🟢 | | WP04b | 🟢 |
| WP04c | 🟢 | | WP04c | 🟢 |
| WP05 | 🟡 | | WP05 | 🟢 |
| WP06 | 🟡 | | WP05b | ⚪ |
| WP07 | 🟡 | | WP06 | 🟢 |
| WP07 | 🟢 |
| WP08 | 🟡 | | WP08 | 🟡 |
| WP09 | 🟡 | | WP09 | 🟡 |
| WP10 | 🟡 | | WP10 | 🟢 |
| WP10a | 🟢 |
| WP11 | 🟡 | | WP11 | 🟡 |
| WP12 | 🟡 | | WP12 | 🟡 |
| WP13 | 🟡 | | WP13 | 🟡 |
@@ -495,19 +571,21 @@ Aufräumen, dokumentieren, stabilisieren – insbesondere für Onboarding Dritte
- Jede wesentliche Änderung an Architektur/Schema erhält einen eigenen Commit. - Jede wesentliche Änderung an Architektur/Schema erhält einen eigenen Commit.
- Jedes Workpackage erhält ein eigenes Chat-Fenster mit dediziertem Prompt (WP-Hand-Over). - Jedes Workpackage erhält ein eigenes Chat-Fenster mit dediziertem Prompt (WP-Hand-Over).
- Programmleitung verantwortet Konsistenz und Priorisierung. - Programmleitung verantwortet Konsistenz und Priorisierung.
- **Modell-Governance:** Das verwendete LLM (z.B. `phi3:mini`) wird in der `.env` und `config.py` festgeschrieben. Updates erfordern Tests gegen die "Why-Layer" Referenzfragen.
--- ---
## 11. Executive Summary ## 11. Executive Summary
mindnet v2.2 ist so aufgesetzt, dass: mindnet v2.4 ist so aufgesetzt, dass:
- du **schrittweise** Wissen erfassen kannst (Obsidian + Chat + später Interview-Assistent), - du **schrittweise** Wissen erfassen kannst (Obsidian + Chat + Interview-Drafts),
- die Struktur **mitwächst**, ohne Retro-Massenarbeit im Vault, - die Struktur **mitwächst**, ohne Retro-Massenarbeit im Vault,
- ein **hybrider Retriever** qualitativ hochwertige, erklärbare Antworten liefert, - ein **hybrider Retriever** qualitativ hochwertige, erklärbare Antworten liefert,
- ein **Self-Healing- und Self-Tuning-Mechanismus** vorbereitet ist (durch WP-04c Feedback-Daten), - ein **Self-Healing- und Self-Tuning-Mechanismus** vorbereitet ist (durch WP-04c Feedback-Daten),
- ein **Persönlichkeitsmodell** und eine **Decision Engine** entstehen, - ein **Persönlichkeitsmodell** (Decision Engine, Empathie) existiert und den Tonfall situativ anpasst,
- eine **grafische Oberfläche** (WP-10/10a) existiert, die komplexe Zusammenhänge visualisiert und Co-Creation ermöglicht,
- langfristig ein **KI-Zwilling** aufgebaut wird, der deine Werte, Erfahrungen und Denkweise spiegelt, - 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. - die technische Architektur (FastAPI, Qdrant, YAML-Policies, MCP-Integration) lokal, nachvollziehbar und erweiterbar bleibt.
Dieser Programmplan bildet die konsolidierte Grundlage (v2.2.1) für alle weiteren Arbeiten. Dieser Programmplan bildet die konsolidierte Grundlage (v2.4.0) für alle weiteren Arbeiten.
+16 -10
View File
@@ -1,17 +1,11 @@
""" """
app/config.py — zentrale Konfiguration (ENV → Settings) app/config.py — zentrale Konfiguration
Version: 0.4.0 (WP-06 Complete)
Version:
0.2.0 (WP-04: Retriever-Gewichte & Defaults ergänzt; keine Verhaltensänderung für bestehende Nutzung)
Stand:
2025-10-06
Hinweis:
Bestehende Attribute bleiben erhalten; neue WP-04 Felder sind optional.
""" """
from __future__ import annotations from __future__ import annotations
import os import os
from functools import lru_cache from functools import lru_cache
from pathlib import Path
class Settings: class Settings:
# Qdrant # Qdrant
@@ -20,11 +14,23 @@ class Settings:
COLLECTION_PREFIX: str = os.getenv("MINDNET_PREFIX", "mindnet") COLLECTION_PREFIX: str = os.getenv("MINDNET_PREFIX", "mindnet")
VECTOR_SIZE: int = int(os.getenv("MINDNET_VECTOR_SIZE", "384")) VECTOR_SIZE: int = int(os.getenv("MINDNET_VECTOR_SIZE", "384"))
DISTANCE: str = os.getenv("MINDNET_DISTANCE", "Cosine") DISTANCE: str = os.getenv("MINDNET_DISTANCE", "Cosine")
# Embeddings # Embeddings
MODEL_NAME: str = os.getenv("MINDNET_MODEL", "sentence-transformers/all-MiniLM-L6-v2") MODEL_NAME: str = os.getenv("MINDNET_MODEL", "sentence-transformers/all-MiniLM-L6-v2")
# WP-05 LLM / Ollama
OLLAMA_URL: str = os.getenv("MINDNET_OLLAMA_URL", "http://127.0.0.1:11434")
LLM_MODEL: str = os.getenv("MINDNET_LLM_MODEL", "phi3:mini")
PROMPTS_PATH: str = os.getenv("MINDNET_PROMPTS_PATH", "config/prompts.yaml")
# NEU für WP-06
LLM_TIMEOUT: float = float(os.getenv("MINDNET_LLM_TIMEOUT", "120.0"))
DECISION_CONFIG_PATH: str = os.getenv("MINDNET_DECISION_CONFIG", "config/decision_engine.yaml")
# API # API
DEBUG: bool = os.getenv("DEBUG", "false").lower() == "true" DEBUG: bool = os.getenv("DEBUG", "false").lower() == "true"
# WP-04 Retriever Defaults (optional; können per ENV überschrieben werden)
# WP-04 Retriever Defaults
RETRIEVER_W_SEM: float = float(os.getenv("MINDNET_WP04_W_SEM", "0.70")) RETRIEVER_W_SEM: float = float(os.getenv("MINDNET_WP04_W_SEM", "0.70"))
RETRIEVER_W_EDGE: float = float(os.getenv("MINDNET_WP04_W_EDGE", "0.25")) RETRIEVER_W_EDGE: float = float(os.getenv("MINDNET_WP04_W_EDGE", "0.25"))
RETRIEVER_W_CENT: float = float(os.getenv("MINDNET_WP04_W_CENT", "0.05")) RETRIEVER_W_CENT: float = float(os.getenv("MINDNET_WP04_W_CENT", "0.05"))
+60 -135
View File
@@ -1,3 +1,9 @@
"""
app/core/retriever.py — Hybrider Such-Algorithmus
Version:
0.5.3 (WP-06 Fix: Populate 'payload' in QueryHit for meta-data access)
"""
from __future__ import annotations from __future__ import annotations
import os import os
@@ -22,24 +28,18 @@ import app.core.graph_adapter as ga
try: try:
import yaml # type: ignore[import] import yaml # type: ignore[import]
except Exception: # pragma: no cover - Fallback, falls PyYAML nicht installiert ist except Exception: # pragma: no cover
yaml = None # type: ignore[assignment] yaml = None # type: ignore[assignment]
@lru_cache @lru_cache
def _get_scoring_weights() -> Tuple[float, float, float]: def _get_scoring_weights() -> Tuple[float, float, float]:
"""Liefert (semantic_weight, edge_weight, centrality_weight) für den Retriever. """Liefert (semantic_weight, edge_weight, centrality_weight) für den Retriever."""
Priorität:
1. Werte aus config/retriever.yaml (falls vorhanden und gültig).
2. Fallback auf Settings.RETRIEVER_W_* (ENV-basiert).
"""
settings = get_settings() settings = get_settings()
sem = float(getattr(settings, "RETRIEVER_W_SEM", 1.0)) sem = float(getattr(settings, "RETRIEVER_W_SEM", 1.0))
edge = float(getattr(settings, "RETRIEVER_W_EDGE", 0.0)) edge = float(getattr(settings, "RETRIEVER_W_EDGE", 0.0))
cent = float(getattr(settings, "RETRIEVER_W_CENT", 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") config_path = os.getenv("MINDNET_RETRIEVER_CONFIG", "config/retriever.yaml")
if yaml is None: if yaml is None:
return sem, edge, cent return sem, edge, cent
@@ -52,22 +52,19 @@ def _get_scoring_weights() -> Tuple[float, float, float]:
edge = float(scoring.get("edge_weight", edge)) edge = float(scoring.get("edge_weight", edge))
cent = float(scoring.get("centrality_weight", cent)) cent = float(scoring.get("centrality_weight", cent))
except Exception: except Exception:
# Bei Fehlern in der YAML-Konfiguration defensiv auf Defaults zurückfallen
return sem, edge, cent return sem, edge, cent
return sem, edge, cent return sem, edge, cent
def _get_client_and_prefix() -> Tuple[Any, str]: def _get_client_and_prefix() -> Tuple[Any, str]:
"""Liefert (QdrantClient, prefix) basierend auf QdrantConfig.from_env().""" """Liefert (QdrantClient, prefix)."""
cfg = qdr.QdrantConfig.from_env() cfg = qdr.QdrantConfig.from_env()
client = qdr.get_client(cfg) client = qdr.get_client(cfg)
return client, cfg.prefix return client, cfg.prefix
def _get_query_vector(req: QueryRequest) -> List[float]: def _get_query_vector(req: QueryRequest) -> List[float]:
""" """Liefert den Query-Vektor aus dem Request."""
Liefert den Query-Vektor aus dem Request.
"""
if req.query_vector: if req.query_vector:
return list(req.query_vector) return list(req.query_vector)
@@ -78,9 +75,9 @@ def _get_query_vector(req: QueryRequest) -> List[float]:
model_name = settings.MODEL_NAME model_name = settings.MODEL_NAME
try: try:
return ec.embed_text(req.query, model_name=model_name) # type: ignore[call-arg] return ec.embed_text(req.query, model_name=model_name)
except TypeError: except TypeError:
return ec.embed_text(req.query) # type: ignore[call-arg] return ec.embed_text(req.query)
def _semantic_hits( def _semantic_hits(
@@ -90,7 +87,7 @@ def _semantic_hits(
top_k: int, top_k: int,
filters: Dict[str, Any] | None = None, filters: Dict[str, Any] | None = None,
) -> List[Tuple[str, float, Dict[str, Any]]]: ) -> List[Tuple[str, float, Dict[str, Any]]]:
"""Führt eine semantische Suche über mindnet_chunks aus und liefert Roh-Treffer.""" """Führt eine semantische Suche aus."""
flt = filters or None flt = filters or None
raw_hits = qp.search_chunks_by_vector(client, prefix, vector, top=top_k, filters=flt) raw_hits = qp.search_chunks_by_vector(client, prefix, vector, top=top_k, filters=flt)
results: List[Tuple[str, float, Dict[str, Any]]] = [] results: List[Tuple[str, float, Dict[str, Any]]] = []
@@ -105,7 +102,7 @@ def _compute_total_score(
edge_bonus: float = 0.0, edge_bonus: float = 0.0,
cent_bonus: float = 0.0, cent_bonus: float = 0.0,
) -> Tuple[float, float, float]: ) -> Tuple[float, float, float]:
"""Berechnet total_score aus semantic_score, retriever_weight und Graph-Boni.""" """Berechnet total_score."""
raw_weight = payload.get("retriever_weight", 1.0) raw_weight = payload.get("retriever_weight", 1.0)
try: try:
weight = float(raw_weight) weight = float(raw_weight)
@@ -129,11 +126,10 @@ def _build_explanation(
subgraph: Optional[ga.Subgraph], subgraph: Optional[ga.Subgraph],
node_key: Optional[str] node_key: Optional[str]
) -> Explanation: ) -> Explanation:
""" """Erstellt ein Explanation-Objekt."""
Erstellt ein detailliertes Explanation-Objekt für einen Treffer. sem_w, _edge_w, _cent_w = _get_scoring_weights()
Analysiert Scores, Typen und Kanten (Incoming & Outgoing). # Scoring weights erneut laden für Reason-Details
""" _, edge_w_cfg, cent_w_cfg = _get_scoring_weights()
sem_w, edge_w, cent_w = _get_scoring_weights()
try: try:
type_weight = float(payload.get("retriever_weight", 1.0)) type_weight = float(payload.get("retriever_weight", 1.0))
@@ -144,8 +140,8 @@ def _build_explanation(
breakdown = ScoreBreakdown( breakdown = ScoreBreakdown(
semantic_contribution=(sem_w * semantic_score * type_weight), semantic_contribution=(sem_w * semantic_score * type_weight),
edge_contribution=(edge_w * edge_bonus), edge_contribution=(edge_w_cfg * edge_bonus),
centrality_contribution=(cent_w * cent_bonus), centrality_contribution=(cent_w_cfg * cent_bonus),
raw_semantic=semantic_score, raw_semantic=semantic_score,
raw_edge_bonus=edge_bonus, raw_edge_bonus=edge_bonus,
raw_centrality=cent_bonus, raw_centrality=cent_bonus,
@@ -155,100 +151,49 @@ def _build_explanation(
reasons: List[Reason] = [] reasons: List[Reason] = []
edges_dto: List[EdgeDTO] = [] edges_dto: List[EdgeDTO] = []
# 1. Semantische Gründe
if semantic_score > 0.85: if semantic_score > 0.85:
reasons.append(Reason( reasons.append(Reason(kind="semantic", message="Sehr hohe textuelle Übereinstimmung.", score_impact=breakdown.semantic_contribution))
kind="semantic",
message="Sehr hohe textuelle Übereinstimmung.",
score_impact=breakdown.semantic_contribution
))
elif semantic_score > 0.70: elif semantic_score > 0.70:
reasons.append(Reason( reasons.append(Reason(kind="semantic", message="Gute textuelle Übereinstimmung.", score_impact=breakdown.semantic_contribution))
kind="semantic",
message="Gute textuelle Übereinstimmung.",
score_impact=breakdown.semantic_contribution
))
# 2. Typ-Gründe
if type_weight != 1.0: if type_weight != 1.0:
msg = "Bevorzugt" if type_weight > 1.0 else "Leicht abgewertet" msg = "Bevorzugt" if type_weight > 1.0 else "Leicht abgewertet"
reasons.append(Reason( reasons.append(Reason(kind="type", message=f"{msg} aufgrund des Typs '{note_type}'.", score_impact=(sem_w * semantic_score * (type_weight - 1.0))))
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: 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"): if hasattr(subgraph, "get_outgoing_edges"):
outgoing = subgraph.get_outgoing_edges(node_key) outgoing = subgraph.get_outgoing_edges(node_key)
for edge in outgoing: for edge in outgoing:
target = edge.get("target", "Unknown") target = edge.get("target", "Unknown")
kind = edge.get("kind", "edge") kind = edge.get("kind", "edge")
weight = edge.get("weight", 0.0) weight = edge.get("weight", 0.0)
# Nur relevante Kanten aufnehmen
if weight > 0.05: if weight > 0.05:
edges_dto.append(EdgeDTO( edges_dto.append(EdgeDTO(id=f"{node_key}->{target}:{kind}", kind=kind, source=node_key, target=target, weight=weight, direction="out"))
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"): if hasattr(subgraph, "get_incoming_edges"):
incoming = subgraph.get_incoming_edges(node_key) incoming = subgraph.get_incoming_edges(node_key)
for edge in incoming: for edge in incoming:
src = edge.get("source", "Unknown") src = edge.get("source", "Unknown")
kind = edge.get("kind", "edge") kind = edge.get("kind", "edge")
weight = edge.get("weight", 0.0) weight = edge.get("weight", 0.0)
if weight > 0.05: if weight > 0.05:
edges_dto.append(EdgeDTO( edges_dto.append(EdgeDTO(id=f"{src}->{node_key}:{kind}", kind=kind, source=src, target=node_key, weight=weight, direction="in"))
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) all_edges = sorted(edges_dto, key=lambda e: e.weight, reverse=True)
for top_edge in all_edges[:3]: for top_edge in all_edges[:3]:
# Impact schätzen (grob, da Edge-Bonus eine Summe ist) impact = edge_w_cfg * top_edge.weight
impact = edge_w * top_edge.weight dir_txt = "Verweist auf" if top_edge.direction == "out" else "Referenziert von"
tgt_txt = top_edge.target if top_edge.direction == "out" else top_edge.source
reasons.append(Reason(kind="edge", message=f"{dir_txt} '{tgt_txt}' via '{top_edge.kind}'", score_impact=impact, details={"kind": top_edge.kind}))
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: if cent_bonus > 0.01:
reasons.append(Reason( reasons.append(Reason(kind="centrality", message="Knoten liegt zentral im Kontext.", score_impact=breakdown.centrality_contribution))
kind="centrality",
message="Knoten liegt zentral im Kontext.",
score_impact=breakdown.centrality_contribution
))
return Explanation( return Explanation(breakdown=breakdown, reasons=reasons, related_edges=edges_dto if edges_dto else None)
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]: def _extract_expand_options(req: QueryRequest) -> Tuple[int, List[str] | None]:
"""Extrahiert depth und edge_types aus req.expand.""" """Extrahiert depth und edge_types."""
expand = getattr(req, "expand", None) expand = getattr(req, "expand", None)
if not expand: if not expand:
return 0, None return 0, None
@@ -278,14 +223,10 @@ def _build_hits_from_semantic(
top_k: int, top_k: int,
used_mode: str, used_mode: str,
subgraph: ga.Subgraph | None = None, subgraph: ga.Subgraph | None = None,
explain: bool = False, # WP-04b explain: bool = False,
) -> QueryResponse: ) -> QueryResponse:
"""Baut aus Raw-Hits und optionalem Subgraph strukturierte QueryHits. """Baut strukturierte QueryHits."""
WP-04b: Wenn explain=True, wird _build_explanation aufgerufen.
"""
t0 = time.time() t0 = time.time()
enriched: List[Tuple[str, float, Dict[str, Any], float, float, float]] = [] enriched: List[Tuple[str, float, Dict[str, Any], float, float, float]] = []
for pid, semantic_score, payload in hits: for pid, semantic_score, payload in hits:
@@ -303,26 +244,14 @@ def _build_hits_from_semantic(
except Exception: except Exception:
cent_bonus = 0.0 cent_bonus = 0.0
total, edge_bonus, cent_bonus = _compute_total_score( total, edge_bonus, cent_bonus = _compute_total_score(semantic_score, payload, edge_bonus=edge_bonus, cent_bonus=cent_bonus)
semantic_score,
payload,
edge_bonus=edge_bonus,
cent_bonus=cent_bonus,
)
enriched.append((pid, float(semantic_score), payload, total, edge_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) enriched_sorted = sorted(enriched, key=lambda h: h[3], reverse=True)
limited = enriched_sorted[: max(1, top_k)] limited = enriched_sorted[: max(1, top_k)]
results: List[QueryHit] = [] results: List[QueryHit] = []
for pid, semantic_score, payload, total, edge_bonus, cent_bonus in limited: for pid, semantic_score, payload, total, edge_bonus, cent_bonus in limited:
note_id = payload.get("note_id")
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 explanation_obj = None
if explain: if explain:
explanation_obj = _build_explanation( explanation_obj = _build_explanation(
@@ -331,59 +260,52 @@ def _build_hits_from_semantic(
edge_bonus=edge_bonus, edge_bonus=edge_bonus,
cent_bonus=cent_bonus, cent_bonus=cent_bonus,
subgraph=subgraph, subgraph=subgraph,
node_key=node_key node_key=payload.get("chunk_id") or payload.get("note_id")
) )
results.append( text_content = payload.get("page_content") or payload.get("text") or payload.get("content")
QueryHit(
results.append(QueryHit(
node_id=str(pid), node_id=str(pid),
note_id=note_id, note_id=payload.get("note_id"),
semantic_score=float(semantic_score), semantic_score=float(semantic_score),
edge_bonus=edge_bonus, edge_bonus=edge_bonus,
centrality_bonus=cent_bonus, centrality_bonus=cent_bonus,
total_score=total, total_score=total,
paths=None, paths=None,
source={ source={
"path": path, "path": payload.get("path"),
"section": section, "section": payload.get("section") or payload.get("section_title"),
"text": text_content
}, },
# --- FIX: Wir füllen das payload-Feld explizit ---
payload=payload,
explanation=explanation_obj explanation=explanation_obj
) ))
)
dt = int((time.time() - t0) * 1000) dt = int((time.time() - t0) * 1000)
return QueryResponse(results=results, used_mode=used_mode, latency_ms=dt) return QueryResponse(results=results, used_mode=used_mode, latency_ms=dt)
def semantic_retrieve(req: QueryRequest) -> QueryResponse: def semantic_retrieve(req: QueryRequest) -> QueryResponse:
"""Reiner semantischer Retriever (ohne Edge-Expansion).""" """Reiner semantischer Retriever."""
client, prefix = _get_client_and_prefix() client, prefix = _get_client_and_prefix()
vector = _get_query_vector(req) vector = _get_query_vector(req)
top_k = req.top_k or get_settings().RETRIEVER_TOP_K top_k = req.top_k or get_settings().RETRIEVER_TOP_K
hits = _semantic_hits(client, prefix, vector, top_k=top_k, filters=req.filters) hits = _semantic_hits(client, prefix, vector, top_k=top_k, filters=req.filters)
return _build_hits_from_semantic(hits, top_k=top_k, used_mode="semantic", subgraph=None, explain=req.explain)
# explain Flag durchreichen
return _build_hits_from_semantic(
hits,
top_k=top_k,
used_mode="semantic",
subgraph=None,
explain=req.explain
)
def hybrid_retrieve(req: QueryRequest) -> QueryResponse: def hybrid_retrieve(req: QueryRequest) -> QueryResponse:
"""Hybrid-Retriever: semantische Suche + optionale Edge-Expansion.""" """Hybrid-Retriever: semantische Suche + optionale Edge-Expansion."""
client, prefix = _get_client_and_prefix() client, prefix = _get_client_and_prefix()
if req.query_vector: if req.query_vector:
vector = list(req.query_vector) vector = list(req.query_vector)
else: else:
vector = _get_query_vector(req) vector = _get_query_vector(req)
top_k = req.top_k or get_settings().RETRIEVER_TOP_K top_k = req.top_k or get_settings().RETRIEVER_TOP_K
hits = _semantic_hits(client, prefix, vector, top_k=top_k, filters=req.filters) hits = _semantic_hits(client, prefix, vector, top_k=top_k, filters=req.filters)
depth, edge_types = _extract_expand_options(req) depth, edge_types = _extract_expand_options(req)
@@ -394,18 +316,21 @@ def hybrid_retrieve(req: QueryRequest) -> QueryResponse:
key = payload.get("chunk_id") or payload.get("note_id") key = payload.get("chunk_id") or payload.get("note_id")
if key and key not in seed_ids: if key and key not in seed_ids:
seed_ids.append(key) seed_ids.append(key)
if seed_ids: if seed_ids:
try: try:
subgraph = ga.expand(client, prefix, seed_ids, depth=depth, edge_types=edge_types) subgraph = ga.expand(client, prefix, seed_ids, depth=depth, edge_types=edge_types)
except Exception: except Exception:
subgraph = None subgraph = None
# explain Flag durchreichen return _build_hits_from_semantic(hits, top_k=top_k, used_mode="hybrid", subgraph=subgraph, explain=req.explain)
return _build_hits_from_semantic(
hits,
top_k=top_k, class Retriever:
used_mode="hybrid", """
subgraph=subgraph, Wrapper-Klasse für WP-05 (Chat).
explain=req.explain """
) def __init__(self):
pass
async def search(self, request: QueryRequest) -> QueryResponse:
return hybrid_retrieve(request)
+375
View File
@@ -0,0 +1,375 @@
import streamlit as st
import requests
import uuid
import os
import json
import re
import yaml
from datetime import datetime
from pathlib import Path
from dotenv import load_dotenv
# --- CONFIGURATION ---
load_dotenv()
API_BASE_URL = os.getenv("MINDNET_API_URL", "http://localhost:8002")
CHAT_ENDPOINT = f"{API_BASE_URL}/chat"
FEEDBACK_ENDPOINT = f"{API_BASE_URL}/feedback"
HISTORY_FILE = Path("data/logs/search_history.jsonl")
# Timeout Strategy
timeout_setting = os.getenv("MINDNET_API_TIMEOUT") or os.getenv("MINDNET_LLM_TIMEOUT")
API_TIMEOUT = float(timeout_setting) if timeout_setting else 300.0
# --- PAGE SETUP ---
st.set_page_config(page_title="mindnet v2.3.2", page_icon="🧠", layout="wide")
# --- CSS STYLING ---
st.markdown("""
<style>
.block-container { padding-top: 2rem; max_width: 1000px; margin: auto; }
.intent-badge {
background-color: #e8f0fe; color: #1a73e8;
padding: 4px 10px; border-radius: 12px;
font-size: 0.8rem; font-weight: 600;
border: 1px solid #d2e3fc; display: inline-block; margin-bottom: 0.5rem;
}
.draft-box {
border: 1px solid #d0d7de;
border-radius: 6px;
padding: 16px;
background-color: #f6f8fa;
margin-top: 10px;
margin-bottom: 10px;
}
.preview-box {
border: 1px solid #e0e0e0;
border-radius: 6px;
padding: 24px;
background-color: white;
font-family: -apple-system,BlinkMacSystemFont,"Segoe UI",Helvetica,Arial,sans-serif;
}
.debug-info {
font-size: 0.7rem;
color: #888;
margin-bottom: 5px;
}
</style>
""", unsafe_allow_html=True)
# --- SESSION STATE ---
if "messages" not in st.session_state: st.session_state.messages = []
if "user_id" not in st.session_state: st.session_state.user_id = str(uuid.uuid4())
# --- HELPER FUNCTIONS ---
def normalize_meta_and_body(meta, body):
"""
Sanitizer: Stellt sicher, dass nur erlaubte Felder im Frontmatter bleiben.
Alles andere wird in den Body verschoben (Repair-Strategie).
"""
ALLOWED_KEYS = {"title", "type", "status", "tags", "id", "created", "updated", "aliases", "lang"}
clean_meta = {}
extra_content = []
# 1. Title/Titel Normalisierung
if "titel" in meta and "title" not in meta:
meta["title"] = meta.pop("titel")
# 2. Tags Normalisierung (Synonyme)
tag_candidates = ["tags", "emotionale_keywords", "keywords", "schluesselwoerter"]
all_tags = []
for key in tag_candidates:
if key in meta:
val = meta[key]
if isinstance(val, list): all_tags.extend(val)
elif isinstance(val, str): all_tags.extend([t.strip() for t in val.split(",")])
# 3. Filterung und Verschiebung
for key, val in meta.items():
if key in ALLOWED_KEYS:
clean_meta[key] = val
elif key in tag_candidates:
pass # Schon oben behandelt
else:
# Unerlaubtes Feld (z.B. 'situation') -> Ab in den Body!
if val and isinstance(val, str):
header = key.replace("_", " ").title()
extra_content.append(f"## {header}\n{val}\n")
if all_tags:
clean_meta["tags"] = list(set(all_tags))
# 4. Body Zusammenbau
if extra_content:
new_section = "\n".join(extra_content)
final_body = f"{new_section}\n{body}"
else:
final_body = body
return clean_meta, final_body
def parse_markdown_draft(full_text):
"""
Robustes Parsing + Sanitization.
"""
clean_text = full_text
# Codeblock entfernen
pattern_block = r"```(?:markdown|md)?\s*(.*?)\s*```"
match_block = re.search(pattern_block, full_text, re.DOTALL | re.IGNORECASE)
if match_block:
clean_text = match_block.group(1).strip()
# Frontmatter splitten
parts = re.split(r"^---+\s*$", clean_text, maxsplit=2, flags=re.MULTILINE)
meta = {}
body = clean_text
if len(parts) >= 3:
yaml_str = parts[1]
body_candidate = parts[2]
try:
parsed = yaml.safe_load(yaml_str)
if isinstance(parsed, dict):
meta = parsed
body = body_candidate.strip()
except Exception:
pass
return normalize_meta_and_body(meta, body)
def build_markdown_doc(meta, body):
"""Baut das finale Dokument zusammen."""
if "id" not in meta or meta["id"] == "generated_on_save":
safe_title = re.sub(r'[^a-zA-Z0-9]', '-', meta.get('title', 'note')).lower()[:30]
meta["id"] = f"{datetime.now().strftime('%Y%m%d')}-{safe_title}-{uuid.uuid4().hex[:4]}"
meta["updated"] = datetime.now().strftime("%Y-%m-%d")
# Sortierung für UX
ordered_meta = {}
prio_keys = ["id", "type", "title", "status", "tags"]
for k in prio_keys:
if k in meta: ordered_meta[k] = meta.pop(k)
ordered_meta.update(meta)
try:
yaml_str = yaml.dump(ordered_meta, default_flow_style=None, sort_keys=False, allow_unicode=True).strip()
except:
yaml_str = "error: generating_yaml"
return f"---\n{yaml_str}\n---\n\n{body}"
def load_history_from_logs(limit=10):
queries = []
if HISTORY_FILE.exists():
try:
with open(HISTORY_FILE, "r", encoding="utf-8") as f:
lines = f.readlines()
for line in reversed(lines):
try:
entry = json.loads(line)
q = entry.get("query_text")
if q and q not in queries:
queries.append(q)
if len(queries) >= limit: break
except: continue
except: pass
return queries
def send_chat_message(message: str, top_k: int, explain: bool):
try:
response = requests.post(
CHAT_ENDPOINT,
json={"message": message, "top_k": top_k, "explain": explain},
timeout=API_TIMEOUT
)
response.raise_for_status()
return response.json()
except Exception as e:
return {"error": str(e)}
def submit_feedback(query_id, node_id, score, comment=None):
try:
requests.post(FEEDBACK_ENDPOINT, json={"query_id": query_id, "node_id": node_id, "score": score, "comment": comment}, timeout=2)
st.toast(f"Feedback ({score}) gesendet!")
except: pass
# --- UI COMPONENTS ---
def render_sidebar():
with st.sidebar:
st.title("🧠 mindnet")
st.caption("v2.3.2 | WP-10 UI")
mode = st.radio("Modus", ["💬 Chat", "📝 Manueller Editor"], index=0)
st.divider()
st.subheader("⚙️ Settings")
top_k = st.slider("Quellen (Top-K)", 1, 10, 5)
explain = st.toggle("Explanation Layer", True)
st.divider()
st.subheader("🕒 Verlauf")
for q in load_history_from_logs(8):
if st.button(f"🔎 {q[:25]}...", key=f"hist_{q}", use_container_width=True):
st.session_state.messages.append({"role": "user", "content": q})
st.rerun()
return mode, top_k, explain
def render_draft_editor(msg):
qid = msg.get('query_id', str(uuid.uuid4()))
key_base = f"draft_{qid}"
# 1. Init
if f"{key_base}_init" not in st.session_state:
meta, body = parse_markdown_draft(msg["content"])
st.session_state[f"{key_base}_type"] = meta.get("type", "default")
st.session_state[f"{key_base}_title"] = meta.get("title", "")
tags_raw = meta.get("tags", [])
st.session_state[f"{key_base}_tags"] = ", ".join(tags_raw) if isinstance(tags_raw, list) else str(tags_raw)
st.session_state[f"{key_base}_body"] = body.strip()
st.session_state[f"{key_base}_meta"] = meta
st.session_state[f"{key_base}_init"] = True
# 2. UI
st.markdown(f'<div class="draft-box">', unsafe_allow_html=True)
st.markdown("### 📝 Entwurf bearbeiten")
# Metadata
c1, c2 = st.columns([2, 1])
with c1:
new_title = st.text_input("Titel", value=st.session_state.get(f"{key_base}_title", ""), key=f"{key_base}_inp_title")
with c2:
known_types = ["concept", "project", "decision", "experience", "journal", "person", "value", "goal", "principle", "default"]
curr_type = st.session_state.get(f"{key_base}_type", "default")
if curr_type not in known_types: known_types.append(curr_type)
new_type = st.selectbox("Typ", known_types, index=known_types.index(curr_type), key=f"{key_base}_sel_type")
new_tags = st.text_input("Tags (kommagetrennt)", value=st.session_state.get(f"{key_base}_tags", ""), key=f"{key_base}_inp_tags")
# Tabs
tab_edit, tab_view = st.tabs(["✏️ Inhalt", "👁️ Vorschau"])
with tab_edit:
st.caption("Bearbeite hier den Inhalt. Metadaten (oben) werden automatisch hinzugefügt.")
new_body = st.text_area(
"Body",
value=st.session_state.get(f"{key_base}_body", ""),
height=500,
key=f"{key_base}_txt_body",
label_visibility="collapsed"
)
# Reassembly
final_tags_list = [t.strip() for t in new_tags.split(",") if t.strip()]
final_meta = st.session_state.get(f"{key_base}_meta", {}).copy()
final_meta.update({
"id": "generated_on_save",
"type": new_type,
"title": new_title,
"status": "draft",
"tags": final_tags_list
})
final_doc = build_markdown_doc(final_meta, new_body)
with tab_view:
st.markdown('<div class="preview-box">', unsafe_allow_html=True)
st.markdown(final_doc)
st.markdown('</div>', unsafe_allow_html=True)
st.markdown("---")
# Actions
b1, b2 = st.columns([1, 1])
with b1:
fname = f"{datetime.now().strftime('%Y%m%d')}-{new_type}.md"
st.download_button("💾 Download .md", data=final_doc, file_name=fname, mime="text/markdown")
with b2:
if st.button("📋 Code anzeigen", key=f"{key_base}_btn_copy"):
st.code(final_doc, language="markdown")
st.markdown("</div>", unsafe_allow_html=True)
def render_chat_interface(top_k, explain):
for idx, msg in enumerate(st.session_state.messages):
with st.chat_message(msg["role"]):
if msg["role"] == "assistant":
# Meta
intent = msg.get("intent", "UNKNOWN")
src = msg.get("intent_source", "?")
icon = {"EMPATHY":"❤️", "DECISION":"⚖️", "CODING":"💻", "FACT":"📚", "INTERVIEW":"📝"}.get(intent, "🧠")
st.markdown(f'<div class="intent-badge">{icon} Intent: {intent} <span style="opacity:0.6; font-size:0.8em">({src})</span></div>', unsafe_allow_html=True)
# Debugging (Always visible for safety)
with st.expander("🐞 Debug Raw Payload", expanded=False):
st.json(msg)
# Logic
if intent == "INTERVIEW":
render_draft_editor(msg)
else:
st.markdown(msg["content"])
# Sources
if "sources" in msg and msg["sources"]:
for hit in msg["sources"]:
with st.expander(f"📄 {hit.get('note_id', '?')} ({hit.get('total_score', 0):.2f})"):
st.markdown(f"_{hit.get('source', {}).get('text', '')[:300]}..._")
if hit.get('explanation'):
st.caption(f"Grund: {hit['explanation']['reasons'][0]['message']}")
def _cb(qid=msg.get("query_id"), nid=hit.get('node_id')):
val = st.session_state.get(f"fb_src_{qid}_{nid}")
if val is not None: submit_feedback(qid, nid, val+1)
st.feedback("faces", key=f"fb_src_{msg.get('query_id')}_{hit.get('node_id')}", on_change=_cb)
if "query_id" in msg:
qid = msg["query_id"]
st.feedback("stars", key=f"fb_glob_{qid}", on_change=lambda: submit_feedback(qid, "generated_answer", st.session_state[f"fb_glob_{qid}"]+1))
else:
st.markdown(msg["content"])
if prompt := st.chat_input("Frage Mindnet..."):
st.session_state.messages.append({"role": "user", "content": prompt})
st.rerun()
if len(st.session_state.messages) > 0 and st.session_state.messages[-1]["role"] == "user":
with st.chat_message("assistant"):
with st.spinner("Thinking..."):
resp = send_chat_message(st.session_state.messages[-1]["content"], top_k, explain)
if "error" in resp:
st.error(resp["error"])
else:
st.session_state.messages.append({
"role": "assistant",
"content": resp.get("answer"),
"intent": resp.get("intent", "FACT"),
"intent_source": resp.get("intent_source", "Unknown"),
"sources": resp.get("sources", []),
"query_id": resp.get("query_id")
})
st.rerun()
def render_manual_editor():
st.header("📝 Manueller Editor")
c1, c2 = st.columns([1, 2])
n_type = c1.selectbox("Typ", ["concept", "project", "decision", "experience", "value", "goal"])
tags = c2.text_input("Tags")
body = st.text_area("Inhalt", height=400, placeholder="# Titel\n\nText...")
if st.button("Code anzeigen"):
meta = {"type": n_type, "status": "draft", "tags": [t.strip() for t in tags.split(",")]}
st.code(build_markdown_doc(meta, body), language="markdown")
mode, top_k, explain = render_sidebar()
if mode == "💬 Chat":
render_chat_interface(top_k, explain)
else:
render_manual_editor()
+6 -3
View File
@@ -10,8 +10,9 @@ from .routers.qdrant_router import router as qdrant_router
from .routers.query import router as query_router from .routers.query import router as query_router
from .routers.graph import router as graph_router from .routers.graph import router as graph_router
from .routers.tools import router as tools_router from .routers.tools import router as tools_router
# NEU: Feedback Router
from .routers.feedback import router as feedback_router from .routers.feedback import router as feedback_router
# NEU: Chat Router (WP-05)
from .routers.chat import router as chat_router
try: try:
from .routers.admin import router as admin_router from .routers.admin import router as admin_router
@@ -19,7 +20,7 @@ except Exception:
admin_router = None admin_router = None
def create_app() -> FastAPI: def create_app() -> FastAPI:
app = FastAPI(title="mindnet API", version="0.4.3") # Version bump app = FastAPI(title="mindnet API", version="0.5.0") # Version bump WP-05
s = get_settings() s = get_settings()
@app.get("/healthz") @app.get("/healthz")
@@ -32,9 +33,11 @@ def create_app() -> FastAPI:
app.include_router(query_router, prefix="/query", tags=["query"]) app.include_router(query_router, prefix="/query", tags=["query"])
app.include_router(graph_router, prefix="/graph", tags=["graph"]) app.include_router(graph_router, prefix="/graph", tags=["graph"])
app.include_router(tools_router, prefix="/tools", tags=["tools"]) app.include_router(tools_router, prefix="/tools", tags=["tools"])
# NEU:
app.include_router(feedback_router, prefix="/feedback", tags=["feedback"]) app.include_router(feedback_router, prefix="/feedback", tags=["feedback"])
# NEU: Chat Endpoint
app.include_router(chat_router, prefix="/chat", tags=["chat"])
if admin_router: if admin_router:
app.include_router(admin_router, prefix="/admin", tags=["admin"]) app.include_router(admin_router, prefix="/admin", tags=["admin"])
+44 -32
View File
@@ -1,17 +1,14 @@
""" """
app/models/dto.py — Pydantic-Modelle (DTOs) für WP-04 Endpunkte app/models/dto.py — Pydantic-Modelle (DTOs) für WP-04/WP-05/WP-06
Zweck: Zweck:
Laufzeit-Modelle für FastAPI (Requests/Responses), getrennt von JSON-Schemas. Laufzeit-Modelle für FastAPI (Requests/Responses).
Deckt die Graph-/Retriever-Endpunkte ab. WP-06 Update: Intent & Intent-Source in ChatResponse.
Enthält Erweiterungen für WP-04b (Explanation Layer) und WP-04c (Feedback).
Kompatibilität:
Python 3.12+, Pydantic 2.x, FastAPI 0.110+
Version: Version:
0.3.0 (Update für WP-04c Feedback) 0.6.2 (WP-06: Decision Engine Transparency, Erweiterung des Feeback Request)
Stand: Stand:
2025-12-07 2025-12-09
""" """
from __future__ import annotations from __future__ import annotations
@@ -42,7 +39,7 @@ class NodeDTO(BaseModel):
class EdgeDTO(BaseModel): class EdgeDTO(BaseModel):
"""Darstellung einer Kante im API-Graph.""" """Darstellung einer Kante im API-Graph."""
id: str id: str
kind: str # String statt Literal, um flexibel für Custom-Types zu bleiben kind: str
source: str source: str
target: str target: str
weight: float weight: float
@@ -53,11 +50,7 @@ class EdgeDTO(BaseModel):
class QueryRequest(BaseModel): class QueryRequest(BaseModel):
""" """
Request für /query: Request für /query.
- mode: 'semantic' | 'edge' | 'hybrid'
- query: (optional) Freitext
- query_vector: (optional) direkter Vektor
- explain: (optional) Fordert detaillierte Erklärungen an (WP-04b)
""" """
mode: Literal["semantic", "edge", "hybrid"] = "hybrid" mode: Literal["semantic", "edge", "hybrid"] = "hybrid"
query: Optional[str] = None query: Optional[str] = None
@@ -71,27 +64,39 @@ class QueryRequest(BaseModel):
class FeedbackRequest(BaseModel): class FeedbackRequest(BaseModel):
""" """
User-Feedback zu einem spezifischen Treffer (WP-04c). User-Feedback zu einem spezifischen Treffer oder der Gesamtantwort.
""" """
query_id: str = Field(..., description="ID der ursprünglichen Suche") query_id: str = Field(..., description="ID der ursprünglichen Suche")
node_id: str = Field(..., description="ID des bewerteten Treffers") # node_id ist optional: Wenn leer oder "generated_answer", gilt es für die Antwort.
score: int = Field(..., ge=0, le=1, description="1 (Positiv) oder 0 (Negativ/Irrelevant)") # Wenn eine echte Chunk-ID, gilt es für die Quelle.
node_id: str = Field(..., description="ID des bewerteten Treffers oder 'generated_answer'")
# Update: Range auf 1-5 erweitert für differenziertes Tuning
score: int = Field(..., ge=1, le=5, description="1 (Irrelevant/Falsch) bis 5 (Perfekt)")
comment: Optional[str] = None comment: Optional[str] = None
class ChatRequest(BaseModel):
"""
WP-05: Request für /chat.
"""
message: str = Field(..., description="Die Nachricht des Users")
conversation_id: Optional[str] = Field(None, description="Optional: ID für Chat-Verlauf (noch nicht implementiert)")
# RAG Parameter (Override defaults)
top_k: int = 5
explain: bool = False
# --- WP-04b Explanation Models --- # --- WP-04b Explanation Models ---
class ScoreBreakdown(BaseModel): class ScoreBreakdown(BaseModel):
"""Aufschlüsselung der Score-Komponenten.""" """Aufschlüsselung der Score-Komponenten."""
semantic_contribution: float = Field(..., description="W_sem * semantic_score * weight") semantic_contribution: float
edge_contribution: float = Field(..., description="W_edge * edge_bonus") edge_contribution: float
centrality_contribution: float = Field(..., description="W_cent * centrality_bonus") centrality_contribution: float
# Rohwerte
raw_semantic: float raw_semantic: float
raw_edge_bonus: float raw_edge_bonus: float
raw_centrality: float raw_centrality: float
node_weight: float = Field(..., description="Typ-Gewicht (retriever_weight)") node_weight: float
class Reason(BaseModel): class Reason(BaseModel):
@@ -115,25 +120,18 @@ class QueryHit(BaseModel):
"""Einzelnes Trefferobjekt für /query.""" """Einzelnes Trefferobjekt für /query."""
node_id: str node_id: str
note_id: Optional[str] note_id: Optional[str]
# Flache Scores
semantic_score: float semantic_score: float
edge_bonus: float edge_bonus: float
centrality_bonus: float centrality_bonus: float
total_score: float total_score: float
paths: Optional[List[List[Dict]]] = None paths: Optional[List[List[Dict]]] = None
source: Optional[Dict] = None source: Optional[Dict] = None
payload: Optional[Dict] = None # Added for flexibility & WP-06 meta-data
# WP-04b: Erklärungsobjekt
explanation: Optional[Explanation] = None explanation: Optional[Explanation] = None
class QueryResponse(BaseModel): class QueryResponse(BaseModel):
""" """Antwortstruktur für /query."""
Antwortstruktur für /query (Liste von Treffern + Telemetrie).
Enthält query_id für Traceability (WP-04c).
"""
query_id: str = Field(default_factory=lambda: str(uuid.uuid4())) query_id: str = Field(default_factory=lambda: str(uuid.uuid4()))
results: List[QueryHit] results: List[QueryHit]
used_mode: str used_mode: str
@@ -146,3 +144,17 @@ class GraphResponse(BaseModel):
nodes: List[NodeDTO] nodes: List[NodeDTO]
edges: List[EdgeDTO] edges: List[EdgeDTO]
stats: Dict[str, int] stats: Dict[str, int]
class ChatResponse(BaseModel):
"""
WP-05/06: Antwortstruktur für /chat.
"""
query_id: str = Field(..., description="Traceability ID (dieselbe wie für Search)")
answer: str = Field(..., description="Generierte Antwort vom LLM")
sources: List[QueryHit] = Field(..., description="Die für die Antwort genutzten Quellen")
latency_ms: int
intent: Optional[str] = Field("FACT", description="WP-06: Erkannter Intent (FACT/DECISION)")
intent_source: Optional[str] = Field("Unknown", description="WP-06: Quelle der Intent-Erkennung (Keyword vs. LLM)")
+345
View File
@@ -0,0 +1,345 @@
"""
app/routers/chat.py — RAG Endpunkt (WP-06 Hybrid Router + WP-07 Interview Mode)
Version: 2.4.0 (Interview Support)
Features:
- Hybrid Intent Router (Keyword + LLM)
- Strategic Retrieval (Late Binding via Config)
- Interview Loop (Schema-driven Data Collection)
- Context Enrichment (Payload/Source Fallback)
- Data Flywheel (Feedback Logging Integration)
"""
from fastapi import APIRouter, HTTPException, Depends
from typing import List, Dict, Any
import time
import uuid
import logging
import yaml
from pathlib import Path
from app.config import get_settings
from app.models.dto import ChatRequest, ChatResponse, QueryRequest, QueryHit
from app.services.llm_service import LLMService
from app.core.retriever import Retriever
from app.services.feedback_service import log_search
router = APIRouter()
logger = logging.getLogger(__name__)
# --- Helper: Config Loader ---
_DECISION_CONFIG_CACHE = None
def _load_decision_config() -> Dict[str, Any]:
settings = get_settings()
path = Path(settings.DECISION_CONFIG_PATH)
default_config = {
"strategies": {
"FACT": {"trigger_keywords": []}
}
}
if not path.exists():
logger.warning(f"Decision config not found at {path}, using defaults.")
return default_config
try:
with open(path, "r", encoding="utf-8") as f:
return yaml.safe_load(f)
except Exception as e:
logger.error(f"Failed to load decision config: {e}")
return default_config
def get_full_config() -> Dict[str, Any]:
global _DECISION_CONFIG_CACHE
if _DECISION_CONFIG_CACHE is None:
_DECISION_CONFIG_CACHE = _load_decision_config()
return _DECISION_CONFIG_CACHE
def get_decision_strategy(intent: str) -> Dict[str, Any]:
config = get_full_config()
strategies = config.get("strategies", {})
return strategies.get(intent, strategies.get("FACT", {}))
# --- Helper: Target Type Detection (WP-07) ---
def _detect_target_type(message: str, configured_schemas: Dict[str, Any]) -> str:
"""
Versucht zu erraten, welchen Notiz-Typ der User erstellen will.
Nutzt Keywords und Mappings.
"""
message_lower = message.lower()
# 1. Direkter Match mit Schema-Keys (z.B. "projekt", "entscheidung")
# Ignoriere 'default' hier
for type_key in configured_schemas.keys():
if type_key == "default":
continue
if type_key in message_lower:
return type_key
# 2. Synonym-Mapping (Deutsch -> Schema Key)
# Dies verbessert die UX, falls User deutsche Begriffe nutzen
synonyms = {
"projekt": "project",
"vorhaben": "project",
"entscheidung": "decision",
"beschluss": "decision",
"ziel": "goal",
"erfahrung": "experience",
"lektion": "experience",
"wert": "value",
"prinzip": "principle",
"grundsatz": "principle",
"notiz": "default",
"idee": "default"
}
for term, schema_key in synonyms.items():
if term in message_lower:
# Prüfen, ob der gemappte Key auch konfiguriert ist
if schema_key in configured_schemas:
return schema_key
return "default"
# --- Dependencies ---
def get_llm_service():
return LLMService()
def get_retriever():
return Retriever()
# --- Logic ---
def _build_enriched_context(hits: List[QueryHit]) -> str:
context_parts = []
for i, hit in enumerate(hits, 1):
source = hit.source or {}
content = (
source.get("text") or source.get("content") or
source.get("page_content") or source.get("chunk_text") or
"[Kein Text]"
)
title = hit.note_id or "Unbekannt"
# [FIX] Robustes Auslesen des Typs (Payload > Source > Unknown)
payload = hit.payload or {}
note_type = payload.get("type") or source.get("type", "unknown")
note_type = str(note_type).upper()
entry = (
f"### QUELLE {i}: {title}\n"
f"TYP: [{note_type}] (Score: {hit.total_score:.2f})\n"
f"INHALT:\n{content}\n"
)
context_parts.append(entry)
return "\n\n".join(context_parts)
async def _classify_intent(query: str, llm: LLMService) -> tuple[str, str]:
"""
Hybrid Router v3:
Gibt Tuple zurück: (Intent, Source)
"""
config = get_full_config()
strategies = config.get("strategies", {})
settings = config.get("settings", {})
query_lower = query.lower()
best_intent = None
max_match_length = 0
# 1. FAST PATH: Keywords
for intent_name, strategy in strategies.items():
if intent_name == "FACT": continue
keywords = strategy.get("trigger_keywords", [])
for k in keywords:
if k.lower() in query_lower:
if len(k) > max_match_length:
max_match_length = len(k)
best_intent = intent_name
if best_intent:
return best_intent, "Keyword (Fast Path)"
# 2. SLOW PATH: LLM Router
if settings.get("llm_fallback_enabled", False):
router_prompt_template = settings.get("llm_router_prompt", "")
if router_prompt_template:
prompt = router_prompt_template.replace("{query}", query)
logger.info("Keywords failed. Asking LLM for Intent...")
raw_response = await llm.generate_raw_response(prompt)
# Parsing logic
llm_output_upper = raw_response.upper()
found_intents = []
for strat_key in strategies.keys():
if strat_key in llm_output_upper:
found_intents.append(strat_key)
if len(found_intents) == 1:
return found_intents[0], "LLM Router (Slow Path)"
elif len(found_intents) > 1:
return found_intents[0], f"LLM Ambiguous {found_intents}"
else:
return "FACT", "LLM Fallback (No Match)"
return "FACT", "Default (No Match)"
@router.post("/", response_model=ChatResponse)
async def chat_endpoint(
request: ChatRequest,
llm: LLMService = Depends(get_llm_service),
retriever: Retriever = Depends(get_retriever)
):
start_time = time.time()
query_id = str(uuid.uuid4())
logger.info(f"Chat request [{query_id}]: {request.message[:50]}...")
try:
# 1. Intent Detection (mit Source)
intent, intent_source = await _classify_intent(request.message, llm)
logger.info(f"[{query_id}] Final Intent: {intent} via {intent_source}")
# Strategy Load
strategy = get_decision_strategy(intent)
prompt_key = strategy.get("prompt_template", "rag_template")
# --- SPLIT LOGIC: INTERVIEW vs. RAG ---
sources_hits = []
final_prompt = ""
if intent == "INTERVIEW":
# --- WP-07: INTERVIEW MODE ---
# Kein Retrieval. Wir nutzen den Dialog-Kontext.
# 1. Schema Loading (Late Binding)
schemas = strategy.get("schemas", {})
target_type = _detect_target_type(request.message, schemas)
active_schema = schemas.get(target_type, schemas.get("default"))
logger.info(f"[{query_id}] Starting Interview for Type: {target_type}")
# Robustes Schema-Parsing (Dict vs List)
if isinstance(active_schema, dict):
fields_list = active_schema.get("fields", [])
hint_str = active_schema.get("hint", "")
else:
fields_list = active_schema # Fallback falls nur Liste definiert
hint_str = ""
fields_str = "\n- " + "\n- ".join(fields_list)
# 2. Context Logic
# Hinweis: In einer Stateless-API ist {context_str} idealerweise die History.
# Da ChatRequest (noch) kein History-Feld hat, nutzen wir einen Placeholder
# oder verlassen uns darauf, dass der Client die History im Prompt mitschickt
# (Streamlit Pattern: Appends history to prompt).
# Wir labeln es hier explizit.
context_str = "Bisheriger Verlauf (falls vorhanden): Siehe oben/unten."
# 3. Prompt Assembly
template = llm.prompts.get(prompt_key, "")
final_prompt = template.replace("{context_str}", context_str) \
.replace("{query}", request.message) \
.replace("{target_type}", target_type) \
.replace("{schema_fields}", fields_str) \
.replace("{schema_hint}", hint_str)
# Keine Hits im Interview
sources_hits = []
else:
# --- WP-06: STANDARD RAG MODE ---
inject_types = strategy.get("inject_types", [])
prepend_instr = strategy.get("prepend_instruction", "")
# 2. Primary Retrieval
query_req = QueryRequest(
query=request.message,
mode="hybrid",
top_k=request.top_k,
explain=request.explain
)
retrieve_result = await retriever.search(query_req)
hits = retrieve_result.results
# 3. Strategic Retrieval (WP-06 Kernfeature)
if inject_types:
logger.info(f"[{query_id}] Executing Strategic Retrieval for types: {inject_types}...")
strategy_req = QueryRequest(
query=request.message,
mode="hybrid",
top_k=3,
filters={"type": inject_types},
explain=False
)
strategy_result = await retriever.search(strategy_req)
existing_ids = {h.node_id for h in hits}
for strat_hit in strategy_result.results:
if strat_hit.node_id not in existing_ids:
hits.append(strat_hit)
# 4. Context Building
if not hits:
context_str = "Keine relevanten Notizen gefunden."
else:
context_str = _build_enriched_context(hits)
# 5. Generation Setup
template = llm.prompts.get(prompt_key, "{context_str}\n\n{query}")
if prepend_instr:
context_str = f"{prepend_instr}\n\n{context_str}"
final_prompt = template.replace("{context_str}", context_str).replace("{query}", request.message)
sources_hits = hits
# --- COMMON GENERATION ---
system_prompt = llm.prompts.get("system_prompt", "")
logger.info(f"[{query_id}] Sending to LLM (Intent: {intent}, Template: {prompt_key})...")
# System-Prompt separat übergeben
answer_text = await llm.generate_raw_response(prompt=final_prompt, system=system_prompt)
duration_ms = int((time.time() - start_time) * 1000)
# 6. Logging (Fire & Forget)
try:
log_search(
query_id=query_id,
query_text=request.message,
results=sources_hits,
mode="interview" if intent == "INTERVIEW" else "chat_rag",
metadata={
"intent": intent,
"intent_source": intent_source,
"generated_answer": answer_text,
"model": llm.settings.LLM_MODEL
}
)
except Exception as e:
logger.error(f"Logging failed: {e}")
# 7. Response
return ChatResponse(
query_id=query_id,
answer=answer_text,
sources=sources_hits,
latency_ms=duration_ms,
intent=intent,
intent_source=intent_source
)
except Exception as e:
logger.error(f"Error in chat endpoint: {e}", exc_info=True)
raise HTTPException(status_code=500, detail=str(e))
+44 -26
View File
@@ -2,13 +2,18 @@
app/services/feedback_service.py app/services/feedback_service.py
Service zum Loggen von Suchanfragen und Feedback (WP-04c). Service zum Loggen von Suchanfragen und Feedback (WP-04c).
Speichert Daten als JSONL für späteres Self-Tuning (WP-08). Speichert Daten als JSONL für späteres Self-Tuning (WP-08).
Version: 1.1 (Chat-Support)
""" """
import json import json
import os import os
import time import time
import logging
from pathlib import Path from pathlib import Path
from typing import Dict, Any, List from typing import Dict, Any, List, Union
from app.models.dto import QueryRequest, QueryResponse, FeedbackRequest from app.models.dto import QueryRequest, QueryResponse, FeedbackRequest, QueryHit
logger = logging.getLogger(__name__)
# Pfad für Logs (lokal auf dem Beelink/PC) # Pfad für Logs (lokal auf dem Beelink/PC)
LOG_DIR = Path("data/logs") LOG_DIR = Path("data/logs")
@@ -19,18 +24,35 @@ def _ensure_log_dir():
if not LOG_DIR.exists(): if not LOG_DIR.exists():
os.makedirs(LOG_DIR, exist_ok=True) os.makedirs(LOG_DIR, exist_ok=True)
def log_search(req: QueryRequest, res: QueryResponse): def _append_jsonl(file_path: Path, data: dict):
try:
with open(file_path, "a", encoding="utf-8") as f:
f.write(json.dumps(data, ensure_ascii=False) + "\n")
except Exception as e:
logger.error(f"Failed to write log: {e}")
def log_search(
query_id: str,
query_text: str,
results: List[QueryHit],
mode: str = "unknown",
metadata: Dict[str, Any] = None
):
""" """
Speichert den "Snapshot" der Suche. Generische Logging-Funktion für Suche UND Chat.
WICHTIG: Wir speichern die Scores (Breakdown), damit wir später wissen,
warum das System so entschieden hat. Args:
query_id: UUID der Anfrage.
query_text: User-Eingabe.
results: Liste der Treffer (QueryHit Objekte).
mode: z.B. "semantic", "hybrid", "chat_rag".
metadata: Zusätzliche Infos (z.B. generierte Antwort, Intent).
""" """
_ensure_log_dir() _ensure_log_dir()
# Wir reduzieren die Datenmenge etwas (z.B. keine vollen Texte)
hits_summary = [] hits_summary = []
for hit in res.results: for hit in results:
# Falls Explanation an war, speichern wir den Breakdown, sonst die Scores # Pydantic Model Dump für saubere Serialisierung
breakdown = None breakdown = None
if hit.explanation and hit.explanation.breakdown: if hit.explanation and hit.explanation.breakdown:
breakdown = hit.explanation.breakdown.model_dump() breakdown = hit.explanation.breakdown.model_dump()
@@ -39,25 +61,24 @@ def log_search(req: QueryRequest, res: QueryResponse):
"node_id": hit.node_id, "node_id": hit.node_id,
"note_id": hit.note_id, "note_id": hit.note_id,
"total_score": hit.total_score, "total_score": hit.total_score,
"breakdown": breakdown, # Wichtig für Training! "breakdown": breakdown,
"rank_semantic": hit.semantic_score, "rank_semantic": hit.semantic_score,
"rank_edge": hit.edge_bonus "rank_edge": hit.edge_bonus,
"type": hit.source.get("type") if hit.source else "unknown"
}) })
entry = { entry = {
"timestamp": time.time(), "timestamp": time.time(),
"query_id": res.query_id, "query_id": query_id,
"query_text": req.query, "query_text": query_text,
"mode": req.mode, "mode": mode,
"top_k": req.top_k, "hits_count": len(hits_summary),
"hits": hits_summary "hits": hits_summary,
"metadata": metadata or {}
} }
try: _append_jsonl(SEARCH_LOG_FILE, entry)
with open(SEARCH_LOG_FILE, "a", encoding="utf-8") as f: logger.info(f"Logged search/chat interaction {query_id}")
f.write(json.dumps(entry, ensure_ascii=False) + "\n")
except Exception as e:
print(f"ERROR logging search: {e}")
def log_feedback(fb: FeedbackRequest): def log_feedback(fb: FeedbackRequest):
""" """
@@ -73,8 +94,5 @@ def log_feedback(fb: FeedbackRequest):
"comment": fb.comment "comment": fb.comment
} }
try: _append_jsonl(FEEDBACK_LOG_FILE, entry)
with open(FEEDBACK_LOG_FILE, "a", encoding="utf-8") as f: logger.info(f"Logged feedback for {fb.query_id}")
f.write(json.dumps(entry, ensure_ascii=False) + "\n")
except Exception as e:
print(f"ERROR logging feedback: {e}")
+80
View File
@@ -0,0 +1,80 @@
"""
app/services/llm_service.py — LLM Client (Ollama)
Version: 0.2.1 (Fix: System Prompt Handling for Phi-3)
"""
import httpx
import yaml
import logging
import os
from pathlib import Path
from app.config import get_settings
logger = logging.getLogger(__name__)
class LLMService:
def __init__(self):
self.settings = get_settings()
self.prompts = self._load_prompts()
self.client = httpx.AsyncClient(
base_url=self.settings.OLLAMA_URL,
timeout=self.settings.LLM_TIMEOUT
)
def _load_prompts(self) -> dict:
path = Path(self.settings.PROMPTS_PATH)
if not path.exists():
return {}
try:
with open(path, "r", encoding="utf-8") as f:
return yaml.safe_load(f)
except Exception as e:
logger.error(f"Failed to load prompts: {e}")
return {}
async def generate_raw_response(self, prompt: str, system: str = None) -> str:
"""
Führt einen LLM Call aus.
Unterstützt nun explizite System-Prompts für sauberes Templating.
"""
payload = {
"model": self.settings.LLM_MODEL,
"prompt": prompt,
"stream": False,
"options": {
# Temperature etwas höher für Empathie, niedriger für Code?
# Wir lassen es auf Standard, oder steuern es später via Config.
"temperature": 0.7,
"num_ctx": 2048
}
}
# WICHTIG: System-Prompt separat übergeben, damit Ollama formatiert
if system:
payload["system"] = system
try:
response = await self.client.post("/api/generate", json=payload)
if response.status_code != 200:
logger.error(f"Ollama Error ({response.status_code}): {response.text}")
return "Fehler bei der Generierung."
data = response.json()
return data.get("response", "").strip()
except Exception as e:
logger.error(f"LLM Raw Gen Error: {e}")
return "Interner LLM Fehler."
async def generate_rag_response(self, query: str, context_str: str) -> str:
"""Legacy Support"""
system_prompt = self.prompts.get("system_prompt", "")
rag_template = self.prompts.get("rag_template", "{context_str}\n\n{query}")
final_prompt = rag_template.format(context_str=context_str, query=query)
# Leite an die neue Methode weiter
return await self.generate_raw_response(final_prompt, system=system_prompt)
async def close(self):
await self.client.aclose()
+143
View File
@@ -0,0 +1,143 @@
# config/decision_engine.yaml
# Steuerung der Decision Engine (WP-06 + WP-07)
# Hybrid-Modus: Keywords (Fast) + LLM Router (Smart Fallback)
version: 1.3
settings:
llm_fallback_enabled: true
# Few-Shot Prompting für bessere SLM-Performance
# Erweitert um INTERVIEW Beispiele
llm_router_prompt: |
Du bist ein Klassifikator. Analysiere die Nachricht und wähle die passende Strategie.
Antworte NUR mit dem Namen der Strategie.
STRATEGIEN:
- INTERVIEW: User will Wissen strukturieren, Notizen anlegen, Projekte starten ("Neu", "Festhalten").
- DECISION: Rat, Strategie, Vor/Nachteile, "Soll ich".
- EMPATHY: Gefühle, Frust, Freude, Probleme, "Alles ist sinnlos", "Ich bin traurig".
- CODING: Code, Syntax, Programmierung, Python.
- FACT: Wissen, Fakten, Definitionen.
BEISPIELE:
User: "Wie funktioniert Qdrant?" -> FACT
User: "Soll ich Qdrant nutzen?" -> DECISION
User: "Ich möchte ein neues Projekt anlegen" -> INTERVIEW
User: "Lass uns eine Entscheidung festhalten" -> INTERVIEW
User: "Schreibe ein Python Script" -> CODING
User: "Alles ist grau und sinnlos" -> EMPATHY
User: "Mir geht es heute gut" -> EMPATHY
NACHRICHT: "{query}"
STRATEGIE:
strategies:
# 1. Fakten-Abfrage (Fallback & Default)
FACT:
description: "Reine Wissensabfrage."
trigger_keywords: []
inject_types: []
prompt_template: "rag_template"
prepend_instruction: null
# 2. Entscheidungs-Frage
DECISION:
description: "Der User sucht Rat, Strategie oder Abwägung."
trigger_keywords:
- "soll ich"
- "meinung"
- "besser"
- "empfehlung"
- "strategie"
- "entscheidung"
- "wert"
- "prinzip"
- "vor- und nachteile"
- "abwägung"
inject_types: ["value", "principle", "goal"]
prompt_template: "decision_template"
prepend_instruction: |
!!! ENTSCHEIDUNGS-MODUS !!!
BITTE WÄGE FAKTEN GEGEN FOLGENDE WERTE, PRINZIPIEN UND ZIELE AB:
# 3. Empathie / "Ich"-Modus
EMPATHY:
description: "Reaktion auf emotionale Zustände."
trigger_keywords:
- "ich fühle"
- "traurig"
- "glücklich"
- "gestresst"
- "angst"
- "nervt"
- "überfordert"
inject_types: ["experience", "belief", "profile"]
prompt_template: "empathy_template"
prepend_instruction: null
# 4. Coding / Technical
CODING:
description: "Technische Anfragen und Programmierung."
trigger_keywords:
- "code"
- "python"
- "script"
- "funktion"
- "bug"
- "syntax"
- "json"
- "yaml"
inject_types: ["snippet", "reference", "source"]
prompt_template: "technical_template"
prepend_instruction: null
# 5. Interview / Datenerfassung (WP-07)
INTERVIEW:
description: "Der User möchte strukturiertes Wissen erfassen (Projekt, Notiz, Idee)."
trigger_keywords:
- "neue notiz"
- "neues projekt"
- "neue entscheidung"
- "neues ziel"
- "festhalten"
- "entwurf erstellen"
- "interview"
- "dokumentieren"
- "erfassen"
- "idee speichern"
inject_types: [] # Keine RAG-Suche, reiner Kontext-Dialog
prompt_template: "interview_template"
prepend_instruction: null
# LATE BINDING SCHEMAS:
# Definition der Pflichtfelder pro Typ (korrespondiert mit types.yaml)
# Wenn ein Typ hier fehlt, wird 'default' genutzt.
schemas:
default:
fields: ["Titel", "Thema/Inhalt", "Tags"]
hint: "Halte es einfach und übersichtlich."
project:
fields: ["Titel", "Zielsetzung (Goal)", "Status (draft/active)", "Wichtige Stakeholder", "Nächste Schritte"]
hint: "Achte darauf, Abhängigkeiten zu anderen Projekten mit [[rel:depends_on]] zu erfragen."
decision:
fields: ["Titel", "Kontext (Warum entscheiden wir?)", "Getroffene Entscheidung", "Betrachtete Alternativen", "Status (proposed/final)"]
hint: "Wichtig: Frage explizit nach den Gründen gegen die Alternativen."
goal:
fields: ["Titel", "Zeitrahmen (Deadline)", "Messkriterien (KPIs)", "Verbundene Werte"]
hint: "Ziele sollten SMART formuliert sein."
experience:
fields: ["Titel", "Situation (Kontext)", "Erkenntnis (Learning)", "Emotionale Keywords (für Empathie-Suche)"]
hint: "Fokussiere dich auf die persönliche Lektion."
value:
fields: ["Titel (Name des Werts)", "Definition (Was bedeutet das für uns?)", "Anti-Beispiel (Was ist es nicht?)"]
hint: "Werte dienen als Entscheidungsgrundlage."
principle:
fields: ["Titel", "Handlungsanweisung", "Begründung"]
hint: "Prinzipien sind härter als Werte."
+140
View File
@@ -0,0 +1,140 @@
# config/prompts.yaml — Final V2.3.1 (Multi-Personality Support)
system_prompt: |
Du bist 'mindnet', mein digitaler Zwilling und strategischer Partner.
DEINE IDENTITÄT:
- Du bist nicht nur eine Datenbank, sondern handelst nach MEINEN Werten und Zielen.
- Du passt deinen Stil dynamisch an die Situation an (Analytisch, Empathisch oder Technisch).
DEINE REGELN:
1. Deine Antwort muss zu 100% auf dem bereitgestellten KONTEXT basieren.
2. Halluziniere keine Fakten, die nicht in den Quellen stehen.
3. Antworte auf Deutsch (außer bei Code/Fachbegriffen).
# ---------------------------------------------------------
# 1. STANDARD: Fakten & Wissen (Intent: FACT)
# ---------------------------------------------------------
rag_template: |
QUELLEN (WISSEN):
=========================================
{context_str}
=========================================
FRAGE:
{query}
ANWEISUNG:
Beantworte die Frage präzise basierend auf den Quellen.
Fasse die Informationen zusammen. Sei objektiv und neutral.
# ---------------------------------------------------------
# 2. DECISION: Strategie & Abwägung (Intent: DECISION)
# ---------------------------------------------------------
decision_template: |
KONTEXT (FAKTEN & STRATEGIE):
=========================================
{context_str}
=========================================
ENTSCHEIDUNGSFRAGE:
{query}
ANWEISUNG:
Du agierst als mein Entscheidungs-Partner.
1. Analysiere die Faktenlage aus den Quellen.
2. Prüfe dies hart gegen meine strategischen Notizen (Typ [VALUE], [PRINCIPLE], [GOAL]).
3. Wäge ab: Passt die technische/faktische Lösung zu meinen Werten?
FORMAT:
- **Analyse:** (Kurze Zusammenfassung der Fakten)
- **Abgleich:** (Gibt es Konflikte mit Werten/Zielen? Nenne die Quelle!)
- **Empfehlung:** (Klare Meinung: Ja/Nein/Vielleicht mit Begründung)
# ---------------------------------------------------------
# 3. EMPATHY: Der Spiegel / "Ich"-Modus (Intent: EMPATHY)
# ---------------------------------------------------------
empathy_template: |
KONTEXT (ERFAHRUNGEN & GLAUBENSSÄTZE):
=========================================
{context_str}
=========================================
SITUATION:
{query}
ANWEISUNG:
Du agierst jetzt als mein empathischer Spiegel.
1. Versuche nicht sofort, das Problem technisch zu lösen.
2. Zeige Verständnis für die Situation basierend auf meinen eigenen Erfahrungen ([EXPERIENCE]) oder Glaubenssätzen ([BELIEF]), falls im Kontext vorhanden.
3. Antworte in der "Ich"-Form oder "Wir"-Form. Sei unterstützend.
TONFALL:
Ruhig, verständnisvoll, reflektiert. Keine Aufzählungszeichen, sondern fließender Text.
# ---------------------------------------------------------
# 4. TECHNICAL: Der Coder (Intent: CODING)
# ---------------------------------------------------------
technical_template: |
KONTEXT (DOCS & SNIPPETS):
=========================================
{context_str}
=========================================
TASK:
{query}
ANWEISUNG:
Du bist Senior Developer.
1. Ignoriere Smalltalk. Komm sofort zum Punkt.
2. Generiere validen, performanten Code basierend auf den Quellen.
3. Wenn Quellen fehlen, nutze dein allgemeines Programmierwissen, aber weise darauf hin.
FORMAT:
- Kurze Erklärung des Ansatzes.
- Markdown Code-Block (Copy-Paste fertig).
- Wichtige Edge-Cases.
# ---------------------------------------------------------
# 5. INTERVIEW: Der "One-Shot Extractor" (Performance Mode)
# ---------------------------------------------------------
interview_template: |
TASK:
Erstelle einen Markdown-Entwurf für eine Notiz vom Typ '{target_type}'.
SCHEMA (Inhaltliche Pflichtfelder für den Body):
{schema_fields}
USER INPUT:
"{query}"
ANWEISUNG:
1. Extrahiere Informationen aus dem Input.
2. Generiere validen Markdown.
OUTPUT REGELN (STRIKT BEACHTEN):
A. FRONTMATTER (YAML):
- Darf NUR folgende Felder enthalten: [type, status, title, tags].
- Schreibe KEINE inhaltlichen Sätze (wie 'Situation', 'Ziel') in das YAML!
- Setze 'status: draft'.
B. BODY (Markdown):
- Nutze für jedes Schema-Feld eine Markdown-Überschrift (## Feldname).
- Schreibe den Inhalt DARUNTER.
- Nutze "[TODO: Ergänzen]", wenn Infos fehlen.
HINWEIS ZUM TYP:
{schema_hint}
OUTPUT FORMAT BEISPIEL:
```markdown
---
type: {target_type}
status: draft
title: ...
tags: [...]
---
# Titel der Notiz
## Erstes Schema Feld
Der Inhalt hier...
+32
View File
@@ -0,0 +1,32 @@
# config/prompts.yaml — Persönlichkeit & RAG-Strategie
# Version: 2.0 (Audit Update)
system_prompt: |
Du bist 'mindnet', ein persönliches KI-Gedächtnis und der Digitale Zwilling deines Erschaffers ("User").
DEINE PERSÖNLICHKEIT & WERTE:
1. Pragmatismus: Du bevorzugst funktionierende Lösungen über theoretische Perfektion.
2. Transparenz: Du erfindest keine Fakten. Wenn Informationen im Kontext fehlen, sagst du das klar.
3. Vernetztes Denken: Du suchst aktiv nach Verbindungen zwischen den bereitgestellten Notizen.
4. Erklärbarkeit: Wenn du eine Aussage machst, beziehst du dich implizit auf die Quelle (z.B. "Wie in Projekt X definiert...").
DEINE AUFGABE:
Beantworte die Frage des Users ausschließlich basierend auf dem untenstehenden KONTEXT.
Der Kontext besteht aus Auszügen verschiedener Notizen. Achte besonders auf den [TYPE] der Notiz:
- [DECISION] erklärt das "Warum".
- [PROJECT] erklärt das "Was" und "Wann".
- [CONCEPT] liefert Definitionen.
- [VALUE] definiert die moralische/strategische Ausrichtung.
rag_template: |
HINTERGRUNDWISSEN (KONTEXT):
=========================================
{context_str}
=========================================
FRAGE DES USERS:
{query}
ANWEISUNG:
Analysiere die Quellen oben. Synthetisiere eine Antwort, die die Frage präzise beantwortet.
Nutze Markdown für Struktur (Fettgedrucktes für Wichtiges).
+24
View File
@@ -0,0 +1,24 @@
system_prompt: |
Du bist 'mindnet', ein persönliches KI-Gedächtnis.
DEINE REGELN:
1. Antworte NUR basierend auf dem untenstehenden KONTEXT.
2. Achte auf den TYP der Quelle:
- [DECISION] enthält Begründungen (Warum?).
- [PROJECT] enthält Ziele (Was?).
- [CONCEPT] enthält Definitionen.
3. Sei präzise. Nenne konkrete technische Gründe, wenn sie im Text stehen.
4. Halluziniere nicht.
rag_template: |
KONTEXT (WISSEN):
=========================================
{context_str}
=========================================
FRAGE:
{query}
ANWEISUNG:
Analysiere den Kontext. Wenn eine [DECISION] Quelle dabei ist, nutze deren Inhalt für die Begründung.
Antworte kurz und präzise auf Deutsch.
+2 -1
View File
@@ -13,7 +13,8 @@ scoring:
# Empfehlung: 0.5 → zentrale Knoten werden bevorzugt, aber moderat # Empfehlung: 0.5 → zentrale Knoten werden bevorzugt, aber moderat
centrality_weight: 0.5 centrality_weight: 0.5
# Optional, für später (aktuell noch nicht ausgewertet, aber als Blaupause): # Die nachfolgenden Werte überschreiben die Defaults aus app/core/retriever_config.
# Wenn neue Kantentypen, z.B. durch Referenzierung innerhalb einer md-Datei im vault anders gewichtet werden sollen, dann muss hier die Konfiguration erfolgen
edge_types: edge_types:
references: 0.20 references: 0.20
depends_on: 0.18 depends_on: 0.18
+116 -60
View File
@@ -1,8 +1,20 @@
# mindnet v2.2 – Knowledge Design Manual # mindnet v2.4 – Knowledge Design Manual
**Datei:** `docs/mindnet_knowledge_design_manual_v2.2.md` **Datei:** `docs/mindnet_knowledge_design_manual_v2.4.md`
**Stand:** 2025-12-07 **Stand:** 2025-12-10
**Status:** **FINAL** (Konsolidiert aus WP01–WP04a) **Status:** **FINAL** (Integrierter Stand WP01–WP10a)
**Quellen:** `knowledge_design.md`, `TYPE_REGISTRY_MANUAL.md`, `chunking_strategy.md`, `mindnet_functional_architecture.md`, `WP03/WP04 Hinweise`. **Quellen:** `knowledge_design.md`, `TYPE_REGISTRY_MANUAL.md`, `chunking_strategy.md`, `mindnet_functional_architecture.md`.
---
## ⚡ Die 5 Goldenen Regeln (TL;DR)
Damit Mindnet als dein Digitaler Zwilling funktioniert, beachte beim Schreiben diese Grundsätze:
1. **Atomare Gedanken:** Eine Notiz = Ein Thema. Wenn du über zwei Projekte schreibst, mach zwei Notizen draus.
2. **Explizite Typen:** Setze immer den `type` im Frontmatter. Mindnet behandelt eine `decision` ("Wir machen X") völlig anders als ein `concept` ("Was ist X").
3. **Semantische Links:** Schreibe nicht nur `[[Link]]`, sondern `[[rel:depends_on Link]]`. Sag dem System *wie* Dinge zusammenhängen.
4. **Werte & Ziele definieren:** Damit die **Decision Engine** dich beraten kann, musst du deine Kriterien (`type: value`, `type: goal`) explizit als Notizen anlegen.
5. **Emotionales Bridging:** Damit die **Empathie** funktioniert, nutze in Erfahrungsberichten (`type: experience`) emotionale Schlüsselwörter ("Krise", "Freude", "Angst"), damit der Vektor-Retriever sie bei Gefühls-Anfragen findet.
--- ---
@@ -11,7 +23,12 @@
Dieses Handbuch ist die **primäre Arbeitsanweisung** für dich als Mindmaster (Owner) und alle Autoren, die Inhalte im mindnet-Vault erstellen. 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 ### 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. Mindnet ist mehr als eine Dokumentablage. Es ist ein vernetztes System, das deine Persönlichkeit, Entscheidungen und Erfahrungen abbildet.
Seit Version 2.3.1 verfügt Mindnet über:
* **Hybrid Router:** Das System erkennt, ob du Fakten, Entscheidungen oder Empathie brauchst.
* **Context Intelligence:** Das System lädt je nach Situation unterschiedliche Notiz-Typen (z.B. Werte bei Entscheidungen).
* **Web UI (WP10):** Du kannst direkt sehen, welche Quellen genutzt wurden.
* **Interview Modus (WP07):** Du kannst Notizen direkt im Chat entwerfen lassen.
### 1.2 Der Vault als „Source of Truth“ ### 1.2 Der Vault als „Source of Truth“
Die Markdown-Dateien in deinem Vault sind die **einzige Quelle der Wahrheit**. Die Markdown-Dateien in deinem Vault sind die **einzige Quelle der Wahrheit**.
@@ -29,10 +46,10 @@ Jede Notiz benötigt einen YAML-Header (Frontmatter) am Dateianfang. Dieser Bloc
Jede Datei muss mindestens folgende Felder enthalten, um korrekt verarbeitet zu werden: Jede Datei muss mindestens folgende Felder enthalten, um korrekt verarbeitet zu werden:
--- ---
id: 20251110-projekt-alpha-8a9b2c # Eindeutige Kennung id: 20251110-projekt-alpha-8a9b2c # Eindeutige Kennung (YYYYMMDD-slug)
title: Projekt Alpha # Sprechender Titel (wird in Suchergebnissen angezeigt) title: Projekt Alpha # Sprechender Titel (wird in Suchergebnissen angezeigt)
type: project # Steuert Verarbeitung & Vernetzung (siehe Kap. 3) type: project # Steuert Verarbeitung & Vernetzung (siehe Kap. 3)
status: active # Status (z.B. draft, active, archived) status: active # active, archived oder 'draft' (für generierte Notes)
created: 2025-11-10 # Erstellungsdatum (ISO 8601 oder YYYY-MM-DD) created: 2025-11-10 # Erstellungsdatum (ISO 8601 oder YYYY-MM-DD)
updated: 2025-12-07 # Letzte Änderung updated: 2025-12-07 # Letzte Änderung
tags: [ki, entwicklung] # Taxonomie für Filterung tags: [ki, entwicklung] # Taxonomie für Filterung
@@ -45,7 +62,7 @@ Diese Felder sind technisch nicht zwingend, aber für bestimmte Typen sinnvoll:
aliases: [Alpha Projekt, Project A] # Synonyme für die Suche aliases: [Alpha Projekt, Project A] # Synonyme für die Suche
visibility: internal # internal (default), public, private 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). > **Hinweis:** Felder wie `retriever_weight` oder `chunk_profile` sollten **nicht** mehr manuell im Frontmatter gesetzt werden. Diese werden zentral über den `type` gesteuert (siehe Kap. 3), um die Wartbarkeit zu sichern.
### 2.3 Empfehlungen für IDs und Pfade ### 2.3 Empfehlungen für IDs und Pfade
@@ -63,23 +80,23 @@ Diese Felder sind technisch nicht zwingend, aber für bestimmte Typen sinnvoll:
## 3. Note-Typen & Typ-Registry ## 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`. Der `type` ist der wichtigste Hebel im Knowledge Design. Er steuert nicht nur das Gewicht bei der Suche, sondern seit WP-06 auch, **wann** eine Notiz aktiv in den Chat geholt wird ("Strategic Retrieval") und **welche Felder** im Interview abgefragt werden.
### 3.1 Übersicht der Kern-Typen ### 3.1 Übersicht der Kern-Typen
Mindnet unterscheidet verschiedene Wissensarten. Wähle den Typ, der die **Rolle** der Notiz am besten beschreibt: Mindnet unterscheidet verschiedene Wissensarten. Wähle den Typ, der die **Rolle** der Notiz am besten beschreibt:
| Typ | Beschreibung & Einsatzzweck | | Typ | Beschreibung & Einsatzzweck | Rolle im Chat (Intent) | Interview Schema (WP07) |
| :--- | :--- | | :--- | :--- | :--- | :--- |
| **`concept`** | Fachbegriffe, Theorien, Modelle. Zeitloses Wissen. (z. B. "Vektordatenbank") | | **`concept`** | Fachbegriffe, Theorien. Zeitloses Wissen. | **FACT** | Titel, Definition, Tags |
| **`project`** | Ein Vorhaben mit Ziel, Dauer und Aufgaben. (z. B. "Aufbau Homelab") | | **`project`** | Ein Vorhaben mit Ziel, Dauer und Aufgaben. | **FACT / DECISION** | Ziel, Status, Stakeholder, Steps |
| **`experience`** | Persönliche Erfahrung, Lektion oder Erkenntnis. (z. B. "Learning: Docker Networking") | | **`experience`** | Persönliche Erfahrung, Lektion oder Erkenntnis. | **EMPATHY** | Situation, Erkenntnis, Emotionen |
| **`decision`** | Eine bewusst getroffene Entscheidung inkl. Alternativen und Begründung. (z. B. "ADR-001: Nutzung von Qdrant") | | **`decision`** | Eine bewusst getroffene Entscheidung (ADR). | **DECISION** | Kontext, Entscheidung, Alternativen |
| **`value`** | Ein persönlicher Wert oder ein Prinzip. (z. B. "Datensparsamkeit") | | **`value`** | Ein persönlicher Wert oder ein Prinzip. | **DECISION** | Definition, Anti-Beispiel |
| **`person`** | Eine reale Person (Netzwerk, Autor). | | **`goal`** | Ein strategisches Ziel (kurz- oder langfristig). | **DECISION** | Zeitrahmen, KPIs, Werte |
| **`event`** | Ein Ereignis (Konferenz, Meeting). | | **`person`** | Eine reale Person (Netzwerk, Autor). | **FACT** | Rolle, Kontext |
| **`journal`** | Zeitbezogener Log-Eintrag, Daily Note. | | **`journal`** | Zeitbezogener Log-Eintrag, Daily Note. | **FACT** | Datum, Tags |
| **`source`** | Externe Quelle (Buch, PDF, Artikel), die exzerpiert wird. | | **`source`** | Externe Quelle (Buch, PDF, Artikel). | **FACT** | Autor, URL |
### 3.2 Zusammenspiel mit `types.yaml` ### 3.2 Zusammenspiel mit `types.yaml`
@@ -87,20 +104,19 @@ Der `type` steuert im Hintergrund drei technische Mechanismen:
1. **`retriever_weight` (Wichtigkeit):** 1. **`retriever_weight` (Wichtigkeit):**
* Ein `concept` (0.6) wiegt weniger als ein `project` (0.97) oder eine `decision` (1.0). * 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. * **Warum?** Bei einer Suche nach "Datenbank" soll Mindnet bevorzugt deine *Entscheidung* ("Warum wir X nutzen") anzeigen.
2. **`chunk_profile` (Textzerlegung):** 2. **`chunk_profile` (Textzerlegung):**
* `journal` (short): Wird fein zerlegt, da sich Themen schnell ändern. * `journal` (short): Wird fein zerlegt.
* `concept` (medium): Standard-Absätze. * `project` (long): Längere Kontext-Fenster.
* `project` (long): Längere Kontext-Fenster, um Zusammenhänge zu wahren.
3. **`edge_defaults` (Automatische Vernetzung):** 3. **`edge_defaults` (Automatische Vernetzung):**
* Mindnet ergänzt automatisch Kanten. * Mindnet ergänzt automatisch Kanten.
* Beispiel: Ein Link in einem `project` wird automatisch als `depends_on` (Abhängigkeit) interpretiert, sofern nicht anders angegeben. * Beispiel: Ein Link in einem `project` wird automatisch als `depends_on` (Abhängigkeit) interpretiert.
--- ---
## 4. Edges & Referenzen in Notes ## 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. Um aus isolierten Dateien ein **Netzwerk** zu machen, nutzen wir Verlinkungen. In Version 2.2 sind diese Verlinkungen die Basis für den **Hybrid Retriever** (Suche über Nachbarn).
### 4.1 Wikilinks (Die Basis-Referenz) ### 4.1 Wikilinks (Die Basis-Referenz)
Der klassische Obsidian-Link. Der klassische Obsidian-Link.
@@ -109,43 +125,95 @@ Der klassische Obsidian-Link.
* **Bedeutung:** "Diese Notiz erwähnt Qdrant." * **Bedeutung:** "Diese Notiz erwähnt Qdrant."
* **Edge-Typ:** `references` * **Edge-Typ:** `references`
* **Confidence:** 1.0
### 4.2 Inline-Relationen (Semantische Verknüpfung) ### 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?"). Dies ist die **mächtigste** Methode. Du sagst dem System explizit, **wie** Dinge zusammenhängen.
Daher [[rel:depends_on Qdrant]]. Daher [[rel:depends_on Qdrant]].
Dieses Konzept ist [[rel:similar_to Pinecone]]. Dieses Konzept ist [[rel:similar_to Pinecone]].
* **Syntax:** `[[rel:RELATION ZIEL]]`. (Wichtig: Das `rel:` Präfix steht *innerhalb* der Klammer). * **Syntax:** `[[rel:RELATION ZIEL]]`.
* **Gültige Relationen:** * **Gültige Relationen:**
* `depends_on`: Hängt ab von / Benötigt. * `depends_on`: Hängt ab von / Benötigt. (Trigger für hohe Graph-Relevanz).
* `similar_to`: Ähnelt / Ist vergleichbar mit. * `similar_to`: Ähnelt / Ist vergleichbar mit.
* `related_to`: Hat zu tun mit (allgemein). * `related_to`: Hat zu tun mit (allgemein).
* `caused_by`: Wurde verursacht durch. * `caused_by`: Wurde verursacht durch.
* `solves`: Löst (Problem). * `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) ### 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. Für Zusammenfassungen oder "Siehe auch"-Blöcke am Ende einer Notiz.
> [!edge] related_to: [[Vector Embeddings]] [[AI Agents]] > [!edge] related_to: [[Vector Embeddings]] [[AI Agents]]
* **Funktion:** Erzeugt `related_to`-Kanten zu allen genannten Zielen in dieser Zeile. * **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. Schreiben für den KI-Zwilling (New in v2.3)
### 5.1 Beispiel: Projekt-Notiz Damit der **RAG-Chat (WP05/06)** nicht nur dumm Fakten wiedergibt, sondern dich berät, musst du "Futter" für die Decision Engine und das Empathie-Modul liefern.
### 5.1 Futter für die Decision Engine (`DECISION`)
Das System soll abwägen: "Passt Tool X zu mir?". Dazu muss es wissen, was "Du" bist.
**Best Practice: Werte definieren**
Erstelle Notizen mit `type: value`.
---
type: value
title: Prinzip: Datensparsamkeit
---
# Prinzip: Datensparsamkeit
Wir speichern nur das Minimum an Daten. Cloud-Uploads persönlicher Daten sind verboten, es sei denn, sie sind E2E-verschlüsselt.
**Best Practice: Ziele definieren**
Erstelle Notizen mit `type: goal`.
---
type: goal
title: Ziel: Unabhängigkeit 2026
---
# Ziel: Unabhängigkeit 2026
Bis Ende 2026 wollen wir alle SaaS-Abos durch Self-Hosted Lösungen ersetzt haben.
*Effekt:* Wenn du fragst "Soll ich Notion nutzen?", lädt die Engine diese beiden Notizen und antwortet: *"Nein, Notion ist SaaS und nicht E2E-verschlüsselt. Das verletzt dein Prinzip der Datensparsamkeit und dein Ziel der Unabhängigkeit."*
### 5.2 Futter für den Empathie-Modus (`EMPATHY`)
Das System soll dich verstehen, wenn du sagst: "Alles ist grau." Dazu braucht es deine Resonanzerfahrungen.
**Best Practice: Erfahrungen & Bridging**
Erstelle Notizen mit `type: experience`. Nutze im Text **emotionale Brückenwörter**, damit der Retriever auch bei abstrakten Gefühlen ("grau") einen Treffer landet.
---
type: experience
title: Erfahrung: Der Durchbruch nach der Krise
tags: [krise, hoffnung, grau, angst]
---
# Erfahrung: Der Durchbruch nach der Krise
Es gibt Projektphasen, da wirkt alles **sinnlos** und **grau**.
Ich habe gelernt: Das ist oft das Zeichen kurz vor dem Durchbruch.
Mein Mantra in solchen Zeiten: "Einfach weitermachen, der Nebel lichtet sich."
*Effekt:* Wenn du im Chat jammerst ("Alles ist sinnlos"), findet das System diese Notiz und spiegelt dir deine eigene Erfahrung zurück.
### 5.3 Schreiben für den Chat (UI Optimization)
Da deine Notizen im Web-Interface (WP10) angezeigt werden:
* **Kurze Absätze:** Das LLM liest besser, und der Mensch scannt schneller.
* **Klare Headings:** Nutze H1/H2, um dem Chunker logische Trennlinien zu geben.
### 5.4 Der Interview-Modus (Auto-Drafting)
Seit v2.4 (WP07) kann Mindnet Notizen für dich entwerfen.
* **Wie:** Schreibe im Chat einfach: *"Ich möchte ein neues Projekt 'Alpha' anlegen, Ziel ist die Markteroberung."*
* **Was passiert:** Mindnet erkennt den Wunsch (`INTERVIEW`), wählt das Schema für `project` und generiert **sofort** einen Markdown-Entwurf.
* **Ergebnis:** Du erhältst einen Code-Block mit `status: draft`. Diesen kannst du im Draft-Editor (UI) direkt bearbeiten und herunterladen.
* **Drafts:** Enthalten oft Platzhalter `[TODO]`. Das ist Absicht. Ergänze sie im Editor.
---
## 6. Best Practices & Beispiele (Klassik)
### 6.1 Beispiel: Projekt-Notiz
Projekte profitieren von `depends_on`, um Abhängigkeiten zu klären. Projekte profitieren von `depends_on`, um Abhängigkeiten zu klären.
--- ---
@@ -165,7 +233,7 @@ Projekte profitieren von `depends_on`, um Abhängigkeiten zu klären.
## Architektur ## Architektur
Das Konzept basiert auf [[RAG Architecture]]. (Automatisch 'depends_on' durch Typ-Default). Das Konzept basiert auf [[RAG Architecture]]. (Automatisch 'depends_on' durch Typ-Default).
### 5.2 Beispiel: Entscheidung (Decision Record) ### 6.2 Beispiel: Entscheidung (Decision Record)
Entscheidungen sind hoch gewichtet (`retriever_weight: 1.0`). Entscheidungen sind hoch gewichtet (`retriever_weight: 1.0`).
--- ---
@@ -186,29 +254,17 @@ Entscheidungen sind hoch gewichtet (`retriever_weight: 1.0`).
## Begründung ## Begründung
Qdrant erlaubt lokalen Betrieb und [[rel:solves Payload Filtering Requirements]]. 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 ## 7. Langfristige Stabilität & Virtual Schema Layer
Mindnet ist auf Langlebigkeit ausgelegt. Mindnet ist auf Langlebigkeit ausgelegt.
### 6.1 Das "Virtual Schema" Prinzip ### 7.1 Das "Virtual Schema" Prinzip
Wir vermeiden es, Logik in den Markdown-Dateien hart zu kodieren. 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`. * 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`). * Wie groß ein Chunk für ein Essay ist, definieren wir in der Konfiguration (`types.yaml`).
### 6.2 Was bedeutet das für dich? ### 7.2 Was bedeutet das für dich?
* Du kannst dich auf den Inhalt konzentrieren. * 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. * Wenn wir in Zukunft (WP08) basierend auf Feedback lernen, dass "Projekte" noch wichtiger sind, ändern wir **eine Zeile** in der Konfiguration, und das gesamte System passt sich beim nächsten Import an.
* Deine Notizen bleiben sauber und zukunftssicher.
+100
View File
@@ -0,0 +1,100 @@
# Mindnet v2.4 – Overview & Einstieg
**Datei:** `docs/mindnet_overview_v2.4.md`
**Stand:** 2025-12-10
**Status:** **FINAL** (Inkl. Interview-Assistent & Web-Editor)
**Version:** 2.4.0
---
## 1. Einführung: Was ist Mindnet?
**Mindnet** ist ein persönliches, lokales KI-Gedächtnis. Es ist der Versuch, einen **Digitalen Zwilling** deines Wissens und deiner Persönlichkeit zu erschaffen.
Anders als herkömmliche Notiz-Apps (wie Obsidian oder Evernote), die Texte nur passiv speichern, ist Mindnet ein **aktives System**:
* Es **versteht** Zusammenhänge über einen Wissensgraphen.
* Es **begründet** Antworten ("Warum ist das so?").
* Es **antwortet** situativ angepasst: Mal als Strategieberater, mal als empathischer Spiegel, und neu: **als Interviewer, der hilft, Wissen zu erfassen.**
### Die Vision
> „Ein System, das nicht nur speichert, was ich weiß, sondern auch wie ich denke, fühle und arbeite.“
---
## 2. Die drei Ebenen des Systems
Mindnet arbeitet auf drei Schichten, die aufeinander aufbauen:
### Ebene 1: Content (Das Gedächtnis)
* **Quelle:** Dein lokaler Obsidian-Vault (Markdown).
* **Funktion:** Speicherung von Fakten, Projekten und Logs.
* **Technik:** Import-Pipeline, Chunking, Vektor-Datenbank (Qdrant).
* **Status:** 🟢 Live (WP01–WP03).
### Ebene 2: Semantik (Das Verstehen)
* **Funktion:** Verknüpfung von isolierten Notizen zu einem Netzwerk.
* **Logik:** "Projekt A *hängt ab von* Entscheidung B".
* **Technik:** Hybrider Retriever (Graph + Vektor), Explanation Engine.
* **Status:** 🟢 Live (WP04).
### Ebene 3: Identität & Interaktion (Die Persönlichkeit)
* **Funktion:** Interaktion, Bewertung und Co-Creation.
* **Logik:**
* "Ich empfehle Lösung X, weil sie unserem Wert 'Datensparsamkeit' entspricht."
* "Ich sehe, du willst ein Projekt starten. Lass uns die Eckdaten erfassen."
* **Technik:**
* **Intent Router:** Erkennt Absichten (Fakt vs. Gefühl vs. Entscheidung vs. Interview).
* **Strategic Retrieval:** Lädt gezielt Werte oder Erfahrungen nach.
* **One-Shot Extraction:** Generiert Entwürfe für neue Notizen.
* **Status:** 🟢 Live (WP05–WP07, WP10).
---
## 3. End-to-End Architektur
Der Datenfluss in Mindnet ist zyklisch ("Data Flywheel"):
1. **Input:** Du schreibst Notizen in Obsidian **ODER** lässt sie von Mindnet im Chat entwerfen.
2. **Ingest:** Ein Python-Skript importiert, zerlegt (Chunking) und vernetzt (Edges) die Daten in Qdrant.
3. **Intent Recognition:** Der Router analysiert deine Frage: Willst du Fakten, Code, Empathie oder etwas dokumentieren?
4. **Retrieval / Action:**
* Bei Fragen: Das System sucht Inhalte passend zum Intent.
* Bei Interviews: Das System wählt das passende Schema (z.B. Projekt-Vorlage).
5. **Generation:** Ein lokales LLM (Ollama) formuliert die Antwort oder den Markdown-Draft.
6. **Feedback:** Du bewertest die Antwort. Das System lernt (langfristig) daraus.
**Tech-Stack:**
* **Backend:** Python 3.10+, FastAPI.
* **Datenbank:** Qdrant (Vektor & Graph).
* **KI:** Ollama (Phi-3 Mini) – 100% lokal.
* **Frontend:** Streamlit Web-UI (v2.4).
---
## 4. Dokumentations-Wegweiser
Wo findest du was?
| Wenn du... | ...lies dieses Dokument |
| :--- | :--- |
| **...wissen willst, wie man Notizen schreibt.** | `mindnet_knowledge_design_manual_v2.4.md` |
| **...das System installieren oder betreiben musst.** | `mindnet_admin_guide_v2.4.md` |
| **...am Python-Code entwickeln willst.** | `mindnet_developer_guide_v2.4.md` |
| **...die Pipeline (Import -> RAG) verstehen willst.** | `mindnet_pipeline_playbook_v2.4.md` |
| **...die genaue JSON-Struktur oder APIs suchst.** | `mindnet_technical_architecture.md` |
| **...verstehen willst, was fachlich passiert.** | `mindnet_functional_architecture.md` |
| **...den aktuellen Projektstatus suchst.** | `mindnet_appendices_v2.4.md` |
---
## 5. Rollen im System
* **Mindmaster (User/Owner):** Du. Du erstellst Inhalte, stellst Fragen und gibst Feedback. Du definierst die Werte (`type: value`).
* **Mindnet (Der Agent):** Der digitale Zwilling. Er agiert als pragmatischer, transparenter Assistent und Analyst.
* **Administrator:** Verantwortlich für Docker-Container, Backups und LLM-Ressourcen.
---
## 6. Aktueller Fokus
Wir haben den **Interview-Assistenten (WP07)** und den **Draft-Editor (WP10a)** erfolgreich integriert.
Das System kann nun aktiv helfen, Wissen zu strukturieren, anstatt es nur abzurufen. Der Fokus verschiebt sich nun in Richtung **Self-Tuning (WP08)**, um aus dem gesammelten Feedback automatisch zu lernen.
+114 -57
View File
@@ -1,19 +1,19 @@
# Mindnet v2.2 – Admin Guide # Mindnet v2.4 – Admin Guide
**Datei:** `docs/mindnet_admin_guide_v2.2.md` **Datei:** `docs/mindnet_admin_guide_v2.4.md`
**Stand:** 2025-12-08 **Stand:** 2025-12-10
**Status:** **FINAL** (Konsolidiert WP02–WP04c) **Status:** **FINAL** (Inkl. Frontend Deployment & Interview Config)
**Quellen:** `Handbuch.md`, `mindnet_v2_implementation_playbook.md`, `mindnet_technical_architecture.md`, `Programmplan_V2.2.md`. **Quellen:** `Handbuch.md`, `mindnet_developer_guide_v2.4.md`.
> Dieses Handbuch richtet sich an **Administratoren**. Es beschreibt Installation, Konfiguration, Backup-Strategien, Monitoring und den sicheren Betrieb der Mindnet-Instanz. > Dieses Handbuch richtet sich an **Administratoren**. Es beschreibt Installation, Konfiguration, Backup-Strategien, Monitoring und den sicheren Betrieb der Mindnet-Instanz (API + UI + DB).
--- ---
## 1. Zielgruppe & Scope ## 1. Zielgruppe & Scope
Mindnet ist als **Single-Node System** konzipiert, das lokal (z.B. Laptop) oder auf einem privaten Server (Homelab, Intranet) läuft. Mindnet ist als **Multi-Service-Architektur** konzipiert, die lokal oder auf einem privaten Server läuft.
Wir unterscheiden strikt zwischen: Wir unterscheiden strikt zwischen:
* **Production (Port 8001):** Stabiler `main` Branch. * **Production:** Backend (8001) + Frontend (8501). Stabiler `main` Branch.
* **Development (Port 8002):** Experimentelle Feature-Branches. * **Development:** Backend (8002) + Frontend (8502). Experimentelle Feature-Branches.
--- ---
@@ -21,13 +21,14 @@ Wir unterscheiden strikt zwischen:
### 2.1 Systemvoraussetzungen ### 2.1 Systemvoraussetzungen
* **OS:** Linux (Ubuntu 22.04+ empfohlen) oder macOS. * **OS:** Linux (Ubuntu 22.04+ empfohlen) oder macOS.
* **Runtime:** Python 3.10+, Docker (für Qdrant). * **Runtime:** Python 3.10+, Docker (für Qdrant), Ollama (für LLM).
* **Hardware:** * **Hardware:**
* CPU: 2+ Cores. * CPU: 4+ Cores empfohlen (für Import & Inference).
* RAM: Min. 4GB (abhängig von der Vault-Größe und Qdrant-Index). * RAM: Min. 8GB empfohlen (4GB System + 4GB für Phi-3/Qdrant).
* Disk: SSD empfohlen für Qdrant-Performance. * Disk: SSD empfohlen für Qdrant-Performance.
### 2.2 Installation (Code) ### 2.2 Installation (Code)
# 1. Repository klonen # 1. Repository klonen
git clone <repo-url> /home/llmadmin/mindnet git clone <repo-url> /home/llmadmin/mindnet
cd /home/llmadmin/mindnet cd /home/llmadmin/mindnet
@@ -35,13 +36,16 @@ Wir unterscheiden strikt zwischen:
# 2. Umgebung einrichten # 2. Umgebung einrichten
python3 -m venv .venv python3 -m venv .venv
source .venv/bin/activate source .venv/bin/activate
# 3. Dependencies installieren (inkl. Streamlit)
pip install -r requirements.txt pip install -r requirements.txt
# 3. Verzeichnisse anlegen # 4. Verzeichnisse anlegen
mkdir -p logs qdrant_storage data/logs mkdir -p logs qdrant_storage data/logs
### 2.3 Qdrant Setup (Docker) ### 2.3 Qdrant Setup (Docker)
Wir nutzen Qdrant als Vektor-Datenbank. Persistenz ist wichtig. Wir nutzen Qdrant als Vektor-Datenbank. Persistenz ist wichtig.
docker run -d \ docker run -d \
--name mindnet_qdrant \ --name mindnet_qdrant \
--restart always \ --restart always \
@@ -49,36 +53,88 @@ Wir nutzen Qdrant als Vektor-Datenbank. Persistenz ist wichtig.
-v $(pwd)/qdrant_storage:/qdrant/storage \ -v $(pwd)/qdrant_storage:/qdrant/storage \
qdrant/qdrant qdrant/qdrant
### 2.4 Konfiguration (ENV) ### 2.4 Ollama Setup (LLM Service)
Erstelle eine `.env` Datei im Root-Verzeichnis. Diese Variablen steuern das Verhalten der Skripte und der API. Mindnet benötigt einen lokalen LLM-Server für den Chat.
# 1. Installieren (Linux Script)
curl -fsSL [https://ollama.com/install.sh](https://ollama.com/install.sh) | sh
# 2. Modell laden (Phi-3 Mini für CPU-Performance)
ollama pull phi3:mini
# 3. Testen
curl http://localhost:11434/api/generate -d '{"model": "phi3:mini", "prompt":"Hi"}'
### 2.5 Konfiguration (ENV)
Erstelle eine `.env` Datei im Root-Verzeichnis. Die neuen Settings für WP-06/WP-07 (Timeout, Decision Config) sind essenziell für stabilen Betrieb auf CPUs.
# Qdrant Verbindung # Qdrant Verbindung
QDRANT_URL="http://localhost:6333" QDRANT_URL="http://localhost:6333"
QDRANT_API_KEY="" # Leer lassen für lokale Instanzen ohne Auth
# Mindnet Core Settings # Mindnet Core Settings
COLLECTION_PREFIX="mindnet" # "mindnet_dev" für Dev-Umgebung COLLECTION_PREFIX="mindnet"
MINDNET_TYPES_FILE="./config/types.yaml" MINDNET_TYPES_FILE="./config/types.yaml"
MINDNET_RETRIEVER_CONFIG="./config/retriever.yaml"
# Embedding Settings (Default: all-MiniLM-L6-v2) # LLM / RAG Settings
VECTOR_DIM=384 MINDNET_LLM_MODEL="phi3:mini"
MINDNET_OLLAMA_URL="http://127.0.0.1:11434"
# Import-Strategie # Config & Timeouts
MINDNET_HASH_COMPARE="Body" MINDNET_PROMPTS_PATH="./config/prompts.yaml"
MINDNET_HASH_SOURCE="parsed" MINDNET_DECISION_CONFIG="./config/decision_engine.yaml"
MINDNET_LLM_TIMEOUT=300.0
### 2.5 Deployment via Systemd (Standard ab v2.2.1) ### 2.6 Deployment via Systemd (Backend & Frontend)
Mindnet wird nicht mehr manuell gestartet, sondern als Systemdienst.
**Production Service (`/etc/systemd/system/mindnet-prod.service`):** Mindnet benötigt zwei Services pro Umgebung: API (Uvicorn) und UI (Streamlit).
* Läuft auf Port 8001.
* Autostart (`enabled`).
* Restart Policy: `always` (heilt Abstürze automatisch).
**Development Service (`/etc/systemd/system/mindnet-dev.service`):** **Production Backend (`/etc/systemd/system/mindnet-prod.service`):**
* Läuft auf Port 8002.
* Getrennter Ordner (`~/mindnet_dev`). [Unit]
Description=Mindnet API Prod (8001)
After=network.target
[Service]
User=llmadmin
Group=llmadmin
WorkingDirectory=/home/llmadmin/mindnet
ExecStart=/home/llmadmin/mindnet/.venv/bin/uvicorn app.main:app --host 0.0.0.0 --port 8001 --env-file .env
Restart=always
RestartSec=5
[Install]
WantedBy=multi-user.target
**Production Frontend (`/etc/systemd/system/mindnet-ui-prod.service`):**
[Unit]
Description=Mindnet UI Prod (8501)
After=mindnet-prod.service
[Service]
User=llmadmin
Group=llmadmin
WorkingDirectory=/home/llmadmin/mindnet
# Environment Variables
Environment="MINDNET_API_URL=http://localhost:8001"
Environment="MINDNET_API_TIMEOUT=300"
Environment="STREAMLIT_SERVER_PORT=8501"
Environment="STREAMLIT_SERVER_ADDRESS=0.0.0.0"
Environment="STREAMLIT_SERVER_HEADLESS=true"
ExecStart=/home/llmadmin/mindnet/.venv/bin/streamlit run app/frontend/ui.py
Restart=always
RestartSec=5
[Install]
WantedBy=multi-user.target
**Firewall (UFW):**
Öffne die Ports für den Zugriff:
sudo ufw allow 8501/tcp # Prod UI
sudo ufw allow 8502/tcp # Dev UI (falls gewünscht)
--- ---
@@ -88,30 +144,22 @@ Mindnet wird nicht mehr manuell gestartet, sondern als Systemdienst.
Der Vault-Zustand sollte regelmäßig (z.B. stündlich per Cronjob) nach Qdrant synchronisiert werden. Der Vault-Zustand sollte regelmäßig (z.B. stündlich per Cronjob) nach Qdrant synchronisiert werden.
**Cronjob-Beispiel (stündlich):** **Cronjob-Beispiel (stündlich):**
0 * * * * cd /home/llmadmin/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 0 * * * * cd /home/llmadmin/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`: Entfernt Fragmente gelöschter Textstellen.
* `--sync-deletes`: Entfernt Notizen aus dem Index, die im Vault gelöscht wurden.
### 3.2 Health-Checks ### 3.2 Health-Checks
Prüfe regelmäßig, ob die API und der Retriever korrekt arbeiten. Prüfe regelmäßig, ob alle Komponenten laufen.
**System Status:**
sudo systemctl status mindnet-prod sudo systemctl status mindnet-prod
sudo systemctl status mindnet-ui-prod
**Logischer Smoke-Test:** sudo systemctl status ollama
python3 scripts/test_retriever_smoke.py --mode hybrid --url http://localhost:8001/query
### 3.3 Logs & Monitoring ### 3.3 Logs & Monitoring
Seit v2.2.1 werden technische Logs im Systemd Journal und fachliche Logs in JSONL-Dateien gespeichert. * **Backend Fehler:** `journalctl -u mindnet-prod -f`
* **Frontend Fehler:** `journalctl -u mindnet-ui-prod -f`
* **Technische Fehler (Live):** * Achte auf "Timeout"-Meldungen im Frontend, wenn das Backend zu langsam antwortet.
`journalctl -u mindnet-prod -f` * **LLM Fehler:** `journalctl -u ollama -f`
* **Fachliche Logs (Data Flywheel):** * **Fachliche Logs:** `data/logs/search_history.jsonl`
`/home/llmadmin/mindnet/data/logs/search_history.jsonl`
`/home/llmadmin/mindnet/data/logs/feedback.jsonl`
> **Hinweis:** Die JSONL-Logs wachsen endlos ("Append Only"). Richte bei Bedarf `logrotate` ein oder archiviere alte Logs. Lösche sie nicht, da sie die Basis für WP08 (Self-Tuning) sind.
--- ---
@@ -120,15 +168,22 @@ Seit v2.2.1 werden technische Logs im Systemd Journal und fachliche Logs in JSON
Wenn neue Versionen ausgerollt werden (Deployment): Wenn neue Versionen ausgerollt werden (Deployment):
1. **Code aktualisieren:** 1. **Code aktualisieren:**
cd /home/llmadmin/mindnet cd /home/llmadmin/mindnet
git pull origin main git pull origin main
2. **Dependencies prüfen:** 2. **Dependencies prüfen:**
source .venv/bin/activate source .venv/bin/activate
pip install -r requirements.txt pip install -r requirements.txt
3. **Dienst neustarten (Zwingend!):**
3. **Dienste neustarten (Zwingend!):**
sudo systemctl restart mindnet-prod sudo systemctl restart mindnet-prod
sudo systemctl restart mindnet-ui-prod
4. **Schema-Migration (falls nötig):** 4. **Schema-Migration (falls nötig):**
Bei Änderungen an `types.yaml` oder Index-Strukturen:
python3 -m scripts.import_markdown ... --apply python3 -m scripts.import_markdown ... --apply
--- ---
@@ -138,19 +193,21 @@ Wenn neue Versionen ausgerollt werden (Deployment):
Datensicherheit ruht auf drei Säulen: Vault (Source), Qdrant (Index), JSONL-Logs (Lern-Daten). Datensicherheit ruht auf drei Säulen: Vault (Source), Qdrant (Index), JSONL-Logs (Lern-Daten).
### 5.1 Vault-Backup (Priorität 1) ### 5.1 Vault-Backup (Priorität 1)
Der Markdown-Vault ist die **Single Source of Truth**. Er muss klassisch gesichert werden (Git/NAS). Der Markdown-Vault ist die **Single Source of Truth**.
### 5.2 Qdrant-Snapshots (Priorität 2) ### 5.2 Qdrant-Snapshots (Priorität 2)
Für schnelle Wiederherstellung des Suchindex. Für schnelle Wiederherstellung des Suchindex.
docker stop mindnet_qdrant docker stop mindnet_qdrant
tar -czf qdrant_backup_$(date +%F).tar.gz ./qdrant_storage tar -czf qdrant_backup_$(date +%F).tar.gz ./qdrant_storage
docker start mindnet_qdrant docker start mindnet_qdrant
### 5.3 Log-Daten (Priorität 3) ### 5.3 Log-Daten (Priorität 3)
Sichere den Ordner `data/logs/`. Verlust dieser Daten bedeutet, dass das System vergisst, welche Antworten Nutzer hilfreich fanden. Sichere den Ordner `data/logs/`. Verlust dieser Daten bedeutet Verlust des Trainingsmaterials für Self-Tuning.
### 5.4 Notfall-Wiederherstellung (Rebuild) ### 5.4 Notfall-Wiederherstellung (Rebuild)
Wenn die Datenbank korrupt ist: Wenn die Datenbank korrupt ist:
# 1. DB komplett leeren (Wipe) # 1. DB komplett leeren (Wipe)
python3 -m scripts.reset_qdrant --mode wipe --prefix "mindnet" --yes python3 -m scripts.reset_qdrant --mode wipe --prefix "mindnet" --yes
# 2. Alles neu importieren # 2. Alles neu importieren
@@ -162,9 +219,9 @@ Wenn die Datenbank korrupt ist:
### 6.1 Zugriffsschutz ### 6.1 Zugriffsschutz
Mindnet hat aktuell **keine integrierte Authentifizierung**. Mindnet hat aktuell **keine integrierte Authentifizierung**.
* **API:** Muss hinter einem Reverse Proxy (Nginx, Traefik) mit Basic Auth laufen, wenn sie im Netzwerk freigegeben wird. * **Frontend:** Streamlit auf Port 8501 ist offen. Nutze Nginx Basic Auth oder VPN.
* **Qdrant:** Sollte via Firewall (ufw) auf `127.0.0.1` beschränkt sein. * **API:** Sollte nicht direkt im öffentlichen Netz stehen.
* **Qdrant:** Auf `127.0.0.1` beschränken.
### 6.2 Typen-Governance ### 6.2 Typen-Governance
Änderungen an der `types.yaml` (z.B. neue Gewichte) wirken global. Änderungen an der `types.yaml` (z.B. neue Gewichte) wirken global und erfordern Tests.
* **Prozess:** Änderungen sollten getestet werden (Smoke-Test), bevor sie produktiv gehen.
+32 -19
View File
@@ -1,7 +1,7 @@
# Mindnet v2.2 – Appendices & Referenzen # Mindnet v2.4 – Appendices & Referenzen
**Datei:** `docs/mindnet_appendices_v2.2.md` **Datei:** `docs/mindnet_appendices_v2.4.md`
**Stand:** 2025-12-08 **Stand:** 2025-12-10
**Status:** **FINAL** **Status:** **FINAL** (Integrierter Stand WP01–WP10a)
**Quellen:** `TYPE_REGISTRY_MANUAL.md`, `chunking_strategy.md`, `mindnet_technical_architecture.md`, `Handbuch.md`. **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. > Dieses Dokument bündelt Tabellen, Schemata und technische Referenzen, die in den Prozess-Dokumenten (Playbook, Guides) den Lesefluss stören würden.
@@ -10,7 +10,7 @@
## Anhang A: Typ-Registry Referenz (Default-Werte) ## Anhang A: Typ-Registry Referenz (Default-Werte)
Diese Tabelle zeigt die Standard-Konfiguration der `types.yaml` (Stand v2.2). Diese Tabelle zeigt die Standard-Konfiguration der `types.yaml` (Stand v2.4).
| Typ (`type`) | Chunk Profile | Retriever Weight | Edge Defaults (Auto-Kanten) | Beschreibung | | Typ (`type`) | Chunk Profile | Retriever Weight | Edge Defaults (Auto-Kanten) | Beschreibung |
| :--- | :--- | :--- | :--- | :--- | | :--- | :--- | :--- | :--- | :--- |
@@ -22,6 +22,9 @@ Diese Tabelle zeigt die Standard-Konfiguration der `types.yaml` (Stand v2.2).
| **person** | `short` | 0.50 | `related_to` | Personen-Profile. | | **person** | `short` | 0.50 | `related_to` | Personen-Profile. |
| **source** | `long` | 0.50 | *(keine)* | Externe Quellen (Bücher, PDFs). | | **source** | `long` | 0.50 | *(keine)* | Externe Quellen (Bücher, PDFs). |
| **event** | `short` | 0.60 | `related_to` | Meetings, Konferenzen. | | **event** | `short` | 0.60 | `related_to` | Meetings, Konferenzen. |
| **value** | `medium` | 1.00 | `related_to` | Persönliche Werte/Prinzipien. |
| **goal** | `medium` | 0.95 | `depends_on` | Strategische Ziele. |
| **belief** | `medium` | 0.90 | `related_to` | Glaubenssätze. |
| **default** | `medium` | 1.00 | `references` | Fallback, wenn Typ unbekannt. | | **default** | `medium` | 1.00 | `references` | Fallback, wenn Typ unbekannt. |
--- ---
@@ -46,9 +49,10 @@ Referenz aller implementierten Kantenarten (`kind`).
## Anhang C: Datenmodelle (JSON Payloads) ## Anhang C: Datenmodelle (JSON Payloads)
Dies sind die Felder, die effektiv in Qdrant gespeichert werden. Diese sind die Felder, die effektiv in Qdrant gespeichert werden.
### C.1 Note Payload (`mindnet_notes`) ### C.1 Note Payload (`mindnet_notes`)
{ {
"note_id": "string (keyword)", // UUIDv5 oder Slug "note_id": "string (keyword)", // UUIDv5 oder Slug
"title": "string (text)", // Titel aus Frontmatter "title": "string (text)", // Titel aus Frontmatter
@@ -63,9 +67,11 @@ Dies sind die Felder, die effektiv in Qdrant gespeichert werden.
} }
### C.2 Chunk Payload (`mindnet_chunks`) ### C.2 Chunk Payload (`mindnet_chunks`)
{ {
"chunk_id": "string (keyword)", // Format: {note_id}#c{index} "chunk_id": "string (keyword)", // Format: {note_id}#c{index}
"note_id": "string (keyword)", // FK zur Note "note_id": "string (keyword)", // FK zur Note
"type": "string (keyword)", // Typ-Kopie aus Note
"text": "string (text)", // Reintext für Anzeige (ohne Overlap) "text": "string (text)", // Reintext für Anzeige (ohne Overlap)
"window": "string (text)", // Text + Overlap (für Embedding) "window": "string (text)", // Text + Overlap (für Embedding)
"ord": "integer", // Laufende Nummer (1..N) "ord": "integer", // Laufende Nummer (1..N)
@@ -75,15 +81,16 @@ Dies sind die Felder, die effektiv in Qdrant gespeichert werden.
} }
### C.3 Edge Payload (`mindnet_edges`) ### C.3 Edge Payload (`mindnet_edges`)
{ {
"edge_id": "string (keyword)", // Deterministischer Hash "edge_id": "string (keyword)", // Deterministischer Hash
"source_id": "string (keyword)", // Chunk-ID (Start) "source_id": "string (keyword)", // Chunk-ID (Start)
"target_id": "string (keyword)", // Chunk-ID oder Note-Titel (Ziel) "target_id": "string (keyword)", // Chunk-ID oder Note-Titel (Ziel)
"kind": "string (keyword)", // z.B. 'depends_on' "kind": "string (keyword)", // z.B. 'depends_on'
"scope": "string (keyword)", // Immer 'chunk' in v2.2 "scope": "string (keyword)", // Immer 'chunk'
"rule_id": "string (keyword)", // Traceability: 'inline:rel', 'explicit:wikilink' "rule_id": "string (keyword)", // Traceability: 'inline:rel', 'explicit:wikilink'
"confidence": "float", // 0.0 - 1.0 "confidence": "float", // 0.0 - 1.0
"note_id": "string (keyword)" // Owner Note ID (für Löschung) "note_id": "string (keyword)" // Owner Note ID
} }
--- ---
@@ -99,6 +106,12 @@ Diese Variablen steuern das Verhalten der Skripte und Container.
| `COLLECTION_PREFIX` | `mindnet` | Namensraum für Collections (`{prefix}_notes` etc). | | `COLLECTION_PREFIX` | `mindnet` | Namensraum für Collections (`{prefix}_notes` etc). |
| `MINDNET_TYPES_FILE` | `config/types.yaml` | Pfad zur Typ-Registry. | | `MINDNET_TYPES_FILE` | `config/types.yaml` | Pfad zur Typ-Registry. |
| `MINDNET_RETRIEVER_CONFIG`| `config/retriever.yaml`| Pfad zur Scoring-Konfiguration. | | `MINDNET_RETRIEVER_CONFIG`| `config/retriever.yaml`| Pfad zur Scoring-Konfiguration. |
| `MINDNET_PROMPTS_PATH` | `config/prompts.yaml` | Pfad zu LLM-Prompts (Neu in v2.2). |
| `MINDNET_DECISION_CONFIG` | `config/decision_engine.yaml` | Router & Interview Config (Neu in v2.3). |
| `MINDNET_LLM_MODEL` | `phi3:mini` | Name des Ollama-Modells (Neu in v2.2). |
| `MINDNET_OLLAMA_URL` | `http://127.0.0.1:11434`| URL zum LLM-Server (Neu in v2.2). |
| `MINDNET_LLM_TIMEOUT` | `300.0` | Timeout für Ollama (Erhöht für CPU-Inference). |
| `MINDNET_API_TIMEOUT` | `300.0` | Frontend Timeout (Streamlit). |
| `MINDNET_HASH_COMPARE` | `Body` | Vergleichsmodus für Import (`Body`, `Frontmatter`, `Full`). | | `MINDNET_HASH_COMPARE` | `Body` | Vergleichsmodus für Import (`Body`, `Frontmatter`, `Full`). |
| `MINDNET_HASH_SOURCE` | `parsed` | Quelle für Hash (`parsed`, `raw`, `file`). | | `MINDNET_HASH_SOURCE` | `parsed` | Quelle für Hash (`parsed`, `raw`, `file`). |
| `VECTOR_DIM` | `384` | Dimension der Embeddings (Modellabhängig). | | `VECTOR_DIM` | `384` | Dimension der Embeddings (Modellabhängig). |
@@ -107,19 +120,16 @@ Diese Variablen steuern das Verhalten der Skripte und Container.
## Anhang E: Glossar ## Anhang E: Glossar
* **Callout-Edge:** Kante via `> [!edge]`. * **Decision Engine:** Komponente, die den Intent prüft und Strategien wählt (WP06).
* **Chunking:** Zerlegung von Notizen in kleinere Einheiten. * **Draft Editor:** Web-Komponente zur Bearbeitung generierter Notizen (WP10a).
* **Confidence:** Vertrauenswürdigkeit einer Kante (0.0-1.0).
* **Explanation Layer:** Komponente, die Scores und Graphen als Begründung liefert. * **Explanation Layer:** Komponente, die Scores und Graphen als Begründung liefert.
* **Feedback Loop:** Prozess des Loggens und Auswertens von User-Reaktionen. * **Hybrid Router:** Kombination aus Keyword-Matching und LLM-Klassifizierung für Intents.
* **Idempotenz:** Mehrfache Ausführung liefert gleiches Ergebnis. * **One-Shot Extractor:** LLM-Strategie zur sofortigen Generierung von Drafts ohne Rückfragen (WP07).
* **Inline-Edge:** Kante via `[[rel:type Ziel]]`. * **RAG (Retrieval Augmented Generation):** Kombination aus Suche und Text-Generierung.
* **Retriever:** Suchmaschine (FastAPI).
* **Vault:** Ordner mit Markdown-Dateien.
--- ---
## Anhang F: Workpackage Status (v2.2.1) ## Anhang F: Workpackage Status (v2.4.0)
Aktueller Implementierungsstand der Module. Aktueller Implementierungsstand der Module.
@@ -131,6 +141,9 @@ Aktueller Implementierungsstand der Module.
| **WP04a**| Retriever Scoring | 🟢 Live | Hybrider Score (Semantik + Graph). | | **WP04a**| Retriever Scoring | 🟢 Live | Hybrider Score (Semantik + Graph). |
| **WP04b**| Explanation Layer | 🟢 Live | API liefert Reasons & Breakdown. | | **WP04b**| Explanation Layer | 🟢 Live | API liefert Reasons & Breakdown. |
| **WP04c**| Feedback Loop | 🟢 Live | Logging (JSONL) & Traceability aktiv. | | **WP04c**| Feedback Loop | 🟢 Live | Logging (JSONL) & Traceability aktiv. |
| **WP05** | Persönlichkeit / Chat | 🟡 Geplant | Nächster Schritt (RAG). | | **WP05** | Persönlichkeit / Chat | 🟢 Live | RAG-Integration mit Context Enrichment. |
| **WP06** | Self-Healing | 🔴 Geplant | Auto-Fixing von Broken Links. | | **WP06** | Decision Engine | 🟢 Live | Intent-Router & Strategic Retrieval. |
| **WP07** | Interview Assistent | 🟢 Live | **One-Shot Extractor & Schemas aktiv.** |
| **WP08** | Self-Tuning | 🔴 Geplant | Auto-Adjustment der Gewichte. | | **WP08** | Self-Tuning | 🔴 Geplant | Auto-Adjustment der Gewichte. |
| **WP10** | Chat Interface | 🟢 Live | Web-Interface (Streamlit). |
| **WP10a**| Draft Editor | 🟢 Live | **Interaktives UI für WP07 Drafts.** |
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
+255
View File
@@ -0,0 +1,255 @@
# mindnet v2.2 – Knowledge Design Manual
**Datei:** `docs/mindnet_knowledge_design_manual_v2.2.md`
**Stand:** 2025-12-09
**Status:** **FINAL** (Integrierter Stand WP01–WP06)
**Quellen:** `knowledge_design.md`, `TYPE_REGISTRY_MANUAL.md`, `chunking_strategy.md`, `mindnet_functional_architecture.md`.
---
## ⚡ Die 5 Goldenen Regeln (TL;DR)
Damit Mindnet als dein Digitaler Zwilling funktioniert, beachte beim Schreiben diese Grundsätze:
1. **Atomare Gedanken:** Eine Notiz = Ein Thema. Wenn du über zwei Projekte schreibst, mach zwei Notizen draus.
2. **Explizite Typen:** Setze immer den `type` im Frontmatter. Mindnet behandelt eine `decision` ("Wir machen X") völlig anders als ein `concept` ("Was ist X").
3. **Semantische Links:** Schreibe nicht nur `[[Link]]`, sondern `[[rel:depends_on Link]]`. Sag dem System *wie* Dinge zusammenhängen.
4. **Werte & Ziele definieren:** Damit die **Decision Engine** dich beraten kann, musst du deine Kriterien (`type: value`, `type: goal`) explizit als Notizen anlegen.
5. **Emotionales Bridging:** Damit die **Empathie** funktioniert, nutze in Erfahrungsberichten (`type: experience`) emotionale Schlüsselwörter ("Krise", "Freude", "Angst"), damit der Vektor-Retriever sie bei Gefühls-Anfragen findet.
---
## 1. Zweck & Scope
Dieses Handbuch ist die **primäre Arbeitsanweisung** für dich als Mindmaster (Owner) und alle Autoren, die Inhalte im mindnet-Vault erstellen.
### 1.1 Zielsetzung
Mindnet ist mehr als eine Dokumentablage. Es ist ein vernetztes System, das deine Persönlichkeit, Entscheidungen und Erfahrungen abbildet.
Seit Version 2.3.1 verfügt Mindnet über:
* **Hybrid Router:** Das System erkennt, ob du Fakten, Entscheidungen oder Empathie brauchst.
* **Context Intelligence:** Das System lädt je nach Situation unterschiedliche Notiz-Typen (z.B. Werte bei Entscheidungen).
### 1.2 Der Vault als „Source of Truth“
Die Markdown-Dateien in deinem Vault sind die **einzige Quelle der Wahrheit**.
* Mindnet importiert diesen Zustand deterministisch in die Datenbank (Qdrant).
* Änderungen an IDs, Typen oder Inhalten müssen **immer** im Markdown erfolgen, niemals direkt in der Datenbank.
* Was nicht im Markdown steht (z. B. implizites Wissen im Kopf), existiert für das System nicht.
---
## 2. Note-Struktur & Frontmatter
Jede Notiz benötigt einen YAML-Header (Frontmatter) am Dateianfang. Dieser Block macht die Notiz maschinenlesbar.
### 2.1 Pflichtfelder
Jede Datei muss mindestens folgende Felder enthalten, um korrekt verarbeitet zu werden:
---
id: 20251110-projekt-alpha-8a9b2c # Eindeutige Kennung (YYYYMMDD-slug)
title: Projekt Alpha # Sprechender Titel (wird in Suchergebnissen angezeigt)
type: project # Steuert Verarbeitung & Vernetzung (siehe Kap. 3)
status: active # Status (z.B. draft, active, archived)
created: 2025-11-10 # Erstellungsdatum (ISO 8601 oder YYYY-MM-DD)
updated: 2025-12-07 # Letzte Änderung
tags: [ki, entwicklung] # Taxonomie für Filterung
---
### 2.2 Optionale Felder
Diese Felder sind technisch nicht zwingend, aber für bestimmte Typen sinnvoll:
lang: de # Sprache (Default: de)
aliases: [Alpha Projekt, Project A] # Synonyme für die Suche
visibility: internal # internal (default), public, private
> **Hinweis:** Felder wie `retriever_weight` oder `chunk_profile` sollten **nicht** mehr manuell im Frontmatter gesetzt werden. Diese werden zentral über den `type` gesteuert (siehe Kap. 3), um die Wartbarkeit zu sichern.
### 2.3 Empfehlungen für IDs und Pfade
**Die ID (Identifikator):**
* Muss global eindeutig und **stabil** sein.
* Darf sich nicht ändern, wenn die Datei umbenannt oder verschoben wird.
* **Empfehlung:** `YYYYMMDD-slug-hash` (z. B. `20231027-vektor-db-a1b2`). Dies garantiert Eindeutigkeit und Chronologie.
**Dateinamen & Pfade:**
* Pfade dienen der menschlichen Ordnung (Ordnerstruktur), sind für Mindnet aber sekundär.
* Dateinamen sollten dem Titel entsprechen (`Projekt Alpha.md`) oder dem Slug (`projekt-alpha.md`).
* Sonderzeichen vermeiden (außer Bindestrich und Unterstrich).
---
## 3. Note-Typen & Typ-Registry
Der `type` ist der wichtigste Hebel im Knowledge Design. Er steuert nicht nur das Gewicht bei der Suche, sondern seit WP-06 auch, **wann** eine Notiz aktiv in den Chat geholt wird ("Strategic Retrieval").
### 3.1 Übersicht der Kern-Typen
Mindnet unterscheidet verschiedene Wissensarten. Wähle den Typ, der die **Rolle** der Notiz am besten beschreibt:
| Typ | Beschreibung & Einsatzzweck | Rolle im Chat (Intent) |
| :--- | :--- | :--- |
| **`concept`** | Fachbegriffe, Theorien. Zeitloses Wissen. | **FACT** (Basiswissen) |
| **`project`** | Ein Vorhaben mit Ziel, Dauer und Aufgaben. | **FACT / DECISION** (Kontext) |
| **`experience`** | Persönliche Erfahrung, Lektion oder Erkenntnis. | **EMPATHY** (Spiegelung) |
| **`decision`** | Eine bewusst getroffene Entscheidung (ADR). | **DECISION** (Begründung "Warum") |
| **`value`** | Ein persönlicher Wert oder ein Prinzip. | **DECISION** (Moralischer Kompass) |
| **`goal`** | Ein strategisches Ziel (kurz- oder langfristig). | **DECISION** (Abgleich) |
| **`person`** | Eine reale Person (Netzwerk, Autor). | **FACT** |
| **`journal`** | Zeitbezogener Log-Eintrag, Daily Note. | **FACT** (Historie) |
| **`source`** | Externe Quelle (Buch, PDF, Artikel). | **FACT** (Faktenbasis) |
### 3.2 Zusammenspiel mit `types.yaml`
Der `type` steuert im Hintergrund drei technische Mechanismen:
1. **`retriever_weight` (Wichtigkeit):**
* Ein `concept` (0.6) wiegt weniger als ein `project` (0.97) oder eine `decision` (1.0).
* **Warum?** Bei einer Suche nach "Datenbank" soll Mindnet bevorzugt deine *Entscheidung* ("Warum wir X nutzen") anzeigen.
2. **`chunk_profile` (Textzerlegung):**
* `journal` (short): Wird fein zerlegt.
* `project` (long): Längere Kontext-Fenster.
3. **`edge_defaults` (Automatische Vernetzung):**
* Mindnet ergänzt automatisch Kanten.
* Beispiel: Ein Link in einem `project` wird automatisch als `depends_on` (Abhängigkeit) interpretiert.
---
## 4. Edges & Referenzen in Notes
Um aus isolierten Dateien ein **Netzwerk** zu machen, nutzen wir Verlinkungen. In Version 2.2 sind diese Verlinkungen die Basis für den **Hybrid Retriever** (Suche über Nachbarn).
### 4.1 Wikilinks (Die Basis-Referenz)
Der klassische Obsidian-Link.
Wir nutzen [[Qdrant]] als Vektordatenbank.
* **Bedeutung:** "Diese Notiz erwähnt Qdrant."
* **Edge-Typ:** `references`
### 4.2 Inline-Relationen (Semantische Verknüpfung)
Dies ist die **mächtigste** Methode. Du sagst dem System explizit, **wie** Dinge zusammenhängen.
Daher [[rel:depends_on Qdrant]].
Dieses Konzept ist [[rel:similar_to Pinecone]].
* **Syntax:** `[[rel:RELATION ZIEL]]`.
* **Gültige Relationen:**
* `depends_on`: Hängt ab von / Benötigt. (Trigger für hohe Graph-Relevanz).
* `similar_to`: Ähnelt / Ist vergleichbar mit.
* `related_to`: Hat zu tun mit (allgemein).
* `caused_by`: Wurde verursacht durch.
* `solves`: Löst (Problem).
### 4.3 Callout-Edges (Kuratierte Listen)
Für Zusammenfassungen oder "Siehe auch"-Blöcke am Ende einer Notiz.
> [!edge] related_to: [[Vector Embeddings]] [[AI Agents]]
* **Funktion:** Erzeugt `related_to`-Kanten zu allen genannten Zielen in dieser Zeile.
---
## 5. Schreiben für den KI-Zwilling (New in v2.3)
Damit der **RAG-Chat (WP05/06)** nicht nur dumm Fakten wiedergibt, sondern dich berät, musst du "Futter" für die Decision Engine und das Empathie-Modul liefern.
### 5.1 Futter für die Decision Engine (`DECISION`)
Das System soll abwägen: "Passt Tool X zu mir?". Dazu muss es wissen, was "Du" bist.
**Best Practice: Werte definieren**
Erstelle Notizen mit `type: value`.
---
type: value
title: Prinzip: Datensparsamkeit
---
# Prinzip: Datensparsamkeit
Wir speichern nur das Minimum an Daten. Cloud-Uploads persönlicher Daten sind verboten, es sei denn, sie sind E2E-verschlüsselt.
**Best Practice: Ziele definieren**
Erstelle Notizen mit `type: goal`.
---
type: goal
title: Ziel: Unabhängigkeit 2026
---
# Ziel: Unabhängigkeit 2026
Bis Ende 2026 wollen wir alle SaaS-Abos durch Self-Hosted Lösungen ersetzt haben.
*Effekt:* Wenn du fragst "Soll ich Notion nutzen?", lädt die Engine diese beiden Notizen und antwortet: *"Nein, Notion ist SaaS und nicht E2E-verschlüsselt. Das verletzt dein Prinzip der Datensparsamkeit und dein Ziel der Unabhängigkeit."*
### 5.2 Futter für den Empathie-Modus (`EMPATHY`)
Das System soll dich verstehen, wenn du sagst: "Alles ist grau." Dazu braucht es deine Resonanzerfahrungen.
**Best Practice: Erfahrungen & Bridging**
Erstelle Notizen mit `type: experience`. Nutze im Text **emotionale Brückenwörter**, damit der Retriever auch bei abstrakten Gefühlen ("grau") einen Treffer landet.
---
type: experience
title: Erfahrung: Der Durchbruch nach der Krise
tags: [krise, hoffnung, grau, angst]
---
# Erfahrung: Der Durchbruch nach der Krise
Es gibt Projektphasen, da wirkt alles **sinnlos** und **grau**.
Ich habe gelernt: Das ist oft das Zeichen kurz vor dem Durchbruch.
Mein Mantra in solchen Zeiten: "Einfach weitermachen, der Nebel lichtet sich."
*Effekt:* Wenn du im Chat jammerst ("Alles ist sinnlos"), findet das System diese Notiz und spiegelt dir deine eigene Erfahrung zurück.
---
## 6. Best Practices & Beispiele (Klassik)
### 6.1 Beispiel: Projekt-Notiz
Projekte profitieren von `depends_on`, um Abhängigkeiten zu klären.
---
id: 20251115-proj-mindnet
title: Mindnet Implementierung
type: project
status: active
---
# Mindnet Implementierung
Wir bauen ein persönliches Wissensnetz.
## Tech Stack
Wir nutzen [[rel:depends_on Qdrant]] für die Vektorsuche und [[rel:depends_on FastAPI]] für das Backend.
## Architektur
Das Konzept basiert auf [[RAG Architecture]]. (Automatisch 'depends_on' durch Typ-Default).
### 6.2 Beispiel: Entscheidung (Decision Record)
Entscheidungen sind hoch gewichtet (`retriever_weight: 1.0`).
---
id: 20251120-adr-vektordb
title: ADR: Wahl von Qdrant
type: decision
status: final
tags: [architektur, db]
---
# Entscheidung: Qdrant
Wir haben uns für Qdrant entschieden.
## Alternativen
Wir haben auch [[rel:similar_to Pinecone]] und [[rel:similar_to Weaviate]] betrachtet.
## Begründung
Qdrant erlaubt lokalen Betrieb und [[rel:solves Payload Filtering Requirements]].
---
## 7. Langfristige Stabilität & Virtual Schema Layer
Mindnet ist auf Langlebigkeit ausgelegt.
### 7.1 Das "Virtual Schema" Prinzip
Wir vermeiden es, Logik in den Markdown-Dateien hart zu kodieren.
* Statt in jeder Notiz zu schreiben `chunk_size: 500`, schreiben wir nur `type: essay`.
* Wie groß ein Chunk für ein Essay ist, definieren wir in der Konfiguration (`types.yaml`).
### 7.2 Was bedeutet das für dich?
* Du kannst dich auf den Inhalt konzentrieren.
* Wenn wir in Zukunft (WP08) basierend auf Feedback lernen, dass "Projekte" noch wichtiger sind, ändern wir **eine Zeile** in der Konfiguration, und das gesamte System passt sich beim nächsten Import an.
File renamed without changes.
+91 -38
View File
@@ -1,6 +1,6 @@
# Mindnet v2.2 – Entwickler-Workflow # Mindnet v2.4 – Entwickler-Workflow
**Datei:** `DEV_WORKFLOW.md` **Datei:** `docs/DEV_WORKFLOW.md`
**Stand:** 2025-12-07 (Aktualisiert: Sync-First Strategie) **Stand:** 2025-12-10 (Aktualisiert: Inkl. Interview-Tests WP07)
Dieses Handbuch beschreibt den Entwicklungszyklus zwischen **Windows PC** (IDE), **Raspberry Pi** (Gitea) und **Beelink** (Runtime/Server). Dieses Handbuch beschreibt den Entwicklungszyklus zwischen **Windows PC** (IDE), **Raspberry Pi** (Gitea) und **Beelink** (Runtime/Server).
@@ -10,9 +10,13 @@ Dieses Handbuch beschreibt den Entwicklungszyklus zwischen **Windows PC** (IDE),
* **Windows 11 (VS Code):** Hier schreibst du Code. **Nie** direkt auf `main` arbeiten! * **Windows 11 (VS Code):** Hier schreibst du Code. **Nie** direkt auf `main` arbeiten!
* **Raspberry Pi (Gitea):** Der Tresor. Speichert den Code und verwaltet Versionen. * **Raspberry Pi (Gitea):** Der Tresor. Speichert den Code und verwaltet Versionen.
* **Beelink (Runtime):** Hier läuft die Software. Wir trennen strikt: * **Beelink (Runtime):** Hier läuft die Software. Wir nutzen **Systemd-Services**:
* **PROD (`~/mindnet`):** Läuft stabil auf `main`. **Port 8001**. * **PROD:**
* **DEV (`~/mindnet_dev`):** Deine Spielwiese für Branches. **Port 8002**. * API: `mindnet-prod` (Port 8001). Ordner: `~/mindnet`.
* UI: `mindnet-ui-prod` (Port 8501).
* **DEV:**
* API: `mindnet-dev` (Port 8002). Ordner: `~/mindnet_dev`.
* UI: `mindnet-ui-dev` (Port 8502).
--- ---
@@ -31,14 +35,14 @@ Hier erstellst du die neue Funktion in einer sicheren Umgebung.
2. **Branch erstellen:** 2. **Branch erstellen:**
* Klicke wieder unten links auf `main`. * Klicke wieder unten links auf `main`.
* Wähle `+ Create new branch...`. * Wähle `+ Create new branch...`.
* Gib den Namen ein: `feature/was-ich-tue` (z.B. `feature/wp04b-explanation`). * Gib den Namen ein: `feature/was-ich-tue` (z.B. `feature/wp07-interview`).
* Drücke **Enter**. * Drücke **Enter**.
3. **Sicherheits-Check:** 3. **Sicherheits-Check:**
* Steht unten links jetzt dein Feature-Branch? **Nur dann darfst du Code ändern!** * Steht unten links jetzt dein Feature-Branch? **Nur dann darfst du Code ändern!**
4. **Coden:** 4. **Coden:**
* Nimm deine Änderungen vor. * Nimm deine Änderungen vor (z.B. neue Schemas in `decision_engine.yaml`).
5. **Sichern & Hochladen:** 5. **Sichern & Hochladen:**
* **Source Control** Icon (Gabel-Symbol) -> Nachricht eingeben -> **Commit**. * **Source Control** Icon (Gabel-Symbol) -> Nachricht eingeben -> **Commit**.
@@ -60,38 +64,73 @@ Hier prüfst du, ob dein neuer Code auf dem echten Server läuft.
```bash ```bash
git fetch git fetch
# Tipp: 'git branch -r' zeigt alle verfügbaren Branches an # Tipp: 'git branch -r' zeigt alle verfügbaren Branches an
git checkout feature/wp04b-explanation git checkout feature/wp07-interview
git pull git pull
``` ```
4. **Umgebung vorbereiten:** 4. **Umgebung vorbereiten (bei Bedarf):**
```bash ```bash
source .venv/bin/activate source .venv/bin/activate
pip install -r requirements.txt # Nur nötig bei neuen Paketen pip install -r requirements.txt # Nur nötig bei neuen Paketen
``` ```
5. **Test-Server neustarten (WICHTIG):** 5. **Test-Server aktualisieren (WICHTIG):**
Falls noch ein alter Prozess läuft, musst du ihn beenden. Der Code ist da, aber die Prozesse im RAM sind noch alt. Wir müssen die Services neustarten.
* Drücke `Strg + C` falls der Server noch im Vordergrund läuft.
* Oder nutze `pkill -f "uvicorn app.main:app"`.
Starten auf **Port 8002**: **Option A: Standard (Als Service laufen lassen)**
Ideal, wenn du nur testen willst, ob es läuft.
```bash ```bash
uvicorn app.main:app --host 0.0.0.0 --port 8002 --env-file .env # 1. API neustarten (Backend)
sudo systemctl restart mindnet-dev
# 2. UI neustarten (Frontend)
sudo systemctl restart mindnet-ui-dev
# Logs prüfen (um Fehler zu sehen):
journalctl -u mindnet-dev -f
# Oder Frontend Logs:
journalctl -u mindnet-ui-dev -f
``` ```
6. **Validieren:** **Option B: Manuell Debuggen (Direct Output)**
Führe deine Tests in einem **zweiten Terminal** aus: Ideal, wenn du Print-Ausgaben direkt sehen willst oder der Service dauernd crasht.
```bash ```bash
# Beispiel für Smoke-Test gegen Dev-Port # 1. Services stoppen (wichtig, sonst sind Ports 8002/8502 belegt!)
python3 tests/test_explanation_smoke.py --url http://localhost:8002/query sudo systemctl stop mindnet-dev
sudo systemctl stop mindnet-ui-dev
# 2. Manuell starten (z.B. API)
uvicorn app.main:app --host 0.0.0.0 --port 8002 --env-file .env
# ... Testen ...
# 3. Wenn fertig: Services wieder anschalten (Optional)
# Strg+C drücken
sudo systemctl start mindnet-dev
sudo systemctl start mindnet-ui-dev
```
6. **Validieren (Smoke Tests):**
* **Browser:** Öffne `http://<IP>:8502` um die UI zu testen (Intent Badge prüfen!).
* **CLI:** Führe Testskripte in einem **zweiten Terminal** aus:
**Test A: Decision Engine**
```bash
python tests/test_wp06_decision.py -p 8002 -q "Soll ich Qdrant nutzen?"
# Erwartung: Intent DECISION
```
**Test B: Interview Modus (Neu!)**
```bash
python tests/test_wp06_decision.py -p 8002 -q "Ich will ein neues Projekt starten"
# Erwartung: Intent INTERVIEW, Output ist Markdown Codeblock
``` ```
--- ---
### Phase 3: Release (Gitea / Raspberry Pi) ### Phase 3: Release (Gitea / Raspberry Pi)
Wenn der Test auf Port 8002 erfolgreich war: Wenn der Test auf Port 8002 / 8502 erfolgreich war:
1. Öffne Gitea im Browser. 1. Öffne Gitea im Browser.
2. Erstelle einen **Pull Request** (Dein Branch -> `main`). 2. Erstelle einen **Pull Request** (Dein Branch -> `main`).
@@ -101,7 +140,7 @@ Wenn der Test auf Port 8002 erfolgreich war:
### Phase 4: Deployment (Beelink / `mindnet`) ### Phase 4: Deployment (Beelink / `mindnet`)
Jetzt bringen wir die Änderung in das Live-System (Port 8001). Jetzt bringen wir die Änderung in das Live-System (Port 8001 / 8501).
1. **Deploy-Agent (Automatisch):** 1. **Deploy-Agent (Automatisch):**
Wenn dein `deploy.yml` aktiv ist, passiert das jetzt von selbst! Wenn dein `deploy.yml` aktiv ist, passiert das jetzt von selbst!
@@ -110,7 +149,17 @@ Jetzt bringen wir die Änderung in das Live-System (Port 8001).
```bash ```bash
cd /home/llmadmin/mindnet cd /home/llmadmin/mindnet
git pull origin main git pull origin main
sudo systemctl restart mindnet-api
# Dependencies updaten
source .venv/bin/activate
pip install -r requirements.txt
# Produktions-Services neustarten
sudo systemctl restart mindnet-prod
sudo systemctl restart mindnet-ui-prod
# Kurz prüfen, ob er läuft
sudo systemctl status mindnet-prod
``` ```
--- ---
@@ -125,11 +174,11 @@ Damit das Chaos nicht wächst, löschen wir den fertigen Branch.
cd ~/mindnet_dev cd ~/mindnet_dev
git checkout main git checkout main
git pull git pull
git branch -d feature/wp04b-explanation git branch -d feature/wp07-interview
``` ```
3. **VS Code:** 3. **VS Code:**
* Auf `main` wechseln. * Auf `main` wechseln.
* Sync drücken (um Löschung vom Server zu erfahren). * Sync drücken.
* `F1` -> `Git: Delete Branch` -> Branch auswählen. * `F1` -> `Git: Delete Branch` -> Branch auswählen.
--- ---
@@ -139,22 +188,26 @@ Damit das Chaos nicht wächst, löschen wir den fertigen Branch.
| Wo? | Befehl | Was tut es? | | Wo? | Befehl | Was tut es? |
| :--- | :--- | :--- | | :--- | :--- | :--- |
| **VS Code** | `Sync (auf main)` | **WICHTIG:** Holt neuesten Code vom Server. | | **VS Code** | `Sync (auf main)` | **WICHTIG:** Holt neuesten Code vom Server. |
| **VS Code** | `Klick auf Branch` | Branch erstellen oder wechseln. | | **Beelink** | `git fetch` | Aktualisiert Liste der Remote-Branches. |
| **Beelink** | `source .venv/bin/activate` | **Aktiviert Python-Umgebung.** | | **Beelink** | `sudo systemctl restart mindnet-dev` | **Neustart Dev-Backend (Port 8002).** |
| **Beelink** | `git fetch` | Aktualisiert Remote-Branches. | | **Beelink** | `sudo systemctl restart mindnet-ui-dev` | **Neustart Dev-Frontend (Port 8502).** |
| **Beelink** | `git checkout <name>` | Wechsle Branch. | | **Beelink** | `journalctl -u mindnet-dev -f` | **Live-Logs Backend.** |
| **Beelink** | `git pull` | Aktualisiere aktuellen Branch. | | **Beelink** | `journalctl -u mindnet-ui-dev -f` | **Live-Logs Frontend.** |
| **Beelink** | `uvicorn ... --port 8002` | Startet Test-Server (Dev). |
--- ---
## 4. Troubleshooting ## 4. Troubleshooting
**"Hilfe, in meinem neuen Branch fehlen Dateien!"** **"Read timed out (300s)" / 500 Error beim Interview**
Das passiert, wenn du beim Erstellen nicht aktuell warst. * **Ursache:** Das LLM (Ollama) braucht für den One-Shot Draft länger als das Timeout erlaubt.
* **Lösung:** * **Lösung:**
```bash 1. Erhöhe in `.env` den Wert: `MINDNET_LLM_TIMEOUT=300.0`.
# In VS Code Terminal: 2. Starte die Server neu.
git checkout feature/mein-kaputter-branch
git merge main **"Port 8002 / 8502 already in use"**
# (Das holt die fehlenden Dateien aus main nach) * **Ursache:** Du willst `uvicorn` oder `streamlit` manuell starten, aber der Service läuft noch.
* **Lösung:** `sudo systemctl stop mindnet-dev` bzw. `mindnet-ui-dev`.
**"UnicodeDecodeError in .env"**
* **Ursache:** Umlaute oder Sonderzeichen in der `.env` Datei.
* **Lösung:** `.env` bereinigen (nur ASCII nutzen) und sicherstellen, dass sie UTF-8 ohne BOM ist.
+172 -50
View File
@@ -1,15 +1,39 @@
# Mindnet v2.2 – Developer Guide # Mindnet v2.4 – Developer Guide
**Datei:** `docs/mindnet_developer_guide_v2.2.md` **Datei:** `docs/mindnet_developer_guide_v2.4.md`
**Stand:** 2025-12-07 **Stand:** 2025-12-10
**Status:** **FINAL** (Konsolidiert WP02–WP04a) **Status:** **FINAL** (Inkl. RAG, Interview Mode & Frontend WP10)
**Quellen:** `mindnet_technical_architecture.md`, `Handbuch.md`, `docs_mindnet_retriever.md`, `mindnet_v2_implementation_playbook.md`. **Quellen:** `mindnet_technical_architecture.md`, `Handbuch.md`, `DEV_WORKFLOW.md`.
> **Zielgruppe:** Entwickler:innen. > **Zielgruppe:** Entwickler:innen.
> **Zweck:** Anleitung zum Aufsetzen der Entwicklungsumgebung, Verständnis der Modulstruktur und Durchführung von Tests. > **Zweck:** Anleitung zum Aufsetzen der Entwicklungsumgebung, Verständnis der Modulstruktur und Durchführung von Tests.
--- ---
- [Mindnet v2.4 – Developer Guide](#mindnet-v24--developer-guide)
- [1. Projektstruktur (Post-WP10)](#1-projektstruktur-post-wp10)
- [2. Lokales Setup (Development)](#2-lokales-setup-development)
- [2.1 Voraussetzungen](#21-voraussetzungen)
- [2.2 Installation](#22-installation)
- [2.3 Konfiguration (Environment)](#23-konfiguration-environment)
- [2.4 Dienste starten (API \& UI)](#24-dienste-starten-api--ui)
- [3. Core-Module \& Entwicklung](#3-core-module--entwicklung)
- [3.1 Der Importer (`scripts.import_markdown`)](#31-der-importer-scriptsimport_markdown)
- [3.2 Der Hybrid Router (`app.routers.chat`)](#32-der-hybrid-router-approuterschat)
- [3.3 Der Retriever (`app.core.retriever`)](#33-der-retriever-appcoreretriever)
- [3.4 Das Frontend (`app.frontend.ui`)](#34-das-frontend-appfrontendui)
- [4. Tests \& Debugging](#4-tests--debugging)
- [4.1 Unit Tests (Pytest)](#41-unit-tests-pytest)
- [4.2 Integration / Pipeline Tests](#42-integration--pipeline-tests)
- [4.3 Smoke Tests (E2E)](#43-smoke-tests-e2e)
- [5. Das "Teach-the-AI" Paradigma (Context Intelligence)](#5-das-teach-the-ai-paradigma-context-intelligence)
- [A. Workflow: Einen neuen Typ implementieren (z. B. `type: risk`)](#a-workflow-einen-neuen-typ-implementieren-z-b-type-risk)
- [B. Workflow: Neue Beziehungen (Edges) nutzen (z. B. `beeinflusst_von`)](#b-workflow-neue-beziehungen-edges-nutzen-z-b-beeinflusst_von)
- [C. Workflow: Interview-Schema anpassen (WP07)](#c-workflow-interview-schema-anpassen-wp07)
- [Fazit](#fazit)
- [6. Nützliche Einzeiler](#6-nützliche-einzeiler)
## 1. Projektstruktur ---
## 1. Projektstruktur (Post-WP10)
Der Code ist modular in `app` (Logik), `scripts` (CLI) und `config` (Steuerung) getrennt. Der Code ist modular in `app` (Logik), `scripts` (CLI) und `config` (Steuerung) getrennt.
@@ -18,18 +42,32 @@ Der Code ist modular in `app` (Logik), `scripts` (CLI) und `config` (Steuerung)
│ ├── core/ # Kernlogik │ ├── core/ # Kernlogik
│ │ ├── chunker.py # Text-Zerlegung │ │ ├── chunker.py # Text-Zerlegung
│ │ ├── derive_edges.py # Edge-Erzeugung (WP03 Logik) │ │ ├── derive_edges.py # Edge-Erzeugung (WP03 Logik)
│ │ ├── retriever.py # Scoring & Graph-Expansion (WP04 Logik) │ │ ├── retriever.py # Scoring & Hybrid Search
│ │ ├── qdrant.py # DB-Verbindung │ │ ├── qdrant.py # DB-Verbindung
│ │ └── ... │ │ └── ...
│ ├── models/ # Pydantic DTOs (Request/Response) │ ├── models/ # Pydantic DTOs
│ │ └── dto.py # Zentrale DTO-Definition
│ ├── routers/ # FastAPI Endpoints │ ├── routers/ # FastAPI Endpoints
│ ├── services/ # Externe Dienste (LLM, Embeddings) │ │ ├── query.py # Suche
│ │ ├── chat.py # Hybrid Router & Interview Logic (WP06/WP07)
│ │ ├── feedback.py # Feedback (WP04c)
│ │ └── ...
│ ├── services/ # Interne & Externe Dienste
│ │ ├── llm_service.py # Ollama Client (Mit Timeout & Raw-Mode)
│ │ ├── feedback_service.py # Logging (JSONL Writer)
│ │ └── embeddings_client.py
│ ├── frontend/ # NEU (WP10)
│ │ └── ui.py # Streamlit Application inkl. Draft-Editor
│ └── main.py # Entrypoint der API │ └── main.py # Entrypoint der API
├── config/ # YAML-Konfigurationen (Single Source of Truth) ├── config/ # YAML-Konfigurationen (Single Source of Truth)
│ ├── types.yaml # Import-Regeln │ ├── types.yaml # Import-Regeln
│ └── retriever.yaml # Scoring-Regeln │ ├── prompts.yaml # LLM Prompts & Interview Templates (WP06/07)
│ ├── decision_engine.yaml # Router-Strategien & Schemas (WP06/07)
│ └── retriever.yaml # Scoring-Regeln & Kantengewichte
├── data/
│ └── logs/ # Lokale Logs (search_history.jsonl, feedback.jsonl)
├── scripts/ # CLI-Tools (Import, Diagnose, Reset) ├── scripts/ # CLI-Tools (Import, Diagnose, Reset)
├── tests/ # Pytest Suite ├── tests/ # Pytest Suite & Smoke Scripts
└── vault/ # Dein lokaler Markdown-Content (Git-ignored) └── vault/ # Dein lokaler Markdown-Content (Git-ignored)
--- ---
@@ -39,9 +77,11 @@ Der Code ist modular in `app` (Logik), `scripts` (CLI) und `config` (Steuerung)
### 2.1 Voraussetzungen ### 2.1 Voraussetzungen
* **Python:** 3.10 oder höher. * **Python:** 3.10 oder höher.
* **Docker:** Für Qdrant. * **Docker:** Für Qdrant.
* **Ollama:** Für lokale LLM-Inference (erforderlich für `/chat`).
* **Vault:** Ein Ordner mit Markdown-Dateien (z.B. `./mindnet_v2_test_vault` für Tests). * **Vault:** Ein Ordner mit Markdown-Dateien (z.B. `./mindnet_v2_test_vault` für Tests).
### 2.2 Installation ### 2.2 Installation
# 1. Repository klonen & Verzeichnis wechseln # 1. Repository klonen & Verzeichnis wechseln
git clone <repo> mindnet git clone <repo> mindnet
cd mindnet cd mindnet
@@ -50,28 +90,53 @@ Der Code ist modular in `app` (Logik), `scripts` (CLI) und `config` (Steuerung)
python3 -m venv .venv python3 -m venv .venv
source .venv/bin/activate source .venv/bin/activate
# 3. Abhängigkeiten installieren # 3. Abhängigkeiten installieren (inkl. Streamlit)
pip install -r requirements.txt pip install -r requirements.txt
# 4. Ollama Setup (Modell laden)
# Wir nutzen Phi-3 Mini für schnelle CPU-Inference
ollama pull phi3:mini
### 2.3 Konfiguration (Environment) ### 2.3 Konfiguration (Environment)
Erstelle eine `.env` Datei im Root-Verzeichnis oder exportiere die Variablen. Erstelle eine `.env` Datei im Root-Verzeichnis.
# Qdrant Verbindung # Qdrant Verbindung
QDRANT_URL="http://localhost:6333" QDRANT_URL="http://localhost:6333"
QDRANT_API_KEY="" # Leer lassen für lokal QDRANT_API_KEY="" # Leer lassen für lokal
# Mindnet Settings # Mindnet Core Settings
COLLECTION_PREFIX="mindnet_dev" COLLECTION_PREFIX="mindnet_dev"
MINDNET_TYPES_FILE="./config/types.yaml" MINDNET_TYPES_FILE="./config/types.yaml"
MINDNET_RETRIEVER_CONFIG="./config/retriever.yaml" MINDNET_RETRIEVER_CONFIG="./config/retriever.yaml"
# Hash-Strategie (für Importer-Debugging) # LLM / RAG Settings (WP06/07)
MINDNET_LLM_MODEL="phi3:mini"
MINDNET_OLLAMA_URL="http://127.0.0.1:11434"
MINDNET_LLM_TIMEOUT=300.0
MINDNET_PROMPTS_PATH="./config/prompts.yaml"
MINDNET_DECISION_CONFIG="./config/decision_engine.yaml"
# Frontend Settings (WP10)
MINDNET_API_URL="http://localhost:8002"
# Import-Strategie
MINDNET_HASH_COMPARE="Body" MINDNET_HASH_COMPARE="Body"
MINDNET_HASH_SOURCE="parsed" MINDNET_HASH_SOURCE="parsed"
### 2.4 Dienste starten ### 2.4 Dienste starten (API & UI)
Starten von Qdrant via Docker:
docker run -d --name mindnet_qdrant_dev -p 6333:6333 -p 6334:6334 qdrant/qdrant Wir entwickeln mit zwei Services. Du kannst sie manuell in zwei Terminals starten oder die Systemd-Services nutzen (siehe `admin_guide.md`).
**Terminal A: Backend (API)**
# Startet auf Port 8002 (Dev Standard)
uvicorn app.main:app --host 0.0.0.0 --port 8002 --env-file .env --reload
**Terminal B: Frontend (UI)**
# Startet auf Port 8502 (Dev Standard)
# --server.port 8502 verhindert Konflikte mit Prod (8501)
streamlit run app/frontend/ui.py --server.port 8502
--- ---
@@ -80,18 +145,25 @@ Starten von Qdrant via Docker:
### 3.1 Der Importer (`scripts.import_markdown`) ### 3.1 Der Importer (`scripts.import_markdown`)
Dies ist das komplexeste Modul. Dies ist das komplexeste Modul.
* **Einstieg:** `scripts/import_markdown.py` -> `main()`. * **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. * **Idempotenz:** Der Importer muss mehrfach laufen können, ohne Duplikate zu erzeugen. Wir nutzen deterministische IDs (UUIDv5).
* **Debugging:** Wenn du am Importer arbeitest, nutze `--dry-run` oder `scripts/payload_dryrun.py`, um DB-Schreibvorgänge zu vermeiden. * **Debugging:** Nutze `--dry-run` oder `scripts/payload_dryrun.py`.
### 3.2 Edge-Logik (`app.core.derive_edges`) ### 3.2 Der Hybrid Router (`app.routers.chat`)
Hier wird entschieden, welche Kanten entstehen. Hier liegt die Logik für Intent Detection (WP06) und Interview-Modus (WP07).
* **Erweiterung:** Wenn du neue Edge-Regeln (z.B. Regex-Parser) hinzufügst, tue dies hier. * **Logic:** `_classify_intent` prüft zuerst Keywords (Fast Path) und fällt auf `llm_service.generate_raw_response` zurück (Slow Path), wenn konfiguriert.
* **Rule-ID:** Vergib zwingend eine eindeutige `rule_id` (z.B. `custom:my_rule`), damit die Herkunft nachvollziehbar bleibt. * **One-Shot:** Wenn Intent `INTERVIEW` erkannt wird, wird **kein Retrieval** ausgeführt. Stattdessen wird ein Draft generiert.
* **Erweiterung:** Um neue Intents hinzuzufügen, editiere nur die YAML, nicht den Python-Code (Late Binding).
### 3.3 Der Retriever (`app.core.retriever`) ### 3.3 Der Retriever (`app.core.retriever`)
Hier passiert das Scoring und die Graph-Expansion. Hier passiert das Scoring.
* **Gewichtung:** Hardcodiere niemals Gewichte (`0.5` etc.) im Code. Nutze `app.core.config.get_retriever_config()`, um `retriever.yaml` zu lesen. * **Hybrid Search:** Der Chat-Endpoint erzwingt `mode="hybrid"`.
* **Graph-Adapter:** Nutze `graph_adapter.expand()`, um Nachbarn zu laden. Vermeide direkte Qdrant-Point-Queries im Retriever-Code, um die Abstraktion zu wahren. * **Strategic Retrieval:** In `chat.py` wird der Retriever *zweimal* aufgerufen, wenn ein Intent (z.B. `DECISION`) eine Injection (`value`) erfordert.
### 3.4 Das Frontend (`app.frontend.ui`)
Eine Streamlit-App (WP10).
* **Draft Editor:** Enthält einen YAML-Sanitizer (`normalize_meta_and_body`), der sicherstellt, dass LLM-Halluzinationen im Frontmatter nicht das File zerstören.
* **State:** Nutzt `st.session_state` für Chat-History und Drafts.
* **Logik:** Ruft `/chat` und `/feedback` Endpoints der API auf.
--- ---
@@ -101,55 +173,105 @@ Wir unterscheiden drei Test-Ebenen. Ein Pull Request sollte alle passieren.
### 4.1 Unit Tests (Pytest) ### 4.1 Unit Tests (Pytest)
Für isolierte Logik (Parsing, Scoring). Für isolierte Logik (Parsing, Scoring).
pytest tests/test_retriever_basic.py pytest tests/test_retriever_basic.py
pytest tests/test_chunking.py pytest tests/test_chunking.py
pytest tests/test_edges_all.py pytest tests/test_edges_all.py
### 4.2 Integration / Pipeline Tests ### 4.2 Integration / Pipeline Tests
Prüfen den Datenfluss von Markdown bis Qdrant-JSON. 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. * **Payload Dryrun:** Prüft JSON-Schema Konformität.
python3 -m scripts.payload_dryrun --vault ./mindnet_v2_test_vault python3 -m scripts.payload_dryrun --vault ./mindnet_v2_test_vault
* **Edge Checks:** Prüft Graph-Invarianten (z.B. `next` muss reziprok zu `prev` sein). * **Edge Checks:** Prüft Graph-Invarianten.
python3 -m scripts.edges_full_check python3 -m scripts.edges_full_check
### 4.3 Smoke Tests (E2E) ### 4.3 Smoke Tests (E2E)
Prüfen das laufende System (API) gegen eine echte (lokale) Qdrant-Instanz. Prüfen das laufende System gegen eine echte Qdrant-Instanz und Ollama.
# 1. API im Hintergrund starten
uvicorn app.main:app --port 8000 &
# 2. Smoke Test feuern # 1. API Test (Decision Engine)
python scripts/test_retriever_smoke.py --query "Test" --mode hybrid --top-k 5 python tests/test_wp06_decision.py -p 8002 -e DECISION -q "Soll ich X tun?"
# 2. UI Test (Manuell)
# Öffne http://localhost:8502
# Stelle eine Frage und prüfe Intent-Badge und Quellen-Anzeige.
# 3. Feedback Test
python tests/test_feedback_smoke.py --url http://localhost:8002/query
--- ---
## 5. Guidelines für Erweiterungen ## 5. Das "Teach-the-AI" Paradigma (Context Intelligence)
### 5.1 Neuen Note-Typ hinzufügen Mindnet lernt nicht durch Training (Fine-Tuning), sondern durch **Konfiguration**, **Vernetzung** und **Prompting**. Dies ist der **Core-Workflow** für Erweiterungen.
* **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 ### A. Workflow: Einen neuen Typ implementieren (z. B. `type: risk`)
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 **1. Daten-Ebene (`config/types.yaml`)**
* Erstelle einen neuen Router in `app/routers/`. Definiere die "Physik" des Typs (Import-Regeln und Basis-Wichtigkeit).
* Nutze Pydantic Models aus `app/models/dto.py` für Request/Response.
* Registriere den Router in `app/main.py`. risk:
chunk_profile: short # Risiken sind oft kurze Statements
retriever_weight: 0.90 # Sehr wichtig, fast so hoch wie Decisions
edge_defaults: ["blocks"] # Automatische Kante zu verlinkten Projekten
**2. Strategie-Ebene (`config/decision_engine.yaml`)**
Damit dieser Typ aktiv geladen wird, musst du ihn einer Strategie zuordnen.
DECISION:
inject_types: ["value", "principle", "goal", "risk"] # <--- "risk" hinzugefügt
*Ergebnis:* Wenn der Intent `DECISION` erkannt wird, sucht das System nun auch aktiv nach Risiken.
**3. Kognitive Ebene (`config/prompts.yaml`)**
Erkläre dem LLM im Template, was es damit tun soll.
### B. Workflow: Neue Beziehungen (Edges) nutzen (z. B. `beeinflusst_von`)
Beziehungen sind der Klebstoff für die "Why"-Erklärungen.
**1. Erfassung im Vault (Markdown)**
Nutze die Inline-Syntax im Fließtext:
> "Die Entscheidung für Qdrant wurde [[rel:beeinflusst_von Budgetkürzung 2024]]."
**2. Gewichtung (`config/retriever.yaml`)**
Konfiguriere `edge_weights`, wenn Kausalität wichtiger ist als Ähnlichkeit.
### C. Workflow: Interview-Schema anpassen (WP07)
Wenn Mindnet neue Fragen stellen soll:
**1. Schema erweitern (`config/decision_engine.yaml`)**
Füge das Feld in die Liste ein.
project:
fields: ["Titel", "Ziel", "Budget"] # <--- Budget neu
**2. Keine Code-Änderung nötig**
Der `One-Shot Extractor` (Prompt Template) liest diese Liste dynamisch und weist das LLM an, das Budget zu extrahieren oder `[TODO]` zu setzen.
### Fazit
* **Vault:** Liefert das Wissen.
* **Config:** Liefert die Strategie (Router & Weights).
* **Prompt:** Liefert die Interpretation.
--- ---
## 6. Nützliche Einzeiler ## 6. Nützliche Einzeiler
**DB komplett zurücksetzen (Vorsicht!):** **DB komplett zurücksetzen (Vorsicht!):**
python3 -m scripts.reset_qdrant --mode wipe --prefix "mindnet_dev" --yes python3 -m scripts.reset_qdrant --mode wipe --prefix "mindnet_dev" --yes
**Einen einzelnen File inspizieren (Parser-Sicht):** **Einen einzelnen File inspizieren (Parser-Sicht):**
python3 tests/inspect_one_note.py --file ./vault/MeinFile.md python3 tests/inspect_one_note.py --file ./vault/MeinFile.md
**Warum wird mein File nicht importiert?** **Live-Logs sehen (Systemd):**
python3 -m scripts.diagnose_changed --vault ./vault --all
# Backend
journalctl -u mindnet-dev -f
# Frontend
journalctl -u mindnet-ui-dev -f
-216
View File
@@ -1,216 +0,0 @@
# mindnet – Knowledge Design
**Version:** 1.5.0 (aktualisiert 2025-11-09)
> Dieses Dokument beschreibt das Ziel, die Architektur, die Datenmodelle sowie die Regeln und Prozesse für den Aufbau von **mindnet** – einem persönlichen, lokal betriebenen Wissensnetz, das auf Markdown-Quellen, Graph-Beziehungen und Vektor-Suche basiert. Es soll die Persönlichkeit, Werte und Erfahrungen des Besitzers widerspiegeln und künftig Antworten generieren, die diese Perspektive authentisch berücksichtigen.
---
## 1. Ziel von mindnet
**1.1 Zweck**
- mindnet dient als persönliches Wissensnetz, das Erfahrungen, Werte, Prinzipien, Ziele und prägenden Ereignisse langfristig strukturiert.
- Es ermöglicht spätere Einsichten in Entscheidungen und Entwicklungen und kann in Zukunft für die Familie (z. B. Kinder) eine nachvollziehbare Quelle sein.
**1.2 Leitidee**
- Statt einer reinen Dokumentablage wird Wissen durch **Knoten (Notes/Chunks)** und **Kanten (Edges)** vernetzt.
- Antworten sollen **persönlich** kontextualisiert werden (Perspektive, Konditionierung, Persönlichkeit).
**1.3 Langfristigkeit**
- Stabiler, zukunftsfähiger Entwurf; spätere Massenmigrationen sollen vermieden werden.
- Architektur unterstützt schrittweise Erweiterung (neue Quellen, neue Agenten, neue Regeln).
---
## 2. Zielarchitektur (High Level)
- **Datenquellen:** Markdown-Vault (Obsidian-kompatibel), perspektivisch weitere Quellen (MediaWiki, PDFs, Web-Exporte, E-Mail-Auszüge).
- **Import-Pipeline:** Parser → Frontmatter/Body → Chunking → Embedding → Qdrant (Notes/Chunks/Edges).
- **Speicher:** Qdrant (Vektoren + Payload + Textindex), Dateien bleiben im Filesystem (Quelle ist Referenz).
- **Graph-Schicht:** Edges explizit modelliert (Typ, Richtung, Evidenz, Confidence); optionale abgeleitete Edges per Batch-Job.
- **Retriever/Composer:** Hybrid-Retrieval (Vektor + Filter + optional Volltext), Komposition zu Antwortkandidaten.
- **Erklärbarkeit:** Begründungspfade (Top-Chunks, Graph-Kette, Provenienz).
- **Schnittstellen:** REST/CLI, n8n-Glue, lokale LLM-Anbindung (Ollama).
---
## 3. Collections in Qdrant
- `mindnet_notes` – Note-Metadaten (id, title, type, path, timestamps, tags, …).
- `mindnet_chunks` – inhaltstragende Segmente inkl. Vektoren und Textindex.
- `mindnet_edges` – Beziehungen (src/dst, relation, direction, evidence, confidence, …).
- (optional) `mindnet_people` – strukturierte Personenobjekte (Eigen-/Fremdbezug).
---
## 4. Identitäten & IDs
- **Deterministische IDs** für Notes (z. B. Namespace-basierte UUIDv5) und stabile, ableitbare IDs für Chunks/Edges.
- ID-Stabilität ist Voraussetzung für Idempotenz (Re-Imports ohne Duplikate).
---
## 5. Frontmatter & Typen
- Pflichtfelder: `id`, `title`, `type`, `created`, `updated`, `tags`, `source_path`.
- Note-Typen (Auszug): `experience`, `principle`, `value`, `goal`, `role`, `persona`, `plan`, `project`, `journal`, `reference`, `translation`.
- **types.yaml** definiert Regeln/Defaults je Typ und für Relationstypen (siehe Abschnitt 10).
---
## 6. Chunking-Strategie
- Satz- bis Absatz-Chunks, moderate Überlappung; Meta-Felder verweisen auf Note/Quelle.
- Named Vectors (z. B. `content`, optional `title`, `tags`) ermöglichen hybride Scores.
---
## 7. Embeddings & Vektoren
- Einheitliche Metrik (cosine), reproduzierbares Embedding-Setup.
- Konsistenz über Zeit durch Versionsfeld (`embedding_model`, `embedding_version`).
---
## 8. Volltext & Filter
- Textindex auf `mindnet_chunks.body` für exakte Term/Operator-Queries.
- Payload-Filter zur schnellen Einschränkung (tags, types, time-buckets, visibility u. a.).
---
## 9. Edges – Beziehungen
- **Explizit**: Jede tatsächliche Beziehung wird als Kante gespeichert (kein Workaround).
- Felder u. a.: `src_id`, `dst_id`, `relation`, `direction`, `confidence (0–1)`, `evidence` (Chunk-IDs), `created_at`, `updated_at`.
- **edge_defaults** liefern **Interpretations-Hints** (Gewichte, Symmetrie, Transitivität) und parametrisieren abgeleitete Edges; sie **ersetzen** keine Originalkanten.
---
## 10. Regeln & Policies (types.yaml)
- Per Typ/Relation:
- Default-Eigenschaften (Gewicht, Directedness, Symmetrie, Transitivität).
- Scoring-Hooks für Graph-Kontext im Retriever.
- (später) Privacy-Hooks je Relation (Mindest-Visibility).
---
## 11. Retrieval & Ranking (Komposition)
- Hybrid: Vektor-Score + Filter + optional BM25/Volltext.
- Zeitgewicht (Decays) und Graph-Kontext werden komponiert (Formel siehe 16.3).
- Konfiguration über `.env`/`config.yaml` (gewichts- und halbwertszeit-basiert).
---
## 12. Erklärbarkeit
- „Warum-Pfad“: Top-Chunks mit Score-Zerlegung (Vektor/Time/Graph), Graph-Kette, Provenienz.
- Mehrschichtige Narrative (Kindheit/Erlebnisse, Werte/Prinzipien, Ziele/Leitbild, Gegenwart).
---
## 13. Betrieb & Sicherheit
- Lokal auf Single-Node starten (Backups via Snapshots).
- Zugriff nur intern/Reverse-Proxy; Festplattenverschlüsselung OS-seitig.
- Migrationspfad zu Qdrant-Distributed (Shards, Replikation) einplanen.
---
## 14. Qualität & Monitoring
- Offline-Eval-Sets, Telemetrie (lokal), Drift-Checks, manuelle Reviews.
- Kennzahlen: Hit-Rate, Overlap, Quellen-Alter, Erklärungspfad-Nutzung.
---
## 15. Offene Punkte
- Ausdetaillierung `types.yaml` (Relationen, Hooks).
- UI-Oberfläche für Erklärpfade und Provenienz.
- Batch-Jobs für abgeleitete Edges.
---
## 16. Ergänzungen 2025-11-09 (v1.5.0)
**Kontext:** Basierend auf den neuen Rahmenbedingungen (nur Deutsch; perspektivische externe Abfragen; einheitliche Vertraulichkeit mit Option auf feinere Stufen; Recency-Priorisierung als Default; Regeln später konfigurierbar; zunächst lokale Speicherung mit optionaler Migration; heutige Hardware, später skalierbar; hohe Erklärbarkeit mit mehreren Erklärungsebenen) werden folgende Entscheidungen und Erweiterungen getroffen. Alle bisherigen Inhalte bleiben gültig und werden **nicht** verändert.
### 16.1 Sprach- und Inhaltsrichtlinie (nur Deutsch)
- `lang: "de"` als verpflichtendes Feld in allen Note-, Chunk- und Edge-Payloads.
- Für spätere Mehrsprachigkeit **nicht** die Collection splitten, sondern ein Feld `lang` + optional `lang_original` behalten; Translation-Artefakte als eigener `type: translation` (verweisend auf `source_id`).
### 16.2 Vertraulichkeit & Sichtbarkeit
- Heute: einheitliche Stufe `visibility: "internal"`.
- Vorausschauend: reservierte Felder in allen Payloads
- `visibility`: `"public" | "internal" | "restricted"`
- `sensitivity`: Integer 0–3 (0 = unkritisch, 3 = hochsensibel)
- `acl`: Liste erlaubter Rollen/Personen-IDs (App-Layer erzwingt Filter vor Query).
- Access-Control erfolgt **im Applikations-Layer** mittels Qdrant-Payload-Filtern (`must: [ { key: "visibility", match: { any: [...] }}, ... ]`); Qdrant bleibt „dumm“ in Bezug auf ACL.
### 16.3 Recency-Modell & Ranking (konfigurierbar)
- Default: **Zeitnähe** priorisieren (sanfte Abwertung älterer Inhalte).
- Im Retrieval kombinieren wir:
1) Vektor-Score (cosine) aus Qdrant
2) Zeitgewicht `time_decay = exp( - ln(2) * age_days / half_life_days )`
3) Graph-Kontext aus Edges (z. B. Degree, Path-Hops zum Anker „Ich/Persona“)
- Konfigurierbare Gewichte (per `.env` oder `config.yaml`):
```text
FINAL_SCORE = w_vec * norm(vec_score)
+ w_time * time_decay
+ w_graph * graph_context_score
# Vorschlag: w_vec=0.70, w_time=0.20, w_graph=0.10; half_life_days=365
```
- Für Fragen, die „zeitlos“ sind, kann `half_life_days = inf` gesetzt werden (kein Decay).
### 16.4 Erklärbarkeit („Warum diese Antwort?“)
- Jeder Antwort wird ein **Erklärpfad** mitgegeben (optional im UI):
- Top-Chunks (mit Score-Zerlegung w_vec/w_time/w_graph)
- **Kausalpfad** im Graphen: `Note → Edge(relation, confidence) → Note …`
- **Provenienz** (Quelle, Erstellungszeit, letzte Änderung).
- Ein **Multi-Layer-Explanations**-Modul ordnet Beiträge zu: Kindheit/Erlebnisse, Werte & Prinzipien, aktuelle Ziele/Leitbild, Gegenwartskontext.
### 16.5 Qdrant-Schemata (Ergänzungen, rückwärtskompatibel)
- **Collections** bleiben: `mindnet_notes`, `mindnet_chunks`, `mindnet_edges` (+ `mindnet_people` falls noch nicht vorhanden).
- Gemeinsame Zusatzfelder (alle Payloads):
- `lang: "de"`
- `visibility`/`sensitivity`/`acl` (s. 16.2)
- `created_at` (ISO-8601), `updated_at` (ISO-8601), `age_days` (App-seitig berechnet)
- **Chunks**:
- Named-Vectors (z. B. `"content"`, optional `"title"`, `"tags"` für Hybrid-Scores).
- `text_index` auf `body` für BM25-ähnliche Volltextsuche (Qdrant-Textindex).
- `recency_group`: Jahr-Monat `YYYY-MM` (ermöglicht Pre-Filter für „letzte N Monate“).
- **Edges** (explizit, keine Workarounds):
- Felder: `src_id`, `dst_id`, `relation`, `direction`, `confidence` (0–1), `evidence` (Chunk-IDs), `created_at`, `updated_at`.
- **edge_defaults** bleiben als **Interpretations-Hints**: z. B. `default_weight`, `symmetry`, `transitivity`. Sie ersetzen **nicht** echte Kanten, sondern parametrisieren abgeleitete/zusätzliche Kantenbildung.
- Abgeleitete Edges: optionaler Batch-Job erzeugt *ergänzende* Kanten entlang `types.yaml`-Regeln (z. B. Backlinks, „inspired_by“ aus Zitaten), niemals statt der Originalkanten.
### 16.6 Regeln & Typen (konfigurierbar)
- `types.yaml` erweitert um:
- Relationstypen mit Default-Eigenschaften (`weight`, `directed`, `symmetric`, `transitive`).
- **Scoring-Hooks**: pro Relation optionaler Einfluss auf `graph_context_score`.
- **Privacy-Hooks**: pro Relation Minimal-Visibility (z. B. Beziehungen zu Personen sind mindestens `internal`).
### 16.7 Speicher- & Betriebsstrategie (heute lokal, später skalierbar)
- **Heute**: Single-Node Qdrant mit HNSW-Index, Text-Index und Payload-Filtern; regelmäßiges Backup (Snapshots).
- **Morgen**: Migrationspfad in **Qdrant-Distributed** (Shards, ggf. Replikation) bei Bedarf; Parameter-Gleichheit sichern (named-vectors, Metrik, HNSW-Param).
- **Sicherheit**: Zugriff nur über internes Netz/Reverse-Proxy, Auth vor Qdrant; Festplatten-Verschlüsselung auf OS-Ebene (z. B. LUKS).
### 16.8 Persona-Layer („meine Essenz“)
- Eigenständiger **Persona-Knoten** (z. B. Note `person/lars`), verbunden mit:
- Werten/Prinzipien, Leitbild, prägenden Erlebnissen, Zielen, Rollen.
- Jede Antwort kann gegen diesen Knoten **kontextualisiert** werden (Graph-Pfadnähe).
- Feld `persona_weight` in Chunks/Notes zur Priorisierung persönlicher Relevanz.
### 16.9 Evaluierung & Qualitätssicherung
- **Offline-Sets** aus echten Fragen (inkl. gewünschter Perspektiven) mit erwarteten Top-Quellen.
- **Telemetrie** (lokal): Query-Arten, Treffer-Overlaps, Zeitgewicht-Effekte, „Warum-Pfad“ genutzt/ignoriert.
- **Drift-Checks**: Anteil sehr alter vs. neuer Quellen in Antworten; manuelle Reviews.
### 16.10 Offene Punkte / Nächste Schritte
1) `types.yaml` um Relationseigenschaften erweitern (s. 16.6).
2) Retriever-Komposition inkl. Zeitgewicht (s. 16.3) implementieren.
3) Explanations-Pfad inkl. Provenienzoberfläche (s. 16.4) im UI.
4) Feld-Erweiterungen in Import-Pipelines (`lang`, `visibility`, Zeitfelder).
5) Optional: Batch-Job für abgeleitete Edges nach Regeln (ergänzend, nicht ersetzend).
+189 -24
View File
@@ -1,10 +1,55 @@
# Mindnet v2.2 – Fachliche Architektur # Mindnet v2.4 – Fachliche Architektur
**Datei:** `docs/mindnet_functional_architecture_v2.2.md` **Datei:** `docs/mindnet_functional_architecture_v2.4.md`
**Stand:** 2025-12-08 **Stand:** 2025-12-10
**Status:** **FINAL** (Integrierter Stand WP01–WP04c) **Status:** **FINAL** (Integrierter Stand WP01–WP10 + WP07)
> 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 und der Feedback-Mechanismen. Die technische Umsetzung wird im technischen Dokument detailliert. > Dieses Dokument beschreibt **was** Mindnet fachlich tut und **warum** – mit Fokus auf die Erzeugung und Nutzung von **Edges** (Kanten), die Logik des Retrievers und den **RAG-Chat** (Decision Engine, Interview-Modus & Persönlichkeit). Die technische Umsetzung wird im technischen Dokument detailliert.
---
<details>
<summary>📖 <b>Inhaltsverzeichnis (Klicken zum Öffnen)</b></summary>
- [Mindnet v2.4 – Fachliche Architektur](#mindnet-v24--fachliche-architektur)
- [](#)
- [0) Zielbild \& Grundprinzip](#0-zielbild--grundprinzip)
- [1) Notizen \& Chunks (fachliche Perspektive)](#1-notizen--chunks-fachliche-perspektive)
- [1.1 Notiz (Note)](#11-notiz-note)
- [1.2 Chunk](#12-chunk)
- [2) Edges – fachliche Typen \& Bedeutung](#2-edges--fachliche-typen--bedeutung)
- [2.1 Struktur-Kanten (Das Skelett)](#21-struktur-kanten-das-skelett)
- [2.2 Inhalts-Kanten (explizit)](#22-inhalts-kanten-explizit)
- [2.3 Typ-basierte Default-Kanten (Regelbasiert)](#23-typ-basierte-default-kanten-regelbasiert)
- [3) Edge-Payload – Felder \& Semantik](#3-edge-payload--felder--semantik)
- [4) Typ-Registry (`config/types.yaml`)](#4-typ-registry-configtypesyaml)
- [4.1 Zweck](#41-zweck)
- [4.2 Beispiel (auslieferungsnah)](#42-beispiel-auslieferungsnah)
- [5) Der Retriever (Funktionaler Layer)](#5-der-retriever-funktionaler-layer)
- [5.1 Scoring-Modell](#51-scoring-modell)
- [5.2 Erklärbarkeit (Explainability) – WP04b](#52-erklärbarkeit-explainability--wp04b)
- [6) Context Intelligence \& Intent Router (WP06/WP07)](#6-context-intelligence--intent-router-wp06wp07)
- [6.1 Das Problem: Statische vs. Dynamische Antworten](#61-das-problem-statische-vs-dynamische-antworten)
- [6.2 Der Intent-Router (Keyword \& Semantik)](#62-der-intent-router-keyword--semantik)
- [6.3 Strategic Retrieval (Injektion von Werten)](#63-strategic-retrieval-injektion-von-werten)
- [6.4 Reasoning (Das Gewissen)](#64-reasoning-das-gewissen)
- [6.5 Der Interview-Modus (One-Shot Extraction) – Neu in v2.4](#65-der-interview-modus-one-shot-extraction--neu-in-v24)
- [7) Future Concepts: The Empathic Digital Twin (Ausblick)](#7-future-concepts-the-empathic-digital-twin-ausblick)
- [7.1 Antizipation durch Erfahrung](#71-antizipation-durch-erfahrung)
- [7.2 Empathie \& "Ich"-Modus](#72-empathie--ich-modus)
- [7.3 Glaubenssätze \& Rituale](#73-glaubenssätze--rituale)
- [8) Erweiterbarkeit \& Teaching (Context Intelligence)](#8-erweiterbarkeit--teaching-context-intelligence)
- [A. Workflow: Einen neuen Typ implementieren (z. B. `type: risk`)](#a-workflow-einen-neuen-typ-implementieren-z-b-type-risk)
- [B. Workflow: Neue Beziehungen nutzen (z. B. `beeinflusst_von`)](#b-workflow-neue-beziehungen-nutzen-z-b-beeinflusst_von)
- [9) Feedback \& Lernen – WP04c/WP10](#9-feedback--lernen--wp04cwp10)
- [9.1 Der Feedback-Loop](#91-der-feedback-loop)
- [10) Confidence \& Provenance – wozu?](#10-confidence--provenance--wozu)
- [11) Semantik ausgewählter `kind`-Werte](#11-semantik-ausgewählter-kind-werte)
- [12) Frontmatter-Eigenschaften – Rolle \& Empfehlung](#12-frontmatter-eigenschaften--rolle--empfehlung)
- [13) Lösch-/Update-Garantien (Idempotenz)](#13-lösch-update-garantien-idempotenz)
- [14) Beispiel – Von Markdown zu Kanten (v2.2)](#14-beispiel--von-markdown-zu-kanten-v22)
- [15) Referenzen (Projektdateien \& Leitlinien)](#15-referenzen-projektdateien--leitlinien)
- [16) Workpackage Status (v2.4.0)](#16-workpackage-status-v240)
</details>
--- ---
## 0) Zielbild & Grundprinzip ## 0) Zielbild & Grundprinzip
@@ -164,11 +209,116 @@ Die API gibt diese Analysen als menschenlesbare Sätze (`reasons`) und als Daten
--- ---
## 6) Feedback & Lernen – WP04c ## 6) Context Intelligence & Intent Router (WP06/WP07)
Seit WP06/WP07 agiert Mindnet nicht mehr statisch, sondern passt seine Suchstrategie dem **Intent** (der Absicht) des Nutzers an. Dies ist die Transformation vom reinen Wissens-Abrufer zum strategischen Partner.
### 6.1 Das Problem: Statische vs. Dynamische Antworten
* **Früher (Pre-WP06):** Jede Frage ("Was ist X?" oder "Soll ich X?") wurde gleich behandelt -> Fakten-Retrieval.
* **Heute (WP06):** Das System erkennt, *was* der User will (Rat, Fakten oder Datenerfassung) und wechselt den Modus.
### 6.2 Der Intent-Router (Keyword & Semantik)
Der Router prüft vor jeder Antwort die Absicht über konfigurierbare Strategien (`config/decision_engine.yaml`):
1. **FACT:** Reine Wissensfrage ("Was ist Qdrant?"). → Standard RAG.
2. **DECISION:** Frage nach Rat oder Strategie ("Soll ich Qdrant nutzen?"). → Aktiviert die Decision Engine.
3. **EMPATHY:** Emotionale Zustände ("Ich bin gestresst"). → Aktiviert den empathischen Modus.
4. **INTERVIEW (Neu in WP07):** Wunsch, Wissen zu erfassen ("Neues Projekt anlegen"). → Aktiviert den Draft-Generator.
5. **CODING:** Technische Anfragen.
### 6.3 Strategic Retrieval (Injektion von Werten)
Im Modus `DECISION` führt das System eine **zweite Suchstufe** aus. Es sucht nicht nur nach semantisch passenden Texten zur Frage, sondern erzwingt das Laden von strategischen Notizen wie:
* **Values (`type: value`):** Moralische Werte (z.B. "Privacy First").
* **Principles (`type: principle`):** Handlungsanweisungen.
* **Goals (`type: goal`):** Strategische Ziele.
### 6.4 Reasoning (Das Gewissen)
Das LLM erhält im Prompt die explizite Anweisung: *"Wäge die Fakten (aus der Suche) gegen die injizierten Werte ab."*
Dadurch entstehen Antworten, die nicht nur technisch korrekt sind, sondern subjektiv passend ("Tool X passt nicht zu deinem Ziel Z").
### 6.5 Der Interview-Modus (One-Shot Extraction) – Neu in v2.4
Wenn der User Wissen erfassen will ("Ich möchte ein neues Projekt anlegen"), wechselt Mindnet in den **Interview-Modus**.
* **Late Binding Schema:** Das System lädt ein konfiguriertes Schema für den Ziel-Typ (z.B. `project`: Pflichtfelder sind Titel, Ziel, Status).
* **One-Shot Extraction:** Statt eines langen Dialogs extrahiert das LLM **sofort** alle verfügbaren Infos aus dem Prompt und generiert einen validen Markdown-Draft mit Frontmatter.
* **Draft-Status:** Fehlende Pflichtfelder werden mit `[TODO]` markiert.
* **UI-Integration:** Das Frontend rendert statt einer Chat-Antwort einen **interaktiven Editor** (WP10), in dem der Entwurf finalisiert werden kann.
---
## 7) Future Concepts: The Empathic Digital Twin (Ausblick)
Um Mindnet von einer Entscheidungsmaschine zu einem echten **Spiegel der Persönlichkeit** zu entwickeln, sind folgende Erweiterungen konzeptionell vorgesehen:
### 7.1 Antizipation durch Erfahrung
* **Konzept:** Das System soll Konsequenzen vorhersagen ("Was passiert, wenn...?").
* **Umsetzung:** Neben Werten werden vergangene Erfahrungen (`type: experience`) geladen.
* **Logik:** *"In einer ähnlichen Situation (Projekt A) hat Entscheidung X zu Ergebnis Y geführt."*
### 7.2 Empathie & "Ich"-Modus
* **Konzept:** Das System antwortet nicht wie ein Roboter, sondern im Tonfall und Stil des Nutzers.
* **Umsetzung (Few-Shot Prompting):** Der System-Prompt wird dynamisch mit Beispielen gefüttert, wie der Nutzer typischerweise auf E-Mails oder Fragen antwortet.
* **Datenbasis:** `type: profile` oder `type: manifesto` definieren das Selbstbild.
### 7.3 Glaubenssätze & Rituale
* **Konzept:** Berücksichtigung weicher Faktoren und Gewohnheiten.
* **Umsetzung:** Erweiterung der `decision_engine.yaml` um `inject_types: ["belief", "ritual"]`.
* **Szenario:** Bei Terminplanungen werden Rituale ("Keine Meetings vor 10 Uhr") automatisch als harte Restriktion gegen Anfragen geprüft.
---
## 8) Erweiterbarkeit & Teaching (Context Intelligence)
Mindnet lernt nicht durch klassisches Training (Fine-Tuning), sondern durch **Konfiguration**, **Vernetzung** und **Prompting**. Dies ist das **"Teach-the-AI" Paradigma**: Wenn du dem System ein neues Konzept beibringen willst, musst du an drei Stellen eingreifen.
### A. Workflow: Einen neuen Typ implementieren (z. B. `type: risk`)
1. **Physik definieren (`config/types.yaml`)**
Steuere, wie schwer der Inhalt wiegt und wie er vernetzt wird.
```yaml
risk:
chunk_profile: short # Risiken sind oft kurze Statements
retriever_weight: 0.90 # Hohe Priorität im Ranking
edge_defaults: ["blocks"] # Automatische Kante zu verlinkten Projekten
```
*Effekt:* Der Retriever spült diese Notizen bei relevanten Anfragen nach oben.
2. **Semantik erklären (`config/prompts.yaml` / `decision_engine.yaml`)**
Bringe dem LLM bei, wie es mit diesem Typ umgehen soll. Füge `risk` zur `DECISION`-Strategie hinzu (`inject_types`), damit es bei Entscheidungen geladen wird.
### B. Workflow: Neue Beziehungen nutzen (z. B. `beeinflusst_von`)
Beziehungen sind der Klebstoff für logische Schlussfolgerungen.
1. **Erfassung im Vault (Markdown)**
Nutze die Inline-Syntax. Du musst nichts vorab definieren.
> "Die Entscheidung für Qdrant wurde [[rel:beeinflusst_von Budgetkürzung 2024]]."
2. **Gewichtung justieren (`config/retriever.yaml`)**
Standardmäßig sind alle Kanten gleich `1.0`. Wenn Kausalität wichtiger ist als Ähnlichkeit, definiere dies hier:
```yaml
retriever:
edge_weights:
beeinflusst_von: 1.5 # Starker Boost: Zieht Ursachen in den Kontext
related_to: 0.5 # Schwacher Boost: Nur "nice to know"
```
*Effekt:* Bei der Frage nach "Qdrant" landet die "Budgetkürzung" (Ursache) im Kontext, weil die Kante stark ist.
3. **Interpretation (Prompting)**
Das LLM erkennt im RAG-Kontext: `Qdrant --[beeinflusst_von]--> Budgetkürzung`.
Es kann daraus den Satz formulieren: *"Die Wahl fiel vermutlich aufgrund der Budgetkürzung auf Qdrant."*
**Fazit:** Nur wenn **Daten** (Vault), **Physik** (Config) und **Semantik** (Prompt) zusammenspielen, entsteht ein intelligenter Zwilling.
---
## 9) Feedback & Lernen – WP04c/WP10
Das System verfügt nun über ein **Kurzzeitgedächtnis für Interaktionen**, das die Basis für zukünftiges Lernen bildet. Das System verfügt nun über ein **Kurzzeitgedächtnis für Interaktionen**, das die Basis für zukünftiges Lernen bildet.
### 6.1 Der Feedback-Loop ### 9.1 Der Feedback-Loop
Die Interaktion erfolgt primär über das **Web-Interface (WP10)**.
1. **Suche (Situation):** 1. **Suche (Situation):**
Wenn ein Nutzer eine Anfrage stellt, loggt Mindnet die "Situation": Wenn ein Nutzer eine Anfrage stellt, loggt Mindnet die "Situation":
* Den Query-Text. * Den Query-Text.
@@ -177,15 +327,15 @@ Das System verfügt nun über ein **Kurzzeitgedächtnis für Interaktionen**, da
* Eine eindeutige `query_id` wird generiert. * Eine eindeutige `query_id` wird generiert.
2. **Bewertung (Label):** 2. **Bewertung (Label):**
Der Nutzer (oder ein Agent) bewertet einen spezifischen Treffer (`node_id`) positiv oder negativ (Score 1-5). Der Nutzer bewertet die Antwort (**Sterne**) oder einzelne Quellen (**Faces**) im Frontend.
Dieses Feedback wird unter Referenzierung der `query_id` gespeichert. Dieses Feedback wird unter Referenzierung der `query_id` in `feedback.jsonl` gespeichert.
3. **Lernen (Perspektive WP08):** 3. **Lernen (Perspektive WP08):**
Durch die Verknüpfung von Situation und Bewertung entstehen Trainingsdaten. Mindnet kann später analysieren: *"Nutzer bevorzugen Treffer mit hohem Edge-Bonus, auch wenn der Text weniger passt."* -> Konsequenz: `edge_weight` erhöhen. Durch die Verknüpfung von Situation und Bewertung entstehen Trainingsdaten. Mindnet kann später analysieren: *"Nutzer bevorzugen Treffer mit hohem Edge-Bonus, auch wenn der Text weniger passt."* -> Konsequenz: `edge_weight` erhöhen.
--- ---
## 7) Confidence & Provenance – wozu? ## 10) Confidence & Provenance – wozu?
Der Retriever kann Edges gewichten: Der Retriever kann Edges gewichten:
- **provenance**: *explicit* > *rule* - **provenance**: *explicit* > *rule*
@@ -197,7 +347,7 @@ Eine typische Gewichtung (konfigurierbar in `retriever.yaml`) ist:
--- ---
## 8) Semantik ausgewählter `kind`-Werte ## 11) Semantik ausgewählter `kind`-Werte
- `references` – „Nutzt/erwähnt“; neutral, aber stützend für Kontext. - `references` – „Nutzt/erwähnt“; neutral, aber stützend für Kontext.
- `related_to` – Ähnlichkeit/Verwandtschaft (symmetrisch interpretierbar). - `related_to` – Ähnlichkeit/Verwandtschaft (symmetrisch interpretierbar).
@@ -209,7 +359,7 @@ Eine typische Gewichtung (konfigurierbar in `retriever.yaml`) ist:
--- ---
## 9) Frontmatter-Eigenschaften – Rolle & Empfehlung ## 12) Frontmatter-Eigenschaften – Rolle & Empfehlung
Frontmatter-Eigenschaften (Properties) bleiben **minimiert**: Frontmatter-Eigenschaften (Properties) bleiben **minimiert**:
- **type** – steuert Typ-Defaults via Registry (Pflicht für differenziertes Verhalten). - **type** – steuert Typ-Defaults via Registry (Pflicht für differenziertes Verhalten).
@@ -219,7 +369,7 @@ Frontmatter-Eigenschaften (Properties) bleiben **minimiert**:
--- ---
## 10) Lösch-/Update-Garantien (Idempotenz) ## 13) Lösch-/Update-Garantien (Idempotenz)
- Jede Note hat einen stabilen **note_id** (Frontmatter/Hash). - Jede Note hat einen stabilen **note_id** (Frontmatter/Hash).
- Vor einem Upsert können *alte Chunks/Edges einer Note* gefiltert gelöscht werden (`note_id`-Filter) – das hält Collections sauber bei Re-Imports. - Vor einem Upsert können *alte Chunks/Edges einer Note* gefiltert gelöscht werden (`note_id`-Filter) – das hält Collections sauber bei Re-Imports.
@@ -227,7 +377,7 @@ Frontmatter-Eigenschaften (Properties) bleiben **minimiert**:
--- ---
## 11) Beispiel – Von Markdown zu Kanten (v2.2) ## 14) Beispiel – Von Markdown zu Kanten (v2.2)
**Markdown (Auszug)** **Markdown (Auszug)**
# Relations Showcase # Relations Showcase
@@ -246,19 +396,34 @@ Frontmatter-Eigenschaften (Properties) bleiben **minimiert**:
--- ---
## 12) Qualitäts- und Testkriterien (fachlich) ## 15) Referenzen (Projektdateien & Leitlinien)
- **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.
---
## 13) Referenzen (Projektdateien & Leitlinien)
- Import-Pipeline & Registry-Auflösung: `scripts/import_markdown.py`. - Import-Pipeline & Registry-Auflösung: `scripts/import_markdown.py`.
- Kantenbildung (V2-Logic): `app/core/derive_edges.py`. - Kantenbildung (V2-Logic): `app/core/derive_edges.py`.
- Typ-Registry: `config/types.yaml` & `TYPE_REGISTRY_MANUAL.md`. - Typ-Registry: `config/types.yaml` & `TYPE_REGISTRY_MANUAL.md`.
- Retriever-Scoring & Explanation: `app/core/retriever.py`. - Retriever-Scoring & Explanation: `app/core/retriever.py`.
- Persönlichkeit & Chat: `config/prompts.yaml` & `app/routers/chat.py`.
- Decision Engine: `config/decision_engine.yaml`.
- Logging Service: `app/services/feedback_service.py`. - Logging Service: `app/services/feedback_service.py`.
- Frontend UI: `app/frontend/ui.py`.
---
## 16) Workpackage Status (v2.4.0)
Aktueller Implementierungsstand der Module.
| WP | Titel | Status | Anmerkung |
| :--- | :--- | :--- | :--- |
| **WP01** | Knowledge Design | 🟢 Live | Typen, Frontmatter definiert. |
| **WP02** | Chunking Strategy | 🟢 Live | Profilbasiertes Chunking aktiv. |
| **WP03** | Edge Logic / Import | 🟢 Live | Neue Importer-Pipeline mit Provenance. |
| **WP04a**| Retriever Scoring | 🟢 Live | Hybrider Score (Semantik + Graph). |
| **WP04b**| Explanation Layer | 🟢 Live | API liefert Reasons & Breakdown. |
| **WP04c**| Feedback Loop | 🟢 Live | Logging (JSONL) & Traceability aktiv. |
| **WP05** | Persönlichkeit / Chat | 🟢 Live | RAG-Integration mit Context Enrichment. |
| **WP06** | Decision Engine | 🟢 Live | Intent-Router & Strategic Retrieval. |
| **WP07** | Interview Assistent | 🟢 Live | **One-Shot Extractor & Schemas aktiv.** |
| **WP08** | Self-Tuning | 🔴 Geplant | Auto-Adjustment der Gewichte. |
| **WP10** | Chat Interface | 🟢 Live | Web-UI mit Feedback & Intents. |
| **WP10a**| Draft Editor | 🟢 Live | **Interaktiver Editor für WP07 Drafts.** |
+186 -29
View File
@@ -1,29 +1,76 @@
# Mindnet v2.2 – Technische Architektur # Mindnet v2.4 – Technische Architektur
**Datei:** `docs/mindnet_technical_architecture_v2.2.md` **Datei:** `docs/mindnet_technical_architecture_v2.4.md`
**Stand:** 2025-12-08 **Stand:** 2025-12-10
**Status:** **FINAL** (Integrierter Stand WP01–WP04c) **Status:** **FINAL** (Integrierter Stand WP01–WP10 + WP07)
**Quellen:** `mindnet_technical_architecture.md`, `chunking_strategy.md`, `Handbuch.md`, `wp04_retriever_scoring.md`. **Quellen:** `Programmplan_V2.2.md`, `Handbuch.md`, `chunking_strategy.md`, `wp04_retriever_scoring.md`.
> **Ziel dieses Dokuments:** > **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. > Vollständige Beschreibung der technischen Architektur inkl. Graph-Datenbank, Retrieval-Logik, der **RAG-Komponenten (Decision Engine & Hybrid Router)**, des **Interview-Modus** und dem **Frontend (Streamlit)**.
---
<details>
<summary>📖 <b>Inhaltsverzeichnis (Klicken zum Öffnen)</b></summary>
- [Mindnet v2.4 – Technische Architektur](#mindnet-v24--technische-architektur)
- [](#)
- [1. Systemüberblick](#1-systemüberblick)
- [1.1 Architektur-Zielbild](#11-architektur-zielbild)
- [1.2 Verzeichnisstruktur \& Komponenten (Post-WP10)](#12-verzeichnisstruktur--komponenten-post-wp10)
- [2. Datenmodell \& Collections (Qdrant)](#2-datenmodell--collections-qdrant)
- [2.1 Notes Collection (`<prefix>_notes`)](#21-notes-collection-prefix_notes)
- [2.2 Chunks Collection (`<prefix>_chunks`)](#22-chunks-collection-prefix_chunks)
- [2.3 Edges Collection (`<prefix>_edges`)](#23-edges-collection-prefix_edges)
- [3. Konfiguration](#3-konfiguration)
- [3.1 Typ-Registry (`config/types.yaml`)](#31-typ-registry-configtypesyaml)
- [3.2 Retriever-Config (`config/retriever.yaml`)](#32-retriever-config-configretrieveryaml)
- [3.3 Decision Engine (`config/decision_engine.yaml`)](#33-decision-engine-configdecision_engineyaml)
- [3.4 Prompts (`config/prompts.yaml`)](#34-prompts-configpromptsyaml)
- [3.5 Environment (`.env`)](#35-environment-env)
- [4. Import-Pipeline (Markdown → Qdrant)](#4-import-pipeline-markdown--qdrant)
- [4.1 Verarbeitungsschritte](#41-verarbeitungsschritte)
- [5. Retriever-Architektur \& Scoring](#5-retriever-architektur--scoring)
- [5.1 Betriebsmodi](#51-betriebsmodi)
- [5.2 Scoring-Formel (WP04a)](#52-scoring-formel-wp04a)
- [5.3 Explanation Layer (WP04b)](#53-explanation-layer-wp04b)
- [5.4 Graph-Expansion](#54-graph-expansion)
- [6. RAG \& Chat Architektur (WP06 Hybrid Router + WP07 Interview)](#6-rag--chat-architektur-wp06-hybrid-router--wp07-interview)
- [6.1 Architektur-Pattern: Intent Router](#61-architektur-pattern-intent-router)
- [6.2 Schritt 1: Intent Detection (Hybrid)](#62-schritt-1-intent-detection-hybrid)
- [6.3 Schritt 2: Strategy Resolution (Late Binding)](#63-schritt-2-strategy-resolution-late-binding)
- [6.4 Schritt 3: Retrieval vs. Extraction](#64-schritt-3-retrieval-vs-extraction)
- [6.5 Schritt 4: Generation \& Response](#65-schritt-4-generation--response)
- [7. Frontend Architektur (WP10)](#7-frontend-architektur-wp10)
- [7.1 Kommunikation](#71-kommunikation)
- [7.2 Features \& UI-Logik](#72-features--ui-logik)
- [7.3 Draft-Editor \& Sanitizer (Neu in WP10a)](#73-draft-editor--sanitizer-neu-in-wp10a)
- [7.4 Deployment Ports](#74-deployment-ports)
- [8. Feedback \& Logging Architektur (WP04c)](#8-feedback--logging-architektur-wp04c)
- [8.1 Komponenten](#81-komponenten)
- [8.2 Log-Dateien](#82-log-dateien)
- [8.3 Traceability](#83-traceability)
- [9. Indizes \& Performance](#9-indizes--performance)
- [10. Offene Punkte / Known Limitations](#10-offene-punkte--known-limitations)
</details>
--- ---
## 1. Systemüberblick ## 1. Systemüberblick
### 1.1 Architektur-Zielbild ### 1.1 Architektur-Zielbild
Mindnet ist ein **persönliches Wissensnetz**. Technisch bedeutet das: Mindnet ist ein **lokales RAG-System (Retrieval Augmented Generation)** mit Web-Interface.
1. **Source:** Markdown-Notizen in einem Vault (Obsidian-kompatibel). 1. **Source:** Markdown-Notizen in einem Vault (Obsidian-kompatibel).
2. **Pipeline:** Ein Python-Importer transformiert diese in **Notes**, **Chunks** und **Edges**. 2. **Pipeline:** Ein Python-Importer transformiert diese in **Notes**, **Chunks** und **Edges**.
3. **Storage:** 3. **Storage:**
* **Qdrant:** Vektor-Datenbank für Graph und Semantik (Collections: notes, chunks, edges). * **Qdrant:** Vektor-Datenbank für Graph und Semantik (Collections: notes, chunks, edges).
* **Local Files (JSONL):** Append-Only Logs für Feedback und Search-History (Data Flywheel). * **Local Files (JSONL):** Append-Only Logs für Feedback und Search-History (Data Flywheel).
4. **Service:** Eine FastAPI-Anwendung stellt Endpunkte für **Semantische** und **Hybride Suche** sowie **Feedback** bereit. 4. **Backend:** Eine FastAPI-Anwendung stellt Endpunkte für **Semantische** und **Hybride Suche** sowie **Feedback** bereit.
5. **Frontend:** Streamlit-App (`ui.py`) für Interaktion und Visualisierung inkl. **Draft Editor**.
6. **Inference:** Lokales LLM (Ollama: Phi-3 Mini) für RAG-Chat und Antwortgenerierung.
Das System arbeitet **deterministisch** (stabile IDs) und ist **konfigurationsgetrieben** (`types.yaml`, `retriever.yaml`). Das System arbeitet **deterministisch** (stabile IDs) und ist **konfigurationsgetrieben** (`types.yaml`, `retriever.yaml`, `decision_engine.yaml`, `prompts.yaml`).
### 1.2 Verzeichnisstruktur & Komponenten ### 1.2 Verzeichnisstruktur & Komponenten (Post-WP10)
Die Codebasis ist modular aufgebaut.
/mindnet/ /mindnet/
├── app/ ├── app/
@@ -38,17 +85,23 @@ Die Codebasis ist modular aufgebaut.
│ │ ├── derive_edges.py # Logik der Kantenableitung (WP03) │ │ ├── derive_edges.py # Logik der Kantenableitung (WP03)
│ │ ├── graph_adapter.py # Subgraph & Reverse-Lookup (WP04b) │ │ ├── graph_adapter.py # Subgraph & Reverse-Lookup (WP04b)
│ │ └── retriever.py # Scoring, Expansion & Explanation (WP04a/b) │ │ └── retriever.py # Scoring, Expansion & Explanation (WP04a/b)
│ ├── models/ # Pydantic DTOs (QueryHit, Explanation, FeedbackRequest) │ ├── models/ # Pydantic DTOs
│ ├── routers/ │ ├── routers/
│ │ ├── query.py # Such-Endpunkt │ │ ├── query.py # Such-Endpunkt
│ │ ├── chat.py # Hybrid Router & Interview Logic (WP06/07)
│ │ ├── feedback.py # Feedback-Endpunkt (WP04c) │ │ ├── feedback.py # Feedback-Endpunkt (WP04c)
│ │ └── ... │ │ └── ...
│ ├── services/ │ ├── services/
│ │ ├── feedback_service.py # Logging-Logik (WP04c) │ │ ├── llm_service.py # Ollama Client mit Timeout & Raw-Mode
│ │ ├── feedback_service.py # JSONL Logging (WP04c)
│ │ └── embeddings_client.py │ │ └── embeddings_client.py
│ ├── frontend/ # NEU (WP10)
│ └── ui.py # Streamlit Application inkl. Sanitizer
├── config/ ├── config/
│ ├── types.yaml # Typ-Definitionen (Import-Zeit) │ ├── types.yaml # Typ-Definitionen (Import-Zeit)
│ └── retriever.yaml # Scoring-Gewichte (Laufzeit) │ ├── retriever.yaml # Scoring-Gewichte (Laufzeit)
│ ├── decision_engine.yaml # Strategien & Schemas (WP06/WP07)
│ └── prompts.yaml # LLM System-Prompts & Templates (WP06)
├── data/ ├── data/
│ └── logs/ # Lokale JSONL-Logs (WP04c) │ └── logs/ # Lokale JSONL-Logs (WP04c)
├── scripts/ ├── scripts/
@@ -89,6 +142,7 @@ Die atomaren Sucheinheiten.
| :--- | :--- | :--- | | :--- | :--- | :--- |
| `chunk_id` | Keyword | Deterministisch: `{note_id}#c{index:02d}`. | | `chunk_id` | Keyword | Deterministisch: `{note_id}#c{index:02d}`. |
| `note_id` | Keyword | Referenz zur Note. | | `note_id` | Keyword | Referenz zur Note. |
| `type` | Keyword | **Kopie des Note-Typs** (Denormalisiert für Filter). |
| `text` | Text | **Reiner Inhalt** (ohne Overlap). Anzeige-Text. | | `text` | Text | **Reiner Inhalt** (ohne Overlap). Anzeige-Text. |
| `window` | Text | **Kontext-Fenster** (mit Overlap). Embedding-Basis. | | `window` | Text | **Kontext-Fenster** (mit Overlap). Embedding-Basis. |
| `ord` | Integer | Sortierreihenfolge (1..N). | | `ord` | Integer | Sortierreihenfolge (1..N). |
@@ -122,24 +176,40 @@ Die Logik ist ausgelagert in YAML-Dateien.
### 3.1 Typ-Registry (`config/types.yaml`) ### 3.1 Typ-Registry (`config/types.yaml`)
Steuert den Import-Prozess. Steuert den Import-Prozess.
* **Priorität:** Frontmatter > Pfad > Default. * **Priorität:** Frontmatter > Pfad > Default.
* **Inhalt:** * **Inhalt (Beispiel):**
```yaml
types: types:
concept: concept:
chunk_profile: medium chunk_profile: medium
edge_defaults: ["references", "related_to"] edge_defaults: ["references", "related_to"]
retriever_weight: 0.60 retriever_weight: 0.60
```
### 3.2 Retriever-Config (`config/retriever.yaml`) ### 3.2 Retriever-Config (`config/retriever.yaml`)
Steuert das Scoring zur Laufzeit (WP04a). Steuert das Scoring zur Laufzeit (WP04a).
* **Inhalt:** * **Inhalt (Beispiel):**
```yaml
scoring: scoring:
semantic_weight: 1.0 semantic_weight: 1.0
edge_weight: 0.7 edge_weight: 0.7
centrality_weight: 0.5 centrality_weight: 0.5
```
### 3.3 Decision Engine (`config/decision_engine.yaml`)
**Neu in WP06/07:** Steuert den Intent-Router und die Interview-Schemas.
* Definiert Strategien (`DECISION`, `INTERVIEW`, etc.).
* Definiert `schemas` für den Interview-Modus (Pflichtfelder pro Typ).
* Definiert LLM-Router-Settings (`llm_fallback_enabled`).
### 3.4 Prompts (`config/prompts.yaml`)
Steuert die LLM-Persönlichkeit und Templates.
* Enthält Templates für alle Strategien inkl. `interview_template` mit One-Shot Logik.
### 3.5 Environment (`.env`)
Erweiterung für LLM-Steuerung:
MINDNET_LLM_MODEL=phi3:mini
MINDNET_OLLAMA_URL=http://127.0.0.1:11434
MINDNET_LLM_TIMEOUT=300.0 # Neu: Erhöht für CPU-Inference Cold-Starts
MINDNET_DECISION_CONFIG="config/decision_engine.yaml"
--- ---
@@ -170,7 +240,7 @@ Das Skript `scripts/import_markdown.py` orchestriert den Prozess.
## 5. Retriever-Architektur & Scoring ## 5. Retriever-Architektur & Scoring
Der Retriever (`app/core/retriever.py`) realisiert die Logik hinter `/query`. Der Retriever (`app/core/retriever.py`) unterstützt zwei Modi. Für den Chat wird **zwingend** der Hybrid-Modus genutzt.
### 5.1 Betriebsmodi ### 5.1 Betriebsmodi
* **Semantic:** Reine Vektorsuche. Schnell. * **Semantic:** Reine Vektorsuche. Schnell.
@@ -204,43 +274,130 @@ Der Hybrid-Modus lädt dynamisch die Nachbarschaft der Top-K Vektor-Treffer ("Se
--- ---
## 6. Feedback & Logging Architektur (WP04c) ## 6. RAG & Chat Architektur (WP06 Hybrid Router + WP07 Interview)
Der Flow für eine Chat-Anfrage (`/chat`) wurde in WP06 auf eine **Configuration-Driven Architecture** umgestellt. Der `ChatRouter` (`app/routers/chat.py`) fungiert als zentraler Dispatcher.
### 6.1 Architektur-Pattern: Intent Router
Die Behandlung einer Anfrage ist nicht mehr hartkodiert, sondern wird dynamisch zur Laufzeit entschieden.
* **Input:** User Message.
* **Config:** `config/decision_engine.yaml` (Strategien & Keywords).
* **Komponenten:**
* **Fast Path:** Keyword Matching (CPU-schonend).
* **Slow Path:** LLM-basierter Semantic Router (für subtile Intents).
### 6.2 Schritt 1: Intent Detection (Hybrid)
Der Router ermittelt die Absicht (`Intent`) des Nutzers.
1. **Keyword Scan (Fast Path):**
* Iteration über alle Strategien in `decision_engine.yaml`.
* Prüfung auf `trigger_keywords`.
* **Best Match:** Bei mehreren Treffern gewinnt das längste/spezifischste Keyword (Robustheit gegen Shadowing).
2. **LLM Fallback (Slow Path):**
* Nur aktiv, wenn `llm_fallback_enabled: true`.
* Greift, wenn keine Keywords gefunden wurden.
* Sendet die Query an das LLM mit einem Klassifizierungs-Prompt (`llm_router_prompt`).
* Ergebnis: `EMPATHY`, `DECISION`, `INTERVIEW`, `CODING` oder `FACT`.
### 6.3 Schritt 2: Strategy Resolution (Late Binding)
Basierend auf dem Intent lädt der Router die Parameter:
* **Bei RAG (FACT/DECISION):** `inject_types` für Strategic Retrieval.
* **Bei INTERVIEW (WP07):** `schemas` (Pflichtfelder) basierend auf der erkannten Ziel-Entität (`_detect_target_type`).
### 6.4 Schritt 3: Retrieval vs. Extraction
Der Router verzweigt hier:
**A) RAG Modus (FACT, DECISION, EMPATHY):**
1. **Primary Retrieval:** Hybride Suche nach der User-Query.
2. **Strategic Retrieval (Conditional):** Wenn `inject_types` definiert sind, erfolgt eine zweite Suche, die explizit auf diese Typen filtert.
3. **Merge:** Ergebnisse werden dedupliziert zusammengeführt.
**B) Interview Modus (INTERVIEW):**
1. **Kein Retrieval:** Der Kontext ist der Chat-Verlauf (oder initial die Query).
2. **Schema Injection:** Das Schema für den erkannten Typ (z.B. "Project") wird geladen.
3. **Prompt Assembly:** Der `interview_template` Prompt wird mit der Schema-Definition ("Ziel", "Status") gefüllt.
### 6.5 Schritt 4: Generation & Response
* **Templating:** Das LLM erhält den Prompt basierend auf dem gewählten Template.
* **Execution:** Der `LLMService` führt den Call aus. Ein konfigurierbarer Timeout (`MINDNET_LLM_TIMEOUT`) fängt Cold-Start-Verzögerungen auf CPU-Hardware ab.
* **Response:** Rückgabe enthält Antworttext (im Interview-Modus: Markdown Codeblock), Quellenliste und den erkannten `intent`.
---
## 7. Frontend Architektur (WP10)
Das Frontend ist eine **Streamlit-Anwendung** (`app/frontend/ui.py`), die als separater Prozess läuft und via HTTP mit dem Backend kommuniziert.
### 7.1 Kommunikation
* **Backend-URL:** Konfiguriert via `MINDNET_API_URL` (Default: `http://localhost:8002`).
* **Endpoints:** Nutzt `/chat` für Interaktion und `/feedback` für Bewertungen.
* **Resilienz:** Das Frontend implementiert eigene Timeouts (`MINDNET_API_TIMEOUT`, Default 300s).
### 7.2 Features & UI-Logik
* **State Management:** Session-State speichert Chat-Verlauf und `query_id`.
* **Visualisierung:**
* **Intent Badges:** Zeigt Router-Entscheidung (`DECISION`, `INTERVIEW`, etc.).
* **Source Expanders:** Zeigt verwendete Chunks inkl. Score und "Why"-Explanation.
* **Sidebar:** Zeigt Suchhistorie (Log-basiert) und Konfiguration.
### 7.3 Draft-Editor & Sanitizer (Neu in WP10a)
Wenn der Intent `INTERVIEW` ist, rendert die UI statt einer Textblase den **Draft-Editor**.
1. **Parsing:** Die Funktion `parse_markdown_draft` extrahiert den Codeblock aus der LLM-Antwort.
2. **Sanitization (`normalize_meta_and_body`):**
* Prüft den YAML-Frontmatter auf unerlaubte Felder (Halluzinationen des LLMs).
* Verschiebt ungültige Felder (z.B. "Situation") in den Body der Notiz.
* Stellt sicher, dass das Markdown valide bleibt.
3. **Editor Widget:** `st.text_area` erlaubt das Bearbeiten des Inhalts vor dem Speichern.
4. **Action:** Buttons zum Download oder Kopieren des fertigen Markdowns.
### 7.4 Deployment Ports
Zur sauberen Trennung von Prod und Dev laufen Frontend und Backend auf dedizierten Ports:
| Umgebung | Backend (FastAPI) | Frontend (Streamlit) |
| :--- | :--- | :--- |
| **Production** | 8001 | 8501 |
| **Development** | 8002 | 8502 |
---
## 8. Feedback & Logging Architektur (WP04c)
Mindnet implementiert ein "Data Flywheel" zur späteren Optimierung (Self-Tuning). Mindnet implementiert ein "Data Flywheel" zur späteren Optimierung (Self-Tuning).
### 6.1 Komponenten ### 8.1 Komponenten
* **Feedback Service (`app/services/feedback_service.py`):** Kapselt die Schreibzugriffe. * **Feedback Service (`app/services/feedback_service.py`):** Kapselt die Schreibzugriffe.
* **Storage:** Lokales Dateisystem (`data/logs/`), Format JSONL (Line-delimited JSON). * **Storage:** Lokales Dateisystem (`data/logs/`), Format JSONL (Line-delimited JSON).
### 6.2 Log-Dateien ### 8.2 Log-Dateien
1. **`search_history.jsonl`**: 1. **`search_history.jsonl`**:
* Speichert jede Anfrage an `/query`. * Speichert jede Anfrage an `/query` und `/chat`.
* Enthält: `query_id`, `query_text`, `timestamp`, `hits` (inkl. `score_breakdown` Snapshots). * Enthält: `query_id`, `query_text`, `timestamp`, `hits` (inkl. `score_breakdown` Snapshots).
* Zweck: Trainingsdaten ("Was hat das System gesehen?"). * Zweck: Trainingsdaten ("Was hat das System gesehen?").
2. **`feedback.jsonl`**: 2. **`feedback.jsonl`**:
* Speichert User-Reaktionen an `/feedback`. * Speichert User-Reaktionen an `/feedback`.
* Enthält: `query_id`, `node_id`, `score` (1-5), `comment`. * Enthält: `query_id`, `node_id`, `score` (1-5), `comment`.
* **Granularität:** Kann sich auf `generated_answer` (Global) oder eine spezifische `node_id` (Quelle) beziehen.
* Zweck: Labels ("War es gut?"). * Zweck: Labels ("War es gut?").
### 6.3 Traceability ### 8.3 Traceability
Die `query_id` (UUIDv4) wird im `/query` Response generiert und muss vom Client beim `/feedback` Aufruf mitgesendet werden. Dies ermöglicht den Join zwischen Snapshot und Bewertung. Die `query_id` (UUIDv4) wird im `/query` Response generiert und muss vom Client beim `/feedback` Aufruf mitgesendet werden. Dies ermöglicht den Join zwischen Snapshot und Bewertung.
--- ---
## 7. Indizes & Performance ## 9. Indizes & Performance
Damit Qdrant performant bleibt, sind Payload-Indizes essenziell. Damit Qdrant performant bleibt, sind Payload-Indizes essenziell.
**Erforderliche Indizes:** **Erforderliche Indizes:**
* **Notes:** `note_id`, `type`, `tags`. * **Notes:** `note_id`, `type`, `tags`.
* **Chunks:** `note_id`, `chunk_id`. * **Chunks:** `note_id`, `chunk_id`, `type`.
* **Edges:** `source_id`, `target_id`, `kind`, `scope`, `note_id`. * **Edges:** `source_id`, `target_id`, `kind`, `scope`, `note_id`.
Validierung erfolgt über `tests/ensure_indexes_and_show.py`. Validierung erfolgt über `tests/ensure_indexes_and_show.py`.
--- ---
## 8. Offene Punkte / Known Limitations ## 10. Offene Punkte / Known Limitations
1. **Multi-Target Inline-Relations:** 1. **Multi-Target Inline-Relations:**
* `rel: similar_to [[A]] [[B]]` wird aktuell parser-seitig nicht unterstützt. * `rel: similar_to [[A]] [[B]]` wird aktuell parser-seitig nicht unterstützt.
+127 -65
View File
@@ -1,25 +1,57 @@
# mindnet v2.2 – Pipeline Playbook # mindnet v2.4 – Pipeline Playbook
**Datei:** `docs/mindnet_pipeline_playbook_v2.2.md` **Datei:** `docs/mindnet_pipeline_playbook_v2.4.md`
**Stand:** 2025-12-07 **Stand:** 2025-12-10
**Status:** **FINAL** (Konsolidiert aus WP02, WP03, WP04a) **Status:** **FINAL** (Inkl. WP07 Interview & WP10a Editor)
**Quellen:** `mindnet_v2_implementation_playbook.md`, `Handbuch.md`, `chunking_strategy.md`, `docs_mindnet_retriever.md`, `wp04_retriever_scoring.md`. **Quellen:** `mindnet_v2_implementation_playbook.md`, `Handbuch.md`, `chunking_strategy.md`, `docs_mindnet_retriever.md`, `mindnet_admin_guide_v2.4.md`.
---
<details>
<summary>📖 <b>Inhaltsverzeichnis (Klicken zum Öffnen)</b></summary>
- [mindnet v2.4 – Pipeline Playbook](#mindnet-v24--pipeline-playbook)
- [](#)
- [1. Zweck \& Einordnung](#1-zweck--einordnung)
- [2. Die Import-Pipeline (Runbook)](#2-die-import-pipeline-runbook)
- [2.1 Der 12-Schritte-Prozess](#21-der-12-schritte-prozess)
- [2.2 Standard-Betrieb (Inkrementell)](#22-standard-betrieb-inkrementell)
- [2.3 Deployment \& Restart (Systemd)](#23-deployment--restart-systemd)
- [2.4 Full Rebuild (Clean Slate)](#24-full-rebuild-clean-slate)
- [3. Chunking \& Payload-Aufbau](#3-chunking--payload-aufbau)
- [3.1 Chunk-Profile](#31-chunk-profile)
- [3.2 Payload-Felder](#32-payload-felder)
- [4. Edge-Erzeugung (Die V2-Logik)](#4-edge-erzeugung-die-v2-logik)
- [4.1 Prioritäten \& Provenance](#41-prioritäten--provenance)
- [4.2 Typ-Defaults](#42-typ-defaults)
- [5. Retriever, Chat \& Generation (RAG Pipeline)](#5-retriever-chat--generation-rag-pipeline)
- [5.1 Retrieval (Hybrid)](#51-retrieval-hybrid)
- [5.2 Intent Router (WP06/07)](#52-intent-router-wp0607)
- [5.3 Context Enrichment](#53-context-enrichment)
- [5.4 Generation (LLM)](#54-generation-llm)
- [6. Feedback \& Lernen (WP04c)](#6-feedback--lernen-wp04c)
- [7. Quality Gates \& Tests](#7-quality-gates--tests)
- [7.1 Pflicht-Tests vor Commit](#71-pflicht-tests-vor-commit)
- [7.2 Smoke-Test (E2E)](#72-smoke-test-e2e)
- [8. Ausblick \& Roadmap (Technische Skizzen)](#8-ausblick--roadmap-technische-skizzen)
- [8.1 WP-08: Self-Tuning (Skizze)](#81-wp-08-self-tuning-skizze)
- [16. Workpackage Status (v2.4.0)](#16-workpackage-status-v240)
</details>
--- ---
## 1. Zweck & Einordnung ## 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. Dieses Playbook ist das zentrale operative Handbuch für die **mindnet-Pipeline**. Es beschreibt, wie Daten vom Markdown-Vault in den Wissensgraphen (Qdrant) gelangen, wie der Retriever betrieben wird und wie die **RAG-Generierung** (inkl. Decision Engine & Interviewer) funktioniert.
**Zielgruppe:** Dev/Ops, Tech-Leads. **Zielgruppe:** Dev/Ops, Tech-Leads.
**Scope:** **Scope:**
* **Ist-Stand (WP01–WP04a):** Markdown-Import, Chunking, Edge-Erzeugung, Hybrider Retriever. * **Ist-Stand (WP01–WP10a):** Import, Chunking, Edge-Erzeugung, Hybrider Retriever, RAG-Chat (Hybrid Router), Feedback Loop, Frontend, Draft Editor.
* **Roadmap (Ausblick):** Self-Healing (WP06), Feedback-Loops (WP08). * **Roadmap (Ausblick):** Technische Skizze für Self-Tuning (WP08).
--- ---
## 2. Die Import-Pipeline (Runbook) ## 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. Der Import ist der kritischste Prozess ("Data Ingestion"). Er muss **deterministisch** und **idempotent** sein. Wir nutzen `scripts/import_markdown.py` als zentralen Entrypoint.
### 2.1 Der 12-Schritte-Prozess ### 2.1 Der 12-Schritte-Prozess
Gemäß WP03-Spezifikation läuft der Import intern wie folgt ab: Gemäß WP03-Spezifikation läuft der Import intern wie folgt ab:
@@ -44,7 +76,8 @@ Für regelmäßige Updates (z.B. Cronjob). Erkennt Änderungen via Hash.
export COLLECTION_PREFIX="mindnet" export COLLECTION_PREFIX="mindnet"
# Import starten (Apply = Schreiben, Purge = Sauberer Upsert) # Import starten (Apply = Schreiben, Purge = Sauberer Upsert)
python3 -m scripts.import_markdown \ # Nutzt das Venv der Produktionsumgebung
/home/llmadmin/mindnet/.venv/bin/python3 -m scripts.import_markdown \
--vault ./vault \ --vault ./vault \
--prefix "$COLLECTION_PREFIX" \ --prefix "$COLLECTION_PREFIX" \
--apply \ --apply \
@@ -55,24 +88,24 @@ Für regelmäßige Updates (z.B. Cronjob). Erkennt Änderungen via Hash.
* `--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. * `--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. * `--sync-deletes`: Entfernt Notizen aus Qdrant, die im Vault gelöscht wurden.
### 2.3 Full Rebuild (Clean Slate) ### 2.3 Deployment & Restart (Systemd)
Nach einem Import oder Code-Update müssen die API-Prozesse neu gestartet werden.
# Neustart des Produktions-Services (API + UI)
sudo systemctl restart mindnet-prod
sudo systemctl restart mindnet-ui-prod
# Prüfung
sudo systemctl status mindnet-prod
### 2.4 Full Rebuild (Clean Slate)
Notwendig bei Änderungen an `types.yaml` (z.B. neue Chunk-Größen) oder Embedding-Modellen. 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) # 1. Qdrant Collections löschen und neu anlegen (Wipe inkl. Schema)
python3 -m scripts.reset_qdrant --mode wipe --prefix "mindnet" --yes python3 -m scripts.reset_qdrant --mode wipe --prefix "mindnet" --yes
# 2. Vollständiger Import aller Dateien # 2. Vollständiger Import aller Dateien
python3 -m scripts.import_markdown \ python3 -m scripts.import_markdown --vault ./vault --prefix "mindnet" --apply
--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.
--- ---
@@ -116,40 +149,49 @@ Wenn in `types.yaml` für einen Typ `edge_defaults` definiert sind, werden diese
--- ---
## 5. Retriever & Scoring ## 5. Retriever, Chat & Generation (RAG Pipeline)
Der Retriever (`app/core/retriever.py`) kombiniert Signale zur Laufzeit. Der Datenfluss endet nicht beim Finden. Er geht weiter bis zur Antwort.
### 5.1 Konfiguration (`retriever.yaml`) ### 5.1 Retrieval (Hybrid)
Diese Datei steuert das Ranking. Änderungen wirken sofort (API-Neustart). Der `/chat` Endpunkt nutzt **Hybrid Retrieval** (Semantic + Graph), um auch logisch verbundene, aber textlich unterschiedliche Notizen zu finden (z.B. Decisions zu einem Projekt).
scoring: ### 5.2 Intent Router (WP06/07)
semantic_weight: 1.0 # Vektor-Ähnlichkeit Der Request durchläuft den **Hybrid Router**:
edge_weight: 0.7 # Graph-Dichte Bonus 1. **Fast Path:** Prüfung auf `trigger_keywords` aus `decision_engine.yaml`.
centrality_weight: 0.5 # Zentralitäts-Bonus 2. **Slow Path:** Falls kein Keyword matched und `llm_fallback_enabled=true`, klassifiziert das LLM den Intent.
* `FACT`: Wissen abfragen.
* `DECISION`: Rat suchen.
* `EMPATHY`: Trost suchen.
* `INTERVIEW`: Wissen eingeben (Neu in WP07).
3. **Result:** Auswahl der Strategie und der `inject_types` oder `schemas`.
### 5.2 Scoring-Formel ### 5.3 Context Enrichment
total_score = Der Router (`chat.py`) reichert die gefundenen Chunks mit Metadaten an:
semantic_weight * semantic_score * **Typ-Injection:** `[DECISION]`, `[PROJECT]`.
+ edge_weight * edge_bonus * **Reasoning-Infos:** `(Score: 0.75)`.
+ centrality_weight * centrality_bonus
+ type_weight * retriever_weight
* `retriever_weight`: Kommt aus dem Note-Payload (via `types.yaml`). ### 5.4 Generation (LLM)
* `edge_bonus`: Summe der `confidence` aller relevanten Kanten im Subgraph. * **Engine:** Ollama (lokal).
* **Modell:** `phi3:mini` (Standard).
### 5.3 Hybrider Modus * **Prompting:** Template wird basierend auf Intent gewählt (`decision_template`, `interview_template` etc.).
Der Request muss `mode="hybrid"` und `expand.depth > 0` setzen, damit der Graph genutzt wird. * **One-Shot (WP07):** Im Interview-Modus generiert das LLM direkt einen Markdown-Block ohne Rückfragen.
* **Expand:** Lädt Nachbarn der Vektor-Treffer.
* **Re-Rank:** Berechnet Boni auf diesem lokalen Graphen.
--- ---
## 6. Quality Gates & Tests ## 6. Feedback & Lernen (WP04c)
Das System schreibt kontinuierlich Logs ("Data Flywheel"):
* `data/logs/search_history.jsonl`: Trainingsdaten (Query + Ergebnisse + Breakdown).
* `data/logs/feedback.jsonl`: Labels (User-Rating zur `query_id`).
---
## 7. Quality Gates & Tests
Diese Tests garantieren die Stabilität der Pipeline. Diese Tests garantieren die Stabilität der Pipeline.
### 6.1 Pflicht-Tests vor Commit ### 7.1 Pflicht-Tests vor Commit
1. **Payload Dryrun (Schema-Check):** 1. **Payload Dryrun (Schema-Check):**
Simuliert Import, prüft JSON-Schema Konformität. Simuliert Import, prüft JSON-Schema Konformität.
@@ -157,35 +199,55 @@ Diese Tests garantieren die Stabilität der Pipeline.
python3 -m scripts.payload_dryrun --vault ./test_vault python3 -m scripts.payload_dryrun --vault ./test_vault
2. **Full Edge Check (Graph-Integrität):** 2. **Full Edge Check (Graph-Integrität):**
Prüft Invarianten (z.B. `next` muss reziprok zu `prev` sein; keine verwaisten Kanten). Prüft Invarianten (z.B. `next` muss reziprok zu `prev` sein).
python3 -m scripts.edges_full_check python3 -m scripts.edges_full_check
3. **Unit Tests:** ### 7.2 Smoke-Test (E2E)
Prüft am laufenden System (Prod oder Dev), ob Semantik, Graph und Feedback funktionieren.
pytest tests/test_retriever_basic.py tests/test_retriever_edges.py # Retriever Test
python scripts/test_retriever_smoke.py --mode hybrid --top-k 5
### 6.2 Smoke-Test (E2E) # Decision Engine Test (WP06)
Prüft am laufenden System, ob Semantik und Graph funktionieren. python tests/test_wp06_decision.py -p 8002 -e EMPATHY -q "Alles ist grau"
python scripts/test_retriever_smoke.py \ # Interview Test (WP07)
--query "mindnet" \ python tests/test_wp06_decision.py -p 8002 -e INTERVIEW -q "Neues Projekt starten"
--mode hybrid \
--expand-depth 1 \
--top-k 5
### 6.3 Roundtrip-Test (Datenverlust-Check) # Feedback Test
Exportiert Qdrant zurück nach Markdown und vergleicht mit Original. python tests/test_feedback_smoke.py --url http://localhost:8001/query
python3 -m scripts.export_markdown --out ./_export
python3 tests/compare_vaults.py --src ./vault --dst ./_export --focus body
--- ---
## 7. Ausblick & Roadmap ## 8. Ausblick & Roadmap (Technische Skizzen)
### 7.1 Self-Healing (WP06) Wie entwickeln wir die Pipeline weiter?
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) ### 8.1 WP-08: Self-Tuning (Skizze)
Geplant: Speicherung von User-Feedback zu Suchergebnissen, um `retriever.yaml` Gewichte mittelfristig automatisch zu justieren ("Self-Tuning"). **Ziel:** Die Gewichte in `retriever.yaml` basierend auf `feedback.jsonl` optimieren.
**Ansatz:** Ein Offline-Learning-Skript `scripts/optimize_weights.py`.
1. **Load:** Liest `search_history.jsonl` und joint mit `feedback.jsonl` via `query_id`.
2. **Analyze:** Korrelation Scores vs. User-Rating.
3. **Optimize:** Vorschlag neuer Gewichte für `retriever.yaml`.
---
## 16. Workpackage Status (v2.4.0)
Aktueller Implementierungsstand der Module.
| WP | Titel | Status | Anmerkung |
| :--- | :--- | :--- | :--- |
| **WP01** | Knowledge Design | 🟢 Live | Typen, Frontmatter definiert. |
| **WP02** | Chunking Strategy | 🟢 Live | Profilbasiertes Chunking aktiv. |
| **WP03** | Edge Logic / Import | 🟢 Live | Neue Importer-Pipeline mit Provenance. |
| **WP04a**| Retriever Scoring | 🟢 Live | Hybrider Score (Semantik + Graph). |
| **WP04b**| Explanation Layer | 🟢 Live | API liefert Reasons & Breakdown. |
| **WP04c**| Feedback Loop | 🟢 Live | Logging (JSONL) & Traceability aktiv. |
| **WP05** | Persönlichkeit / Chat | 🟢 Live | RAG-Integration mit Context Enrichment. |
| **WP06** | Decision Engine | 🟢 Live | Hybrid Router, Strategic Retrieval. |
| **WP07** | Interview Assistent | 🟢 Live | **One-Shot Extractor & Schemas aktiv.** |
| **WP08** | Self-Tuning | 🔴 Geplant | Auto-Adjustment der Gewichte. |
| **WP10** | Chat Interface | 🟢 Live | Web-Interface (Streamlit). |
| **WP10a**| Draft Editor | 🟢 Live | **Interaktives UI für WP07 Drafts.** |
+93 -76
View File
@@ -1,114 +1,131 @@
# Mindnet v2.2 – User Guide # Mindnet v2.4 – User Guide
**Datei:** `docs/mindnet_user_guide_v2.2.md` **Datei:** `docs/mindnet_user_guide_v2.4.md`
**Stand:** 2025-12-07 **Stand:** 2025-12-10
**Status:** **FINAL** (Konsolidiert WP01–WP04a) **Status:** **FINAL** (Inkl. RAG, Web-Interface & Interview-Assistent)
**Quellen:** `knowledge_design.md`, `wp04_retriever_scoring.md`, `Programmplan_V2.2.md`, `Handbuch.md`. **Quellen:** `knowledge_design.md`, `wp04_retriever_scoring.md`, `Programmplan_V2.2.md`, `Handbuch.md`.
> **Willkommen bei Mindnet.** > **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. > Dies ist dein persönliches Wissensnetzwerk und dein Digitaler Zwilling. Es hilft dir beim Erinnern, beim Entscheiden, beim Reflektieren und beim **Erstellen von Inhalten**.
--- ---
## 1. Was Mindnet für dich tut ## 1. Was Mindnet für dich tut
Mindnet ist ein **assoziatives Gedächtnis**. Es verbindet deine Notizen zu einem Graphen. Mindnet ist ein **assoziatives Gedächtnis** mit Persönlichkeit. Es unterscheidet sich von einer reinen Suche (wie Google) dadurch, dass es **kontextsensitiv** agiert.
### 1.1 Mehr als nur Stichworte ### 1.1 Das Gedächtnis (Der Graph)
Wenn du nach "Projekt Alpha" suchst, findet Mindnet nicht nur das Dokument mit diesem Titel. Es findet auch: Wenn du nach "Projekt Alpha" suchst, findet Mindnet nicht nur das Dokument. Es findet auch:
* **Abhängigkeiten:** "Technologie X wird benötigt" (weil sie verlinkt ist). * **Abhängigkeiten:** "Technologie X wird benötigt".
* **Entscheidungen:** "Warum nutzen wir X?" (weil eine Decision-Note existiert). * **Entscheidungen:** "Warum nutzen wir X?".
* **Ähnliches:** "Projekt Beta war ähnlich" (weil es strukturell verwandt ist). * **Ähnliches:** "Projekt Beta war ähnlich".
### 1.2 Dein KI-Zwilling (Vision) ### 1.2 Der Zwilling (Die Personas)
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. Mindnet passt seinen Charakter dynamisch an deine Frage an:
1. **Der Bibliothekar (FACT):** Liefert präzise Fakten und Definitionen.
2. **Der Berater (DECISION):** Hilft dir beim Abwägen, basierend auf deinen Werten und Zielen.
3. **Der Spiegel (EMPATHY):** Hört zu und antwortet basierend auf deinen Erfahrungen ("Ich"-Perspektive).
4. **Der Analyst (INTERVIEW):** Hilft dir, neue Notizen zu entwerfen und strukturiert zu erfassen.
--- ---
## 2. Gute Fragen an Mindnet stellen ## 2. Die Oberfläche (Web UI)
Mindnet nutzt eine **Hybride Suche**. Das heißt, es schaut auf deine Worte (Semantik) und auf das Netzwerk (Graph). Seit Version 2.3.1 bedienst du Mindnet über eine grafische Oberfläche im Browser.
### 2.1 Frage-Muster ### 2.1 Der Chat-Bereich
Um gute Antworten zu erhalten, formuliere deine Anfragen präzise: * **Eingabe:** Unten findest du das Textfeld.
* **Intent-Badge:** Über jeder Antwort zeigt ein kleines Label (z.B. **⚖️ Intent: DECISION**), in welchem Modus das System arbeitet und ob dies durch ein Schlüsselwort oder die KI erkannt wurde.
* **Quellen-Karten:** Unter der Antwort findest du ausklappbare Karten ("Expanders").
* **Grüner Punkt:** Hohe Relevanz (Score > 0.8).
* **Gelber Punkt:** Mittlere Relevanz.
* **Klick darauf:** Zeigt den Textauszug und die **Begründung** ("Warum wurde das gefunden?").
* **Faktensuche:** "Wie installiere ich Qdrant?" ### 2.2 Die Sidebar (Einstellungen & Verlauf)
* *Mindnet sucht:* Chunks mit technischer Anleitung. Hier gewinnt oft die reine Text-Ähnlichkeit. * **Modus-Wahl:** Umschalten zwischen "💬 Chat" und "📝 Manueller Editor".
* **Zusammenhänge:** "Womit hängt Projekt Alpha zusammen?" * **Verlauf:** Die letzten Suchanfragen sind hier gelistet. Ein Klick führt die Suche erneut aus.
* *Mindnet sucht:* Den Projekt-Knoten und folgt den Kanten (`depends_on`, `related_to`). Hier gewinnt der Graph. * **Settings:**
* **Entscheidungen:** "Warum nutzen wir Vektordatenbanken?" * **Top-K:** Wie viele Quellen sollen gelesen werden? (Standard: 5).
* *Mindnet sucht:* Notizen vom Typ `decision` oder `principle`. Hier gewinnt das Typ-Gewicht (`retriever_weight`). * **Explanation Layer:** Schaltet die "Warum"-Erklärungen an/aus.
### 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 ## 3. Den Chat steuern (Intents)
Wenn Mindnet antwortet, siehst du oft mehr als nur Text. Du siehst eine **Begründung**. Du steuerst die Persönlichkeit von Mindnet durch deine Wortwahl. Das System nutzt einen **Hybrid Router**, der sowohl auf Schlüsselwörter als auch auf die Bedeutung achtet.
### 3.1 Der Score (Warum ist das hier oben?) ### 3.1 Modus: Entscheidung ("Der Berater")
Mindnet berechnet für jeden Treffer einen `total_score`. Dieser ist keine Magie, sondern Mathematik: Wenn du vor einer Wahl stehst, hilft Mindnet dir, konform zu deinen Prinzipien zu bleiben.
Score = (Text-Treffer) + (Wichtigkeit) + (Vernetzung) * **Auslöser (Keywords):** "Soll ich...", "Was ist deine Meinung?", "Strategie für...", "Vor- und Nachteile".
* **Was passiert:** Mindnet lädt deine **Werte** (`type: value`) und **Ziele** (`type: goal`) in den Kontext und prüft die Fakten dagegen.
* **Beispiel-Dialog:**
* *Du:* "Soll ich Tool X nutzen?"
* *Mindnet:* "Nein. Tool X speichert Daten in den USA. Das verstößt gegen dein Prinzip 'Privacy First' und dein Ziel 'Digitale Autarkie'."
* **Text-Treffer (Semantik):** Wie gut passen die Worte? ### 3.2 Modus: Empathie ("Der Spiegel")
* **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. Wenn du frustriert bist oder reflektieren willst, wechselt Mindnet in den "Ich"-Modus.
* **Vernetzung (Edge Bonus):** Wird dieser Inhalt oft von anderen wichtigen Projekten referenziert? Ein "zentraler" Knoten wird bevorzugt.
### 3.2 Pfade (Der Kontext) * **Auslöser (Keywords & Semantik):** "Ich fühle mich...", "Traurig", "Gestresst", "Alles ist sinnlos", "Ich bin überfordert".
Oft zeigt Mindnet im Hintergrund (Explainability): * **Was passiert:** Mindnet lädt deine **Erfahrungen** (`type: experience`) und **Glaubenssätze** (`type: belief`). Es antwortet verständnisvoll und zitiert deine eigenen Lektionen.
*"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". ### 3.3 Modus: Interview ("Der Analyst") – Neu!
Wenn du Wissen festhalten willst, statt zu suchen.
* **Auslöser:** "Neues Projekt", "Notiz erstellen", "Ich will etwas festhalten", "Neue Entscheidung dokumentieren".
* **Was passiert:** Siehe Kapitel 6.3.
--- ---
## 4. Neues Wissen beisteuern (Authoring) ## 4. Ergebnisse interpretieren (Explanation Layer)
Mindnet lebt von deinem Input. Du musst kein Techniker sein, um gutes Wissen zu designen. Du schreibst einfach Markdown. Mindnet liefert nicht einfach nur Treffer. Es liefert eine **Begründung** (Explanation), warum es etwas gefunden hat.
### 4.1 Die Goldene Regel: "Verlinke semantisch" ### 4.1 Die Gründe ("Reasons")
Statt einfach nur `[[Link]]` zu schreiben, versuche zu sagen, *wie* es zusammenhängt. Das hilft dem Retriever später, den "Pfad" zu finden. Öffne eine Quellen-Karte, um zu sehen:
* *"Hohe textuelle Übereinstimmung."* (Semantik)
* Hängt es davon ab? -> `[[rel:depends_on Ziel]]` * *"Bevorzugt aufgrund des Typs 'decision'."* (Wichtigkeit)
* Ist es ähnlich? -> `[[rel:similar_to Ziel]]` * *"Verweist auf 'Projekt X' via 'depends_on'."* (Graph-Kontext)
* 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 ## 5. Feedback & Lernen
Mindnet wird schlauer, wenn du es pflegst. Mindnet wird schlauer, wenn du es pflegst. Nutze die Feedback-Funktionen im Chat:
### 5.1 Ergebnis fehlt? ### 5.1 Globales Feedback (Antwort-Qualität)
* Existiert die Notiz im Vault? * **Wie:** Klicke auf die **Sterne (1-5)** unter der Antwort.
* Ist sie isoliert (keine Links)? Isolierte Notizen haben keinen Graph-Bonus und werden schlechter gefunden. **Verlinke sie!** * **Bedeutung:** Bewertet, wie gut die generierte Antwort war (Prompting, Tonfall).
* 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? ### 5.2 Granulares Feedback (Quellen-Relevanz)
* Ist die Notiz veraltet? Setze `status: archived` (wenn du Filter konfiguriert hast) oder lösche sie. * **Wie:** Klicke innerhalb einer Quellen-Karte auf die **Smileys (Faces)**.
* Wird ein Begriff falsch verstanden? Füge Synonyme oder eine Definition hinzu. * **Bedeutung:**
* 😞 (Sad): Diese Quelle ist irrelevant/falsch. (Senkt zukünftig das Gewicht).
* 😐 (Neutral): Okay, aber nicht entscheidend.
* 😀 (Grin): Das ist der perfekte Treffer! (Stärkt diesen Typ/Kante).
### 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.
## 6. Neues Wissen beisteuern (Authoring)
Mindnet lebt von deinem Input. Du musst kein Techniker sein, um gutes Wissen zu designen. Siehe dazu das **Knowledge Design Manual** für Details.
### 6.1 Die Goldene Regel: "Verlinke semantisch"
Statt einfach nur `[[Link]]` zu schreiben, versuche zu sagen, *wie* es zusammenhängt.
* Hängt es davon ab? -> `[[rel:depends_on Ziel]]`
* Ist es ähnlich? -> `[[rel:similar_to Ziel]]`
### 6.2 Typen nutzen (Wichtig!)
Setze im Frontmatter deiner Notizen den richtigen Typ. Das ist der wichtigste Hebel für den Chat:
* Willst du, dass Mindnet etwas als **Regel** nutzt? -> `type: principle`
* Willst du, dass Mindnet dich an eine **Lektion** erinnert? -> `type: experience`
### 6.3 Der Interview-Assistent (Drafting)
Mindnet kann dir helfen, Markdown-Notizen zu schreiben.
1. **Start:** Schreibe im Chat: *"Ich möchte ein neues Projekt 'Apollo' starten, Ziel ist die Mondlandung."*
2. **Generierung:** Mindnet erkennt den Wunsch (`INTERVIEW`), analysiert den Satz und erstellt **sofort** einen Entwurf.
3. **Editor:** Die UI wechselt von der Chat-Blase zu einem **Draft-Editor**.
* Du siehst das generierte Frontmatter (`type: project`, `status: draft`).
* Du siehst den Body-Text mit Platzhaltern (`[TODO]`), wo Infos fehlten (z.B. Stakeholder).
4. **Finalisierung:** Ergänze die fehlenden Infos direkt im Editor und klicke auf **Download** oder **Kopieren**.
5. **Speichern:** Speichere die Datei in deinen Obsidian Vault. Beim nächsten Import ist sie im System.
+4 -6
View File
@@ -11,25 +11,23 @@ qdrant-client>=1.15.1
pydantic>=2.11.7 pydantic>=2.11.7
numpy>=2.3.2 numpy>=2.3.2
# --- Markdown & Parsing (Hier fehlten Pakete!) --- # --- Markdown & Parsing ---
python-frontmatter>=1.1.0 python-frontmatter>=1.1.0
# WICHTIG: Das fehlte und verursachte den Fehler
markdown-it-py>=3.0.0 markdown-it-py>=3.0.0
# WICHTIG: Für types.yaml und retriever.yaml
PyYAML>=6.0.2 PyYAML>=6.0.2
python-slugify>=8.0.4 python-slugify>=8.0.4
# --- KI & Embeddings --- # --- KI & Embeddings ---
sentence-transformers>=5.1.0 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 torch>=2.0.0
# --- Utilities --- # --- Utilities ---
# WICHTIG: Damit .env Dateien gelesen werden
python-dotenv>=1.1.1 python-dotenv>=1.1.1
requests>=2.32.5 requests>=2.32.5
tqdm>=4.67.1 tqdm>=4.67.1
# --- Testing --- # --- Testing ---
pytest>=8.4.2 pytest>=8.4.2
# --- Frontend (WP-10) ---
streamlit>=1.39.0
+44
View File
@@ -0,0 +1,44 @@
import requests
import json
import sys
# Konfiguration
API_URL = "http://localhost:8002/chat/" # Port ggf. anpassen
QUESTION = "Warum nutzen wir Qdrant für mindnet?" # Eine Frage, zu der du Notizen hast
def test_chat():
payload = {
"message": QUESTION,
"top_k": 3,
"explain": True
}
print(f"Sending Question: '{QUESTION}'...")
try:
response = requests.post(API_URL, json=payload)
response.raise_for_status()
data = response.json()
print("\n=== RESPONSE ===")
print(data["answer"])
print("================\n")
print(f"Query ID: {data['query_id']}")
print(f"Latency: {data['latency_ms']}ms")
print("\nUsed Sources:")
for source in data["sources"]:
score = source.get("total_score", 0)
note = source.get("note_id", "unknown")
print(f"- {note} (Score: {score:.3f})")
except requests.exceptions.ConnectionError:
print("Error: Could not connect to API. Is it running on port 8002?")
except Exception as e:
print(f"Error: {e}")
if 'response' in locals():
print(response.text)
if __name__ == "__main__":
test_chat()
+40
View File
@@ -0,0 +1,40 @@
import requests
import sys
API_URL = "http://localhost:8002/chat/"
def test_intent(message):
print(f"📡 Sende: '{message}' ...")
payload = {
"message": message,
"top_k": 0,
"explain": False
}
try:
# Timeout nach 30 Sekunden erzwingen
response = requests.post(API_URL, json=payload, timeout=30)
if response.status_code != 200:
print(f"❌ Server Error {response.status_code}: {response.text}")
return
data = response.json()
intent = data.get("intent")
source = data.get("intent_source")
answer = data.get("answer")
print(f"✅ Ergebnis erhalten:")
print(f" Intent: {intent} (Quelle: {source})")
print(f" Antwort: {answer[:100]}...") # Nur die ersten 100 Zeichen
print("-" * 40)
except requests.exceptions.Timeout:
print("❌ TIMEOUT: Das Backend antwortet nicht innerhalb von 30 Sekunden.")
print(" -> Prüfe das Terminal, wo uvicorn läuft. Gibt es dort Fehlermeldungen?")
except Exception as e:
print(f"❌ Fehler: {e}")
if __name__ == "__main__":
# Testfall: Muss INTERVIEW auslösen
test_intent("Ich möchte ein neues Projekt anlegen")
+122
View File
@@ -0,0 +1,122 @@
"""
tests/test_wp06_decision.py — Flexibler Integrationstest für WP-06
Update:
- Timeout 300s.
- Zeigt Intent Source an.
- Payload/Source Fallback für Metadaten.
- Debug-Dump bei unknown Type.
"""
import requests
import json
import sys
import argparse
def test_decision_engine(query: str, port: int, expected_intent: str):
api_url = f"http://localhost:{port}"
print(f"🔵 Starte WP-06 Decision Engine Test gegen {api_url}...\n")
payload = {
"message": query,
"top_k": 3,
"explain": True
}
try:
# Request senden
print(f"FRAGE: '{query}'")
print("... warte auf LLM (kann auf CPU >120s dauern) ...")
# FIX: Timeout auf 300 erhöht
response = requests.post(f"{api_url}/chat/", json=payload, timeout=300)
response.raise_for_status()
data = response.json()
# --- CHECKS ---
# 1. Intent Check
intent = data.get("intent", "UNKNOWN")
source_method = data.get("intent_source", "Unknown Source")
match = intent.upper() == expected_intent.upper()
print(f"\n1. INTENT DETECTION: [{'✅' if match else '❌'}]")
print(f" Erkannt: {intent}")
print(f" Erwartet: {expected_intent}")
print(f" Methode: {source_method}")
# 2. Source Check (Strategic Retrieval)
sources = data.get("sources", [])
strategic_hits = []
fact_hits = []
print(f"\n2. RETRIEVED SOURCES:")
if not sources:
print(" (Keine Quellen gefunden)")
debug_printed = False
for i, source in enumerate(sources):
# --- FIX: Robusterer Zugriff auf Metadaten ---
src_meta = source.get("payload") or source.get("source") or {}
node_type = src_meta.get("type", "unknown")
title = source.get("note_id", "Unknown")
score = source.get("total_score", 0.0)
# DEBUG: Wenn Typ unknown ist, dumpen wir das erste Objekt
if node_type == "unknown" and not debug_printed:
print(f"\n 🔴 DEBUG: Raw Data von Quelle {i+1} (da Typ unknown):")
print(json.dumps(source, indent=2, ensure_ascii=False))
print(" ------------------------------------------------")
debug_printed = True
# Marker für Ausgabe
marker = " "
if node_type in ["value", "principle", "goal", "experience", "belief", "profile", "decision"]:
marker = "🎯" # Strategischer Treffer
strategic_hits.append(f"{title} ({node_type})")
else:
marker = "📄"
fact_hits.append(title)
print(f" {marker} [{i+1}] {title} (Typ: {node_type}, Score: {score:.2f})")
# Analyse der Strategie
if strategic_hits:
print(f"\n ✅ ERFOLG: Strategische Quellen geladen: {strategic_hits}")
else:
print(f"\n ℹ️ INFO: Keine strategischen Quellen (Value/Experience/etc.) gefunden.")
# 3. Reasoning Check (LLM Antwort)
answer = data.get("answer", "")
print(f"\n3. REASONING (LLM Antwort):")
print("-" * 60)
print(answer)
print("-" * 60)
except requests.exceptions.ReadTimeout:
print(f"\n❌ TIMEOUT: Der Server hat nicht innerhalb von 300s geantwortet.")
print(" Tipp: Prüfe die Server-Logs (Terminal 1). Lädt er noch das Modell?")
sys.exit(1)
except requests.exceptions.ConnectionError:
print(f"\n❌ FEHLER: Keine Verbindung zu {api_url}. Läuft der Server?")
sys.exit(1)
except Exception as e:
print(f"\n❌ CRITICAL ERROR: {e}")
sys.exit(1)
if __name__ == "__main__":
parser = argparse.ArgumentParser(description="Testet die WP-06 Decision Engine.")
parser.add_argument("--query", "-q", type=str,
default="Soll ich SuperCloud Sync für meine privaten Tagebücher nutzen?",
help="Die Frage, die an das System gestellt wird.")
parser.add_argument("--port", "-p", type=int,
default=8002,
help="Der Port der API (Default: 8002 für Dev).")
parser.add_argument("--expect", "-e", type=str,
default="DECISION",
help="Der erwartete Intent (z.B. DECISION, EMPATHY, FACT).")
args = parser.parse_args()
test_decision_engine(args.query, args.port, args.expect)