Add budget_amount parameter to recommendations/check endpoint to generate recommendations based on provided budget

Smart_Budget_Recommendation_API.postman_collection.json

@@ -169,7 +169,7 @@
 						],
 						"body": {
 							"mode": "raw",
-							"raw": "{\n  \"user_id\": \"68a834c3f4694b11efedacd2\",\n  \"category_id\": \"688c80ca990b63f0e945ecf1\"\n}"
+							"raw": "{\n  \"user_id\": \"6741abd38d30ab5b7176397f\",\n  \"category_id\": \"677f6c117ca4500f15dbf108\",\n  \"budget_amount\": 10000.0\n}"
 						},
 						"url": {
 							"raw": "{{base_url}}/recommendations/check?month=1&year=2026",

app/main.py

@@ -207,13 +207,15 @@ async def check_and_get_recommendations(request: RecommendationRequest, month: O
     # Check if user has previous data for this category
     has_data = recommender.check_user_has_category_data(request.user_id, request.category_id)
     
-    if has_data:
+    if has_data or request.budget_amount:
         # Get recommendations for this specific category
+        # Pass budget_amount if provided
         recommendations = recommender.get_recommendation_for_category(
             request.user_id, 
             request.category_id, 
             month, 
-            year
+            year,
+            request.budget_amount
         )
         
         if recommendations:
@@ -230,11 +232,28 @@ async def check_and_get_recommendations(request: RecommendationRequest, month: O
                 message="User has previous data but no recommendations could be generated for this category."
             )
     else:
-        # User doesn't have previous data
+        # User doesn't have previous data, but if budget_amount is provided, generate recommendation anyway
+        if request.budget_amount and request.budget_amount > 0:
+            recommendations = recommender.get_recommendation_for_category(
+                request.user_id, 
+                request.category_id, 
+                month, 
+                year,
+                request.budget_amount
+            )
+            
+            if recommendations:
+                return RecommendationResponse(
+                    has_previous_data=False,
+                    recommendations=recommendations,
+                    message=f"Recommendation generated based on provided budget amount. User does not have previous data for this category."
+                )
+        
+        # User doesn't have previous data and no budget_amount provided
         return RecommendationResponse(
             has_previous_data=False,
             recommendations=None,
-            message=f"User does not have previous data for category_id: {request.category_id}. Please create a budget or add expenses for this category first."
+            message=f"User does not have previous data for category_id: {request.category_id}. Please provide a budget_amount or create a budget/expenses for this category first."
         )
 
 @app.get("/recommendations/{user_id}", response_model=List[BudgetRecommendation])

app/models.py

@@ -44,6 +44,7 @@ class CategoryExpense(BaseModel):
 class RecommendationRequest(BaseModel):
     user_id: str = Field(..., description="User identifier")
     category_id: str = Field(..., description="Category ID to check for previous data")
+    budget_amount: Optional[float] = Field(None, description="Current budget amount for this category (optional)")
 
 class RecommendationResponse(BaseModel):
     has_previous_data: bool

app/smart_recommendation.py

@@ -3,7 +3,7 @@ import math
 import os
 from collections import defaultdict
 from datetime import datetime, timedelta
-from typing import Dict, List
+from typing import Dict, List, Optional
 
 import requests
 from dotenv import load_dotenv
@@ -180,7 +180,7 @@ class SmartBudgetRecommender:
             print(f"Error checking user category data: {e}")
             return False
     
-    def get_recommendation_for_category(self, user_id: str, category_id: str, month: int, year: int) -> List[BudgetRecommendation]:
+    def get_recommendation_for_category(self, user_id: str, category_id: str, month: int, year: int, budget_amount: Optional[float] = None) -> List[BudgetRecommendation]:
         """
         Get budget recommendations for a specific category for a user.
         
@@ -189,6 +189,7 @@ class SmartBudgetRecommender:
             category_id: Category ID to get recommendations for
             month: Target month (1-12)
             year: Target year
+            budget_amount: Optional current budget amount to use for recommendations
             
         Returns:
             List of budget recommendations for the specific category
@@ -202,6 +203,57 @@ class SmartBudgetRecommender:
             if rec.category_id == category_id or str(rec.category_id) == str(category_id)
         ]
         
+        # If budget_amount is provided and we have a recommendation, use it to generate a new recommendation
+        if budget_amount and budget_amount > 0 and filtered_recommendations:
+            # Get the first recommendation (should be the one for this category)
+            original_rec = filtered_recommendations[0]
+            
+            # Get category name
+            category_name = original_rec.category
+            
+            # Use the provided budget_amount as average_expense for comparison
+            avg_expense = budget_amount
+            
+            # Create data structure for recommendation calculation
+            data = {
+                "average_monthly": avg_expense,
+                "total": avg_expense,
+                "count": 1,
+                "months_analyzed": 1,
+                "std_dev": 0.0,
+                "monthly_values": [avg_expense],
+            }
+            
+            confidence = self._calculate_confidence(data)
+            
+            # Always try OpenAI first (primary source of recommendation)
+            ai_result = self._get_ai_recommendation(category_name, data, avg_expense)
+            if ai_result and ai_result.get("recommended_budget"):
+                recommended_budget = ai_result.get("recommended_budget")
+                reason = ai_result.get("reason", f"AI recommendation for {category_name} based on your budget of Rs.{budget_amount:,.2f}")
+                action = ai_result.get("action")
+                print(f"✅ OpenAI recommendation for {category_name} (budget: {budget_amount}): {recommended_budget} (action: {action})")
+            else:
+                # Fallback to rule-based recommendation if OpenAI fails
+                recommended_budget = self._calculate_recommended_budget(avg_expense, data)
+                reason = self._generate_reason(category_name, avg_expense, recommended_budget)
+                action = None
+                if not ai_result:
+                    print(f"❌ OpenAI unavailable (no API key or error), using rule-based for {category_name} (budget: {budget_amount}): {recommended_budget}")
+                else:
+                    print(f"⚠️ OpenAI returned invalid data, using rule-based for {category_name} (budget: {budget_amount}): {recommended_budget}")
+            
+            # Create new recommendation based on provided budget_amount
+            filtered_recommendations = [BudgetRecommendation(
+                category=category_name,
+                category_id=category_id,
+                average_expense=round(avg_expense, 2),
+                recommended_budget=round(recommended_budget or 0, 2),
+                reason=reason,
+                confidence=confidence,
+                action=action
+            )]
+        
         return filtered_recommendations
     
     def _calculate_category_statistics(self, expenses: List[Dict], start_date: datetime, end_date: datetime) -> Dict: