add backend source

.env

@@ -0,0 +1,13 @@
+# 資料庫設定
+DATABASE_URL=sqlite:///./data/health_assistant.db
+
+# Redis 設定
+REDIS_HOST=localhost
+REDIS_PORT=6379
+REDIS_DB=0
+
+# API 設定
+API_HOST=localhost
+API_PORT=8000
+
+USDA_API_KEY="0bZCszzPSbc5r6RXfm0aHKtWGX2V0SX1hLiMmXwi"

__init__.py

@@ -0,0 +1 @@
+

app.py

@@ -0,0 +1,65 @@
+from fastapi import FastAPI, File, UploadFile
+from fastapi.middleware.cors import CORSMiddleware
+import uvicorn
+from datetime import datetime
+from PIL import Image
+import io
+import random
+
+app = FastAPI()
+
+# 允許跨域請求
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# 模擬食物列表
+FOOD_ITEMS = [
+    "牛肉麵",
+    "滷肉飯",
+    "炒飯",
+    "水餃",
+    "炸雞",
+    "三明治",
+    "沙拉",
+    "義大利麵",
+    "披薩",
+    "漢堡"
+]
+
+@app.post("/api/ai/analyze-food")
+async def analyze_food(file: UploadFile = File(...)):
+    # 讀取圖片（僅作為示範，不進行實際分析）
+    contents = await file.read()
+    image = Image.open(io.BytesIO(contents))
+    
+    # 隨機選擇一個食物和信心度
+    food = random.choice(FOOD_ITEMS)
+    confidence = random.uniform(85.0, 99.9)
+    
+    # 模擬營養資訊
+    nutrition = {
+        "calories": random.randint(200, 800),
+        "protein": random.randint(10, 30),
+        "carbs": random.randint(20, 60),
+        "fat": random.randint(5, 25)
+    }
+    
+    # 返回結果
+    return {
+        "success": True,
+        "analysis_time": datetime.now().isoformat(),
+        "top_prediction": {
+            "label": food,
+            "confidence": confidence,
+            "nutrition": nutrition,
+            "description": f"這是一道美味的{food}，營養豐富且美味可口。"
+        }
+    }
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="127.0.0.1", port=8000)

app/main.py

@@ -0,0 +1,26 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from app.routers import ai_router, meal_router
+from app.database import engine, Base
+
+# 創建資料庫表
+Base.metadata.create_all(bind=engine)
+
+app = FastAPI(title="Health Assistant API")
+
+# 配置 CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["http://localhost:5173"],  # React 開發伺服器的位址
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# 註冊路由
+app.include_router(ai_router.router)
+app.include_router(meal_router.router)
+
+@app.get("/")
+async def root():
+    return {"message": "Health Assistant API is running"}

backend/requirements.txt

@@ -0,0 +1,8 @@
+fastapi
+uvicorn
+transformers
+torch
+pillow
+opencv-python
+python-multipart
+requests 

backend/setup.py

@@ -0,0 +1,47 @@
+import os
+import sys
+from pathlib import Path
+
+def setup_project():
+    """設置專案目錄結構和必要檔案"""
+    # 獲取專案根目錄
+    project_root = Path(__file__).parent
+    
+    # 創建必要的目錄
+    directories = [
+        'data',  # 資料庫目錄
+        'logs',  # 日誌目錄
+        'uploads'  # 上傳檔案目錄
+    ]
+    
+    for directory in directories:
+        dir_path = project_root / directory
+        dir_path.mkdir(exist_ok=True)
+        print(f"Created directory: {dir_path}")
+    
+    # 創建 .env 檔案（如果不存在）
+    env_file = project_root / '.env'
+    if not env_file.exists():
+        with open(env_file, 'w', encoding='utf-8') as f:
+            f.write("""# 資料庫設定
+DATABASE_URL=sqlite:///./data/health_assistant.db
+
+# Redis 設定
+REDIS_HOST=localhost
+REDIS_PORT=6379
+REDIS_DB=0
+
+# API 設定
+API_HOST=localhost
+API_PORT=8000
+""")
+        print(f"Created .env file: {env_file}")
+    
+    print("\nProject setup completed successfully!")
+    print("\nNext steps:")
+    print("1. Install required packages: pip install -r requirements.txt")
+    print("2. Start the Redis server")
+    print("3. Run the application: uvicorn app.main:app --reload")
+
+if __name__ == "__main__":
+    setup_project()

conftest.py

@@ -0,0 +1,7 @@
+import os
+import sys
+from pathlib import Path
+
+# Add the backend directory to the Python path
+sys.path.insert(0, str(Path(__file__).parent / "backend"))
+sys.path.insert(0, str(Path(__file__).parent))

database.py

@@ -0,0 +1,31 @@
+from sqlalchemy import create_engine
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+import os
+
+# 確保資料庫目錄存在
+DB_DIR = os.path.join(os.path.dirname(os.path.dirname(__file__)), "data")
+os.makedirs(DB_DIR, exist_ok=True)
+
+# 資料庫 URL
+SQLALCHEMY_DATABASE_URL = f"sqlite:///{os.path.join(DB_DIR, 'health_assistant.db')}"
+
+# 創建資料庫引擎
+engine = create_engine(
+    SQLALCHEMY_DATABASE_URL,
+    connect_args={"check_same_thread": False}  # SQLite 特定配置
+)
+
+# 創建 SessionLocal 類
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+# 創建 Base 類
+Base = declarative_base()
+
+# 獲取資料庫會話的依賴項
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()

food_analyzer.py

