Bauen Sie Ihren eigenen KI-Ernährungsberater: LLM, RAG und personalisierte Ernährung

In der heutigen hektischen Umgebung ist die Aufrechterhaltung einer ausgewogenen Ernährung zunehmend schwierig. Widersprüchliche Ernährungsratschläge und Modediäten verwirren die Menschen oft. Ein KI-Personal-Ernährungsberater, der rund um die Uhr verfügbar ist, kann spezifische Ernährungsfragen beantworten, den Nährstoffbedarf berechnen und personalisierte Empfehlungen geben. Dies ist nun dank Fortschritten in der künstlichen Intelligenz, insbesondere bei großen Sprachmodellen (LLMs) und Retrieval-Techniken, möglich. Dieser Artikel führt Sie durch die Erstellung Ihres eigenen KI-Personal-Ernährungsberater-Assistenten, der Googles Gemini LLM mit spezialisierten Ernährungsfunktionen und einer realen Wissensdatenbank für Ernährungsdaten kombiniert. Der Assistent kann Fragen zur Lebensmittelernährung beantworten, den BMI berechnen, den täglichen Kalorienbedarf schätzen, Lebensmittel nach Kriterien empfehlen und evidenzbasierte Ernährungsratschläge geben.

Unser KI-Personal-Ernährungsberater-Assistent wird von drei Schlüsseltechnologien angetrieben: Große Sprachmodelle (LLMs) wie Googles Gemini 1.5 Pro, Function Calling und Retrieval-Augmented Generation (RAG). LLMs verstehen und generieren menschenähnlichen Text und eignen sich hervorragend für natürliche Sprachabfragen zur Ernährung. Function Calling ermöglicht es dem LLM, spezialisierte Berechnungen wie BMI oder Kalorienbedarf zu nutzen. RAG untermauert die Antworten des Assistenten mit faktenbasierten Ernährungsdaten und ruft relevante Informationen aus einer Ernährungsdatenbank ab. Diese Technologien arbeiten zusammen, um Benutzeranfragen zu verstehen, Ernährungsfakten abzurufen und präzise Berechnungen durchzuführen.

Um die Entwicklungsumgebung einzurichten, installieren Sie die notwendigen Bibliotheken und konfigurieren Sie den API-Zugriff. Verwenden Sie die folgenden Befehle: ```bash !pip install -U -q "google-genai==1.7.0" !pip install chromadb ``` Diese Befehle installieren das Google Generative AI Python SDK und ChromaDB für die Vektordatenbank. Richten Sie anschließend den Zugriff auf die Google Gemini API ein: ```python import google.generativeai as genai import os # API-Schlüssel einrichten GOOGLE_API_KEY = "YOUR_API_KEY" # Ersetzen Sie dies durch Ihren tatsächlichen API-Schlüssel genai.configure(api_key=GOOGLE_API_KEY) ``` Ersetzen Sie `YOUR_API_KEY` durch Ihren tatsächlichen Gemini API-Schlüssel von der Google AI Studio-Website.

Bauen Sie die Ernährungs-Wissensdatenbank auf, indem Sie einen umfassenden Datensatz von Ernährungsfakten mit pandas laden: ```python import pandas as pd import numpy as np # Ernährungsdaten laden nutrition_data = pd.read_csv('/kaggle/input/nutrition-facts-for-3636-foods/nutrition_facts.csv') nutrition_data.head() ``` Dieser Datensatz enthält detaillierte Ernährungsinformationen für über 3.600 Lebensmittel. Konvertieren Sie diese Daten mit ChromaDB in Vektor-Embeddings: ```python # Embeddings für die Ernährungsdaten erstellen from chromadb.utils import embedding_functions import chromadb # ChromaDB-Client initialisieren chroma_client = chromadb.Client() # Eine Sammlung für Ernährungsdaten erstellen nutrition_collection = chroma_client.create_collection( name="nutrition_facts", embedding_function=embedding_functions.DefaultEmbeddingFunction() ) # Daten für Embedding vorbereiten for i, row in nutrition_data.iterrows(): # Ein Dokument mit Ernährungsinformationen erstellen document = f"Lebensmittel: {row['name']}, Kalorien: {row['calories']}, Protein: {row['protein_g']}g, Fett: {row['fat_g']}g, Kohlenhydrate: {row['carbohydrate_g']}g" # Mit eindeutiger ID zur Sammlung hinzufügen nutrition_collection.add( documents=[document], ids=[f"food_{i}"] ) ``` Dieser Code erstellt eine ChromaDB-Sammlung und füllt sie mit Ernährungsdaten, was eine semantische Suche ermöglicht.

