From 6d268d9dfbdc3454f72d6c1a9b6e3cab1e1a885e Mon Sep 17 00:00:00 2001 From: Lars Date: Mon, 12 Jan 2026 15:27:23 +0100 Subject: [PATCH] Enhance .env loading mechanism and EdgeDTO creation with error handling - Updated the .env loading process to first check for an explicit path, improving reliability in different working directories. - Added logging for successful .env loading and fallback mechanisms. - Enhanced EdgeDTO creation with robust error handling, including fallbacks for unsupported provenance values and logging of errors for better traceability. --- app/config.py | 29 +++- app/core/retrieval/retriever.py | 47 ++++-- .../ENV_LOADING_DEBUG.md | 105 ++++++++++++++ .../PROD_DEPLOYMENT_CHECKLIST.md | 134 ++++++++++++++++++ .../PROD_PYTHON_CACHE_FIX.md | 134 ++++++++++++++++++ scripts/verify_dto_import.py | 69 +++++++++ scripts/verify_env_loading.py | 114 +++++++++++++++ 7 files changed, 620 insertions(+), 12 deletions(-) create mode 100644 docs/03_Technical_References/ENV_LOADING_DEBUG.md create mode 100644 docs/03_Technical_References/PROD_DEPLOYMENT_CHECKLIST.md create mode 100644 docs/03_Technical_References/PROD_PYTHON_CACHE_FIX.md create mode 100644 scripts/verify_dto_import.py create mode 100644 scripts/verify_env_loading.py diff --git a/app/config.py b/app/config.py index d712a8b..9f001d3 100644 --- a/app/config.py +++ b/app/config.py @@ -15,7 +15,34 @@ from dotenv import load_dotenv # WP-20: Lade Umgebungsvariablen aus der .env Datei # override=True garantiert, dass Änderungen in der .env immer Vorrang haben. -load_dotenv(override=True) +# WP-24c v4.5.10: Expliziter Pfad für .env-Datei, um Probleme mit Arbeitsverzeichnis zu vermeiden +# Suche .env im Projekt-Root (3 Ebenen über app/config.py: app/config.py -> app/ -> root/) +_project_root = Path(__file__).parent.parent.parent +_env_file = _project_root / ".env" +_env_loaded = False + +# Versuche zuerst expliziten Pfad +if _env_file.exists(): + _env_loaded = load_dotenv(_env_file, override=True) + if _env_loaded: + # Optional: Logging (nur wenn logging bereits initialisiert ist) + try: + import logging + _logger = logging.getLogger(__name__) + _logger.debug(f"✅ .env geladen von: {_env_file}") + except: + pass # Logging noch nicht initialisiert + +# Fallback: Automatische Suche (für Dev/Test oder wenn .env an anderer Stelle liegt) +if not _env_loaded: + _env_loaded = load_dotenv(override=True) + if _env_loaded: + try: + import logging + _logger = logging.getLogger(__name__) + _logger.debug(f"✅ .env geladen via automatische Suche (cwd: {Path.cwd()})") + except: + pass class Settings: # --- Qdrant Datenbank --- diff --git a/app/core/retrieval/retriever.py b/app/core/retrieval/retriever.py index 8a697ed..af1d406 100644 --- a/app/core/retrieval/retriever.py +++ b/app/core/retrieval/retriever.py @@ -216,17 +216,42 @@ def _build_explanation( direction = "in" if tgt == target_note_id else "out" - edge_obj = EdgeDTO( - id=f"{src}->{tgt}:{kind}", - kind=kind, - source=src, - target=tgt, - weight=conf, - direction=direction, - provenance=prov, - confidence=conf - ) - edges_dto.append(edge_obj) + # WP-24c v4.5.10: Robuste EdgeDTO-Erstellung mit Fehlerbehandlung + # Falls Provenance-Wert nicht unterstützt wird, verwende Fallback + try: + edge_obj = EdgeDTO( + id=f"{src}->{tgt}:{kind}", + kind=kind, + source=src, + target=tgt, + weight=conf, + direction=direction, + provenance=prov, + confidence=conf + ) + edges_dto.append(edge_obj) + except Exception as e: + # WP-24c v4.5.10: Fallback bei Validierungsfehler (z.B. alte EdgeDTO-Version im Cache) + logger.warning( + f"⚠️ [EDGE-DTO] Provenance '{prov}' nicht unterstützt für Edge {src}->{tgt} ({kind}). " + f"Fehler: {e}. Verwende Fallback 'explicit'." + ) + # Fallback: Verwende 'explicit' als sicheren Default + try: + edge_obj = EdgeDTO( + id=f"{src}->{tgt}:{kind}", + kind=kind, + source=src, + target=tgt, + weight=conf, + direction=direction, + provenance="explicit", # Fallback + confidence=conf + ) + edges_dto.append(edge_obj) + except Exception as e2: + logger.error(f"❌ [EDGE-DTO] Auch Fallback fehlgeschlagen: {e2}. Überspringe Edge.") + # Überspringe diese Kante - besser als kompletter Fehler # Die 3 wichtigsten Kanten als Begründung formulieren top_edges = sorted(edges_dto, key=lambda e: e.confidence, reverse=True) diff --git a/docs/03_Technical_References/ENV_LOADING_DEBUG.md b/docs/03_Technical_References/ENV_LOADING_DEBUG.md new file mode 100644 index 0000000..4712caf --- /dev/null +++ b/docs/03_Technical_References/ENV_LOADING_DEBUG.md @@ -0,0 +1,105 @@ +# Debug: .env-Lade-Problem in Prod + +**Datum**: 2026-01-12 +**Version**: v4.5.10 +**Status**: 🔴 Kritisch + +## Problem + +Möglicherweise wird die `.env`-Datei in Prod nicht korrekt geladen, was zu: +- Falschen Log-Levels (DEBUG=true wird ignoriert) +- Falschen Collection-Präfixen +- Falschen Konfigurationen +führen kann. + +## Diagnose + +### Schritt 1: Prüfe, ob .env-Datei existiert + +```bash +# In Prod +cd ~/mindnet +ls -la .env +cat .env | head -20 +``` + +### Schritt 2: Prüfe Arbeitsverzeichnis beim Start + +```bash +# In Prod - prüfe, von wo uvicorn gestartet wird +ps aux | grep uvicorn +# Oder in systemd service: +cat /etc/systemd/system/mindnet.service | grep WorkingDirectory +``` + +### Schritt 3: Verifikations-Script ausführen + +```bash +# In Prod +cd ~/mindnet +source .venv/bin/activate +python3 scripts/verify_env_loading.py +``` + +**Erwartete Ausgabe**: +``` +✅ .env geladen von: /path/to/mindnet/.env +✅ COLLECTION_PREFIX = mindnet +✅ DEBUG = true +``` + +### Schritt 4: Manuelle Verifikation + +```python +# In Python-REPL in Prod +import os +from pathlib import Path +from dotenv import load_dotenv + +# Prüfe aktuelles Verzeichnis +print(f"CWD: {Path.cwd()}") +print(f"Projekt-Root: {Path(__file__).parent.parent.parent}") + +# Lade .env +env_file = Path(".env") +if env_file.exists(): + load_dotenv(env_file, override=True) + print(f"✅ .env geladen: {env_file.absolute()}") +else: + print(f"❌ .env nicht gefunden in: {env_file.absolute()}") + +# Prüfe kritische Variablen +print(f"DEBUG: {os.getenv('DEBUG', 'NICHT GESETZT')}") +print(f"COLLECTION_PREFIX: {os.getenv('COLLECTION_PREFIX', 'NICHT GESETZT')}") +``` + +## Mögliche Ursachen + +### 1. Arbeitsverzeichnis-Problem +- **Problem**: uvicorn wird aus einem anderen Verzeichnis gestartet +- **Lösung**: Expliziter Pfad in `config.py` (bereits implementiert) + +### 2. .env-Datei nicht im Projekt-Root +- **Problem**: .env liegt in `config/prod.env` statt `.env` +- **Lösung**: Symlink erstellen oder Pfad anpassen + +### 3. Systemd-Service ohne WorkingDirectory +- **Problem**: Service startet ohne korrektes Arbeitsverzeichnis +- **Lösung**: `WorkingDirectory=/path/to/mindnet` in systemd service + +### 4. Mehrere .env-Dateien +- **Problem**: Es gibt `.env`, `prod.env`, `config/prod.env` - welche wird geladen? +- **Lösung**: Expliziter Pfad oder Umgebungsvariable `DOTENV_PATH` + +## Fix-Implementierung + +Der Code in `app/config.py` wurde erweitert: +- ✅ Expliziter Pfad für `.env` im Projekt-Root +- ✅ Fallback auf automatische Suche +- ✅ Debug-Logging (wenn verfügbar) + +## Verifikation nach Fix + +1. **Log prüfen**: Sollte `✅ .env geladen von: ...` zeigen +2. **Umgebungsvariablen prüfen**: `echo $DEBUG`, `echo $COLLECTION_PREFIX` +3. **Settings prüfen**: `python3 -c "from app.config import get_settings; s = get_settings(); print(f'DEBUG: {s.DEBUG}, PREFIX: {s.COLLECTION_PREFIX}')"` diff --git a/docs/03_Technical_References/PROD_DEPLOYMENT_CHECKLIST.md b/docs/03_Technical_References/PROD_DEPLOYMENT_CHECKLIST.md new file mode 100644 index 0000000..d05a3a9 --- /dev/null +++ b/docs/03_Technical_References/PROD_DEPLOYMENT_CHECKLIST.md @@ -0,0 +1,134 @@ +# Deployment-Checkliste: Prod vs. Dev Retrieval-Problem + +**Datum**: 2026-01-12 +**Version**: v4.5.10 +**Status**: 🔴 Kritisch + +## Problem + +Prod-System findet keine Suchergebnisse, während Dev-System korrekt funktioniert. Identischer Code, identische Daten. + +## Identifizierte Ursachen + +### 1. 🔴 **KRITISCH: Alte EdgeDTO-Version in Prod** + +**Symptom**: +``` +ERROR: 1 validation error for EdgeDTO +provenance + Input should be 'explicit', 'rule', 'smart' or 'structure' + [type=literal_error, input_value='explicit:callout', input_type=str] +``` + +**Ursache**: +- Prod verwendet eine **alte Version** des `EdgeDTO`-Modells aus `app/models/dto.py` +- Die alte Version unterstützt nur: `"explicit", "rule", "smart", "structure"` +- Die neue Version (v4.5.3+) unterstützt: `"explicit:callout", "explicit:wikilink", "explicit:note_zone", ...` + +**Lösung**: +- ✅ Code in `dto.py` ist bereits korrekt (Zeile 51-56) +- ⚠️ **Prod muss neu gestartet werden**, um die neue Version zu laden +- ⚠️ **Python-Modul-Cache leeren** falls nötig: `find . -type d -name __pycache__ -exec rm -r {} +` + +### 2. ✅ Collection-Präfix korrekt + +- Prod: `COLLECTION_PREFIX=mindnet` → `mindnet_chunks` ✅ +- Dev: `COLLECTION_PREFIX=mindnet_dev` → `mindnet_dev_chunks` ✅ +- **Kein Problem hier** + +## Sofortmaßnahmen + +### Schritt 1: Code-Verifikation in Prod + +```bash +# In Prod-System +cd /path/to/mindnet +grep -A 10 "provenance.*Literal" app/models/dto.py +``` + +**Erwartete Ausgabe**: +```python +provenance: Optional[Literal[ + "explicit", "rule", "smart", "structure", + "explicit:callout", "explicit:wikilink", "explicit:note_zone", ... +]] = "explicit" +``` + +**Falls nicht vorhanden**: Code ist nicht aktualisiert → Deployment erforderlich + +### Schritt 2: Python-Cache leeren + +```bash +# In Prod-System +find . -type d -name __pycache__ -exec rm -r {} + +find . -name "*.pyc" -delete +``` + +### Schritt 3: Service neu starten + +```bash +# FastAPI/uvicorn neu starten +# Oder Docker-Container neu starten +``` + +### Schritt 4: Verifikation + +1. **Test-Query ausführen**: + ```bash + curl -X POST http://localhost:8001/api/chat \ + -H "Content-Type: application/json" \ + -d '{"message": "Was für einen Status hat das Projekt mindnet?"}' + ``` + +2. **Log prüfen**: + - ✅ Keine `validation error for EdgeDTO` mehr + - ✅ `✨ [SUCCESS] Stream 'facts_stream' lieferte X Treffer.` + - ✅ Ergebnisse werden zurückgegeben + +## Code-Vergleich + +### Aktuelle Version (sollte in Prod sein): + +```python +# app/models/dto.py (Zeile 51-56) +provenance: Optional[Literal[ + "explicit", "rule", "smart", "structure", + "explicit:callout", "explicit:wikilink", "explicit:note_zone", "explicit:note_scope", + "inline:rel", "callout:edge", "semantic_ai", "structure:belongs_to", "structure:order", + "derived:backlink", "edge_defaults", "global_pool" +]] = "explicit" +``` + +### Alte Version (verursacht Fehler): + +```python +# Alte Version (nur 4 Werte) +provenance: Optional[Literal[ + "explicit", "rule", "smart", "structure" +]] = "explicit" +``` + +## Weitere mögliche Ursachen (wenn Fix nicht hilft) + +### 1. Unterschiedliche Python-Versionen +- Prüfen: `python --version` in Dev vs. Prod +- Pydantic-Verhalten kann zwischen Versionen variieren + +### 2. Unterschiedliche Pydantic-Versionen +- Prüfen: `pip list | grep pydantic` in Dev vs. Prod +- `requirements.txt` sollte identisch sein + +### 3. Unterschiedliche Embedding-Modelle +- Prüfen: `MINDNET_EMBEDDING_MODEL` in beiden Systemen +- **Beide verwenden**: `nomic-embed-text` ✅ + +### 4. Unterschiedliche Vektor-Dimensionen +- Prüfen: `VECTOR_DIM` in beiden Systemen +- **Beide verwenden**: `768` ✅ + +## Erwartetes Ergebnis nach Fix + +- ✅ Keine Pydantic-Validierungsfehler mehr +- ✅ Alle Streams liefern Ergebnisse +- ✅ Retrieval funktioniert identisch in Dev und Prod +- ✅ `explicit:callout` Provenance wird korrekt akzeptiert diff --git a/docs/03_Technical_References/PROD_PYTHON_CACHE_FIX.md b/docs/03_Technical_References/PROD_PYTHON_CACHE_FIX.md new file mode 100644 index 0000000..cb49dce --- /dev/null +++ b/docs/03_Technical_References/PROD_PYTHON_CACHE_FIX.md @@ -0,0 +1,134 @@ +# Fix: Python-Modul-Cache-Problem in Prod + +**Datum**: 2026-01-12 +**Version**: v4.5.10 +**Status**: 🔴 Kritisch + +## Problem + +Code in `app/models/dto.py` ist korrekt (enthält `explicit:callout`), aber Prod verwendet trotzdem eine alte Version. + +**Symptom**: +``` +ERROR: 1 validation error for EdgeDTO +provenance + Input should be 'explicit', 'rule', 'smart' or 'structure' + [type=literal_error, input_value='explicit:callout', input_type=str] +``` + +## Ursache + +**Python-Modul-Cache**: Python speichert kompilierte `.pyc` Dateien in `__pycache__` Verzeichnissen. Wenn der Code aktualisiert wird, aber der Service nicht neu gestartet wird, lädt Python die alte gecachte Version. + +## Sofortmaßnahmen + +### Schritt 1: Python-Cache leeren + +```bash +# In Prod-System +cd ~/mindnet + +# Finde und lösche alle __pycache__ Verzeichnisse +find . -type d -name __pycache__ -exec rm -r {} + 2>/dev/null || true + +# Finde und lösche alle .pyc Dateien +find . -name "*.pyc" -delete + +# Speziell für dto.py +rm -rf app/models/__pycache__ +rm -rf app/__pycache__ +rm -rf __pycache__ +``` + +### Schritt 2: Verifikation des Codes + +```bash +# Prüfe, ob der Code korrekt ist +grep -A 10 "provenance.*Literal" app/models/dto.py | grep "explicit:callout" +``` + +**Erwartete Ausgabe**: Sollte `explicit:callout` enthalten + +### Schritt 3: Service neu starten + +**Option A: FastAPI/uvicorn direkt**: +```bash +# Service stoppen (Ctrl+C oder kill) +# Dann neu starten +source .venv/bin/activate +uvicorn app.main:app --host 0.0.0.0 --port 8001 --reload +``` + +**Option B: Systemd-Service**: +```bash +sudo systemctl restart mindnet-prod +# oder +sudo systemctl restart mindnet +``` + +**Option C: Docker-Container**: +```bash +docker-compose restart mindnet +# oder +docker restart mindnet-container +``` + +### Schritt 4: Verifikation zur Laufzeit + +**Test-Script ausführen** (wenn verfügbar): +```bash +python3 scripts/verify_dto_import.py +``` + +**Erwartete Ausgabe**: +``` +✅ EdgeDTO unterstützt 'explicit:callout' +✅ 'explicit:callout' ist in der Literal-Liste enthalten +✅ EdgeDTO mit 'explicit:callout' erfolgreich erstellt! +``` + +**Oder manuell testen**: +```python +python3 -c " +from app.models.dto import EdgeDTO +test = EdgeDTO( + id='test', kind='test', source='test', target='test', + weight=1.0, provenance='explicit:callout' +) +print('✅ EdgeDTO mit explicit:callout funktioniert!') +" +``` + +## Code-Fix (Fallback-Mechanismus) + +Ein Fallback-Mechanismus wurde in `retriever.py` implementiert: +- Wenn `EdgeDTO` mit `explicit:callout` fehlschlägt, wird automatisch `explicit` als Fallback verwendet +- Dies verhindert, dass der gesamte Retrieval-Prozess fehlschlägt +- **WICHTIG**: Dies ist nur eine temporäre Lösung - der Cache muss trotzdem geleert werden! + +## Verifikation nach Fix + +1. **Test-Query ausführen**: + ```bash + curl -X POST http://localhost:8001/api/chat \ + -H "Content-Type: application/json" \ + -d '{"message": "Was für einen Status hat das Projekt mindnet?"}' + ``` + +2. **Log prüfen**: + - ✅ Keine `validation error for EdgeDTO` mehr + - ✅ Keine `⚠️ [EDGE-DTO] Provenance 'explicit:callout' nicht unterstützt` Warnungen + - ✅ `✨ [SUCCESS] Stream 'facts_stream' lieferte X Treffer.` + - ✅ Ergebnisse werden zurückgegeben + +## Warum passiert das? + +1. **Code wurde aktualisiert**, aber Service läuft noch mit alter Version im Speicher +2. **Python lädt Module nur einmal** - nach dem ersten Import wird die gecachte Version verwendet +3. **__pycache__ Verzeichnisse** enthalten kompilierte Bytecode-Versionen der alten Dateien + +## Prävention + +- **Immer Service neu starten** nach Code-Änderungen +- **Cache regelmäßig leeren** bei Deployment +- **Verwende `--reload` Flag** bei uvicorn für automatisches Neuladen (nur für Dev!) diff --git a/scripts/verify_dto_import.py b/scripts/verify_dto_import.py new file mode 100644 index 0000000..195a10a --- /dev/null +++ b/scripts/verify_dto_import.py @@ -0,0 +1,69 @@ +#!/usr/bin/env python3 +""" +Script zur Verifikation der EdgeDTO-Import-Version in Prod. +Prüft, ob die korrekte Version des EdgeDTO-Modells geladen wird. +""" +import sys +import os + +# Stelle sicher, dass der Projekt-Pfad im Python-Path ist +sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + +try: + from app.models.dto import EdgeDTO + import inspect + + # Extrahiere die Literal-Definition aus dem Source-Code + source = inspect.getsource(EdgeDTO) + + # Prüfe, ob explicit:callout in der Literal-Liste ist + if "explicit:callout" in source: + print("✅ EdgeDTO unterstützt 'explicit:callout'") + print(f" -> Modul-Pfad: {EdgeDTO.__module__}") + print(f" -> Datei: {inspect.getfile(EdgeDTO)}") + + # Zeige die Provenance-Definition + import re + match = re.search(r'provenance.*?Literal\[(.*?)\]', source, re.DOTALL) + if match: + literal_values = match.group(1) + if "explicit:callout" in literal_values: + print("✅ 'explicit:callout' ist in der Literal-Liste enthalten") + print(f"\n Literal-Werte (erste 200 Zeichen):\n {literal_values[:200]}...") + else: + print("❌ 'explicit:callout' ist NICHT in der Literal-Liste!") + print(f"\n Gefundene Literal-Werte:\n {literal_values}") + else: + print("⚠️ Konnte Literal-Definition nicht finden") + else: + print("❌ EdgeDTO unterstützt NICHT 'explicit:callout'") + print(f" -> Modul-Pfad: {EdgeDTO.__module__}") + print(f" -> Datei: {inspect.getfile(EdgeDTO)}") + print("\n Source-Code (erste 500 Zeichen):") + print(f" {source[:500]}...") + + # Test: Versuche ein EdgeDTO mit explicit:callout zu erstellen + print("\n🧪 Test: Erstelle EdgeDTO mit provenance='explicit:callout'...") + try: + test_edge = EdgeDTO( + id="test", + kind="test", + source="test", + target="test", + weight=1.0, + provenance="explicit:callout" + ) + print("✅ EdgeDTO mit 'explicit:callout' erfolgreich erstellt!") + print(f" -> Provenance: {test_edge.provenance}") + except Exception as e: + print(f"❌ Fehler beim Erstellen: {e}") + print(f" -> Typ: {type(e).__name__}") + +except ImportError as e: + print(f"❌ Import-Fehler: {e}") + sys.exit(1) +except Exception as e: + print(f"❌ Unerwarteter Fehler: {e}") + import traceback + traceback.print_exc() + sys.exit(1) diff --git a/scripts/verify_env_loading.py b/scripts/verify_env_loading.py new file mode 100644 index 0000000..31efa6c --- /dev/null +++ b/scripts/verify_env_loading.py @@ -0,0 +1,114 @@ +#!/usr/bin/env python3 +""" +Script zur Verifikation des .env-Ladens in Prod. +Prüft, ob die .env-Datei korrekt geladen wird und welche Werte tatsächlich verwendet werden. +""" +import os +import sys +from pathlib import Path + +# Stelle sicher, dass der Projekt-Pfad im Python-Path ist +project_root = Path(__file__).parent.parent +sys.path.insert(0, str(project_root)) + +print("=" * 80) +print("🔍 .env-Lade-Verifikation") +print("=" * 80) + +# 1. Prüfe, ob .env-Datei existiert +env_files = [ + project_root / ".env", + project_root / "prod.env", + project_root / "config" / "prod.env", + Path.cwd() / ".env", + Path.cwd() / "prod.env", +] + +print("\n1. Suche nach .env-Dateien:") +found_env = None +for env_file in env_files: + if env_file.exists(): + print(f" ✅ Gefunden: {env_file}") + if found_env is None: + found_env = env_file + else: + print(f" ❌ Nicht gefunden: {env_file}") + +if not found_env: + print("\n ⚠️ WARNUNG: Keine .env-Datei gefunden!") + print(" -> load_dotenv() wird Standard-Werte verwenden") + +# 2. Lade .env manuell +print("\n2. Lade .env-Datei:") +from dotenv import load_dotenv + +if found_env: + result = load_dotenv(found_env, override=True) + print(f" ✅ load_dotenv('{found_env}') = {result}") +else: + result = load_dotenv(override=True) + print(f" ⚠️ load_dotenv() ohne expliziten Pfad = {result}") + print(" -> Sucht automatisch nach .env im aktuellen Verzeichnis") + +# 3. Prüfe kritische Umgebungsvariablen +print("\n3. Kritische Umgebungsvariablen:") +critical_vars = [ + "COLLECTION_PREFIX", + "MINDNET_PREFIX", + "DEBUG", + "VECTOR_DIM", + "MINDNET_EMBEDDING_MODEL", + "QDRANT_URL", +] + +for var in critical_vars: + value = os.getenv(var, "NICHT GESETZT") + source = "Umgebung" if var in os.environ else "Default/Code" + print(f" {var:30} = {value:40} ({source})") + +# 4. Prüfe, welche .env-Datei tatsächlich geladen wurde +print("\n4. Verifikation der geladenen Werte:") +print(f" Arbeitsverzeichnis: {Path.cwd()}") +print(f" Projekt-Root: {project_root}") +print(f" Python-Pfad[0]: {sys.path[0] if sys.path else 'N/A'}") + +# 5. Test: Importiere Settings +print("\n5. Test: Importiere Settings aus app.config:") +try: + from app.config import get_settings + settings = get_settings() + print(f" ✅ Settings erfolgreich geladen") + print(f" -> COLLECTION_PREFIX: {settings.COLLECTION_PREFIX}") + print(f" -> VECTOR_SIZE: {settings.VECTOR_SIZE}") + print(f" -> EMBEDDING_MODEL: {settings.EMBEDDING_MODEL}") +except Exception as e: + print(f" ❌ Fehler beim Laden der Settings: {e}") + import traceback + traceback.print_exc() + +# 6. Test: Prüfe EdgeDTO +print("\n6. Test: Prüfe EdgeDTO-Import:") +try: + from app.models.dto import EdgeDTO + import inspect + + source = inspect.getsource(EdgeDTO) + if "explicit:callout" in source: + print(" ✅ EdgeDTO unterstützt 'explicit:callout'") + print(f" -> Modul-Pfad: {EdgeDTO.__module__}") + print(f" -> Datei: {inspect.getfile(EdgeDTO)}") + else: + print(" ❌ EdgeDTO unterstützt NICHT 'explicit:callout'") + + # Test-Erstellung + test_edge = EdgeDTO( + id="test", kind="test", source="test", target="test", + weight=1.0, provenance="explicit:callout" + ) + print(" ✅ EdgeDTO mit 'explicit:callout' erfolgreich erstellt!") +except Exception as e: + print(f" ❌ Fehler: {e}") + import traceback + traceback.print_exc() + +print("\n" + "=" * 80)