Kapitel 20/Premium Rohtext.md hinzugefügt

Kapitel 20/Premium Rohtext.md

@@ -0,0 +1,656 @@
+# Premium – Tandoor: Erweiterte Rollen, Nährwertanalyse & KI-gestützte Wochenplanung
+
+Tandoor ist im UCC weit mehr als nur eine digitale Rezeptdatenbank.  
+Im Premium-Kapitel wird das System zu einem **vollwertigen Planungstool für Ernährung, Organisation und Einkauf**,  
+das dir ermöglicht, Rezepte gemeinsam zu verwalten, automatisch Nährwerte zu berechnen  
+und mit Hilfe einer lokalen KI personalisierte Wochenpläne zu erstellen – komplett integriert in deine bestehende Infrastruktur.
+
+Ziel ist eine **erweiterte Nutzung von Tandoor als zentrale Ernährungs- und Planungsplattform** innerhalb deines UCC.  
+Dazu werden neue Funktionen aktiviert, Berechnungen optimiert und Automatisierungen ergänzt,  
+die sowohl in der Küche als auch im täglichen Workflow echten Mehrwert bieten.
+
+Das Kapitel ist in drei praxisnahe Szenarien unterteilt:
+
+1. **Erweiterte Rollenverwaltung und Freigaben**  
+   – Einrichtung zusätzlicher Berechtigungsstufen und gemeinsamer Rezeptbereiche  
+   – ideal für Familien, Teams oder Showgruppen, die gemeinsam an Rezepten arbeiten
+
+2. **Automatische Nährwertberechnung auf Basis der Zutatenlisten**  
+   – Nutzung der in Tandoor hinterlegten Nährwertdatenbanken  
+   – Ergänzende Kontrolle durch externe Nährwert-APIs, lokal oder via n8n abrufbar
+
+3. **KI-gestützte Wochen- und Diätplan-Erstellung**  
+   – Kombination aus Tandoor-Rezeptdaten, vorhandenen Nährwertinformationen und persönlichen Vorgaben  
+   – Generierung individueller Wochenpläne über eine lokale KI-Instanz (z. B. Ollama mit Mistral oder Llama 3)  
+   – Automatische Übernahme in die Einkaufsliste, optional mit Portionierung nach Benutzerrolle
+
+> [!CAUTION]  
+> Die KI-Funktion dient ausschließlich zur **lokalen Unterstützung** und ersetzt keine ärztliche Ernährungsberatung.  
+> Sie analysiert vorhandene Rezeptdaten, erstellt Vorschläge und kann nach deinen Vorgaben optimieren,  
+> arbeitet jedoch rein mathematisch und ohne medizinische Einschätzung.
+
+👉 **Screenshot geeignet:** Übersicht in Tandoor mit sichtbaren Bereichen *Rollenverwaltung*, *Nährwerte* und *Wochenplan*
+
+Am Ende dieses Kapitels verfügst du über ein vollständig integriertes Planungssystem,  
+das Ernährung, Einkauf und Automatisierung intelligent miteinander verbindet –  
+ein weiterer Schritt hin zu einem selbstlernenden, datensouveränen Kontrollzentrum.
+
+---
+
+# Premium – Tandoor: Erweiterte Rollen, Nährwertanalyse & KI-gestützte Wochenplanung
+
+Tandoor ist im UCC weit mehr als nur eine digitale Rezeptdatenbank.  
+Im Premium-Kapitel wird das System zu einem **vollwertigen Planungstool für Ernährung, Organisation und Einkauf**,  
+das dir ermöglicht, Rezepte gemeinsam zu verwalten, automatisch Nährwerte zu berechnen  
+und mit Hilfe einer lokalen KI personalisierte Wochenpläne zu erstellen – komplett integriert in deine bestehende Infrastruktur.
+
+Ziel ist eine **erweiterte Nutzung von Tandoor als zentrale Ernährungs- und Planungsplattform** innerhalb deines UCC.  
+Dazu werden neue Funktionen aktiviert, Berechnungen optimiert und Automatisierungen ergänzt,  
+die sowohl in der Küche als auch im täglichen Workflow echten Mehrwert bieten.
+
+Das Kapitel ist in drei praxisnahe Szenarien unterteilt:
+
+1. **Erweiterte Rollenverwaltung und Freigaben**  
+   – Einrichtung zusätzlicher Berechtigungsstufen und gemeinsamer Rezeptbereiche  
+   – ideal für Familien, Teams oder Showgruppen, die gemeinsam an Rezepten arbeiten
+
+2. **Automatische Nährwertberechnung auf Basis der Zutatenlisten**  
+   – Nutzung der in Tandoor hinterlegten Nährwertdatenbanken  
+   – Ergänzende Kontrolle durch externe Nährwert-APIs, lokal oder via n8n abrufbar
+
+3. **KI-gestützte Wochen- und Diätplan-Erstellung**  
+   – Kombination aus Tandoor-Rezeptdaten, vorhandenen Nährwertinformationen und persönlichen Vorgaben  
+   – Generierung individueller Wochenpläne über eine lokale KI-Instanz (z. B. Ollama mit Mistral oder Llama 3)  
+   – Automatische Übernahme in die Einkaufsliste, optional mit Portionierung nach Benutzerrolle
+
+> [!CAUTION]  
+> Die KI-Funktion dient ausschließlich zur **lokalen Unterstützung** und ersetzt keine ärztliche Ernährungsberatung.  
+> Sie analysiert vorhandene Rezeptdaten, erstellt Vorschläge und kann nach deinen Vorgaben optimieren,  
+> arbeitet jedoch rein mathematisch und ohne medizinische Einschätzung.
+
+👉 **Screenshot geeignet:** Übersicht in Tandoor mit sichtbaren Bereichen *Rollenverwaltung*, *Nährwerte* und *Wochenplan*
+
+Am Ende dieses Kapitels verfügst du über ein vollständig integriertes Planungssystem,  
+das Ernährung, Einkauf und Automatisierung intelligent miteinander verbindet –  
+ein weiterer Schritt hin zu einem selbstlernenden, datensouveränen Kontrollzentrum.
+
+---
+
+## Nährwertberechnung und Analyse
+
+Neben der reinen Rezeptverwaltung bietet Tandoor die Möglichkeit, **Nährwerte automatisch zu berechnen**.  
+Diese Funktion wird im Premium-Kapitel erweitert und optimiert, damit du auf Grundlage deiner eigenen Zutatenlisten  
+präzise Angaben zu Kalorien, Makronährstoffen und Portionsgrößen erhältst.
+
+Ziel ist eine nachvollziehbare und reproduzierbare Berechnung, die sich sowohl für Alltagsrezepte  
+als auch für spezielle Ernährungspläne – etwa bei Diäten oder sportlichen Programmen – eignet.
+
+### Aktivieren der Nährwertfunktion
+
+Die Nährwertberechnung basiert auf den hinterlegten Daten in der Tandoor-Zutatenbibliothek.  
+Um sie zu aktivieren:
+
+1. Öffne **Einstellungen → Allgemein → Rezept-Darstellung**.  
+2. Aktiviere die Option **Nährwertangaben anzeigen**.  
+3. Bestätige mit **Speichern** und lade die Seite neu.
+
+> [!NOTE]  
+> Sobald diese Funktion aktiv ist, zeigt Tandoor in jedem Rezept eine Nährwert-Sektion an.  
+> Dort werden automatisch Kalorien, Fette, Eiweiße, Kohlenhydrate und Ballaststoffe berechnet –  
+> basierend auf der verwendeten Zutatenmenge.
+
+👉 **Screenshot geeignet:** Rezeptansicht mit sichtbarer Tabelle „Nährwerte pro Portion“
+
+### Zutaten mit Nährwertdaten verknüpfen
+
+Damit die Berechnung funktioniert, muss jede Zutat eine zugehörige Datenquelle besitzen.  
+Tandoor verwendet standardmäßig interne Referenzen aus bekannten Lebensmitteldatenbanken  
+(z. B. **USDA FoodData Central** oder **Open Food Facts**).
+
+1. Öffne **Zutatenverwaltung → Zutat bearbeiten**.  
+2. Trage im Feld **Nährwertquelle** die passende Datenbank-ID ein.  
+3. Gib bei Bedarf zusätzliche Angaben an – z. B. Dichte, Portionsgröße oder Umrechnungsfaktoren.
+
+> [!TIP]  
+> Du kannst eigene Zutaten mit individuellen Werten anlegen – ideal für regionale Produkte oder Eigenkreationen.  
+> Wichtig ist nur, dass die Einheit (z. B. g, ml, Stück) konsistent bleibt.
+
+👉 **Screenshot geeignet:** Zutat „Kartoffeln“ mit ausgefüllter Nährwertquelle (z. B. `fooddata:12345`)
+
+### Berechnung kontrollieren
+
+Nach dem Speichern aktualisiert Tandoor die Nährwerte automatisch.  
+In der Rezeptansicht erscheint dann eine Tabelle mit den berechneten Werten pro Portion und pro Rezept.
+
+| Feld | Beschreibung |
+|-------|--------------|
+| **Kalorien** | Gesamtenergie in kcal |
+| **Eiweiß** | Gesamtprotein in g |
+| **Fett** | Gesamtfett in g |
+| **Kohlenhydrate** | Gesamt-Carbs in g |
+| **Ballaststoffe** | Nicht verwertbare Kohlenhydrate in g |
+| **Portionsgröße** | automatisch berechnet anhand der Zutatenmenge |
+
+> [!NOTE]  
+> Änderungen an den Zutaten wirken sich sofort auf die Berechnung aus.  
+> Tandoor speichert die Ergebnisse automatisch im Hintergrund, sodass du jederzeit nachvollziehen kannst,  
+> welche Werte zur jeweiligen Version eines Rezepts gehören.
+
+👉 **Screenshot geeignet:** Rezept „Gemüseauflauf“ mit angezeigter Nährwerttabelle
+
+### Automatische Nährwertberechnung über OpenFoodFacts
+
+Ziel ist eine vollständig automatisierte Berechnung der Nährwerte für jedes Rezept in Tandoor.  
+Dazu liest n8n regelmäßig alle neu erstellten oder geänderten Rezepte aus der Tandoor-API,  
+analysiert deren Zutaten über die öffentliche OpenFoodFacts-API  
+und schreibt die berechneten Durchschnittswerte direkt zurück in Tandoor.
+
+👉 **Screenshot geeignet:** n8n-Canvas mit verbundenen Nodes *Cron → HTTP GET (Tandoor) → Function (Zutaten vorbereiten) → HTTP Request (OpenFoodFacts) → Function (Berechnen) → HTTP PATCH (Tandoor)*
+
+#### Node 1 – Cron (Trigger: Regelmäßige Analyse)
+
+**Zweck:**  
+Startet den Workflow automatisch in festen Intervallen, z. B. alle 60 Minuten,  
+um neue oder geänderte Rezepte zu verarbeiten.
+
+**Node-Typ:** Cron  
+**Name:** Tandoor – Automatische Nährwertanalyse  
+
+**Parameter:**  
+- **Mode:** Every X Minutes  
+- **Every:** 60  
+
+> [!NOTE]  
+> Die Intervallzeit kann an die Rezeptaktivität angepasst werden.  
+> Bei intensiver Nutzung sind 30 Minuten sinnvoll, für kleine Systeme genügt 1 Stunde.
+
+👉 **Screenshot geeignet:** Cron-Node mit Einstellung „Every 60 Minutes“
+
+#### Node 2 – HTTP Request (Tandoor API → Rezepte abrufen)
+
+**Zweck:**  
+Fragt die zuletzt geänderten Rezepte über die interne Tandoor-API ab.  
+Verwendet Standard-Django-REST-Authentifizierung.
+
+**Node-Typ:** HTTP Request  
+**Name:** Tandoor – Rezepte abfragen  
+
+**Parameter:**  
+- **Method:** `GET`  
+- **URL:**  
+  ```
+  https://tandoor.deinedomain.tld/api/recipes/?ordering=-modified_at&limit=5
+  ```
+- **Authentication:** HTTP Basic Auth  
+  - **Username:** `apiuser`  
+  - **Password:** `<API-Token-aus-Vaultwarden>`  
+- **Response Format:** JSON
+
+> [!NOTE]  
+> Das Feld `modified_at` gibt den Zeitpunkt der letzten Änderung an.  
+> Durch `ordering=-modified_at` werden die neuesten Rezepte zuerst geliefert.
+
+👉 **Screenshot geeignet:** HTTP-Node mit sichtbarer URL und Auth-Feldern
+
+#### Node 3 – Function (Zutatenliste aufbereiten)
+
+**Zweck:**  
+Extrahiert aus den Rezeptdaten nur die Zutaten als Textliste  
+und formatiert sie für die Abfrage an OpenFoodFacts.
+
+**Node-Typ:** Function  
+**Name:** Zutaten vorbereiten  
+
+**Code:**  
+```js
+const recipes = items[0].json.results || [];
+const outputs = [];
+
+for (const r of recipes) {
+  if (r.ingredients_text) {
+    const list = r.ingredients_text
+      .split('\n')
+      .map(x => x.trim())
+      .filter(x => x.length > 0);
+    for (const ing of list) {
+      outputs.push({ json: { recipe_id: r.id, ingredient: ing } });
+    }
+  }
+}
+
+return outputs;
+```
+
+> [!TIP]  
+> Diese Version nutzt das Textfeld `ingredients_text`.  
+> Wenn deine Tandoor-Installation Zutaten in separaten Objekten speichert,  
+> kann der Zugriff über `r.ingredients[i].food.name` angepasst werden.
+
+👉 **Screenshot geeignet:** Function-Node mit markierter Zeile `outputs.push({ json: { recipe_id: r.id, ingredient: ing } });`
+
+#### Node 4 – HTTP Request (OpenFoodFacts – Automatische Nährwertsuche)
+
+**Zweck:**  
+Sucht jede Zutat im OpenFoodFacts-Katalog, analysiert den ersten Treffer  
+und liefert standardisierte Nährwertdaten (pro 100 g).
+
+**Node-Typ:** HTTP Request  
+**Name:** OpenFoodFacts – Nährwertsuche  
+
+**Parameter:**  
+- **Method:** `GET`  
+- **URL:**  
+  ```
+  https://world.openfoodfacts.org/cgi/search.pl?search_terms={{$json["ingredient"]}}&search_simple=1&action=process&json=1&page_size=1
+  ```
+- **Response Format:** JSON  
+
+> [!NOTE]  
+> OpenFoodFacts ist eine öffentliche, kostenfreie Datenbank.  
+> Es wird kein API-Key benötigt, und der Zugriff funktioniert direkt über HTTPS.  
+> Die Suche liefert für jeden Begriff den besten Treffer (`products[0]`).
+
+👉 **Screenshot geeignet:** HTTP-Node mit sichtbarer URL und Ergebnisfeld `products[0].nutriments.energy-kcal_100g`
+
+#### Node 5 – Function (Nährwerte berechnen)
+
+**Zweck:**  
+Berechnet aus allen Zutaten die Durchschnittswerte für Kalorien,  
+Protein, Fett und Kohlenhydrate pro 100 g.
+
+**Node-Typ:** Function  
+**Name:** Nährwerte berechnen  
+
+**Code:**  
+```js
+let total = { kcal: 0, protein: 0, fat: 0, carbs: 0 };
+let count = 0;
+
+for (const item of items) {
+  const n = item.json.products?.[0]?.nutriments || {};
+  if (Object.keys(n).length) {
+    total.kcal += n["energy-kcal_100g"] || 0;
+    total.protein += n["proteins_100g"] || 0;
+    total.fat += n["fat_100g"] || 0;
+    total.carbs += n["carbohydrates_100g"] || 0;
+    count++;
+  }
+}
+
+if (!count) {
+  return [{ json: { kcal: 0, protein: 0, fat: 0, carbs: 0 } }];
+}
+
+return [{
+  json: {
+    kcal: +(total.kcal / count).toFixed(1),
+    protein: +(total.protein / count).toFixed(1),
+    fat: +(total.fat / count).toFixed(1),
+    carbs: +(total.carbs / count).toFixed(1)
+  }
+}];
+```
+
+> [!TIP]  
+> Die Werte beziehen sich auf 100 g und stellen einen Durchschnitt über alle Zutaten dar.  
+> Dadurch erhältst du auch bei unvollständigen Daten eine brauchbare Orientierung.
+
+👉 **Screenshot geeignet:** Function-Node mit markiertem Block `total.kcal += n["energy-kcal_100g"]`
+
+#### Node 6 – HTTP Request (Tandoor API → Nährwerte aktualisieren)
+
+**Zweck:**  
+Schreibt die berechneten Werte automatisch in das zugehörige Rezept in Tandoor.
+
+**Node-Typ:** HTTP Request  
+**Name:** Tandoor – Nährwerte aktualisieren  
+
+**Parameter:**  
+- **Method:** `PATCH`  
+- **URL:**  
+  ```
+  https://tandoor.deinedomain.tld/api/recipes/{{$json["recipe_id"]}}/
+  ```
+- **Headers:**  
+  - `Content-Type`: `application/json`  
+- **Authentication:** HTTP Basic Auth  
+- **Body → JSON:**  
+  ```json
+  {
+    "energy": "={{$json['kcal']}}",
+    "carbohydrates": "={{$json['carbs']}}",
+    "fat": "={{$json['fat']}}",
+    "protein": "={{$json['protein']}}"
+  }
+  ```
+
+> [!NOTE]  
+> Die genauen Feldnamen können je nach Tandoor-Version leicht variieren.  
+> Prüfe über `GET /api/recipes/<id>/`, welche Bezeichner deine Installation verwendet.
+
+👉 **Screenshot geeignet:** HTTP-Node mit sichtbarer PATCH-URL und JSON-Body
+
+> [!CAUTION]  
+> OpenFoodFacts ist community-basiert. Unvollständige Datensätze werden automatisch übersprungen.  
+> Wenn keine Werte gefunden werden, bleibt das Rezept unverändert.  
+
+> [!TIP]  
+> Um API-Aufrufe zu reduzieren, kann n8n die letzten 50 analysierten Zutaten lokal zwischenspeichern (z. B. über den Cache-Node oder Redis-Integration).  
+> So werden wiederkehrende Zutaten nicht erneut abgefragt und die Verarbeitung beschleunigt.
+
+> [!CAUTION]  
+> Die OpenFoodFacts-API ist öffentlich zugänglich, unterliegt aber **Rate-Limits**,  
+> um Missbrauch zu vermeiden.  
+> Für Suchanfragen (`/search.pl`) gelten maximal **10 Requests pro Minute**,  
+> für direkte Produktabfragen (`/api/v2/product/...`) bis zu **100 Requests pro Minute**.  
+> Bei Überschreitung antwortet der Server mit `HTTP 429 – Too Many Requests`.  
+> In diesem Fall pausiert n8n den Workflow automatisch, bis das Limit zurückgesetzt ist.
+
+> [!NOTE]  
+> OpenFoodFacts speichert seine Daten global und aktualisiert sie regelmäßig.  
+> Manche Produkte enthalten unvollständige oder veraltete Nährwertangaben.  
+> Der Workflow berücksichtigt nur Datensätze mit vollständigen Feldern  
+> (`energy-kcal_100g`, `proteins_100g`, `fat_100g`, `carbohydrates_100g`).  
+> Fehlen Werte, werden diese Zutaten automatisch übersprungen.
+
+> [!TIP]  
+> Um Limits einzuhalten und die Verarbeitung zu beschleunigen,  
+> kann in n8n ein **Delay Node** oder ein **Cache Node** eingebaut werden.  
+> Beispiel: 1 Sekunde Verzögerung zwischen Anfragen oder  
+> Zwischenspeicherung häufig genutzter Zutaten wie „Zwiebel“ oder „Olivenöl“.  
+> Dadurch bleibt der Workflow stabil und vermeidet API-Fehler bei größeren Rezeptmengen.
+
+---
+
+### Wochenplan & Einkaufsliste
+
+Der Wochenplan ist das Herzstück von Tandoor, wenn du Ernährung und Einkauf aktiv steuern möchtest.  
+Hier lassen sich Gerichte tageweise zuordnen, Portionen anpassen und automatisch Einkaufslisten erzeugen.  
+Alle Daten bleiben in deinem UCC lokal gespeichert und sind damit jederzeit nachvollziehbar und datensouverän.  
+
+Ein strukturierter Wochenplan hilft nicht nur beim Essen, sondern auch bei Ressourcenplanung und Vorratsverwaltung.  
+Tandoor kombiniert hier Komfort mit Kontrolle – du bestimmst, was gekocht wird, und das System übernimmt die Organisation.
+
+👉 **Screenshot geeignet:** Tandoor-Wochenplan-Ansicht mit mehreren Tagen und Gerichten
+
+> [!NOTE]  
+> Der Wochenplan arbeitet direkt mit deinen bestehenden Rezepten.  
+> Änderungen im Rezept (z. B. Mengen oder Zutaten) werden automatisch in künftige Planungen übernommen.  
+> Bestehende Pläne bleiben davon unberührt.
+
+> [!TIP]  
+> Wenn du Tandoor mit mehreren Benutzer:innen nutzt, kannst du gemeinsame Wochenpläne anlegen,  
+> z. B. getrennt nach Personen, Diätformen oder Mahlzeitenarten (Frühstück, Mittag, Abend).  
+> So behältst du auch in größeren Haushalten oder Teams den Überblick.
+
+### Wochenplan anlegen
+
+1. Öffne in der linken Navigationsleiste den Menüpunkt **Meal Plan**.  
+2. Wähle im Kalender den gewünschten Zeitraum aus (z. B. Montag – Sonntag).  
+3. Klicke bei einem Tag auf **Add Meal** und suche nach einem gespeicherten Rezept.  
+4. Wähle optional die **Portionsgröße** und die Mahlzeit (z. B. Frühstück, Mittagessen, Abendessen).  
+5. Speichere den Eintrag – das Gericht erscheint nun im Wochenplan.  
+
+👉 **Screenshot geeignet:** Dialogfenster „Add Meal“ mit geöffnetem Suchfeld
+
+> [!NOTE]  
+> Tandoor speichert Wochenpläne automatisch.  
+> Du kannst jederzeit neue Rezepte hinzufügen oder bestehende löschen –  
+> der Plan wird sofort aktualisiert, ohne dass ein separater Speichervorgang nötig ist.
+
+### Einkaufslisten generieren
+
+Aus jedem Wochenplan lässt sich automatisch eine Einkaufsliste erstellen.  
+Tandoor summiert dabei alle benötigten Zutaten, fasst doppelte Einträge zusammen  
+und ordnet sie nach Kategorien (z. B. Gemüse, Milchprodukte, Gewürze).
+
+1. Öffne im Menü den Punkt **Shopping List**.  
+2. Wähle den gewünschten Plan oder Zeitraum aus.  
+3. Klicke auf **Generate List** – Tandoor erstellt automatisch die Einkaufsliste.  
+4. Optional: Exportiere die Liste als **PDF**, **CSV** oder über den Button **Share Link**.  
+
+👉 **Screenshot geeignet:** Einkaufslisten-Ansicht mit kategorisierten Zutaten
+
+### Automatische Wochenplanerstellung durch KI
+
+Damit die KI regelmäßig neue Wochenpläne erstellt, wird der gesamte Ablauf über einen n8n-Workflow gesteuert.  
+Der Workflow startet automatisch in einem festen Intervall (z. B. einmal pro Woche),  
+ruft alle verfügbaren Rezepte aus Tandoor ab, übergibt sie an die KI (Ollama oder OpenRouter),  
+bereitet die Antwort auf und trägt die neuen Plan-Einträge in Tandoor ein.  
+
+👉 **Screenshot geeignet:** n8n-Canvas mit vier verbundenen Nodes – *Cron Trigger → HTTP Request (Rezepte) → HTTP Request (KI) → Function (Formatieren) → HTTP Request (Mealplan POST)*
+
+### Schritt 1 – n8n-Workflow erstellen
+
+#### Node 1 – Cron (Trigger)
+
+**Zweck:**  
+Startet den Workflow automatisch in regelmäßigen Abständen, z. B. sonntags um 18:00 Uhr.  
+
+**Node-Typ:** Cron  
+**Name:** Automatische Wochenplan-Erstellung starten  
+**Parameter:**  
+- **Mode:** Specific Time  
+- **Day of Week:** Sunday  
+- **Hour:** 18  
+- **Minute:** 0  
+
+👉 **Screenshot geeignet:** Cron-Node mit aktiviertem „Every Sunday 18:00“  
+
+> [!NOTE]  
+> Dieser Zeitplan kann frei angepasst werden.  
+> Bei Haushalten mit täglicher Essensplanung empfiehlt sich ein Intervall von 1–2 Tagen.  
+> Der Workflow kann alternativ auch manuell gestartet werden,  
+> wenn ein *Manual Trigger* statt des Cron-Nodes genutzt wird.  
+
+#### Node 2 – HTTP Request (Tandoor → Rezepte abrufen)
+
+**Zweck:**  
+Liest alle verfügbaren Rezepte mit ihren Nährwertdaten,  
+damit die KI auf reale Werte und Portionsgrößen zugreifen kann.  
+
+**Node-Typ:** HTTP Request  
+**Name:** Tandoor – Rezepte abrufen  
+**Parameter:**  
+- **Method:** `GET`  
+- **URL:**  
+  ```
+  https://tandoor.deinedomain.tld/api/recipes/?include_nutrition=true
+  ```  
+- **Headers:**  
+  - `Authorization`: `Token ${{env.TANDOOR_TOKEN}}`  
+  - `Content-Type`: `application/json`  
+
+> [!NOTE]  
+> Der Parameter `include_nutrition=true` liefert vollständige Nährwertdaten.  
+> Diese Informationen werden von der KI genutzt,  
+> um Rezepte passend zu den gewünschten Kalorien- und Makrowerten auszuwählen.  
+
+👉 **Screenshot geeignet:** HTTP-Node mit GET-Request auf `/api/recipes/`
+
+#### Node 3 – HTTP Request (KI – Wochenplan erstellen)
+
+**Zweck:**  
+Übergibt die abgerufenen Rezepte an das gewünschte KI-Modell (Ollama oder OpenRouter)  
+und fordert die Erstellung eines kompletten Wochenplans an.  
+
+**Node-Typ:** HTTP Request  
+**Name:** KI – Wochenplan erstellen  
+**Parameter:**  
+- **Method:** `POST`  
+- **URL:**  
+  ```
+  http://ollama.deinedomain.tld:11434/api/chat
+  ```  
+  *(alternativ für OpenRouter)*  
+  ```
+  https://openrouter.ai/api/v1/chat/completions
+  ```  
+- **Headers:**  
+  - `Content-Type`: `application/json`  
+  - *(bei OpenRouter)* `Authorization`: `Bearer ${{env.OPENROUTER_TOKEN}}`  
+- **Body → JSON:**  
+  ```json
+  {
+    "model": "mistral",
+    "messages": [
+      {
+        "role": "system",
+        "content": "Du bist ein Ernährungsassistent. Erstelle auf Basis der übergebenen Rezepte einen vollständigen Wochenplan für 7 Tage mit Frühstück, Mittag- und Abendessen. Achte auf Ausgewogenheit, Wiederholungen vermeiden, gleiche Zutaten bündeln."
+      },
+      {
+        "role": "user",
+        "content": "={{JSON.stringify($json.results)}}"
+      }
+    ]
+  }
+  ```  
+
+> [!TIP]  
+> Für OpenRouter kannst du Modelle wie **Claude 3 Sonnet**, **GPT-4 Turbo** oder **Mixtral** wählen.  
+> Je komplexer der Datensatz, desto stabiler sind größere Modelle.  
+> Das Modell sollte JSON-Strukturen zuverlässig ausgeben können.  
+
+👉 **Screenshot geeignet:** HTTP-Node mit markiertem Promptabschnitt „Erstelle auf Basis der übergebenen Rezepte…“
+
+#### Node 4 – Function (Antwort in Mealplan-Format umwandeln)
+
+**Zweck:**  
+Formatiert die von der KI generierte Antwort so,  
+dass sie direkt an die Tandoor-API übergeben werden kann.  
+
+**Node-Typ:** Function  
+**Name:** Mealplan formatieren  
+**Code:**  
+```js
+const plan = items[0].json.response || [];
+const output = [];
+
+for (const day of plan) {
+  for (const meal of day.meals) {
+    output.push({
+      json: {
+        date: day.date,
+        recipe: meal.recipe_id,
+        meal_type: meal.type
+      }
+    });
+  }
+}
+
+return output;
+```  
+
+> [!NOTE]  
+> Die KI gibt idealerweise eine strukturierte Liste im Format  
+> `[{ "date": "...", "meals": [{ "recipe_id": ..., "type": "dinner" }] }]` zurück.  
+> Diese wird hier in einzelne POST-fähige Datensätze zerlegt.  
+
+👉 **Screenshot geeignet:** Function-Node mit markierter Zeile `output.push({...})`
+
+#### Node 5 – HTTP Request (Tandoor → Mealplan POST)
+
+**Zweck:**  
+Sendet die formatierten Einträge an Tandoor,  
+wo automatisch neue Wochenplan-Einträge angelegt werden.  
+
+**Node-Typ:** HTTP Request  
+**Name:** Mealplan eintragen  
+**Parameter:**  
+- **Method:** `POST`  
+- **URL:**  
+  ```
+  https://tandoor.deinedomain.tld/api/mealplan/
+  ```  
+- **Headers:**  
+  - `Authorization`: `Token ${{env.TANDOOR_TOKEN}}`  
+  - `Content-Type`: `application/json`  
+- **Body → JSON:**  
+  ```json
+  {
+    "date": "={{$json[\"date\"]}}",
+    "recipe": "={{$json[\"recipe\"]}}",
+    "meal_type": "={{$json[\"meal_type\"]}}"
+  }
+  ```  
+
+> [!CAUTION]  
+> Achte darauf, dass die Rezept-IDs gültig sind.  
+> Wenn die KI auf nicht mehr existierende Rezepte verweist,  
+> antwortet Tandoor mit Fehler 400.  
+> Füge ggf. eine Validierung ein, die ungültige IDs überspringt.  
+
+👉 **Screenshot geeignet:** HTTP-Node mit POST-URL `/api/mealplan/`
+
+> [!TIP]  
+> Nach erfolgreicher Ausführung erscheinen die neuen Einträge sofort im Wochenplan.  
+> Die Einkaufsliste kann anschließend wie gewohnt direkt in Tandoor erzeugt werden.  
+> Du kannst zusätzlich einen **WAHA-Node** anhängen,  
+> um dir automatisch eine WhatsApp-Benachrichtigung zu schicken,  
+> sobald der neue Plan fertig ist.
+
+### Abschluss – KI-gestützte Wochenplanung
+
+Mit diesem Abschnitt ist die intelligente Wochenplanung vollständig integriert.  
+Die KI übernimmt den kreativen Teil der Planung, während Tandoor weiterhin alle Daten verwaltet,  
+Einkaufslisten erstellt und die Nährwertberechnung durchführt.  
+Damit kombiniert dein UCC drei Ebenen zu einem durchgängigen System:  
+Analyse, Entscheidung und Umsetzung.
+
+| Bereich | Umsetzung |
+|----------|-----------|
+| Planung | Die KI generiert automatisch ausgewogene Wochenpläne auf Basis deiner vorhandenen Rezepte. |
+| Integration | n8n ruft Tandoor-Daten ab, übergibt sie an die KI und trägt den fertigen Plan wieder ein. |
+| Einkauf | Tandoor erstellt automatisch die Einkaufsliste aus den neuen Einträgen. |
+| Kontrolle | Du kannst alle Einträge direkt in Tandoor anpassen oder manuell überschreiben. |
+
+> [!TIP]  
+> Durch den modularen Aufbau kannst du später weitere Parameter einführen –  
+> etwa Kalorienziele, Diätpräferenzen oder Zeitfenster für Mahlzeiten.  
+> Die KI berücksichtigt diese Angaben automatisch,  
+> sobald sie im Prompt oder in einem separaten n8n-Node hinterlegt sind.
+
+Damit ist der Premium-Teil von Kapitel 20 abgeschlossen.  
+Dein UCC verfügt jetzt über eine vollständige, KI-gestützte Rezept- und Ernährungsverwaltung –  
+von der Datenbasis über die Berechnung bis hin zur automatischen Wochen- und Einkaufsplanung.  
+Ein weiterer Schritt hin zu einem selbstverwalteten, datensouveränen Kontrollzentrum.
+
+---
+
+## Abschluss – Kapitel 20 Tandoor (Rezeptdatenbank)
+
+Mit diesem Kapitel hast du Tandoor vollständig in dein UCC integriert – von der Installation über Benutzerverwaltung und SSL-Einbindung bis hin zu den erweiterten Premium-Funktionen für Nährwertberechnung, Rollen, Wochenpläne und KI-Unterstützung.  
+Tandoor ist damit nicht mehr nur eine Rezeptsammlung, sondern ein zentraler Bestandteil deiner digitalen Infrastruktur:  
+ein eigenständiges Ernährungssystem, das Wissen, Planung und Automatisierung miteinander verbindet.
+
+| Bereich | Umsetzung |
+|----------|-----------|
+| Basisinstallation | Container erstellt, Datenbank angebunden, SSL über NPM aktiviert. |
+| Benutzer & Rechte | Mehrbenutzersystem mit differenzierter Rollenverwaltung für getrennte Kochbereiche oder Teammitglieder. |
+| Rezepte & Import | Bestehende Rezepte importiert, eigene Kategorien, Bilder und Nährwerte gepflegt. |
+| Nährwertberechnung | Erweiterte Analyse über interne Daten oder OpenFoodFacts-API mit automatischer Aktualisierung. |
+| Wochenplan & Einkauf | Manuelle und KI-gestützte Planung von Mahlzeiten mit automatischer Einkaufsliste. |
+| Automatisierung | n8n übernimmt Berechnungen, Kategorisierung und Kommunikation mit KI-Modellen. |
+
+> [!NOTE]  
+> Tandoor nutzt ausschließlich lokale Datenbanken und API-Zugriffe innerhalb deines UCC.  
+> Kein externer Clouddienst ist erforderlich.  
+> Bei Verwendung von OpenRouter erfolgt der Zugriff nur über deinen persönlichen API-Key,  
+> sodass du jederzeit die volle Kontrolle über Daten und Kosten behältst.
+
+> [!CAUTION]  
+> Beim Einsatz externer KI-Modelle gilt: übermittle keine sensiblen Gesundheits- oder Personendaten.  
+> Beschränke die Eingaben auf anonyme Rezeptinformationen und allgemeine Ernährungsparameter.  
+> Beachte außerdem, dass Modelle wie GPT-4 oder Claude 3 Sonnet Antwortlängen begrenzen können –  
+> plane ggf. Aufteilungen in Tagesblöcke, wenn der Wochenplan sehr umfangreich ist.
+
+> [!TIP]  
+> Für erweiterte Nutzung kannst du Tandoor mit weiteren Modulen deines UCC verknüpfen –  
+> z. B. Nextcloud für Rezept-Backups, Vaultwarden für API-Zugangsdaten oder WAHA für automatische Einkaufslisten.  
+> In Verbindung mit Ollama oder OpenRouter entsteht ein selbstlernendes Ernährungssystem,  
+> das sich an deine Essgewohnheiten anpasst und Pläne intelligent optimiert.
+
+Damit ist Kapitel 20 abgeschlossen.  
+Tandoor ist nun vollständig in dein UCC eingebunden – von der Grundinstallation bis zur KI-gestützten Wochenplanung.  
+Dein Kontrollzentrum verwaltet Rezepte, analysiert Nährwerte, erstellt Pläne und Einkaufslisten automatisch  
+und entwickelt sich mit jeder Eingabe weiter – modular, nachvollziehbar und komplett unter deiner eigenen Kontrolle.