Implementieren Sie zwei wesentliche Ernährungsfunktionen: BMI-Berechnung und Schätzung des täglichen Kalorienbedarfs: ```python def calculate_bmi(weight_kg, height_cm): """Berechnet den BMI anhand von Gewicht in kg und Größe in cm.""" height_m = height_cm / 100 bmi = weight_kg / (height_m * height_m) # BMI-Kategorie bestimmen if bmi < 18.5: category = "Untergewicht" elif bmi < 25: category = "Normalgewicht" elif bmi < 30: category = "Übergewicht" else: category = "Adipositas" return { "bmi": round(bmi, 1), "category": category } def calculate_calorie_needs(weight_kg, height_cm, age, gender, activity_level): """Berechnet den täglichen Kalorienbedarf basierend auf der Harris-Benedict-Gleichung.""" # Grundumsatz (BMR) if gender.lower() == "male": bmr = 88.362 + (13.397 * weight_kg) + (4.799 * height_cm) - (5.677 * age) else: # female bmr = 447.593 + (9.247 * weight_kg) + (3.098 * height_cm) - (4.330 * age) # Aktivitätsmultiplikatoren activity_multipliers = { "sedentary": 1.2, # Wenig oder keine Bewegung "light": 1.375, # Leichte Bewegung 1-3 Tage/Woche "moderate": 1.55, # Moderate Bewegung 3-5 Tage/Woche "active": 1.725, # Intensive Bewegung 6-7 Tage/Woche "very_active": 1.9 # Sehr intensive Bewegung & körperlich anspruchsvoller Job oder zweimal tägliches Training } # Gesamtenergieverbrauch pro Tag (TDEE) berechnen multiplier = activity_multipliers.get(activity_level.lower(), 1.2) tdee = bmr * multiplier return { "bmr": round(bmr), "daily_calories": round(tdee), "weight_loss": round(tdee - 500), # 500 Kaloriendefizit "weight_gain": round(tdee + 500) # 500 Kalorienüberschuss } ``` Die Funktion `calculate_bmi` implementiert die Body-Mass-Index-Formel, und die Funktion `calculate_calorie_needs` verwendet die Harris-Benedict-Gleichung.

Definieren Sie Funktionsschemata, damit Gemini diese Funktionen nutzen kann: ```python nutrition_functions = [ { "name": "calculate_bmi", "description": "Berechnet den BMI (Body Mass Index) und bestimmt die Gewichtskategorie", "parameters": { "type": "object", "properties": { "weight_kg": { "type": "number", "description": "Gewicht in Kilogramm" }, "height_cm": { "type": "number", "description": "Größe in Zentimetern" } }, "required": ["weight_kg", "height_cm"] } }, { "name": "calculate_calorie_needs", "description": "Berechnet den täglichen Kalorienbedarf basierend auf persönlichen Daten", "parameters": { "type": "object", "properties": { "weight_kg": { "type": "number", "description": "Gewicht in Kilogramm" }, "height_cm": { "type": "number", "description": "Größe in Zentimetern" }, "age": { "type": "integer", "description": "Alter in Jahren" }, "gender": { "type": "string", "description": "Geschlecht (männlich oder weiblich)" }, "activity_level": { "type": "string", "description": "Aktivitätslevel (sedentary, light, moderate, active, very_active)" } }, "required": ["weight_kg", "height_cm", "age", "gender", "activity_level"] } } ] ``` Diese Schemata definieren den Namen, die Beschreibung und die Parameter für jede Funktion, sodass das LLM bestimmen kann, wann und wie es diese verwenden soll.

Die Komponente Retrieval-Augmented Generation (RAG) stellt sicher, dass Antworten zu Ernährungsfakten auf der Datenbank basieren. Rufen Sie relevante Einträge aus der Ernährungsdatenbank ab und stellen Sie sie dem LLM als Kontext zur Verfügung: ```python def nutrition_assistant(query): """Verarbeitet eine ernährungsbezogene Anfrage mithilfe von RAG und Function Calling.""" # Schritt 1: Relevante Ernährungsinformationen mithilfe von RAG abrufen results = nutrition_collection.query( query_texts=[query], n_results=5 ) # Abgerufene Informationen formatieren context = "\n".join(results["documents"][0]) ``` Dieser Code verwendet die Abfragefunktion von ChromaDB, um die 5 relevantesten Einträge für die Anfrage des Benutzers zu finden.

