diff --git a/Kapitel 20/Premium Rohtext.md b/Kapitel 20/Premium Rohtext.md new file mode 100644 index 0000000..feaadf6 --- /dev/null +++ b/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:** `` +- **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//`, 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. \ No newline at end of file