docs/06_Roadmap/06_active_roadmap.md

@@ -2,18 +2,18 @@
 doc_type: roadmap
 audience: product_owner, developer
 status: active
-version: 2.6
+version: 2.7
 context: "Aktuelle Planung für kommende Features (ab WP16), Release-Strategie und Historie der abgeschlossenen WPs."
 ---
 
 # Mindnet Active Roadmap
 
-**Aktueller Stand:** v2.6.0 (Post-WP19)
+**Aktueller Stand:** v2.6.0 (Post-WP15/WP19)
-**Fokus:** Visualisierung, Exploration & Deep Search.
+**Fokus:** Visualisierung, Exploration & Intelligent Ingestion.
 
 ## 1. Programmstatus
 
-Wir haben mit der Implementierung des Graph Explorers (WP19) einen Meilenstein in **Phase E (Maintenance & Scaling)** erreicht. Die Architektur ist nun modular. Der nächste Schritt (WP19a) vertieft die Analyse-Fähigkeiten.
+Wir haben mit der Implementierung des Graph Explorers (WP19) und der Smart Edge Allocation (WP15) die Basis für ein intelligentes, robustes System gelegt. Der nächste Schritt (WP19a) vertieft die Analyse, während WP16 die "Eingangs-Intelligenz" erhöht.
 
 | Phase | Fokus | Status |
 | :--- | :--- | :--- |
@@ -43,14 +43,14 @@ Eine Übersicht der implementierten Features zum schnellen Auffinden von Funktio
 | **WP-10** | Web UI | Streamlit-Frontend als Ersatz für das Terminal. |
 | **WP-10a**| Draft Editor | GUI-Komponente zum Bearbeiten und Speichern generierter Notizen. |
 | **WP-11** | Backend Intelligence | `nomic-embed-text` (768d) und Matrix-Logik für Kanten-Typisierung. |
-| **WP-15** | Smart Edge Allocation | LLM-Filter für Kanten in Chunks + Traffic Control (Semaphore). |
+| **WP-15** | Smart Edge Allocation | LLM-Filter für Kanten in Chunks + Traffic Control (Semaphore) + Strict Chunking. |
 | **WP-19** | Graph Visualisierung | **Frontend Modularisierung:** Umbau auf `ui_*.py`.<br>**Graph Engines:** Parallelbetrieb von Cytoscape (COSE) und Agraph.<br>**Tools:** "Single Source of Truth" Editor, Persistenz via URL. |
 
 ---
 
 ## 3. Offene Workpackages (Planung)
 
-Diese Features stehen als nächstes an.
+Diese Features stehen als nächstes an oder befinden sich in der Umsetzung.
 
 ### WP-19a – Graph Intelligence & Discovery (Sprint-Fokus)
 **Status:** 🚀 Startklar
@@ -59,11 +59,26 @@ Diese Features stehen als nächstes an.
 * **Filter-Logik:** "Zeige nur Wege, die zu `type:decision` führen".
 * **Chunk Inspection:** Umschaltbare Granularität (Notiz vs. Chunk) zur Validierung des Smart Chunkers.
 
-### WP-16 – Auto-Discovery & Enrichment
+### WP-14 – Review / Refactoring / Dokumentation
+**Status:** 🟡 Laufend (Phase E)
+**Ziel:** Technische Schulden abbauen, die durch schnelle Feature-Entwicklung (WP15/WP19) entstanden sind.
+* **Refactoring `chunker.py`:** Die Datei ist monolithisch geworden (Parsing, Strategien, LLM-Orchestrierung).
+    * *Lösung:* Aufteilung in ein Package `app/core/chunking/` mit Modulen (`strategies.py`, `orchestration.py`, `utils.py`).
+* **Dokumentation:** Kontinuierliche Synchronisation von Code und Docs (v2.6 Stand).
+
+### WP-16 – Auto-Discovery & Intelligent Ingestion
 **Status:** 🟡 Geplant
-**Ziel:** Automatisches Erkennen von fehlenden Kanten in "dummem" Text *vor* der Speicherung.
+**Ziel:** Das System soll "dumme" Textdateien beim Import automatisch analysieren, strukturieren und anreichern, bevor sie gespeichert werden.
-* **Problem:** Nutzer vergessen Wikilinks.
+**Kern-Features:**
-* **Lösung:** Ein "Enricher" scannt Text vor dem Import, findet Keywords (z.B. "Mindnet") und schlägt Links vor (`[[Mindnet]]`).
+1.  **Smart Link Enricher:** Automatisches Erkennen von fehlenden Kanten in Texten ohne explizite Wikilinks. Ein "Enricher" scannt Text vor dem Import, findet Keywords (z.B. "Mindnet") und schlägt Links vor (`[[Mindnet]]`).
+2.  **Structure Analyzer (Auto-Strategy):**
+    * *Problem:* Manuelle Zuweisung von `chunking_profile` in `types.yaml` ist starr.
+    * *Lösung:* Vorschalten einer Analysestufe im Importer (`chunker.py`), die die Text-Topologie prüft und die Strategie wählt.
+    * *Metrik 1 (Heading Density):* Verhältnis `Anzahl Überschriften / Wortanzahl`. Hohe Dichte (> 1/200) -> Indikator für `structured_smart_edges`. Niedrige Dichte -> `sliding_smart_edges`.
+    * *Metrik 2 (Variance):* Regelmäßigkeit der Abstände zwischen Headings.
+3.  **Context-Aware Hierarchy Merging:**
+    * *Problem:* Leere Zwischenüberschriften (z.B. "Tier 2") gingen früher als bedeutungslose Chunks verloren oder wurden isoliert.
+    * *Lösung:* Generalisierung der Logik aus WP-15, die leere Eltern-Elemente automatisch mit dem ersten Kind-Element verschmilzt ("Tier 2 + MP1"), um den Kontext für das Embedding zu wahren.
 
 ### WP-17 – Conversational Memory (Gedächtnis)
 **Status:** 🟡 Geplant
@@ -77,6 +92,11 @@ Diese Features stehen als nächstes an.
 * **Feature:** Cronjob `check_graph_integrity.py`.
 * **Funktion:** Findet "Dangling Edges" (Links auf gelöschte Notizen) und repariert/löscht sie.
 
+### WP-13 – MCP-Integration & Agenten-Layer
+**Status:** 🟡 Geplant
+**Ziel:** mindnet als MCP-Server bereitstellen, damit Agenten (Claude Desktop, OpenAI) standardisierte Tools nutzen können.
+* **Umfang:** MCP-Server mit Tools (`mindnet_query`, `mindnet_explain`, etc.).
+
 ### WP-20 – Cloud Hybrid Mode (Optional)
 **Status:** ⚪ Optional
 **Ziel:** "Turbo-Modus" für Massen-Imports.
@@ -91,4 +111,6 @@ graph TD
     WP19(Graph Viz) --> WP19a(Discovery)
     WP19a --> WP17(Memory)
     WP15(Smart Edges) --> WP16(Auto-Discovery)
+    WP15 --> WP14(Refactoring)
     WP03(Import) --> WP18(Health Check)
+    WP03/WP04 --> WP13(MCP)

docs/06_Roadmap/06_handover_prompts.md

