Erstellen einer GenAI-Fitness-App mit Gemini

Als ich letzten Sommer vom Gemini API Developer Competition erfuhr, sah ich darin eine großartige Chance, mich mit GenAI-Anwendungen die Hände schmutzig zu machen. Als Fitnessbegeisterte dachten wir (ich und Manos Chainakis) darüber nach, eine App zu entwickeln, die personalisierte Trainings- und Ernährungspläne erstellen könnte – und dabei KI mit den Vorlieben menschlicher Trainer kombiniert. So wurde Fitness Tribe AI geboren. Dieser Beitrag führt Sie durch den Entwicklungsprozess und den von mir verwendeten Tech-Stack, wobei der Schwerpunkt auf dem GenAI-Aspekt liegt.

Fitness Tribe AI  |  Gemini API-Entwicklerwettbewerb  |  Google AI für Entwickler

Persönliches Training für alle und überall besser machen.

ai.google.dev

Das Konzept hinter Fitness Tribe AI

Fitness Tribe AI kombiniert das Fachwissen menschlicher Trainer mit den Fähigkeiten von KI-Modellen, um individuelle Fitnessprogramme zu erstellen, die den Bedürfnissen und Zielen jedes Athleten gerecht werden.

Der Tech-Stack

Die Hauptkomponenten des Tech-Stacks sind:

• FastAPI für die Backend- und KI-Modellintegration
• Supabase zur Benutzerauthentifizierung und Datenverwaltung
• Ionic & Angular für die Frontend-Mobile-App
• Astro für die Landingpage

FastAPI: Backend- und KI-Integration

FastAPI dient als Rückgrat von Fitness Tribe AI und übernimmt die KI-gestützte Analyse.

So ist das Projekt aufgebaut:

fitness-tribe-ai/
├── app/
│   ├── main.py              # Entry point for FastAPI app
│   ├── routers/             # Handles API routes (meals, nutrition, workouts)
│   ├── models/              # Manages interactions with AI models
│   ├── schemas/             # Pydantic models for input validation
│   ├── services/            # Business logic for each feature

Schlüsselelemente der FastAPI-Implementierung:

• API-Routing: Routen werden in separate Dateien für Mahlzeiten (meals.py), Workouts (workouts.py) und Ernährung (nutrition.py) unterteilt, wodurch die API-Struktur organisiert und skalierbar bleibt. Jeder Router ist in main.py verbunden, wo das Routing-System von FastAPI alles miteinander verbindet.

from fastapi import FastAPI
from app.routers import meals, nutrition, workouts

app = FastAPI()

app.include_router(meals.router)
app.include_router(nutrition.router)
app.include_router(workouts.router)

• Gemini Model Integration: Die Klasse GeminiModel in gemini_model.py verwaltet die KI-Modellinteraktion. Nehmen wir als Beispiel die Mahlzeitanalysemethode: Ich verwende Pillow, um Bilddaten zu verarbeiten, und die App sendet sowohl das Bild als auch eine benutzerdefinierte Aufforderung an die Gemini-KI, um die Mahlzeitdetails zu analysieren. Ein wichtiges Detail hierbei ist, dass die Eingabeaufforderung spezifisch genug sein sollte, was das Format der erwarteten Antwort betrifft, damit sie von der Serviceschicht verarbeitet werden kann.

class GeminiModel:
    @staticmethod
    def analyze_meal(image_data):
        prompt = (
            "Analyze the following meal image and provide the name of the food, "
            "total calorie count, and calories per ingredient..."
            "Respond in the following JSON format:"
            "{'food_name': 'df57eb746fe8e90f79b5901b2a85225c' ...}"
        )
        image = Image.open(BytesIO(image_data))
        response = model.generate_content([prompt, image])
        return response.text

• Pydantic-Schema zur Datenvalidierung: Die Antwort des KI-Modells wird mithilfe von Pydantic-Modellen validiert und strukturiert. Beispielsweise stellt das Meal-Schema in schemas/meal.py sicher, dass die Antwort konsistent ist, bevor sie an den Benutzer zurückgegeben wird.

from pydantic import BaseModel
from typing import Dict

class Meal(BaseModel):
    food_name: str
    total_calories: int
    calories_per_ingredient: Dict[str, int]