@@ -0,0 +1,339 @@
+from fastapi import FastAPI, UploadFile, File, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from PIL import Image
+import io
+import base64
+from transformers import pipeline
+import requests
+import json
+from typing import Dict, Any
+from pydantic import BaseModel
+import uvicorn
+
+app = FastAPI(title="Health Assistant AI - Food Recognition API")
+
+# CORS設定
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # 生產環境請設定具體的域名
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# 初始化Hugging Face模型
+try:
+    # 使用nateraw/food專門的食物分類模型
+    food_classifier = pipeline(
+        "image-classification",
+        model="nateraw/food",
+        device=-1  # 使用CPU，如果有GPU可以設為0
+    )
+    print("nateraw/food 食物辨識模型載入成功")
+except Exception as e:
+    print(f"模型載入失敗: {e}")
+    food_classifier = None
+
+# 食物營養資料庫（擴展版，涵蓋nateraw/food模型常見的食物類型）
+NUTRITION_DATABASE = {
+    # 水果類
+    "apple": {"name": "蘋果", "calories_per_100g": 52, "protein": 0.3, "carbs": 14, "fat": 0.2, "fiber": 2.4, "sugar": 10.4, "vitamin_c": 4.6},
+    "banana": {"name": "香蕉", "calories_per_100g": 89, "protein": 1.1, "carbs": 23, "fat": 0.3, "fiber": 2.6, "sugar": 12.2, "potassium": 358},
+    "orange": {"name": "橘子", "calories_per_100g": 47, "protein": 0.9, "carbs": 12, "fat": 0.1, "fiber": 2.4, "sugar": 9.4, "vitamin_c": 53.2},
+    "strawberry": {"name": "草莓", "calories_per_100g": 32, "protein": 0.7, "carbs": 7.7, "fat": 0.3, "fiber": 2, "sugar": 4.9, "vitamin_c": 58.8},
+    "grape": {"name": "葡萄", "calories_per_100g": 62, "protein": 0.6, "carbs": 16.8, "fat": 0.2, "fiber": 0.9, "sugar": 16.1},
+    
+    # 主食類
+    "bread": {"name": "麵包", "calories_per_100g": 265, "protein": 9, "carbs": 49, "fat": 3.2, "fiber": 2.7, "sodium": 491},
+    "rice": {"name": "米飯", "calories_per_100g": 130, "protein": 2.7, "carbs": 28, "fat": 0.3, "fiber": 0.4},
+    "pasta": {"name": "義大利麵", "calories_per_100g": 131, "protein": 5, "carbs": 25, "fat": 1.1, "fiber": 1.8},
+    "noodles": {"name": "麵條", "calories_per_100g": 138, "protein": 4.5, "carbs": 25, "fat": 2.2, "fiber": 1.2},
+    "pizza": {"name": "披薩", "calories_per_100g": 266, "protein": 11, "carbs": 33, "fat": 10, "sodium": 598},
+    
+    # 肉類
+    "chicken": {"name": "雞肉", "calories_per_100g": 165, "protein": 31, "carbs": 0, "fat": 3.6, "iron": 0.9},
+    "beef": {"name": "牛肉", "calories_per_100g": 250, "protein": 26, "carbs": 0, "fat": 15, "iron": 2.6, "zinc": 4.8},
+    "pork": {"name": "豬肉", "calories_per_100g": 242, "protein": 27, "carbs": 0, "fat": 14, "thiamine": 0.7},
+    "fish": {"name": "魚肉", "calories_per_100g": 206, "protein": 22, "carbs": 0, "fat": 12, "omega_3": "豐富"},
+    
+    # 蔬菜類
+    "broccoli": {"name": "花椰菜", "calories_per_100g": 34, "protein": 2.8, "carbs": 7, "fat": 0.4, "fiber": 2.6, "vitamin_c": 89.2},
+    "carrot": {"name": "胡蘿蔔", "calories_per_100g": 41, "protein": 0.9, "carbs": 10, "fat": 0.2, "fiber": 2.8, "vitamin_a": 835},
+    "tomato": {"name": "番茄", "calories_per_100g": 18, "protein": 0.9, "carbs": 3.9, "fat": 0.2, "fiber": 1.2, "vitamin_c": 13.7},
+    "lettuce": {"name": "萵苣", "calories_per_100g": 15, "protein": 1.4, "carbs": 2.9, "fat": 0.2, "fiber": 1.3, "folate": 38},
+    
+    # 飲品類
+    "coffee": {"name": "咖啡", "calories_per_100g": 2, "protein": 0.3, "carbs": 0, "fat": 0, "caffeine": 95},
+    "tea": {"name": "茶", "calories_per_100g": 1, "protein": 0, "carbs": 0.3, "fat": 0, "antioxidants": "豐富"},
+    "milk": {"name": "牛奶", "calories_per_100g": 42, "protein": 3.4, "carbs": 5, "fat": 1, "calcium": 113},
+    "juice": {"name": "果汁", "calories_per_100g": 45, "protein": 0.7, "carbs": 11, "fat": 0.2, "vitamin_c": "因果汁種類而異"},
+    
+    # 甜點類
+    "cake": {"name": "蛋糕", "calories_per_100g": 257, "protein": 4, "carbs": 46, "fat": 6, "sugar": 35},
+    "cookie": {"name": "餅乾", "calories_per_100g": 502, "protein": 5.9, "carbs": 64, "fat": 25, "sugar": 39},
+    "ice_cream": {"name": "冰淇淋", "calories_per_100g": 207, "protein": 3.5, "carbs": 24, "fat": 11, "sugar": 21},
+    "chocolate": {"name": "巧克力", "calories_per_100g": 546, "protein": 4.9, "carbs": 61, "fat": 31, "sugar": 48},
+    
+    # 其他常見食物
+    "egg": {"name": "雞蛋", "calories_per_100g": 155, "protein": 13, "carbs": 1.1, "fat": 11, "choline": 294},
+    "cheese": {"name": "起司", "calories_per_100g": 113, "protein": 7, "carbs": 1, "fat": 9, "calcium": 200},
+    "yogurt": {"name": "優格", "calories_per_100g": 59, "protein": 10, "carbs": 3.6, "fat": 0.4, "probiotics": "豐富"},
+    "nuts": {"name": "堅果", "calories_per_100g": 607, "protein": 15, "carbs": 7, "fat": 54, "vitamin_e": 26},
+    "salad": {"name": "沙拉", "calories_per_100g": 20, "protein": 1.5, "carbs": 4, "fat": 0.2, "fiber": 2, "vitamins": "多種維生素"}
+}
+
+# 回應模型
+class FoodAnalysisResponse(BaseModel):
+    success: bool
+    food_name: str
+    confidence: float
+    nutrition_info: Dict[str, Any]
+    ai_suggestions: list
+    message: str
+
+class HealthResponse(BaseModel):
+    status: str
+    message: str
+
+def get_nutrition_info(food_name: str) -> Dict[str, Any]:
+    """根據食物名稱獲取營養資訊"""
+    # 將食物名稱轉為小寫並清理
+    food_key = food_name.lower().strip()
+    
+    # 移除常見的修飾詞和格式化字符
+    food_key = food_key.replace("_", " ").replace("-", " ")
+    
+    # 直接匹配
+    if food_key in NUTRITION_DATABASE:
+        return NUTRITION_DATABASE[food_key]
+    
+    # 模糊匹配 - 檢查是否包含關鍵字
+    for key, value in NUTRITION_DATABASE.items():
+        if key in food_key or food_key in key:
+            return value
+        # 也檢查中文名稱
+        if value["name"] in food_name:
+            return value
+    
+    # 更智能的匹配 - 處理複合詞
+    food_words = food_key.split()
+    for word in food_words:
+        for key, value in NUTRITION_DATABASE.items():
+            if word == key or word in key:
+                return value
+    
+    # 特殊情況處理
+    special_mappings = {
+        "french fries": "potato",
+        "hamburger": "beef",
+        "sandwich": "bread", 
+        "soda": "juice",
+        "water": {"name": "水", "calories_per_100g": 0, "protein": 0, "carbs": 0, "fat": 0},
+        "soup": {"name": "湯", "calories_per_100g": 50, "protein": 2, "carbs": 8, "fat": 1, "sodium": 400}
+    }
+    
+    for special_key, mapping in special_mappings.items():
+        if special_key in food_key:
+            if isinstance(mapping, str):
+                return NUTRITION_DATABASE.get(mapping, {"name": food_name, "message": "營養資料不完整"})
+            else:
+                return mapping
+    
+    # 如果沒有找到，返回預設值
+    return {
+        "name": food_name,
+        "calories_per_100g": "未知",
+        "protein": "未知",
+        "carbs": "未知", 
+        "fat": "未知",
+        "message": f"抱歉，暫時沒有「{food_name}」的詳細營養資料，建議查詢專業營養資料庫"
+    }
+
+def generate_ai_suggestions(food_name: str, nutrition_info: Dict) -> list:
+    """根據食物和營養資訊生成AI建議"""
+    suggestions = []
+    food_name_lower = food_name.lower()
+    
+    # 檢查是否有完整的營養資訊
+    if isinstance(nutrition_info.get("calories_per_100g"), (int, float)):
+        calories = nutrition_info["calories_per_100g"]
+        
+        # 熱量相關建議
+        if calories > 400:
+            suggestions.append("⚠️ 這是高熱量食物，建議控制份量，搭配運動")
+        elif calories > 200:
+            suggestions.append("🍽️ 中等熱量食物，適量食用，建議搭配蔬菜")
+        elif calories < 50:
+            suggestions.append("✅ 低熱量食物，適合減重期間食用")
+        
+        # 營養素相關建議
+        protein = nutrition_info.get("protein", 0)
+        if isinstance(protein, (int, float)) and protein > 20:
+            suggestions.append("💪 高蛋白食物，有助於肌肉發展和修復")
+        
+        fiber = nutrition_info.get("fiber", 0)
+        if isinstance(fiber, (int, float)) and fiber > 3:
+            suggestions.append("🌿 富含纖維，有助於消化健康和增加飽足感")
+        
+        sugar = nutrition_info.get("sugar", 0)
+        if isinstance(sugar, (int, float)) and sugar > 20:
+            suggestions.append("🍯 含糖量較高，建議適量食用，避免血糖快速上升")
+        
+        # 特殊營養素
+        if nutrition_info.get("vitamin_c", 0) > 30:
+            suggestions.append("🍊 富含維生素C，有助於增強免疫力和抗氧化")
+        
+        if nutrition_info.get("calcium", 0) > 100:
+            suggestions.append("🦴 富含鈣質，有助於骨骼和牙齒健康")
+        
+        if nutrition_info.get("omega_3"):
+            suggestions.append("🐟 含有Omega-3脂肪酸，對心血管健康有益")
+    
+    # 根據食物類型給出特定建議
+    if any(fruit in food_name_lower for fruit in ["apple", "banana", "orange", "strawberry", "grape"]):
+        suggestions.append("🍎 建議在餐前或運動前食用，提供天然糖分和維生素")
+    
+    elif any(meat in food_name_lower for meat in ["chicken", "beef", "pork", "fish"]):
+        suggestions.append("🥩 建議搭配蔬菜食用，選擇健康的烹調方式（烤、蒸、煮）")
+    
+    elif any(sweet in food_name_lower for sweet in ["cake", "cookie", "ice_cream", "chocolate"]):
+        suggestions.append("🍰 甜點建議偶爾享用，可在運動後適量食用")
+        suggestions.append("💡 可以考慮與朋友分享，減少單次攝取量")
+    
+    elif any(drink in food_name_lower for drink in ["coffee", "tea"]):
+        suggestions.append("☕ 建議控制咖啡因攝取量，避免影響睡眠")
+    
+    elif "salad" in food_name_lower:
+        suggestions.append("🥗 很棒的選擇！可以添加堅果或橄欖油增加健康脂肪")
+    
+    # 通用健康建議
+    if not suggestions:
+        suggestions.extend([
+            "🍽️ 建議均衡飲食，搭配多樣化的食物",
+            "💧 記得多喝水，保持身體水分充足",
+            "🏃‍♂️ 搭配適量運動，維持健康生活型態"
+        ])
+    else:
+        # 添加一些通用的健康提醒
+        suggestions.append("💧 記得多喝水，幫助營養吸收")
+        if len(suggestions) < 4:
+            suggestions.append("⚖️ 注意食物份量，適量攝取是健康飲食的關鍵")
+    
+    return suggestions[:5]  # 限制建議數量，避免過多
+
+@app.get("/", response_model=HealthResponse)
+async def root():
+    """API根路径"""
+    return HealthResponse(
+        status="success",
+        message="Health Assistant AI - Food Recognition API is running!"
+    )
+
+@app.get("/health", response_model=HealthResponse)
+async def health_check():
+    """健康檢查端點"""
+    model_status = "正常" if food_classifier else "模型載入失敗"
+    return HealthResponse(
+        status="success",
+        message=f"API運行正常，模型狀態: {model_status}"
+    )
+
+@app.post("/analyze-food", response_model=FoodAnalysisResponse)
+async def analyze_food(file: UploadFile = File(...)):
+    """分析上傳的食物圖片"""
+    try:
+        # 檢查模型是否載入成功
+        if not food_classifier:
+            raise HTTPException(status_code=500, detail="AI模型尚未載入，請稍後再試")
+        
+        # 檢查文件類型
+        if not file.content_type.startswith("image/"):
+            raise HTTPException(status_code=400, detail="請上傳圖片文件")
+        
+        # 讀取圖片
+        image_data = await file.read()
+        image = Image.open(io.BytesIO(image_data))
+        
+        # 確保圖片是RGB格式
+        if image.mode != "RGB":
+            image = image.convert("RGB")
+        
+        # 使用AI模型進行食物辨識
+        results = food_classifier(image)
+        
+        # 獲取最高信心度的結果
+        top_result = results[0]
+        food_name = top_result["label"]
+        confidence = top_result["score"]
+        
+        # 獲取營養資訊
+        nutrition_info = get_nutrition_info(food_name)
+        
+        # 生成AI建議
+        ai_suggestions = generate_ai_suggestions(food_name, nutrition_info)
+        
+        return FoodAnalysisResponse(
+            success=True,
+            food_name=food_name,
+            confidence=round(confidence * 100, 2),
+            nutrition_info=nutrition_info,
+            ai_suggestions=ai_suggestions,
+            message="食物分析完成"
+        )
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"分析失敗: {str(e)}")
+
+@app.post("/analyze-food-base64", response_model=FoodAnalysisResponse)
+async def analyze_food_base64(image_data: dict):
+    """分析base64編碼的食物圖片"""
+    try:
+        # 檢查模型是否載入成功
+        if not food_classifier:
+            raise HTTPException(status_code=500, detail="AI模型尚未載入，請稍後再試")
+        
+        # 解碼base64圖片
+        base64_string = image_data.get("image", "")
+        if not base64_string:
+            raise HTTPException(status_code=400, detail="缺少圖片資料")
+        
+        # 移除base64前綴（如果有的話）
+        if "," in base64_string:
+            base64_string = base64_string.split(",")[1]
+        
+        # 解碼圖片
+        image_bytes = base64.b64decode(base64_string)
+        image = Image.open(io.BytesIO(image_bytes))
+        
+        # 確保圖片是RGB格式
+        if image.mode != "RGB":
+            image = image.convert("RGB")
+        
+        # 使用AI模型進行食物辨識
+        results = food_classifier(image)
+        
+        # 獲取最高信心度的結果
+        top_result = results[0]
+        food_name = top_result["label"]
+        confidence = top_result["score"]
+        
+        # 獲取營養資訊
+        nutrition_info = get_nutrition_info(food_name)
+        
+        # 生成AI建議
+        ai_suggestions = generate_ai_suggestions(food_name, nutrition_info)
+        
+        return FoodAnalysisResponse(
+            success=True,
+            food_name=food_name,
+            confidence=round(confidence * 100, 2),
+            nutrition_info=nutrition_info,
+            ai_suggestions=ai_suggestions,
+            message="食物分析完成"
+        )
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"分析失敗: {str(e)}")
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=8000)