@@ -0,0 +1,202 @@
+---
+doc_type: operations
+audience: developer, admin
+status: active
+version: 1.0
+context: "Sammlung von Initialisierungs-Prompts für neue Chat-Sessions. Jeder Prompt entspricht dem Projektauftrag für ein spezifisches Workpackage."
+---
+
+# Mindnet WP-Handover Prompts
+
+**Verwendung:**
+Kopiere den entsprechenden Block in ein **neues** Chat-Fenster, um die KI-Instanz exakt auf den Kontext und die Ziele des Workpackages einzustellen.
+
+---
+
+## WP-19a: Graph Intelligence & Discovery
+
+**Status:** 🚀 Startklar
+**Fokus:** Frontend-Erweiterung, Semantische Suche, Filterung.
+
+```text
+Du bist der Lead Developer für "Mindnet", ein lokales RAG-System (Python/FastAPI/Streamlit/Qdrant).
+Wir starten jetzt **WP-19a: Graph Intelligence & Discovery**.
+
+**Status Quo (v2.6.0):**
+- Backend: Async API mit `/query` (Hybrid Search) und `/chat`.
+- Frontend: Modularisiertes Streamlit (`ui.py`, `ui_graph.py`).
+- Daten: Qdrant Indizes (`notes`, `chunks`, `edges`) sind gefüllt.
+
+**Dein Auftrag (WP-19a):**
+Implementiere "Deep Dive" Werkzeuge im Frontend, um den Graphen nicht nur zu sehen, sondern zu verstehen.
+1. **Neues UI-Modul:** Erstelle `app/frontend/ui_discovery.py`.
+2. **Discovery Tab:** Implementiere eine Oberfläche für:
+   - Semantische Suche (ohne Chat-Modus).
+   - Wildcard-Filter ("Zeige alle Notes vom Typ 'decision'").
+   - Pfad-Analyse ("Wie sind Note A und Note B verbunden?").
+3. **Chunk Inspection:** Baue einen Toggle, der im Graph-Explorer zwischen "Note-View" (grob) und "Chunk-View" (fein) umschaltet.
+
+**Regeln:**
+- Nutze `st.session_state` für Persistenz zwischen Re-Renders.
+- Halte die Business-Logik im Backend (ggf. neue Endpoints in `app/routers/query.py`).
+- Gib vollständigen, lauffähigen Code aus.
+
+Bitte bestätige die Übernahme und skizziere die Architektur für `ui_discovery.py`.
+```
+
+---
+
+## WP-13: MCP Integration & Agenten-Layer
+
+**Status:** 🟡 Geplant
+**Fokus:** Schnittstelle für externe Agenten (Claude Desktop).
+
+```text
+Du bist der Lead Developer für "Mindnet" (Python/FastAPI/Qdrant).
+Wir starten jetzt **WP-13: MCP Integration**.
+
+**Status Quo (v2.6.0):**
+- Das System läuft stabil asynchron.
+- `types.yaml` steuert die Logik.
+- Es existieren Services für Retrieval und Graph-Access.
+
+**Dein Auftrag (WP-13):**
+Implementiere einen MCP-Server (Model Context Protocol), der Mindnet als "Tool" für Claude Desktop verfügbar macht.
+1. **Server:** Erstelle `app/mcp_server.py` basierend auf dem `mcp`-SDK.
+2. **Tools:** Implementiere folgende Tools:
+   - `search_notes(query)`: Nutzt unseren Hybriden Retriever.
+   - `read_note(id)`: Liest Fulltext einer Notiz.
+   - `list_connections(id)`: Zeigt Edges an.
+   - `Notes(content)`: (Optional) Nutzt die Ingestion-Pipeline.
+3. **Integration:** Nutze die bestehenden Services (`Retriever`, `QdrantClient`) wieder – kein redundanter Code!
+4. **Async:** Achte auf Kompatibilität zwischen MCP und unserem `asyncio` Core.
+
+**Regeln:**
+- Halte dich strikt an die Architektur in `mindnet_technical_architecture.md`.
+- Aktualisiere den `admin_guide.md` mit Anweisungen zur Einbindung in Claude Desktop config.
+
+Bitte bestätige die Übernahme und zeige einen ersten Entwurf für `app/mcp_server.py`.
+```
+
+---
+
+## WP-14: Review & Refactoring
+
+**Status:** 🟡 Laufend
+**Fokus:** Code-Qualität, Modularisierung, Technische Schulden.
+
+```text
+Du bist der Software-Architekt für "Mindnet".
+Wir starten **WP-14: Review & Refactoring**.
+
+**Status Quo (v2.6.0):**
+- Das System ist funktional mächtig, aber einige Dateien (z.B. `chunker.py`) sind monolithisch geworden.
+- Dokumentation und Code müssen synchronisiert werden.
+
+**Dein Auftrag (WP-14):**
+1. **Refactoring `chunker.py`:** Zerlege den Monolithen in ein sauberes Package `app/core/chunking/`.
+   - `strategies.py`: Enthält `sliding_window` und `by_heading` Logik.
+   - `orchestration.py`: Enthält `assemble_chunks` und Smart-Edge-Flow.
+   - `utils.py`: Helper.
+2. **Cleanup:** Entferne veraltete / auskommentierte Code-Blöcke im gesamten Projekt.
+3. **Doc-Sync:** Prüfe, ob alle Parameter in `types.yaml` auch im Code verwendet werden (Dead Config Detection).
+
+**Regeln:**
+- Funktionalität darf sich nicht ändern (Regression Tests!).
+- Imports in `scripts/import_markdown.py` müssen angepasst werden.
+
+Bitte bestätige und beginne mit der Strukturierung des neuen `chunking` Packages.
+```
+
+---
+
+## WP-16: Auto-Discovery & Intelligent Ingestion
+
+**Status:** 🟡 Geplant
+**Fokus:** Automatisierung beim Import, "Smarter Text".
+
+```text
+Du bist der Lead Developer für "Mindnet".
+Wir starten **WP-16: Auto-Discovery & Intelligent Ingestion**.
+
+**Status Quo (v2.6.0):**
+- Import verlässt sich auf explizite Wikilinks und manuelle Profil-Wahl in `types.yaml`.
+- Smart Edges filtern nur vorhandene Links.
+
+**Dein Auftrag (WP-16):**
+Mache den Import intelligenter, bevor Daten gespeichert werden.
+1. **Structure Analyzer:** Erweitere den Chunker um eine Vor-Analyse.
+   - Berechne "Heading Density" (Überschriften pro Wort).
+   - Wähle automatisch `structured` (hohe Dichte) oder `sliding` (niedrige Dichte), wenn `profile: auto` gesetzt ist.
+2. **Smart Link Enricher:** Implementiere einen Service, der im Text nach Keywords sucht, die als Titel anderer Notizen existieren (Exact Match & Fuzzy Match).
+   - Schlage diese als `suggested_edges` vor.
+3. **Hierarchy Merging:** Generalisiere die Logik, dass leere Überschriften ("Tier 2") automatisch mit dem folgenden Inhalt verschmelzen.
+
+**Regeln:**
+- Performance beachten! Der Import darf nicht ewig dauern.
+- Änderungen am Content nur im RAM, Original-Datei bleibt unangetastet (außer User will Writeback).
+
+Bitte bestätige und skizziere den Algorithmus für den Structure Analyzer.
+```
+
+---
+
+## WP-17: Conversational Memory
+
+**Status:** 🟡 Geplant
+**Fokus:** Dialog-Qualität, Kontext.
+
+```text
+Du bist der AI-Engineer für "Mindnet".
+Wir starten **WP-17: Conversational Memory**.
+
+**Status Quo (v2.6.0):**
+- Chat ist "stateless". Jede Anfrage wird isoliert betrachtet.
+- RAG funktioniert, aber Rückfragen ("Was meinst du damit?") scheitern.
+
+**Dein Auftrag (WP-17):**
+Implementiere ein Kurzzeitgedächtnis für den Chat.
+1. **API Update:** Erweitere `ChatRequest` (DTO) um ein Feld `history: List[Message]`.
+2. **Frontend:** Passe `ui.py` an, um die letzten N Nachrichten mitzusenden.
+3. **Token Management:** Implementiere eine Logik im `LLMService`, die das Kontext-Fenster (z.B. 4k Token) balanciert:
+   - System Prompt (fest)
+   - RAG Chunks (hoch gewichtet)
+   - Chat History (auffüllen bis Limit)
+4. **Prompting:** Integriere `{chat_history}` in das Template in `prompts.yaml`.
+
+**Regeln:**
+- Nutze effizientes Truncation (älteste Nachrichten zuerst weg).
+- History darf RAG-Wissen nicht verdrängen (Reserviere min. 60% für RAG).
+
+Bitte bestätige und zeige das aktualisierte Pydantic-Modell für `ChatRequest`.
+```
+
+---
+
+## WP-18: Graph Health & Maintenance
+
+**Status:** 🟡 Geplant
+**Fokus:** Datenintegrität, Garbage Collection.
+
+```text
+Du bist der DevOps Engineer für "Mindnet".
+Wir starten **WP-18: Graph Health & Maintenance**.
+
+**Status Quo (v2.6.0):**
+- Import ist asynchron. Bei Timeouts kann der DB-Stand vom File-System abweichen (Hash-Mismatch).
+- Gelöschte Notizen hinterlassen "Dangling Edges".
+
+**Dein Auftrag (WP-18):**
+1. **Transactional Ingestion:** Implementiere einen "Two-Phase Commit" für den Import.
+   - Der File-Hash für die Änderungserkennung darf erst aktualisiert werden, wenn der Qdrant-Upsert *bestätigt* erfolgreich war.
+2. **Integrity Script:** Erstelle `scripts/check_graph_integrity.py`.
+   - Prüfe: Gibt es Edges, deren `target_id` nicht in `notes` existiert?
+   - Aktion: Report oder Auto-Delete.
+3. **Resolve References:** Erweitere das Skript um Logik, die "Unresolved Targets" (Text-Links) nachträglich in echte UUID-Links wandelt, wenn die Ziel-Notiz später importiert wurde.
+
+**Regeln:**
+- Sicherheit geht vor Geschwindigkeit.
+- Keine Datenlöschung ohne Log-Eintrag.
+
+Bitte bestätige und skizziere die Logik für den Transactional Hash Update.
+```