Kombinieren Sie alle Komponenten in der Hauptassistentenfunktion: ```python def nutrition_assistant(query): """Verarbeitet eine ernährungsbezogene Anfrage mithilfe von RAG und Function Calling.""" # Schritt 1: Relevante Ernährungsinformationen mithilfe von RAG abrufen results = nutrition_collection.query( query_texts=[query], n_results=5 ) # Abgerufene Informationen formatieren context = "\n".join(results["documents"][0]) # Schritt 2: Das Modell mit Function Calling einrichten model = genai.GenerativeModel( model_name="gemini-1.5-pro", generation_config={"temperature": 0.2} ) # Schritt 3: Den Prompt mit Kontext und Anfrage erstellen prompt = f"""Sie sind ein hilfreicher Ernährungsassistent. Verwenden Sie die folgenden Ernährungsinformationen, um die Anfrage zu beantworten. ERNÄHRUNGSINFORMATIONEN: {context} BENUTZERANFRAGE: {query} Wenn der Benutzer nach BMI- oder Kalorienberechnungen fragt, verwenden Sie die entsprechende Funktion. Geben Sie für andere Ernährungsfragen hilfreiche Ratschläge basierend auf dem Kontext und Ihrem Wissen. """ # Schritt 4: Antwort mit möglichen Funktionsaufrufen generieren response = model.generate_content( prompt, tools=nutrition_functions ) # Schritt 5: Funktionsaufrufe verarbeiten, falls vorhanden if hasattr(response, 'candidates') and len(response.candidates) > 0: candidate = response.candidates[0] if hasattr(candidate, 'content') and hasattr(candidate.content, 'parts'): for part in candidate.content.parts: if hasattr(part, 'function_call'): function_call = part.function_call function_name = function_call.name function_args = function_call.args # Die entsprechende Funktion ausführen if function_name == "calculate_bmi": result = calculate_bmi( function_args["weight_kg"], function_args["height_cm"] ) elif function_name == "calculate_calorie_needs": result = calculate_calorie_needs( function_args["weight_kg"], function_args["height_cm"], function_args["age"], function_args["gender"], function_args["activity_level"] ) # Eine neue Antwort mit dem Funktionsergebnis generieren final_prompt = f"""Sie sind ein hilfreicher Ernährungsassistent. Ein Benutzer fragte: "{query}" Sie haben die Funktion {function_name} aufgerufen, die dieses Ergebnis zurückgegeben hat: {result} Bitte geben Sie eine hilfreiche, konversationelle Antwort, die diese Ergebnisse erklärt und angemessene Ernährungsratschläge gibt. Fügen Sie bei Bedarf spezifische Lebensmittelempfehlungen basierend auf den Ernährungsinformationen hinzu. """ final_response = model.generate_content(final_prompt) return final_response.text # Wenn kein Funktionsaufruf gemacht wurde, die ursprüngliche Antwort zurückgeben return response.text ``` Diese Funktion ruft Ernährungsinformationen ab, richtet das Gemini-Modell ein, erstellt einen Prompt, generiert eine Antwort und verarbeitet bei Bedarf Funktionsaufrufe.

Testen Sie den KI-Personal-Ernährungsberater mit realen Anfragen: ```python test_queries = [ "Was sind die Nährwerte eines Apfels?", "Können Sie meinen BMI berechnen? Ich bin 70 kg und 175 cm groß.", "Wie viele Kalorien sollte ich essen? Ich bin ein 30-jähriger Mann, 80 kg, 180 cm groß und mäßig aktiv.", "Was sind einige proteinreiche Lebensmittel zum Muskelaufbau?", "Können Sie einen Ernährungsplan zur Gewichtsabnahme vorschlagen?" ] for query in test_queries: print(f"\nAnfrage: {query}") print("-" * 50) response = nutrition_assistant(query) print(response) print("=" * 80) ``` Diese Beispiele zeigen die Vielseitigkeit des KI-Personal-Ernährungsberaters, der sachliche Anfragen bearbeitet, Berechnungen durchführt und personalisierte Empfehlungen gibt.

Mögliche Verbesserungen umfassen die Erweiterung der Ernährungsdatenbank, die Verbesserung der Genauigkeit von Kalorienschätzungen, die Hinzufügung von Unterstützung für komplexere diätetische Anforderungen und die Integration mit Wearables. Der KI-Personal-Ernährungsberater-Assistent kombiniert LLMs, Function Calling und RAG, um personalisierte Ernährungsberatung anzubieten. Dieses System kann Ernährungsfragen beantworten, BMI und Kalorienbedarf berechnen und personalisierte Empfehlungen geben, was das Potenzial von KI für die persönliche Gesundheit aufzeigt.