• Service-Schicht: Die Service-Schicht, die sich in „services/“ befindet, kapselt die Logik jeder Funktion. Beispielsweise übernimmt die Datei „meal_service.py“ die Analyse der Mahlzeiten und stellt sicher, dass die Daten ordnungsgemäß verarbeitet werden, bevor die KI-Ergebnisse zurückgegeben werden.

from app.models.gemini_model import GeminiModel
from app.schemas.meal import Meal
from fastapi import HTTPException
import logging
import json

def analyze_meal(image_data: bytes) -> Meal:
    try:
        result_text = GeminiModel.analyze_meal(image_data)
        if not result_text:
            raise HTTPException(status_code=500, detail="No response from Gemini API")

        clean_result_text = result_text.strip("```

json\n").strip("

```")
        result = json.loads(clean_result_text)
        return Meal(
            food_name=result.get("food_name"),
            total_calories=result.get("total_calories"),
            calories_per_ingredient=result.get("calories_per_ingredient"),
        )
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

Durch die Nutzung der modularen Struktur von FastAPI, des klaren API-Routings, von Pydantic zur Datenvalidierung und der gut organisierten Servicelogik verarbeitet Fitness Tribe AI KI-Modellinteraktionen effizient mit benutzerdefinierten Eingabeaufforderungen, um personalisierte Fitness- und Ernährungserkenntnisse zu liefern. Das vollständige Repo finden Sie hier:

Fitness-Stamm / Fitness-Tribe-AI

Fitness Tribe AI ist eine KI-gestützte API, die Endpunkte für Trainer und Sportler bereitstellt.

Fitness Tribe API

Fitness Tribe AI ist eine KI-gestützte Fitness-API, die für Trainer und Sportler entwickelt wurde. Die API bietet Funktionen zur Essensanalyse durch die Analyse von Essensfotos und einen KI-gestützten Workout-Builder, der Trainingspläne basierend auf Sportlerprofilen erstellen kann. Fitness Tribe AI wurde nach dem Gemini-Modell entwickelt.

Funktionen

• Meal Analysis: Upload a photo of a meal to receive a detailed analysis of its ingredients and calorie count.
• Workout Builder: Input an athlete's profile details to receive a personalized workout plan tailored to the athlete's fitness goal.

Project Structure

fitness-tribe-ai/
├── app/
│   ├── __init__.py
│   ├── main.py
│   ├── models/
│   │   ├── __init__.py
│   │   ├── gemini_model.py
│   ├── routers/
│   │   ├── __init__.py
│   │   ├── meals.py
│   │   ├── nutrition.py
│   │   ├── workouts.py
│   ├── schemas/
│   │   ├── __init__.py
│   │   ├── meal.py
│   │   ├── nutrition.py
│   │   ├──

…

View on GitHub

Supabase: User Management & Auth

For user authentication and account management, I used Supabase, which provided a secure, scalable solution without requiring a custom-built authentication system.

Key features I leveraged:

• Authentication: Supabase's built-in authentication enabled users to log in and manage their profiles with ease.

• Database Management: Using Supabase’s PostgreSQL-backed database, I stored user preferences, workout routines, and meal plans to ensure updates reflected immediately in the app.

Ionic & Angular: Cross-Platform Frontend

For the frontend, I chose Ionic and Angular, which enabled me to create a mobile-first app that could be deployed on the web right away while it could also be shipped as native for both iOS and Android.

Astro: A Lightning-Fast Landing Page

For the landing page, I opted for Astro, which focuses on performance by shipping minimal JavaScript. Astro allowed me to build a fast, lightweight page that efficiently showcased the app.

Conclusion

Developing Fitness Tribe AI was a learning journey that enabled me to explore the power that AI models give us nowadays. Each framework played a role, from FastAPI’s robust backend capabilities and ease of use to Supabase’s user management, Ionic’s cross-platform frontend and Astro’s high-performance landing pages.

For anyone looking to build a GenAI app, I highly recommend exploring these frameworks (and especially FastAPI) for their powerful features and smooth developer experience.

Have questions or want to learn more about it? Let me know in the comments!

Das obige ist der detaillierte Inhalt vonErstellen einer GenAI-Fitness-App mit Gemini. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!