init_db.py

@@ -0,0 +1,70 @@
+from .database import Base, engine, SessionLocal
+from .models.meal_log import MealLog
+from .models.nutrition import Nutrition
+import json
+
+def init_db():
+    """初始化資料庫並填入初始營養數據"""
+    print("Creating database tables...")
+    # 根據模型建立所有表格
+    Base.metadata.create_all(bind=engine)
+    print("Database tables created successfully!")
+
+    # 檢查是否已有資料，避免重複新增
+    db = SessionLocal()
+    if db.query(Nutrition).count() == 0:
+        print("Populating nutrition table with initial data...")
+        
+        # 從 main.py 移植過來的模擬資料
+        mock_nutrition_data = [
+            {
+                "food_name": "hamburger", "chinese_name": "漢堡", "calories": 540, "protein": 25, "fat": 31, "carbs": 40,
+                "fiber": 3, "sugar": 6, "sodium": 1040, "health_score": 45,
+                "recommendations": ["脂肪和鈉含量過高，建議減少食用頻率。"],
+                "warnings": ["高熱量", "高脂肪", "高鈉"]
+            },
+            {
+                "food_name": "pizza", "chinese_name": "披薩", "calories": 266, "protein": 11, "fat": 10, "carbs": 33,
+                "fiber": 2, "sugar": 4, "sodium": 598, "health_score": 65,
+                "recommendations": ["可搭配沙拉以增加纖維攝取。"],
+                "warnings": ["高鈉"]
+            },
+            {
+                "food_name": "sushi", "chinese_name": "壽司", "calories": 200, "protein": 12, "fat": 8, "carbs": 20,
+                "fiber": 1, "sugar": 2, "sodium": 380, "health_score": 85,
+                "recommendations": ["優質的蛋白質和碳水化合物來源。"],
+                "warnings": []
+            },
+            {
+                "food_name": "fried rice", "chinese_name": "炒飯", "calories": 238, "protein": 8, "fat": 12, "carbs": 26,
+                "fiber": 2, "sugar": 3, "sodium": 680, "health_score": 60,
+                "recommendations": ["注意油脂和鈉含量。"],
+                "warnings": ["高鈉"]
+            },
+            {
+                "food_name": "chicken wings", "chinese_name": "雞翅", "calories": 203, "protein": 18, "fat": 14, "carbs": 0,
+                "fiber": 0, "sugar": 0, "sodium": 380, "health_score": 70,
+                "recommendations": ["蛋白質的良好來源。"],
+                "warnings": []
+            },
+            {
+                "food_name": "salad", "chinese_name": "沙拉", "calories": 33, "protein": 3, "fat": 0.2, "carbs": 6,
+                "fiber": 3, "sugar": 3, "sodium": 65, "health_score": 95,
+                "recommendations": ["低熱量高纖維，是健康的選擇。"],
+                "warnings": []
+            }
+        ]
+
+        for food_data in mock_nutrition_data:
+            db_item = Nutrition(**food_data)
+            db.add(db_item)
+        
+        db.commit()
+        print(f"{len(mock_nutrition_data)} items populated.")
+    else:
+        print("Nutrition table already contains data. Skipping population.")
+    
+    db.close()
+
+if __name__ == "__main__":
+    init_db()

