L'été dernier, lorsque j'ai découvert le concours de développeurs d'API Gemini, j'y ai vu une excellente occasion de me salir les mains avec les applications GenAI. En tant que passionnés de fitness, nous (moi et Manos Chainakis) avons pensé à créer une application capable de générer des plans d'entraînement et de nutrition personnalisés, combinant l'IA avec les préférences des entraîneurs humains. C’est ainsi qu’est né Fitness Tribe AI. Cet article vous guidera à travers le processus de développement et la pile technologique que j'ai utilisée, en mettant l'accent sur l'aspect GenAI.
Améliorer l'entraînement personnel pour tous, partout.
ai.google.dev
Fitness Tribe AI combine l'expertise des entraîneurs humains avec les capacités des modèles d'IA pour créer des programmes de remise en forme personnalisés qui répondent aux besoins et aux objectifs de chaque athlète.
Les principaux composants de la pile technologique sont :
FastAPI sert d'épine dorsale à Fitness Tribe AI, gérant l'analyse basée sur l'IA.
Voici comment le projet est structuré :
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
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)
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': '<food name>' ...}"
)
image = Image.open(BytesIO(image_data))
response = model.generate_content([prompt, image])
return response.text
from pydantic import BaseModel
from typing import Dict
class Meal(BaseModel):
food_name: str
total_calories: int
calories_per_ingredient: Dict[str, int]
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))
En tirant parti de la structure modulaire de FastAPI, du routage clair des API, de Pydantic pour la validation des données et d'une logique de service bien organisée, Fitness Tribe AI gère efficacement les interactions du modèle d'IA avec des invites personnalisées pour fournir des informations personnalisées sur la condition physique et la nutrition. Vous pouvez trouver le dépôt complet ici :
tribu fitness
/
fitness-tribu-ai
Fitness Tribe AI est une API de fitness basée sur l'IA conçue pour les entraîneurs et les athlètes. L'API fournit une fonctionnalité d'analyse des repas en analysant les photos des repas et un générateur d'entraînement alimenté par l'IA, qui peut générer des plans d'entraînement basés sur les profils des athlètes. Fitness Tribe AI a été construit sur le modèle Gemini.
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 │ │ ├──
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.
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.
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.
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!
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
