added agent and other services update

services/ai_agent.py

@@ -1,122 +0,0 @@
-from sqlalchemy.orm import Session
-from fastapi import HTTPException
-from utils.fetch_data import fetch_product_data_from_api
-from utils.file_operations import save_json_file
-from models.ingredient import Ingredient
-from models.product import Product
-from services.ingredients import get_ingredient_by_name, save_ingredient_data, fetch_ingredient_data_from_api
-from typing import Dict, Any
-import json
-from transformers import pipeline
-
-def preprocess_data(barcode: str) -> Dict[str, Any]:
-    data = fetch_product_data_from_api(barcode)
-    product = data.get('product', {})
-
-    product_info = {
-        "product_name": product.get('product_name_en', product.get('product_name', 'N/A')),
-        "generic_name": product.get('generic_name_en', product.get('generic_name', 'N/A')),
-        "brands": product.get('brands', 'N/A'),
-        "ingredients": [],
-        "ingredients_text": product.get('ingredients_text_en', product.get('ingredients_text', 'N/A')),
-        "ingredients_analysis": product.get('ingredients_analysis', {}),
-        "nutriscore": product.get('nutriscore', {}),
-        "nutrient_levels": product.get('nutrient_levels', {}),
-        "nutriments": product.get('nutriments', {}),
-        "data_quality_warnings": product.get('data_quality_warnings_tags', [])
-    }
-
-    ingredients_list = product.get('ingredients', [])
-    for ingredient in ingredients_list:
-        ingredient_info = {
-            "text": ingredient.get('text', 'N/A'),
-            "percent": ingredient.get('percent', ingredient.get('percent_estimate', 'N/A')),
-            "vegan": ingredient.get('vegan', 'N/A'),
-            "vegetarian": ingredient.get('vegetarian', 'N/A'),
-            "sub_ingredients": []
-        }
-        sub_ingredients = ingredient.get('ingredients', [])
-        for sub_ingredient in sub_ingredients:
-            sub_ingredient_info = {
-                "text": sub_ingredient.get('text', 'N/A'),
-                "percent": sub_ingredient.get('percent', sub_ingredient.get('percent_estimate', 'N/A')),
-                "vegan": sub_ingredient.get('vegan', 'N/A'),
-                "vegetarian": sub_ingredient.get('vegetarian', 'N/A')
-            }
-            ingredient_info["sub_ingredients"].append(sub_ingredient_info)
-        product_info["ingredients"].append(ingredient_info)
-
-    return product_info
-
-def validate_data(data: Dict[str, Any]) -> bool:
-    required_fields = ["product_name", "generic_name", "brands", "ingredients", "nutriscore", "nutrient_levels", "nutriments"]
-    for field in required_fields:
-        if field not in data or not data[field]:
-            return False
-    return True
-
-def clean_data(data: Dict[str, Any]) -> Dict[str, Any]:
-    for ingredient in data["ingredients"]:
-        if "percent" in ingredient and ingredient["percent"] == "N/A":
-            ingredient["percent"] = 0
-        for sub_ingredient in ingredient["sub_ingredients"]:
-            if "percent" in sub_ingredient and sub_ingredient["percent"] == "N/A":
-                sub_ingredient["percent"] = 0
-    return data
-
-def standardize_data(data: Dict[str, Any]) -> Dict[str, Any]:
-    for ingredient in data["ingredients"]:
-        ingredient["text"] = ingredient["text"].lower()
-        for sub_ingredient in ingredient["sub_ingredients"]:
-            sub_ingredient["text"] = sub_ingredient["text"].lower()
-    return data
-
-def enrich_data(db: Session, data: Dict[str, Any]) -> Dict[str, Any]:
-    for ingredient in data["ingredients"]:
-        ingredient_data = get_ingredient_by_name(db, ingredient["text"])
-        if not ingredient_data:
-            ingredient_data = fetch_ingredient_data_from_api(ingredient["text"])
-            save_ingredient_data(db, ingredient["text"], ingredient_data)
-        ingredient["nutritional_info"] = ingredient_data
-    return data
-
-def process_data(db: Session, barcode: str) -> Dict[str, Any]:
-    data = preprocess_data(barcode)
-    if not validate_data(data):
-        raise HTTPException(status_code=400, detail="Invalid data")
-    data = clean_data(data)
-    data = standardize_data(data)
-    data = enrich_data(db, data)
-    
-    # Save product details in the Product model
-    product = Product(
-        product_name=data["product_name"],
-        generic_name=data["generic_name"],
-        brands=data["brands"],
-        ingredients=data["ingredients"],
-        ingredients_text=data["ingredients_text"],
-        ingredients_analysis=data["ingredients_analysis"],
-        nutriscore=data["nutriscore"],
-        nutrient_levels=data["nutrient_levels"],
-        nutriments=data["nutriments"],
-        data_quality_warnings=data["data_quality_warnings"]
-    )
-    db.add(product)
-    db.commit()
-    db.refresh(product)
-    
-    # Save ingredient details in the Ingredient model
-    for ingredient in data["ingredients"]:
-        ingredient_data = get_ingredient_by_name(db, ingredient["text"])
-        if not ingredient_data:
-            ingredient_data = fetch_ingredient_data_from_api(ingredient["text"])
-            save_ingredient_data(db, ingredient["text"], ingredient_data)
-        ingredient["nutritional_info"] = ingredient_data
-    
-    save_json_file(barcode, data)
-    return data
-
-def integrate_hugging_face_transformers(model_name: str, text: str) -> str:
-    nlp = pipeline("fill-mask", model=model_name)
-    result = nlp(text)
-    return result[0]['sequence']

services/analysis_agent.py

@@ -1,49 +0,0 @@
-from sqlalchemy.orm import Session
-from fastapi import HTTPException
-from typing import Dict, Any, List
-from models.user_preferences import UserPreferences
-from services.ingredients import get_ingredient_data, filter_ingredients_by_preferences
-from models.ingredient import Ingredient
-
-def analyze_ingredients(db: Session, ingredients: List[Dict[str, Any]], user_id: int) -> Dict[str, Any]:
-    preferences = db.query(UserPreferences).filter(UserPreferences.user_id == user_id).first()
-    if not preferences:
-        raise HTTPException(status_code=404, detail="User preferences not found")
-
-    filtered_ingredients = filter_ingredients_by_preferences(ingredients, preferences.__dict__)
-    analysis_results = {
-        "safe_ingredients": [],
-        "unsafe_ingredients": [],
-        "additional_facts": []
-    }
-
-    for ingredient in filtered_ingredients:
-        ingredient_data = get_ingredient_data(db, ingredient["text"])
-        if ingredient_data:
-            analysis_results["safe_ingredients"].append({
-                "name": ingredient["text"],
-                "nutritional_info": ingredient_data
-            })
-        else:
-            analysis_results["unsafe_ingredients"].append({
-                "name": ingredient["text"],
-                "reason": "Information not found"
-            })
-
-    return analysis_results
-
-def provide_personalized_recommendations(db: Session, user_id: int) -> Dict[str, Any]:
-    preferences = db.query(UserPreferences).filter(UserPreferences.user_id == user_id).first()
-    if not preferences:
-        raise HTTPException(status_code=404, detail="User preferences not found")
-
-    recommended_ingredients = []
-    all_ingredients = db.query(Ingredient).all()
-    for ingredient in all_ingredients:
-        if ingredient.name not in preferences.disliked_ingredients:
-            recommended_ingredients.append({
-                "name": ingredient.name,
-                "nutritional_info": ingredient.nutritional_info
-            })
-
-    return {"recommended_ingredients": recommended_ingredients}

services/auth_service.py

@@ -4,9 +4,10 @@ from datetime import datetime, timedelta
 from fastapi import Depends, HTTPException, status
 from fastapi.security import OAuth2PasswordBearer
 from sqlalchemy.orm import Session,Mapped
-from database import get_db
-from models.user import User
-from pydantic import BaseModel
+from db.database import get_db
+from db.models import User
+from interfaces.authModels import UserResponse,TokenData
+from logger_manager import log_info, log_error
 
 # to get a string like this run:
 # openssl rand -hex 32
@@ -17,42 +18,62 @@ ACCESS_TOKEN_EXPIRE_MINUTES = 30
 pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
 oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
 
-class Token(BaseModel):
-    access_token: str
-    token_type: str
-
-class TokenData(BaseModel):
-    username: str | None = None
 
 
 def verify_password(plain_password, hashed_password):
-    return pwd_context.verify(plain_password, hashed_password)
+    log_info("Verifying password")
+    try:
+        return pwd_context.verify(plain_password, hashed_password)
+    except Exception as e:
+        log_error(f"Error verifying password: {str(e)}")
+        raise HTTPException(status_code=500, detail="Internal Server Error")
 
 def get_password_hash(password):
-    return pwd_context.hash(password)
+    log_info("Hashing password")
+    try:
+        return pwd_context.hash(password)
+    except Exception as e:
+        log_error(f"Error hashing password: {str(e)}")
+        raise HTTPException(status_code=500, detail="Internal Server Error")
 
 def get_user(db, username: str):
-    return db.query(User).filter(User.username == username).first()
+    log_info(f"Getting user: {username}")
+    try:
+        return db.query(User).filter(User.username == username).first()
+    except Exception as e:
+        log_error(f"Error getting user: {str(e)}")
+        raise HTTPException(status_code=500, detail="Internal Server Error")
 
 def authenticate_user(db, username: str, password: str):
-    user = get_user(db, username)
-    if not user:
-        return False
-    if not verify_password(password, user.hashed_password):
-        return False
-    return user
+    log_info(f"Authenticating user: {username}")
+    try:
+        user = get_user(db, username)
+        if not user:
+            return False
+        if not verify_password(password, user.hashed_password):
+            return False
+        return user
+    except Exception as e:
+        log_error(f"Error authenticating user: {str(e)}")
+        raise HTTPException(status_code=500, detail="Internal Server Error")
 
 def create_access_token(data: dict, expires_delta: timedelta | None = None):
-    to_encode = data.copy()
-    if expires_delta:
-        expire = datetime.utcnow() + expires_delta
-    else:
-        expire = datetime.utcnow() + timedelta(minutes=15)
-    to_encode.update({"exp": expire})
-    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
-    return encoded_jwt
+    log_info("Creating access token")
+    try:
+        to_encode = data.copy()
+        if expires_delta:
+            expire = datetime.utcnow() + expires_delta
+        else:
+            expire = datetime.utcnow() + timedelta(minutes=15)
+        to_encode.update({"exp": expire})
+        encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
+        return encoded_jwt
+    except Exception as e:
+        log_error(f"Error creating access token: {str(e)}")
+        raise HTTPException(status_code=500, detail="Internal Server Error")
 
 async def get_current_user(db: Session = Depends(get_db), token: str = Depends(oauth2_scheme)):
+    log_info("Getting current user")
     credentials_exception = HTTPException(
         status_code=status.HTTP_401_UNAUTHORIZED,
         detail="Could not validate credentials",
@@ -64,22 +85,36 @@ async def get_current_user(db: Session = Depends(get_db), token: str = Depends(o
         if username is None:
             raise credentials_exception
         token_data = TokenData(username=username)
-    except JWTError:
+    except JWTError as e:
+        log_error(f"JWT error: {str(e)}")
         raise credentials_exception
+    except Exception as e:
+        log_error(f"Error decoding token: {str(e)}")
+        raise HTTPException(status_code=500, detail="Internal Server Error")
     user = get_user(db, username=token_data.username)
     if user is None:
         raise credentials_exception
     return user
 
 async def get_current_active_user(current_user: User = Depends(get_current_user)):
-    if not current_user.is_active:
-        raise HTTPException(status_code=400, detail="Inactive user")
-    return current_user
+    log_info("Getting current active user")
+    try:
+        if not current_user.is_active:
+            raise HTTPException(status_code=400, detail="Inactive user")
+        return UserResponse.from_orm(current_user)
+    except Exception as e:
+        log_error(f"Error getting current active user: {str(e)}")
+        raise HTTPException(status_code=500, detail="Internal Server Error")
 
 def create_user(db: Session, username: str, email: str, password: str):
-    hashed_password = get_password_hash(password)
-    db_user = User(username=username, email=email, hashed_password=hashed_password)
-    db.add(db_user)
-    db.commit()
-    db.refresh(db_user)
-    return db_user
+    log_info(f"Creating user: {username}")
+    try:
+        hashed_password = get_password_hash(password)
+        db_user = User(username=username, email=email, hashed_password=hashed_password)
+        db.add(db_user)
+        db.commit()
+        db.refresh(db_user)
+        return db_user
+    except Exception as e:
+        log_error(f"Error creating user: {str(e)}")
+        raise HTTPException(status_code=500, detail="Internal Server Error")

services/ingredientFinderAgent.py

@@ -0,0 +1,628 @@
+import os
+import json
+import traceback
+import requests
+import pandas as pd
+from dotenv import load_dotenv
+
+from typing import Dict, Any
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain_community.tools import DuckDuckGoSearchRun
+from langchain_community.tools import WikipediaQueryRun
+from langchain_community.utilities.wikipedia import WikipediaAPIWrapper
+from langchain_core.tools import tool
+
+# modular
+from logger_manager import logger
+from interfaces.ingredientModels import IngredientAnalysisResult,IngredientState
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Load Scraped Database
+SCRAPED_DB_PATH = "data/Food_Aditives_E_numbers.csv"  # Ensure this file exists
+if os.path.exists(SCRAPED_DB_PATH):
+    additives_df = pd.read_csv(SCRAPED_DB_PATH)
+    logger.info(f"Loaded database with {len(additives_df)} entries")
+else:
+    additives_df = None
+    logger.warning("Scraped database not found!")
+
+
+
+# Define tool functions
+@tool("search_local_db")
+def search_local_db(ingredient: str) -> Dict[str, Any]:
+    """Search local database for ingredient information. E number database scrapped"""
+    logger.info(f"Searching local DB for: {ingredient}")
+    if additives_df is not None:
+        match = additives_df[additives_df['Name of Aditive'].str.contains(ingredient, case=False, na=False)]
+        if not match.empty:
+            return {"source": "Local DB", "found": True, "data": match.iloc[0].to_dict()}
+    return {"source": "Local DB", "found": False, "data": None}
+
+@tool("search_open_food_facts")
+def search_open_food_facts(ingredient: str) -> Dict[str, Any]:
+    """Search Open Food Facts database for ingredient information."""
+    logger.info(f"Searching Open Food Facts for: {ingredient}")
+    
+    try:
+        open_food_facts_api = "https://world.openfoodfacts.org/api/v0"
+        # Search for the ingredient
+        search_url = f"{open_food_facts_api}/ingredient/{ingredient.lower().replace(' ', '-')}.json"
+        response = requests.get(search_url, timeout=10)
+        
+        if response.status_code == 200:
+            data = response.json()
+            if data.get("status") == 1:  # Successfully found
+                return {
+                    "source": "Open Food Facts",
+                    "found": True,
+                    "data": data
+                }
+        
+        # Try searching products containing this ingredient
+        product_search_url = f"{open_food_facts_api}/search.json?ingredients_tags={ingredient.lower().replace(' ', '_')}&page_size=5"
+        response = requests.get(product_search_url, timeout=10)
+        
+        if response.status_code == 200:
+            data = response.json()
+            if data.get("count") > 0:
+                return {
+                    "source": "Open Food Facts Products",
+                    "found": True,
+                    "data": data
+                }
+        
+        return {"source": "Open Food Facts", "found": False, "data": None}
+    
+    except Exception as e:
+        logger.error(f"Error searching Open Food Facts: {e}")
+        return {"source": "Open Food Facts", "found": False, "error": str(e)}
+
+@tool("search_usda")
+def search_usda(ingredient: str) -> Dict[str, Any]:
+    """Search USDA FoodData Central for ingredient information."""
+    logger.info(f"Searching USDA for: {ingredient}")
+    
+    try:
+        usda_api = "https://api.nal.usda.gov/fdc/v1"
+        usda_api_key = os.getenv("USDA_API_KEY", "DEMO_KEY")  # Use DEMO_KEY if not provided
+        
+        # Search for the ingredient
+        search_url = f"{usda_api}/foods/search"
+        params = {
+            "api_key": usda_api_key,
+            "query": ingredient,
+            "dataType": ["Foundation", "SR Legacy", "Branded"],
+            "pageSize": 5
+        }
+        
+        response = requests.get(search_url, params=params, timeout=10)
+        
+        if response.status_code == 200:
+            data = response.json()
+            if data.get("totalHits", 0) > 0:
+                return {
+                    "source": "USDA FoodData Central",
+                    "found": True,
+                    "data": data
+                }
+        
+        return {"source": "USDA FoodData Central", "found": False, "data": None}
+    
+    except Exception as e:
+        logger.error(f"Error searching USDA: {e}")
+        return {"source": "USDA FoodData Central", "found": False, "error": str(e)}
+
+@tool("search_pubchem")
+def search_pubchem(ingredient: str) -> Dict[str, Any]:
+    """Search PubChem for chemical information about the ingredient."""
+    logger.info(f"Searching PubChem for: {ingredient}")
+    
+    try:
+        pubchem_api = "https://pubchem.ncbi.nlm.nih.gov/rest/pug"
+        
+        # First try to get compound information by name
+        search_url = f"{pubchem_api}/compound/name/{ingredient}/JSON"
+        response = requests.get(search_url, timeout=10)
+        
+        if response.status_code == 200:
+            data = response.json()
+            if "PC_Compounds" in data:
+                compound_id = data["PC_Compounds"][0]["id"]["id"]["cid"]
+                
+                # Get more detailed information using the CID
+                property_url = f"{pubchem_api}/compound/cid/{compound_id}/property/MolecularFormula,MolecularWeight,IUPACName,InChI,InChIKey,CanonicalSMILES/JSON"
+                prop_response = requests.get(property_url, timeout=10)
+                properties_data = None
+                if prop_response.status_code == 200:
+                    properties_data = prop_response.json()
+                    
+                # Get classifications and categories
+                classification_url = f"{pubchem_api}/compound/cid/{compound_id}/classification/JSON"
+                class_response = requests.get(classification_url, timeout=10)
+                classification_data = None
+                if class_response.status_code == 200:
+                    classification_data = class_response.json()
+                    
+                return {
+                    "source": "PubChem",
+                    "found": True,
+                    "data": {
+                        "compound_info": data,
+                        "properties": properties_data,
+                        "classification": classification_data
+                    }
+                }
+        
+        return {"source": "PubChem", "found": False, "data": None}
+    
+    except Exception as e:
+        logger.error(f"Error searching PubChem: {e}")
+        return {"source": "PubChem", "found": False, "error": str(e)}
+
+@tool("search_wikipedia")
+def search_wikipedia(ingredient: str) -> Dict[str, Any]:
+    """Search Wikipedia for ingredient information."""
+    logger.info(f"Searching Wikipedia for: {ingredient}")
+    
+    try:
+        wikipedia = WikipediaQueryRun(api_wrapper=WikipediaAPIWrapper())
+        wiki_result = wikipedia.run(ingredient)
+        
+        if wiki_result and len(wiki_result) > 100:  # Only count substantial results
+            return {
+                "source": "Wikipedia",
+                "found": True,
+                "data": wiki_result
+            }
+        else:
+            # Try with more specific searches
+            food_wiki = wikipedia.run(f"{ingredient} food additive")
+            if food_wiki and len(food_wiki) > 100:
+                return {
+                    "source": "Wikipedia",
+                    "found": True,
+                    "data": food_wiki
+                }
+            
+            chemical_wiki = wikipedia.run(f"{ingredient} chemical compound")
+            if chemical_wiki and len(chemical_wiki) > 100:
+                return {
+                    "source": "Wikipedia",
+                    "found": True,
+                    "data": chemical_wiki
+                }
+        
+        return {"source": "Wikipedia", "found": False, "data": None}
+    
+    except Exception as e:
+        logger.error(f"Error searching Wikipedia: {e}")
+        return {"source": "Wikipedia", "found": False, "error": str(e)}
+
+@tool("search_web")
+def search_web(ingredient: str) -> Dict[str, Any]:
+    """Search web for ingredient information using DuckDuckGo."""
+    logger.info(f"Searching web for: {ingredient}")
+    
+    try:
+        duckduckgo = DuckDuckGoSearchRun()
+        search_queries = [f"{ingredient} food ingredient safety", f"{ingredient} E-number food additive"]
+        all_results = []
+        for query in search_queries:
+            result = duckduckgo.run(query)
+            if result:
+                all_results.append({"query": query, "result": result})
+        return {"source": "DuckDuckGo", "found": bool(all_results), "data": all_results}
+    except Exception as e:
+        logger.error(f"Web search error: {e}")
+        return {"source": "DuckDuckGo", "found": False, "error": str(e)}
+
+def create_summary_from_source(source: Dict[str, Any]) -> str:
+    """Create a meaningful summary from source data."""
+    source_name = source.get("source", "Unknown")
+    source_data = source.get("data")
+    
+    if not source_data:
+        return "Data found but empty"
+    
+    # Handle different types of sources
+    if source_name == "Local DB":
+        if isinstance(source_data, dict):
+            # Get the most informative fields from local DB
+            return f"E-Number: {source_data.get('E No.', 'N/A')}, " \
+                   f"Category: {source_data.get('Functional Class', 'N/A')}, " \
+                   f"Description: {source_data.get('Main Use', '')[:100]}..."
+    
+    elif source_name == "DuckDuckGo":
+        if isinstance(source_data, list) and source_data:
+            # Get the first query and a snippet of the result
+            first_result = source_data[0]
+            query = first_result.get("query", "")
+            result_snippet = first_result.get("result", "")[:150]
+            return f"Query: '{query}', Result: '{result_snippet}...'"
+    
+    elif source_name == "Wikipedia":
+        # For wikipedia, return the first paragraph
+        if isinstance(source_data, str):
+            first_paragraph = source_data.split("\n\n")[0][:200]
+            return f"Wikipedia excerpt: {first_paragraph}..."
+    
+    elif source_name in ["Open Food Facts", "Open Food Facts Products"]:
+        if isinstance(source_data, dict):
+            # Try to extract product name or ingredient description
+            if "product" in source_data:
+                return f"Product info: {source_data.get('product', {}).get('product_name', 'Unknown')}"
+            elif "ingredients_text" in source_data:
+                return f"Ingredients: {source_data.get('ingredients_text', '')[:150]}..."
+            else:
+                return f"Found data with {len(source_data)} fields"
+    
+    elif source_name == "USDA FoodData Central":
+        if isinstance(source_data, dict) and "foods" in source_data:
+            foods = source_data.get("foods", [])
+            if foods:
+                first_food = foods[0]
+                return f"Food: {first_food.get('description', 'Unknown')}, " \
+                       f"Category: {first_food.get('foodCategory', 'N/A')}"
+            else:
+                return "Found USDA data, but no specific foods listed"
+    
+    elif source_name == "PubChem":
+        if isinstance(source_data, dict):
+            compound_info = source_data.get("compound_info", {})
+            properties = source_data.get("properties", {})
+            
+            if "PC_Compounds" in compound_info and compound_info["PC_Compounds"]:
+                compound = compound_info["PC_Compounds"][0]
+                return f"Chemical ID: {compound.get('id', {}).get('id', {}).get('cid', 'N/A')}, " \
+                       f"Found chemical property data"
+    
+    # Default for unknown or complex sources
+    return f"Found data from {source_name} ({type(source_data).__name__})"
+
+def analyze_ingredient(state: IngredientState) -> IngredientState:
+    """Analyze ingredient data with LLM to generate structured information.
+    
+    Takes the current state with collected sources_data and uses an LLM to generate
+    a comprehensive analysis of the ingredient including safety rating, health effects,
+    description, and alternate names.
+    
+    Args:
+        state: The current IngredientState containing all collected data
+        
+    Returns:
+        Updated state with analysis results
+    """
+    # Get API key and model from environment
+    api_key = os.getenv("GOOGLE_API_KEY")
+    model_name = os.getenv("LLM_MODEL_NAME", "gemini-1.5-pro")
+    
+    # Basic validation
+    if not api_key:
+        logger.error("No Google API key found in environment variables")
+        new_state = state.copy()
+        new_state["result"] = {
+            "name": state["ingredient"],
+            "is_found": False,
+            "description": "Error: Missing API credentials for analysis"
+        }
+        new_state["analysis_done"] = True
+        new_state["status"] = "analysis_error"
+        return new_state
+    
+    # Initialize LLM
+    try:
+        llm = ChatGoogleGenerativeAI(
+            google_api_key=api_key,
+            model=model_name,
+            temperature=0.3,  # Lower temperature for more factual responses
+            convert_system_message_to_human=True
+        )
+    except Exception as e:
+        logger.error(f"Error initializing LLM: {e}")
+        new_state = state.copy()
+        new_state["result"] = {
+            "name": state["ingredient"],
+            "is_found": False,
+            "description": f"Error initializing LLM: {str(e)}"
+        }
+        new_state["analysis_done"] = True
+        new_state["status"] = "analysis_error"
+        return new_state
+    
+    # Get sources from state
+    sources_data = state["sources_data"]
+    logger.info(f"Analyzing ingredient with {len(sources_data)} total sources")
+    
+    # Filter for successful sources only
+    found_sources = [source for source in sources_data if source.get('found', False)]
+    logger.info(f"Found {len(found_sources)} sources with usable data")
+    
+    # Create default result structure
+    result = {
+        "name": state["ingredient"],
+        "alternate_names": [],
+        "is_found": len(found_sources) > 0,
+        "safety_rating": 5,  # Default middle rating
+        "description": "No reliable information found." if not found_sources else "",
+        "health_effects": ["Unknown - insufficient data"] if not found_sources else [],
+        "details_with_source": [
+            {
+                "source": source.get("source", "Unknown"),
+                "found": source.get("found", False),
+                "summary": create_summary_from_source(source) if source.get("found", False) else "No data found",
+            }
+            for source in sources_data
+        ]
+    }
+    
+    # If we have data, analyze it
+    if found_sources:
+        # Format source data for the prompt
+        source_texts = []
+        for i, source in enumerate(found_sources):
+            source_name = source.get('source', f'Source {i+1}')
+            source_data = source.get('data')
+            
+            # Process different data formats appropriately
+            try:
+                if isinstance(source_data, dict):
+                    source_text = format_dict_source(source_name, source_data)
+                elif isinstance(source_data, list):
+                    source_text = format_list_source(source_name, source_data)
+                elif isinstance(source_data, str):
+                    # For string data, include as is (limiting length)
+                    source_text = f"--- {source_name} ---\n{source_data[:1500]}"
+                else:
+                    # For other types, convert to string
+                    source_text = f"--- {source_name} ---\n{str(source_data)[:1000]}"
+                
+                source_texts.append(source_text)
+            except Exception as e:
+                logger.error(f"Error formatting source {source_name}: {e}")
+                source_texts.append(f"--- {source_name} ---\nError formatting data: {str(e)}")
+        
+        # Combine all source texts
+        combined_data = "\n\n".join(source_texts)
+        logger.debug(f"Combined data for analysis:\n{combined_data[:500]}...(truncated)")
+        
+        # Create the analysis prompt
+        analysis_prompt = f"""
+        Task: Analyze food ingredient data and provide a structured assessment.
+        
+        Ingredient: {state["ingredient"]}
+        
+        Based on the following data sources, provide:
+        1. Safety rating (scale 1-10, where 1=unsafe for consumption, 5=moderate concerns, 10=very safe)
+        2. List of potential health effects (both positive & negative, maximum 5 points)
+        3. Brief description of what this ingredient is, how it's used, and its properties
+        4. Alternative names for this ingredient
+        
+        Available data:
+        {combined_data}
+        
+        Format your response as a JSON object with these keys:
+        - "safety_rating": (number between 1-10)
+        - "health_effects": (array of strings)
+        - "description": (string)
+        - "alternate_names": (array of strings)
+        
+        Only include factual information supported by the provided data. If information is 
+        unavailable for any field, use appropriate default values.
+        """
+        
+        # Process with LLM
+        try:
+            logger.info("Sending analysis prompt to LLM")
+            llm_response = llm.invoke(analysis_prompt)
+            logger.info("Received LLM response")
+            
+            # Extract and parse JSON from LLM response
+            try:
+                analysis_text = llm_response.content
+                logger.debug(f"LLM response: {analysis_text[:500]}...(truncated)")
+                
+                # Find JSON in the response
+                start_idx = analysis_text.find('{')
+                end_idx = analysis_text.rfind('}') + 1
+                
+                if start_idx >= 0 and end_idx > start_idx:
+                    json_str = analysis_text[start_idx:end_idx]
+                    analysis = json.loads(json_str)
+                    
+                    # Update result with analyzed data
+                    result.update({
+                        "safety_rating": analysis.get("safety_rating", 5),
+                        "description": analysis.get("description", "No description available."),
+                        "health_effects": analysis.get("health_effects", []),
+                        "alternate_names": analysis.get("alternate_names", [])
+                    })
+                    logger.info(f"Analysis complete - Safety Rating: {result['safety_rating']}")
+                else:
+                    logger.warning("Could not find JSON in LLM response")
+                    result["description"] = "Error: Failed to parse LLM analysis output."
+            except json.JSONDecodeError as e:
+                logger.error(f"JSON parsing error: {e}")
+                result["description"] = f"Error parsing analysis: {str(e)}"
+                
+        except Exception as e:
+            logger.error(f"Error in LLM analysis: {e}")
+            logger.error(traceback.format_exc())
+            result.update({
+                "description": f"Error in analysis: {str(e)}",
+                "health_effects": ["Error in analysis"],
+            })
+    
+    # Update state with results
+    new_state = state.copy()
+    new_state["result"] = result
+    new_state["analysis_done"] = True
+    new_state["status"] = "analysis_complete"
+    return new_state
+
+def format_dict_source(source_name: str, source_data: dict) -> str:
+    """Format dictionary source data for LLM consumption."""
+    source_text = f"--- {source_name} ---\n"
+    
+    # Handle different sources appropriately
+    if source_name == "Local DB":
+        relevant_keys = [k for k in source_data.keys()]
+        for key in relevant_keys:
+            source_text += f"{key}: {source_data[key]}\n"
+    elif source_name == "DuckDuckGo":
+        if isinstance(source_data, list):
+            for item in source_data:
+                source_text += f"Query: {item.get('query', '')}\n"
+                source_text += f"Summary: {item.get('result', '')[:500]}...\n"
+    elif source_name in ["Open Food Facts", "USDA FoodData Central"]:
+        # Extract key info for food databases
+        if "ingredients_text" in source_data:
+            source_text += f"Ingredients: {source_data['ingredients_text']}\n"
+        if "description" in source_data:
+            source_text += f"Description: {source_data['description']}\n"
+        if "categories" in source_data:
+            source_text += f"Categories: {source_data['categories']}\n"
+        # Include top-level fields only
+        for key, value in source_data.items():
+            if not isinstance(value, (dict, list)) and key not in ["ingredients_text", "description", "categories"]:
+                source_text += f"{key}: {value}\n"
+    elif source_name == "PubChem":
+        # Extract key chemical information
+        if "compound_info" in source_data:
+            source_text += "Chemical information:\n"
+            compound_data = source_data.get("compound_info", {})
+            if "PC_Compounds" in compound_data and len(compound_data["PC_Compounds"]) > 0:
+                compound = compound_data["PC_Compounds"][0]
+                source_text += f"Compound ID: {compound.get('id', {}).get('id', {}).get('cid', 'N/A')}\n"
+        
+        if "properties" in source_data and source_data["properties"]:
+            properties = source_data["properties"]
+            if "PropertyTable" in properties:
+                prop_table = properties["PropertyTable"]
+                if "Properties" in prop_table and len(prop_table["Properties"]) > 0:
+                    props = prop_table["Properties"][0]
+                    source_text += "Properties:\n"
+                    for key, value in props.items():
+                        source_text += f"{key}: {value}\n"
+    else:
+        # Generic dictionary handling for other sources
+        for key, value in source_data.items():
+            if not isinstance(value, (dict, list)) or len(str(value)) < 100:
+                source_text += f"{key}: {value}\n"
+            else:
+                source_text += f"{key}: [Complex data]\n"
+    
+    return source_text
+
+def format_list_source(source_name: str, source_data: list) -> str:
+    """Format list source data for LLM consumption."""
+    source_text = f"--- {source_name} ---\n"
+    
+    # Handle different list structures
+    if len(source_data) > 0:
+        if isinstance(source_data[0], dict):
+            # List of dictionaries
+            source_text += f"Found {len(source_data)} items:\n"
+            for i, item in enumerate(source_data[:3]):  # Limit to first 3 items
+                source_text += f"Item {i+1}:\n"
+                for key, value in item.items():
+                    if not isinstance(value, (dict, list)):
+                        source_text += f"  {key}: {value}\n"
+        else:
+            # List of other types
+            source_text += f"Data points ({len(source_data)}):\n"
+            for i, item in enumerate(source_data[:5]):  # Limit to first 5 items
+                source_text += f"{i+1}. {str(item)[:200]}\n"
+    else:
+        source_text += "Empty list\n"
+    
+    return source_text
+
+class IngredientInfoAgentLangGraph:
+    # Add this method to your IngredientInfoAgentLangGraph class
+    def process_ingredient(self, ingredient: str) -> IngredientAnalysisResult:
+        """Process an ingredient using direct sequential approach instead of LangGraph."""
+        logger.info(f"=== Direct sequential processing for: {ingredient} ===")
+        
+        # Initialize empty sources data
+        sources_data = []
+        
+        # Run each tool directly in sequence and collect results
+        logger.info(f"Searching local database for {ingredient}")
+        result = search_local_db(ingredient)
+        if result.get("found", False):
+            sources_data.append(result)
+            logger.info(f"Local DB found data for {ingredient}")
+        
+        logger.info(f"Searching web for {ingredient}")
+        result = search_web(ingredient)
+        if result.get("found", False):
+            sources_data.append(result)
+            logger.info(f"Web search found data for {ingredient}")
+        
+        logger.info(f"Searching Wikipedia for {ingredient}")
+        result = search_wikipedia(ingredient)
+        if result.get("found", False):
+            sources_data.append(result)
+            logger.info(f"Wikipedia found data for {ingredient}")
+        
+        logger.info(f"Searching Open Food Facts for {ingredient}")
+        result = search_open_food_facts(ingredient)
+        if result.get("found", False):
+            sources_data.append(result)
+            logger.info(f"Open Food Facts found data for {ingredient}")
+        
+        # Optional - Add these if needed:
+        logger.info(f"Searching USDA for {ingredient}")
+        result = search_usda(ingredient)
+        if result.get("found", False):
+            sources_data.append(result)
+            logger.info(f"USDA found data for {ingredient}")
+        
+        logger.info(f"Searching PubChem for {ingredient}")
+        result = search_pubchem(ingredient)
+        if result.get("found", False):
+            sources_data.append(result)
+            logger.info(f"PubChem found data for {ingredient}")
+        
+        # Create a state for analysis
+        state = {
+            "ingredient": ingredient,
+            "sources_data": sources_data,
+            "result": None,
+            "status": "ready_for_analysis",
+            "analysis_done": False,
+            "local_db_checked": True,
+            "web_search_done": True,
+            "wikipedia_checked": True,
+            "open_food_facts_checked": True,
+            "usda_checked": True,
+            "pubchem_checked": True
+        }
+        
+        # Run the analysis with the collected data
+        final_state = analyze_ingredient(state)
+        
+        # Extract the result or create a default
+        if final_state.get("result"):
+            logger.info(f"Analysis complete for {ingredient}")
+            return IngredientAnalysisResult(**final_state["result"])
+        else:
+            logger.info(f"No result in final state for {ingredient}, returning default")
+            return IngredientAnalysisResult(
+                name=ingredient, 
+                is_found=len(sources_data) > 0, 
+                details_with_source=sources_data
+            )
+
+if __name__ == "__main__":
+    agent = IngredientInfoAgentLangGraph()
+    
+    # Use the simple method that works reliably
+    result = agent.process_ingredient("SODIUM TRIPOLYPHOSPHATE")
+    print(json.dumps(result.model_dump(), indent=2))
+    
+    benzoate_result = agent.process_ingredient("Sodium Benzoate")
+    print(json.dumps(benzoate_result.model_dump(), indent=2))

services/ingredients.py

@@ -1,10 +1,10 @@
 from sqlalchemy.orm import Session
-from models.ingredient import Ingredient
+from db.models import Ingredient
 from fastapi import HTTPException
 from cachetools import cached, TTLCache
 from typing import List, Dict, Any
 import requests
-from utils.fetch_data import fetch_ingredient_data_from_api
+from utils.fetch_data import fetch_product_data_from_api
 
 cache = TTLCache(maxsize=100, ttl=300)
 
@@ -55,15 +55,3 @@ def save_ingredient_data(db: Session, name: str, data: Dict[str, Any]):
     db.add(ingredient)
     db.commit()
     db.refresh(ingredient)
-
-def filter_ingredients_by_preferences(ingredients: List[Dict[str, Any]], preferences: Dict[str, Any]) -> List[Dict[str, Any]]:
-    filtered_ingredients = []
-    for ingredient in ingredients:
-        if preferences.get("low_sugar") and ingredient.get("sugar", 0) > 5:
-            continue
-        if preferences.get("low_fat") and ingredient.get("fat", 0) > 5:
-            continue
-        if preferences.get("allergens") and any(allergen in ingredient.get("allergens", []) for allergen in preferences["allergens"]):
-            continue
-        filtered_ingredients.append(ingredient)
-    return filtered_ingredients

services/logging_service.py

@@ -1,38 +0,0 @@
-import logging
-from logging.handlers import RotatingFileHandler
-
-# Configure logging
-logger = logging.getLogger("food_analyzer")
-logger.setLevel(logging.DEBUG)
-
-# Create a file handler that logs debug and higher level messages
-file_handler = RotatingFileHandler("food_analyzer.log", maxBytes=5*1024*1024, backupCount=3)
-file_handler.setLevel(logging.DEBUG)
-
-# Create a console handler that logs error and higher level messages
-console_handler = logging.StreamHandler()
-console_handler.setLevel(logging.ERROR)
-
-# Create a formatter and set it for both handlers
-formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
-file_handler.setFormatter(formatter)
-console_handler.setFormatter(formatter)
-
-# Add the handlers to the logger
-logger.addHandler(file_handler)
-logger.addHandler(console_handler)
-
-def log_debug(message: str):
-    logger.debug(message)
-
-def log_info(message: str):
-    logger.info(message)
-
-def log_warning(message: str):
-    logger.warning(message)
-
-def log_error(message: str):
-    logger.error(message)
-
-def log_critical(message: str):
-    logger.critical(message)

services/scan_history.py

@@ -1,20 +1,35 @@
+from fastapi import HTTPException
 from sqlalchemy.orm import Session
-from models.scan_history import ScanHistory
+from db.models import ScanHistory
 from datetime import datetime
+from logger_manager import log_info, log_error
 
 def record_scan(db: Session, user_id: int, product_id: int) -> ScanHistory:
-    scan_entry = ScanHistory(
-        user_id=user_id,
-        product_id=product_id,
-        scan_date=datetime.utcnow()
-    )
-    db.add(scan_entry)
-    db.commit()
-    db.refresh(scan_entry)
-    return scan_entry
+    log_info("Recording scan")
+    try:
+        scan_entry = ScanHistory(
+            user_id=user_id,
+            product_id=product_id,
+            scan_date=datetime.utcnow()
+        )
+        db.add(scan_entry)
+        db.commit()
+        db.refresh(scan_entry)
+        log_info("Scan recorded successfully")
+        return scan_entry
+    except Exception as e:
+        log_error(f"Error recording scan: {str(e)}")
+        raise HTTPException(status_code=500, detail="Internal Server Error")
 
 def get_scan_history(db: Session, user_id: int) -> list[ScanHistory]:
-    return db.query(ScanHistory)\
-        .filter(ScanHistory.user_id == user_id)\
-        .order_by(ScanHistory.scan_date.desc())\
-        .all()
+    log_info("Getting scan history")
+    try:
+        scan_history = db.query(ScanHistory)\
+            .filter(ScanHistory.user_id == user_id)\
+            .order_by(ScanHistory.scan_date.desc())\
+            .all()
+        log_info("Scan history retrieved successfully")
+        return scan_history
+    except Exception as e:
+        log_error(f"Error getting scan history: {str(e)}")
+        raise HTTPException(status_code=500, detail="Internal Server Error")