main.py

@@ -0,0 +1,209 @@
+from fastapi import FastAPI, UploadFile, File, HTTPException, Depends
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from typing import Dict, Any, List, Optional
+import uvicorn
+import base64
+from io import BytesIO
+from PIL import Image
+import json
+import os
+from dotenv import load_dotenv
+
+# Database and services
+from .app.database import get_db
+from sqlalchemy.orm import Session
+from .app.models.nutrition import Nutrition
+from .app.services import nutrition_api_service
+
+# Routers
+from .app.routers import ai_router, meal_router
+
+app = FastAPI(title="Health Assistant API")
+app.include_router(ai_router.router)
+app.include_router(meal_router.router) 
+
+# Load environment variables
+load_dotenv()
+
+# CORS middleware to allow frontend access
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+class FoodRecognitionResponse(BaseModel):
+    food_name: str
+    chinese_name: str
+    confidence: float
+    success: bool
+
+class NutritionAnalysisResponse(BaseModel):
+    success: bool
+    food_name: str
+    chinese_name: Optional[str] = None
+    nutrition: Dict[str, Any]
+    analysis: Dict[str, Any]
+
+class ErrorResponse(BaseModel):
+    detail: str
+
+@app.get("/")
+async def root():
+    return {"message": "Health Assistant API is running"}
+
+@app.get("/api/analyze-nutrition/{food_name}", response_model=NutritionAnalysisResponse, responses={404: {"model": ErrorResponse}})
+async def analyze_nutrition(food_name: str, db: Session = Depends(get_db)):
+    """
+    Analyze nutrition for a recognized food item by querying the database.
+    If not found locally, it queries an external API and saves the new data.
+    """
+    try:
+        # Query the database for the food item (case-insensitive search)
+        food_item = db.query(Nutrition).filter(Nutrition.food_name.ilike(f"%{food_name.strip()}%")).first()
+        
+        if not food_item:
+            # If not found, query the external API
+            print(f"Food '{food_name}' not in local DB. Querying external API...")
+            api_data = nutrition_api_service.fetch_nutrition_data(food_name)
+            
+            if not api_data:
+                # If external API also doesn't find it, raise 404
+                raise HTTPException(status_code=404, detail=f"Food '{food_name}' not found in local database or external API.")
+
+            # Create a new Nutrition object from the API data
+            recommendations = generate_recommendations(api_data)
+            warnings = generate_warnings(api_data)
+            health_score = calculate_health_score(api_data)
+            
+            new_food_item = Nutrition(
+                food_name=api_data.get('food_name', food_name),
+                chinese_name=api_data.get('chinese_name'),
+                calories=api_data.get('calories', 0),
+                protein=api_data.get('protein', 0),
+                fat=api_data.get('fat', 0),
+                carbs=api_data.get('carbs', 0),
+                fiber=api_data.get('fiber', 0),
+                sugar=api_data.get('sugar', 0),
+                sodium=api_data.get('sodium', 0),
+                health_score=health_score,
+                recommendations=recommendations,
+                warnings=warnings,
+                details={} # API doesn't provide extra details in our format
+            )
+            
+            # Add to DB and commit
+            db.add(new_food_item)
+            db.commit()
+            db.refresh(new_food_item)
+            print(f"Saved new food '{new_food_item.food_name}' to the database.")
+            food_item = new_food_item # Use the new item for the response
+        
+        if not food_item:
+            raise HTTPException(status_code=404, detail=f"Food '{food_name}' not found in the database.")
+        
+        # Structure the response
+        nutrition_details = {
+            "calories": food_item.calories,
+            "protein": food_item.protein,
+            "fat": food_item.fat,
+            "carbs": food_item.carbs,
+            "fiber": food_item.fiber,
+            "sugar": food_item.sugar,
+            "sodium": food_item.sodium,
+            }
+        
+        # Safely add details if they exist and are a dictionary
+        if isinstance(food_item.details, dict):
+            nutrition_details.update(food_item.details)
+        
+        analysis_details = {
+            "healthScore": food_item.health_score,
+            "recommendations": food_item.recommendations,
+            "warnings": food_item.warnings
+        }
+        
+        return {
+            "success": True,
+            "food_name": food_item.food_name,
+            "chinese_name": food_item.chinese_name,
+            "nutrition": nutrition_details,
+            "analysis": analysis_details
+        }
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        # Log the error for debugging
+        print(f"Error in analyze_nutrition: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Internal server error while processing '{food_name}'.")
+
+def calculate_health_score(nutrition: Dict[str, Any]) -> int:
+    """Calculate a health score based on nutritional values"""
+    score = 100
+    
+    # 熱量評分
+    if nutrition.get("calories", 0) > 400:
+        score -= 20
+    elif nutrition.get("calories", 0) > 300:
+        score -= 10
+    
+    # 脂肪評分
+    if nutrition.get("fat", 0) > 20:
+        score -= 15
+    elif nutrition.get("fat", 0) > 15:
+        score -= 8
+    
+    # 蛋白質評分
+    if nutrition.get("protein", 0) > 15:
+        score += 10
+    elif nutrition.get("protein", 0) < 5:
+        score -= 10
+    
+    # 鈉含量評分
+    if nutrition.get("sodium", 0) > 800:
+        score -= 15
+    elif nutrition.get("sodium", 0) > 600:
+        score -= 8
+    
+    return max(0, min(100, score))
+
+def generate_recommendations(nutrition: Dict[str, Any]) -> List[str]:
+    """Generate dietary recommendations based on nutrition data"""
+    recommendations = []
+    
+    if nutrition.get("protein", 0) < 10:
+        recommendations.append("建議增加蛋白質攝取，可搭配雞蛋或豆腐")
+    
+    if nutrition.get("fat", 0) > 20:
+        recommendations.append("脂肪含量較高，建議適量食用")
+    
+    if nutrition.get("fiber", 0) < 3:
+        recommendations.append("纖維含量不足，建議搭配蔬菜沙拉")
+    
+    if nutrition.get("sodium", 0) > 600:
+        recommendations.append("鈉含量偏高，建議多喝水並減少其他鹽分攝取")
+    
+    return recommendations
+
+def generate_warnings(nutrition: Dict[str, Any]) -> List[str]:
+    """Generate dietary warnings based on nutrition data"""
+    warnings = []
+    
+    if nutrition.get("calories", 0) > 500:
+        warnings.append("高熱量食物")
+    
+    if nutrition.get("fat", 0) > 25:
+        warnings.append("高脂肪食物")
+    
+    if nutrition.get("sodium", 0) > 1000:
+        warnings.append("高鈉食物")
+    
+    return warnings
+
+if __name__ == "__main__":
+    # It's better to run with `uvicorn backend.main:app --reload` from the project root.
+    uvicorn.run("main:app", host="0.0.0.0", port=8000, reload=True)

models/meal_log.py

@@ -0,0 +1,19 @@
+from sqlalchemy import Column, Integer, String, Float, DateTime, JSON
+from ..database import Base
+
+class MealLog(Base):
+    __tablename__ = "meal_logs"
+
+    id = Column(Integer, primary_key=True, index=True)
+    food_name = Column(String, index=True)
+    meal_type = Column(String)  # breakfast, lunch, dinner, snack
+    portion_size = Column(String)  # small, medium, large
+    calories = Column(Float)
+    protein = Column(Float)
+    carbs = Column(Float)
+    fat = Column(Float)
+    fiber = Column(Float)
+    meal_date = Column(DateTime, index=True)
+    image_url = Column(String)
+    ai_analysis = Column(JSON)  # 儲存完整的 AI 分析結果
+    created_at = Column(DateTime)

models/nutrition.py

@@ -0,0 +1,22 @@
+# backend/app/models/nutrition.py
+from sqlalchemy import Column, Integer, String, Float, JSON
+from ..database import Base
+
+class Nutrition(Base):
+    __tablename__ = "nutrition"
+
+    id = Column(Integer, primary_key=True, index=True)
+    food_name = Column(String, unique=True, index=True, nullable=False)
+    chinese_name = Column(String)
+    calories = Column(Float)
+    protein = Column(Float)
+    fat = Column(Float)
+    carbs = Column(Float)
+    fiber = Column(Float)
+    sugar = Column(Float)
+    sodium = Column(Float)
+    # For more complex data like vitamins, minerals, etc.
+    details = Column(JSON)
+    health_score = Column(Integer)
+    recommendations = Column(JSON)
+    warnings = Column(JSON) 

routers/ai_router.py

@@ -0,0 +1,36 @@
+# 檔案路徑: backend/app/routers/ai_router.py
+
+from fastapi import APIRouter, File, UploadFile, HTTPException
+from ..services.ai_service import classify_food_image  # 直接引入分類函式
+from ..services.nutrition_api_service import fetch_nutrition_data  # 匯入營養查詢函式
+
+router = APIRouter(
+    prefix="/ai",
+    tags=["AI"],
+)
+
+@router.post("/analyze-food-image/")
+async def analyze_food_image_endpoint(file: UploadFile = File(...)):
+    """
+    這個端點接收使用者上傳的食物圖片，使用 AI 模型進行辨識，
+    並返回辨識出的食物名稱。
+    """
+    # 檢查上傳的檔案是否為圖片格式
+    if not file.content_type or not file.content_type.startswith("image/"):
+        raise HTTPException(status_code=400, detail="上傳的檔案不是圖片格式。")
+
+    # 讀取圖片的二進位制內容
+    image_bytes = await file.read()
+    
+    # 呼叫 AI 服務中的分類函式
+    food_name = classify_food_image(image_bytes)
+
+    # 查詢營養資訊
+    nutrition_info = fetch_nutrition_data(food_name)
+    if nutrition_info is None:
+        raise HTTPException(status_code=404, detail=f"找不到 {food_name} 的營養資訊。")
+
+    # TODO: 在下一階段，我們會在這裡加入從資料庫查詢營養資訊的邏輯
+    # 目前，我們先直接回傳辨識出的食物名稱
+    
+    return {"food_name": food_name, "nutrition_info": nutrition_info}

routers/meal_router.py

@@ -0,0 +1,103 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+from typing import List, Dict, Any, Optional
+from datetime import datetime
+from ..services.meal_service import MealService
+from ..database import get_db
+from pydantic import BaseModel
+
+router = APIRouter(prefix="/api/meals", tags=["Meals"])
+
+class MealCreate(BaseModel):
+    food_name: str
+    meal_type: str
+    portion_size: str
+    meal_date: datetime
+    nutrition: Dict[str, float]
+    image_url: Optional[str] = None
+    ai_analysis: Optional[Dict[str, Any]] = None
+
+class DateRange(BaseModel):
+    start_date: datetime
+    end_date: datetime
+    meal_type: Optional[str] = None
+
+@router.post("/log")
+async def create_meal_log(
+    meal: MealCreate,
+    db: Session = Depends(get_db)
+) -> Dict[str, Any]:
+    """創建新的用餐記錄"""
+    meal_service = MealService(db)
+    try:
+        meal_log = meal_service.create_meal_log(
+            food_name=meal.food_name,
+            meal_type=meal.meal_type,
+            portion_size=meal.portion_size,
+            nutrition=meal.nutrition,
+            meal_date=meal.meal_date,
+            image_url=meal.image_url,
+            ai_analysis=meal.ai_analysis
+        )
+        return {
+            "success": True,
+            "message": "用餐記錄已創建",
+            "data": {
+                "id": meal_log.id,
+                "food_name": meal_log.food_name,
+                "meal_type": meal_log.meal_type,
+                "meal_date": meal_log.meal_date
+            }
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post("/list")
+async def get_meal_logs(
+    date_range: DateRange,
+    db: Session = Depends(get_db)
+) -> Dict[str, Any]:
+    """獲取用餐記錄列表"""
+    meal_service = MealService(db)
+    try:
+        logs = meal_service.get_meal_logs(
+            start_date=date_range.start_date,
+            end_date=date_range.end_date,
+            meal_type=date_range.meal_type
+        )
+        return {
+            "success": True,
+            "data": [{
+                "id": log.id,
+                "food_name": log.food_name,
+                "meal_type": log.meal_type,
+                "portion_size": log.portion_size,
+                "calories": log.calories,
+                "protein": log.protein,
+                "carbs": log.carbs,
+                "fat": log.fat,
+                "meal_date": log.meal_date,
+                "image_url": log.image_url
+            } for log in logs]
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post("/nutrition-summary")
+async def get_nutrition_summary(
+    date_range: DateRange,
+    db: Session = Depends(get_db)
+) -> Dict[str, Any]:
+    """獲取營養攝入總結"""
+    meal_service = MealService(db)
+    try:
+        summary = meal_service.get_nutrition_summary(
+            start_date=date_range.start_date,
+            end_date=date_range.end_date
+        )
+        return {
+            "success": True,
+            "data": summary
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

services/__init__.py

@@ -0,0 +1,5 @@
+# This file makes the services directory a Python package
+# Import the HybridFoodAnalyzer class to make it available when importing from app.services
+from .food_analyzer_service import HybridFoodAnalyzer
+
+__all__ = ['HybridFoodAnalyzer']

services/ai_service.py

@@ -0,0 +1,95 @@
+# 檔案路徑: backend/app/services/ai_service.py
+
+from transformers.pipelines import pipeline
+from PIL import Image
+import io
+import logging
+
+# 設置日誌
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# 全局變量
+image_classifier = None
+
+def load_model():
+    """載入模型的函數"""
+    global image_classifier
+    
+    try:
+        logger.info("正在載入食物辨識模型...")
+        # 載入模型 - 移除不支持的參數
+        image_classifier = pipeline(
+            "image-classification", 
+            model="juliensimon/autotrain-food101-1471154053",
+            device=-1  # 使用CPU
+        )
+        logger.info("模型載入成功！")
+        return True
+    except Exception as e:
+        logger.error(f"模型載入失敗: {str(e)}")
+        image_classifier = None
+        return False
+
+def classify_food_image(image_bytes: bytes) -> str:
+    """
+    接收圖片的二進位制數據，進行分類並返回可能性最高的食物名稱。
+    """
+    global image_classifier
+    
+    # 如果模型未載入，嘗試重新載入
+    if image_classifier is None:
+        logger.warning("模型未載入，嘗試重新載入...")
+        if not load_model():
+            return "Error: Model not loaded"
+    
+    if image_classifier is None:
+        return "Error: Model could not be loaded"
+
+    try:
+        # 驗證圖片數據
+        if not image_bytes:
+            return "Error: Empty image data"
+        
+        # 從記憶體中的 bytes 打開圖片
+        image = Image.open(io.BytesIO(image_bytes))
+        
+        # 確保圖片是RGB格式
+        if image.mode != 'RGB':
+            image = image.convert('RGB')
+        
+        logger.info(f"處理圖片，尺寸: {image.size}")
+        
+        # 使用模型管線進行分類
+        pipeline_output = image_classifier(image)
+        
+        logger.info(f"模型輸出: {pipeline_output}")
+        
+        # 處理輸出結果
+        if not pipeline_output:
+            return "Unknown"
+        
+        # pipeline_output 通常是一個列表
+        if isinstance(pipeline_output, list) and len(pipeline_output) > 0:
+            result = pipeline_output[0]
+            if isinstance(result, dict) and 'label' in result:
+                label = result['label']
+                confidence = result.get('score', 0)
+                
+                logger.info(f"辨識結果: {label}, 信心度: {confidence:.2f}")
+                
+            # 標籤可能包含底線，我們將其替換為空格，並讓首字母大寫
+                formatted_label = str(label).replace('_', ' ').title()
+                return formatted_label
+            
+        return "Unknown"
+        
+    except Exception as e:
+        logger.error(f"圖片分類過程中發生錯誤: {str(e)}")
+        return f"Error: {str(e)}"
+
+# 在模塊載入時嘗試載入模型
+logger.info("初始化 AI 服務...")
+load_model()
+
+__all__ = ["classify_food_image"]

services/food_analyzer_service.py

@@ -0,0 +1,256 @@
+import torch
+import json
+from typing import Dict, Any, Optional
+from PIL import Image
+from io import BytesIO
+import base64
+import os
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+class HybridFoodAnalyzer:
+    def __init__(self, claude_api_key: Optional[str] = None):
+        """
+        Initialize the HybridFoodAnalyzer with HuggingFace model and Claude API.
+        
+        Args:
+            claude_api_key: Optional API key for Claude. If not provided, will try to get from environment variable CLAUDE_API_KEY.
+        """
+        # Initialize HuggingFace model
+        from transformers import AutoImageProcessor, AutoModelForImageClassification
+        
+        print("Loading HuggingFace food recognition model...")
+        self.processor = AutoImageProcessor.from_pretrained("nateraw/food")
+        self.model = AutoModelForImageClassification.from_pretrained("nateraw/food")
+        self.model.eval()  # Set model to evaluation mode
+        
+        # Initialize Claude API
+        print("Initializing Claude API...")
+        import anthropic
+        self.claude_api_key = claude_api_key or os.getenv('CLAUDE_API_KEY')
+        if not self.claude_api_key:
+            raise ValueError("Claude API key is required. Please set CLAUDE_API_KEY environment variable or pass it as an argument.")
+            
+        self.claude_client = anthropic.Anthropic(api_key=self.claude_api_key)
+    
+    def recognize_food(self, image: Image.Image) -> Dict[str, Any]:
+        """
+        Recognize food from an image using HuggingFace model.
+        
+        Args:
+            image: PIL Image object containing the food image
+            
+        Returns:
+            Dictionary containing food name and confidence score
+        """
+        try:
+            print("Processing image for food recognition...")
+            inputs = self.processor(images=image, return_tensors="pt")
+            
+            with torch.no_grad():
+                outputs = self.model(**inputs)
+                predictions = torch.nn.functional.softmax(outputs.logits, dim=-1)
+            
+            predicted_class_id = int(predictions.argmax().item())
+            confidence = predictions[0][predicted_class_id].item()
+            food_name = self.model.config.id2label[predicted_class_id]
+            
+            # Map common food names to Chinese
+            food_name_mapping = {
+                "hamburger": "漢堡",
+                "pizza": "披薩",
+                "sushi": "壽司",
+                "fried rice": "炒飯",
+                "chicken wings": "雞翅",
+                "salad": "沙拉",
+                "apple": "蘋果",
+                "banana": "香蕉",
+                "orange": "橙子",
+                "noodles": "麵條"
+            }
+            
+            chinese_name = food_name_mapping.get(food_name.lower(), food_name)
+            
+            return {
+                "food_name": food_name,
+                "chinese_name": chinese_name,
+                "confidence": confidence,
+                "success": True
+            }
+            
+        except Exception as e:
+            print(f"Error in food recognition: {str(e)}")
+            return {
+                "success": False,
+                "error": str(e)
+            }
+    
+    def analyze_nutrition(self, food_name: str) -> Dict[str, Any]:
+        """
+        Analyze nutrition information for a given food using Claude API.
+        
+        Args:
+            food_name: Name of the food to analyze
+            
+        Returns:
+            Dictionary containing nutrition information
+        """
+        try:
+            print(f"Analyzing nutrition for {food_name}...")
+            prompt = f"""
+            請分析 {food_name} 的營養成分（每100g），並以JSON格式回覆：
+            {{
+                "calories": 數值,
+                "protein": 數值,
+                "fat": 數值,
+                "carbs": 數值,
+                "fiber": 數值,
+                "sugar": 數值,
+                "sodium": 數值
+            }}
+            """
+            
+            message = self.claude_client.messages.create(
+                model="claude-3-sonnet-20240229",
+                max_tokens=500,
+                messages=[{"role": "user", "content": prompt}]
+            )
+            
+            # Extract and parse the JSON response
+            response_text = message.content[0].get("text", "") if isinstance(message.content[0], dict) else str(message.content[0])
+            try:
+                nutrition_data = json.loads(response_text.strip())
+                return {
+                    "success": True,
+                    "nutrition": nutrition_data
+                }
+            except json.JSONDecodeError as e:
+                print(f"Error parsing Claude response: {e}")
+                return {
+                    "success": False,
+                    "error": f"Failed to parse nutrition data: {e}",
+                    "raw_response": response_text
+                }
+                
+        except Exception as e:
+            print(f"Error in nutrition analysis: {str(e)}")
+            return {
+                "success": False,
+                "error": str(e)
+            }
+
+    def process_image(self, image_data: bytes) -> Dict[str, Any]:
+        """
+        Process an image to recognize food and analyze its nutrition.
+        
+        Args:
+            image_data: Binary image data
+            
+        Returns:
+            Dictionary containing recognition and analysis results
+        """
+        try:
+            # Convert bytes to PIL Image
+            image = Image.open(BytesIO(image_data))
+            
+            # Step 1: Recognize food
+            recognition_result = self.recognize_food(image)
+            if not recognition_result.get("success"):
+                return recognition_result
+            
+            # Step 2: Analyze nutrition
+            nutrition_result = self.analyze_nutrition(recognition_result["food_name"])
+            if not nutrition_result.get("success"):
+                return nutrition_result
+            
+            # Calculate health score
+            nutrition = nutrition_result["nutrition"]
+            health_score = self.calculate_health_score(nutrition)
+            
+            # Generate recommendations and warnings
+            recommendations = self.generate_recommendations(nutrition)
+            warnings = self.generate_warnings(nutrition)
+            
+            return {
+                "success": True,
+                "food_name": recognition_result["food_name"],
+                "chinese_name": recognition_result["chinese_name"],
+                "confidence": recognition_result["confidence"],
+                "nutrition": nutrition,
+                "analysis": {
+                    "healthScore": health_score,
+                    "recommendations": recommendations,
+                    "warnings": warnings
+                }
+            }
+            
+        except Exception as e:
+            return {
+                "success": False,
+                "error": f"Failed to process image: {str(e)}"
+            }
+    
+    def calculate_health_score(self, nutrition: Dict[str, float]) -> int:
+        """Calculate a health score based on nutritional values"""
+        score = 100
+        
+        # 熱量評分
+        if nutrition["calories"] > 400:
+            score -= 20
+        elif nutrition["calories"] > 300:
+            score -= 10
+        
+        # 脂肪評分
+        if nutrition["fat"] > 20:
+            score -= 15
+        elif nutrition["fat"] > 15:
+            score -= 8
+        
+        # 蛋白質評分
+        if nutrition["protein"] > 15:
+            score += 10
+        elif nutrition["protein"] < 5:
+            score -= 10
+        
+        # 鈉含量評分
+        if "sodium" in nutrition and nutrition["sodium"] > 800:
+            score -= 15
+        elif "sodium" in nutrition and nutrition["sodium"] > 600:
+            score -= 8
+        
+        return max(0, min(100, score))
+    
+    def generate_recommendations(self, nutrition: Dict[str, float]) -> list:
+        """Generate dietary recommendations based on nutrition data"""
+        recommendations = []
+        
+        if nutrition["protein"] < 10:
+            recommendations.append("建議增加蛋白質攝取，可搭配雞蛋或豆腐")
+        
+        if nutrition["fat"] > 20:
+            recommendations.append("脂肪含量較高，建議適量食用")
+        
+        if "fiber" in nutrition and nutrition["fiber"] < 3:
+            recommendations.append("纖維含量不足，建議搭配蔬菜沙拉")
+        
+        if "sodium" in nutrition and nutrition["sodium"] > 600:
+            recommendations.append("鈉含量偏高，建議多喝水並減少其他鹽分攝取")
+        
+        return recommendations
+    
+    def generate_warnings(self, nutrition: Dict[str, float]) -> list:
+        """Generate dietary warnings based on nutrition data"""
+        warnings = []
+        
+        if nutrition["calories"] > 500:
+            warnings.append("高熱量食物")
+        
+        if nutrition["fat"] > 25:
+            warnings.append("高脂肪食物")
+        
+        if "sodium" in nutrition and nutrition["sodium"] > 1000:
+            warnings.append("高鈉食物")
+        
+        return warnings

services/meal_service.py

@@ -0,0 +1,89 @@
+from datetime import datetime
+from typing import List, Dict, Any, Optional
+from sqlalchemy.orm import Session
+from ..models.meal_log import MealLog
+
+class MealService:
+    def __init__(self, db: Session):
+        self.db = db
+
+    def create_meal_log(
+        self,
+        food_name: str,
+        meal_type: str,
+        portion_size: str,
+        nutrition: Dict[str, float],
+        meal_date: datetime,
+        image_url: Optional[str] = None,
+        ai_analysis: Optional[Dict[str, Any]] = None
+    ) -> MealLog:
+        """創建新的用餐記錄"""
+        meal_log = MealLog(
+            food_name=food_name,
+            meal_type=meal_type,
+            portion_size=portion_size,
+            calories=nutrition.get('calories', 0),
+            protein=nutrition.get('protein', 0),
+            carbs=nutrition.get('carbs', 0),
+            fat=nutrition.get('fat', 0),
+            fiber=nutrition.get('fiber', 0),
+            meal_date=meal_date,
+            image_url=image_url,
+            ai_analysis=ai_analysis,
+            created_at=datetime.utcnow()
+        )
+        
+        self.db.add(meal_log)
+        self.db.commit()
+        self.db.refresh(meal_log)
+        return meal_log
+
+    def get_meal_logs(
+        self,
+        start_date: Optional[datetime] = None,
+        end_date: Optional[datetime] = None,
+        meal_type: Optional[str] = None
+    ) -> List[MealLog]:
+        """獲取用餐記錄"""
+        query = self.db.query(MealLog)
+        
+        if start_date:
+            query = query.filter(MealLog.meal_date >= start_date)
+        if end_date:
+            query = query.filter(MealLog.meal_date <= end_date)
+        if meal_type:
+            query = query.filter(MealLog.meal_type == meal_type)
+            
+        return query.order_by(MealLog.meal_date.desc()).all()
+
+    def get_nutrition_summary(
+        self,
+        start_date: datetime,
+        end_date: datetime
+    ) -> Dict[str, float]:
+        """獲取指定時間範圍內的營養攝入總結"""
+        meals = self.get_meal_logs(start_date, end_date)
+        
+        summary = {
+            'total_calories': 0,
+            'total_protein': 0,
+            'total_carbs': 0,
+            'total_fat': 0,
+            'total_fiber': 0
+        }
+        
+        for meal in meals:
+            # 根據份量大小調整營養值
+            multiplier = {
+                'small': 0.7,
+                'medium': 1.0,
+                'large': 1.3
+            }.get(meal.portion_size, 1.0)
+            
+            summary['total_calories'] += meal.calories * multiplier
+            summary['total_protein'] += meal.protein * multiplier
+            summary['total_carbs'] += meal.carbs * multiplier
+            summary['total_fat'] += meal.fat * multiplier
+            summary['total_fiber'] += meal.fiber * multiplier
+            
+        return summary

services/nutrition_api_service.py

@@ -0,0 +1,101 @@
+# backend/app/services/nutrition_api_service.py
+import os
+import requests
+from dotenv import load_dotenv
+import logging
+
+# 設置日誌
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# 載入環境變數
+load_dotenv()
+
+# 從環境變數中獲取 API 金鑰
+USDA_API_KEY = os.getenv("USDA_API_KEY", "DEMO_KEY")
+USDA_API_URL = "https://api.nal.usda.gov/fdc/v1/foods/search"
+
+# 我們關心的主要營養素及其在 USDA API 中的名稱或編號
+# 我們可以透過 nutrient.nutrientNumber 或 nutrient.name 來匹配
+NUTRIENT_MAP = {
+    'calories': 'Energy',
+    'protein': 'Protein',
+    'fat': 'Total lipid (fat)',
+    'carbs': 'Carbohydrate, by difference',
+    'fiber': 'Fiber, total dietary',
+    'sugar': 'Total sugars',
+    'sodium': 'Sodium, Na'
+}
+
+def fetch_nutrition_data(food_name: str):
+    """
+    從 USDA FoodData Central API 獲取食物的營養資訊。
+
+    :param food_name: 要查詢的食物名稱 (例如 "Donuts")。
+    :return: 包含營養資訊的字典，如果找不到則返回 None。
+    """
+    if not USDA_API_KEY:
+        logger.error("USDA_API_KEY 未設定，無法查詢營養資訊。")
+        return None
+
+    params = {
+        'query': food_name,
+        'api_key': USDA_API_KEY,
+        'dataType': 'Branded',  # 優先搜尋品牌食品，結果通常更符合預期
+        'pageSize': 1  # 我們只需要最相關的一筆結果
+    }
+
+    try:
+        logger.info(f"正在向 USDA API 查詢食物：{food_name}")
+        response = requests.get(USDA_API_URL, params=params)
+        response.raise_for_status()  # 如果請求失敗 (例如 4xx 或 5xx)，則會拋出異常
+
+        data = response.json()
+
+        # 檢查是否有找到食物
+        if data.get('foods') and len(data['foods']) > 0:
+            food_data = data['foods'][0]  # 取第一個最相關的結果
+            logger.info(f"從 API 成功獲取到食物 '{food_data.get('description')}' 的資料")
+            
+            nutrition_info = {
+                "food_name": food_data.get('description', food_name).capitalize(),
+                "chinese_name": None,  # USDA API 不提供中文名
+            }
+
+            # 遍歷我們需要的營養素
+            extracted_nutrients = {key: 0.0 for key in NUTRIENT_MAP.keys()} # 初始化
+            
+            for nutrient in food_data.get('foodNutrients', []):
+                for key, name in NUTRIENT_MAP.items():
+                    if nutrient.get('nutrientName').strip().lower() == name.strip().lower():
+                        # 將值存入我們的格式
+                        extracted_nutrients[key] = float(nutrient.get('value', 0.0))
+                        break # 找到後就跳出內層迴圈
+
+            nutrition_info.update(extracted_nutrients)
+            
+            # 由於 USDA 不直接提供健康建議，我們先回傳原始數據
+            # 後續可以在 main.py 中根據這些數據生成我們自己的建議
+            return nutrition_info
+
+        else:
+            logger.warning(f"在 USDA API 中找不到食物：{food_name}")
+            return None
+
+    except requests.exceptions.RequestException as e:
+        logger.error(f"請求 USDA API 時發生錯誤: {e}")
+        return None
+    except Exception as e:
+        logger.error(f"處理 API 回應時發生未知錯誤: {e}")
+        return None
+
+if __name__ == '__main__':
+    # 測試此模組的功能
+    test_food = "donuts"
+    nutrition = fetch_nutrition_data(test_food)
+    if nutrition:
+        import json
+        print(f"成功獲取 '{test_food}' 的營養資訊:")
+        print(json.dumps(nutrition, indent=2))
+    else:
+        print(f"無法獲取 '{test_food}' 的營養資訊。") 

setup.py

@@ -0,0 +1,30 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="health_assistant",
+    version="0.1.0",
+    packages=find_packages(where="backend"),
+    package_dir={"": "backend"},
+    install_requires=[
+        "fastapi>=0.68.0",
+        "uvicorn>=0.15.0",
+        "python-multipart>=0.0.5",
+        "Pillow>=8.3.1",
+        "transformers>=4.11.3",
+        "torch>=1.9.0",
+        "python-dotenv>=0.19.0",
+        "httpx>=0.19.0",
+        "pydantic>=1.8.0",
+    ],
+    extras_require={
+        "dev": [
+            "pytest>=6.2.5",
+            "pytest-cov>=2.12.1",
+            "pytest-asyncio>=0.15.1",
+            "black>=21.7b0",
+            "isort>=5.9.3",
+            "mypy>=0.910",
+        ],
+    },
+    python_requires=">=3.8",
+)

test_pytest.py

@@ -0,0 +1,2 @@
+def test_example():
+    assert 1 + 1 == 2