feat: added dynamic config support for ai endpoints

api/main.py

@@ -82,11 +82,15 @@ class ChatResponseRequest(BaseModel): prompt: str = Field(..., description="The
 class ChatResponsePayload(BaseModel): response: str
 class CaptionRequest(BaseModel): caption: str; action: str
 class CaptionResponse(BaseModel): new_caption: str
-class BudgetRequest(BaseModel): campaign_goal: str; influencer_count: int; platform: str; location: str; category: str; final_reach: int
+class BudgetRequest(BaseModel):
+    campaign_goal: str; influencer_count: int; platform: str; location: str; category: str; final_reach: int
+    config: Optional[Dict[str, str]] = None
 class BudgetResponse(BaseModel): predicted_budget_usd: float
 class MatcherRequest(BaseModel): campaign_description: str; target_audience_age: str; target_audience_gender: str; engagement_rate: float; followers: int; country: str; niche: str
 class MatcherResponse(BaseModel): suggested_influencer_ids: List[int]
-class PerformanceRequest(BaseModel): budget_usd: float; influencer_count: int; platform: str; location: str; category: str; budget: float
+class PerformanceRequest(BaseModel):
+    budget_usd: float; influencer_count: int; platform: str; location: str; category: str; budget: float
+    config: Optional[Dict[str, str]] = None
 class PerformanceResponse(BaseModel): predicted_engagement_rate: float; predicted_reach: int
 class StrategyRequest(BaseModel): prompt: str
 class StrategyResponse(BaseModel): response: str
@@ -121,9 +125,13 @@ class RankedCampaignResult(BaseModel): campaign_id: int; score: float
 class RankCampaignsResponse(BaseModel): ranked_campaigns: List[RankedCampaignResult] 
 class CaptionAssistRequest(BaseModel): caption: str; action: str = Field(..., description="Action to perform: 'improve', 'hashtags', or 'check_guidelines'"); guidelines: Optional[str] = None
 class CaptionAssistResponse(BaseModel): new_text: str
-class ForecastRequest(BaseModel): budget: float; category: str; follower_count: int; engagement_rate: float
+class ForecastRequest(BaseModel):
+    budget: float; category: str; follower_count: int; engagement_rate: float
+    config: Optional[Dict[str, str]] = None
 class PerformanceForecast(BaseModel): predicted_engagement_rate: float; predicted_reach: int
-class PayoutForecast(BaseModel): estimated_earning: float
+class PayoutForecastInput(BaseModel):
+    total_budget_active_campaigns: float
+    config: Optional[Dict[str, str]] = None
 class ForecastResponse(BaseModel): performance: PerformanceForecast; payout: PayoutForecast
 class InfluencerKpiData(BaseModel): totalReach: int; totalLikes: int; totalComments: int; avgEngagementRate: float; totalSubmissions: int
 class InfluencerAnalyticsSummaryResponse(BaseModel): summary: str
@@ -163,6 +171,14 @@ class WeeklyPlanContext(BaseModel): niche: str; current_mood: str; recent_achiev
 class WeeklyPlanRequest(BaseModel): context: WeeklyPlanContext
 class PlanOption(BaseModel): type: str; title: str; platform: str; contentType: str; instructions: str; reasoning: str
 class WeeklyPlanResponse(BaseModel): options: List[PlanOption]
+class RequestConfig(BaseModel):
+    model_name: Optional[str] = "phi-2"
+    temperature: Optional[float] = 0.7
+    system_prompt: Optional[str] = None
+
+class DirectPromptPayload(BaseModel):
+    prompt: str
+    config: Optional[RequestConfig] = None 
 
 # --- FastAPI App ---
 app = FastAPI(title="Reachify AI Service (Deploy-Ready)", version="11.0.0")
@@ -395,11 +411,18 @@ async def generate_strategy_route(request: StrategyRequest):
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"An internal error occurred in the AI model: {e}")
 
-@app.post("/api/v1/predict/budget", response_model=BudgetResponse, summary="Predict Campaign Budget")
+@app.post("/api/v1/predict/budget", response_model=BudgetResponse)
 async def predict_budget(request: BudgetRequest):
-    if not _budget_predictor: raise HTTPException(status_code=503, detail="Budget predictor is not available.")
-    input_data = pd.DataFrame([request.model_dump()])
-    prediction = _budget_predictor.predict(input_data)[0]
+    if not _budget_predictor: raise HTTPException(status_code=503, detail="Predictor Unavailable")
+    
+    input_data = pd.DataFrame([request.model_dump(exclude={'config'})])
+    prediction = float(_budget_predictor.predict(input_data)[0])
+    
+    # ⚙️ CONTROL: Admin Multiplier Check
+    if request.config:
+        multiplier = float(request.config.get("budget_multiplier", 1.0))
+        prediction = prediction * multiplier
+        
     return BudgetResponse(predicted_budget_usd=round(prediction, 2))
 
 @app.post("/api/v1/match/influencers", response_model=MatcherResponse, summary="Match Influencers to Campaign")
@@ -658,36 +681,17 @@ def generate_weekly_summary_route(request: WeeklySummaryRequest):
         print(f"🚨 An error occurred in /strategist/generate-weekly-summary: {e}")
         raise HTTPException(status_code=500, detail=str(e))     
     
-@app.post("/predict/payout_forecast", response_model=PayoutForecastOutput, summary="Predicts future influencer payouts for a manager")
+@app.post("/predict/payout_forecast", response_model=PayoutForecastOutput)
 def predict_payout(data: PayoutForecastInput):
-    """
-    Predicts the estimated influencer payout for the next 30 days
-    based on the total budget of a manager's active campaigns.
-    """
-    print(f"\n✅ Received request on /predict/payout_forecast")
-    if not _payout_forecaster:
-        raise HTTPException(status_code=503, detail="Model is not available. Please train the payout forecaster model first.")
+    if not _payout_forecaster: raise HTTPException(status_code=503, detail="Model Unavailable")
 
-    try:
-        # Prediction ke liye data ko sahi DataFrame format mein convert karo
-        input_df = pd.DataFrame([{'budget': data.total_budget_active_campaigns}])
-        
-        # Prediction karo
-        prediction = _payout_forecaster.predict(input_df)[0]
-        
-        # Ensure the prediction is never negative
-        forecasted_amount = max(0, float(prediction))
-        
-        print(f"   - ✅ Generated payout forecast: {forecasted_amount}")
-        return {
-            "forecastedAmount": forecasted_amount,
-            "commentary": "Based on the total budget of your current active campaigns."
-        }
-        
-    except Exception as e:
-        print(f"🚨 An error occurred in /predict/payout_forecast endpoint:")
-        traceback.print_exc()
-        raise HTTPException(status_code=500, detail=f"An error occurred during prediction: {str(e)}")
+    pred = float(_payout_forecaster.predict(pd.DataFrame([{'budget': data.total_budget_active_campaigns}]))[0])
+    
+    # ⚙️ CONTROL
+    if data.config:
+        pred = pred * float(data.config.get("budget_multiplier", 1.0))
+
+    return {"forecastedAmount": max(0, pred), "commentary": "Based on budget trends."}
 
 
 @app.post("/analyze/content_quality", response_model=ContentQualityResponse, summary="Analyzes a caption for a quality score")
@@ -838,58 +842,29 @@ async def caption_assistant_route(request: CaptionAssistRequest):
         raise HTTPException(status_code=500, detail=str(e))
 
 
-@app.post("/predict/campaign-outcome", response_model=ForecastResponse, summary="Forecasts influencer performance and earnings for a campaign")
+@app.post("/predict/campaign-outcome", response_model=ForecastResponse)
 async def predict_campaign_outcome(request: ForecastRequest):
-    """
-    Takes campaign and influencer stats and uses ML models to predict
-    performance (reach, engagement) and potential earnings.
-    """
-    print(f"\n✅ Received request on /predict/campaign-outcome")
-    
-    if not _performance_predictor or not _payout_forecaster:
-        raise HTTPException(status_code=503, detail="Forecasting models are not available.")
+    if not _performance_predictor or not _payout_forecaster: raise HTTPException(status_code=503, detail="Models Unavailable")
 
-    try:
-        # ✅ THE FIX IS HERE: Create a single 'budget' column.
-        # Column names MUST match the training script's columns.
-        input_data = pd.DataFrame([{
-            'budget': request.budget,
-            'category': request.category,
-            'influencer_count': 1,
-            'platform': 'instagram',
-            'location': 'USA',
-            'followers': request.follower_count,
-            'engagement_rate': request.engagement_rate
-        }])
-
-        # --- Performance Prediction ---
-        print("   - Predicting performance...")
-        # ✅ THE FIX: Pass the columns the model ACTUALLY needs.
-        performance_model_cols = ['budget', 'influencer_count', 'platform', 'location', 'category']
-        reach_prediction = _performance_predictor.predict(input_data[performance_model_cols])[0]
-        engagement_prediction = request.engagement_rate * 100 
-        
-        perf_forecast = PerformanceForecast(
-            predicted_reach=int(reach_prediction),
-            predicted_engagement_rate=round(engagement_prediction, 2)
-        )
+    input_df = pd.DataFrame([request.model_dump(exclude={'config'})])
+    input_df['influencer_count'] = 1; input_df['platform'] = 'instagram'; input_df['location'] = 'USA'; input_df['followers'] = request.follower_count 
 
-        # --- Payout Prediction ---
-        print("   - Predicting payout...")
-        # This model only needs 'budget'
-        payout_prediction = _payout_forecaster.predict(input_data[['budget']])[0]
-        
-        payout_forecast = PayoutForecast(
-            estimated_earning=max(0, float(payout_prediction))
-        )
+    # Predict
+    reach = _performance_predictor.predict(input_df[['budget','influencer_count','platform','location','category']])[0]
+    payout = float(_payout_forecaster.predict(input_df[['budget']])[0])
 
-        print("   - ✅ Successfully generated forecasts.")
-        return ForecastResponse(performance=perf_forecast, payout=payout_forecast)
+    # ⚙️ CONTROL: Adjust Values if needed
+    if request.config:
+        payout_multiplier = float(request.config.get("budget_multiplier", 1.0)) # Shared Logic for simplicity
+        payout = payout * payout_multiplier
+        # Ensure Minimum Payout (Floor)
+        min_payout = float(request.config.get("ml_payout_floor", 0))
+        payout = max(min_payout, payout)
 
-    except Exception as e:
-        print(f"🚨 An error occurred during outcome prediction:")
-        traceback.print_exc()
-        raise HTTPException(status_code=500, detail=str(e))
+    return ForecastResponse(
+        performance=PerformanceForecast(predicted_reach=int(reach), predicted_engagement_rate=round(request.engagement_rate*100, 2)),
+        payout=PayoutForecast(estimated_earning=max(0, payout))
+    )
 
 @app.post("/ai/summarize/influencer-analytics", response_model=InfluencerAnalyticsSummaryResponse, summary="Generates a summary for the influencer's analytics page")
 async def summarize_influencer_analytics(request: InfluencerKpiData):
@@ -1643,3 +1618,23 @@ def finalize_script_endpoint(request: FinalizeScriptRequest):
         print(f"🚨 Finalize Script Error: {e}")
         traceback.print_exc()
         raise HTTPException(status_code=500, detail="Failed to generate the final plan.")
+
+
+@app.post("/api/v1/generate-campaign-from-prompt")
+def create_campaign_from_prompt_endpoint(payload: DirectPromptPayload):
+    # Check if Strategist is loaded
+    if not _ai_strategist:
+        raise HTTPException(status_code=503, detail="AI Strategist model unavailable.")
+
+    # Use Config or Default
+    current_config = payload.config if payload.config else RequestConfig()
+
+    try:
+        # Core Logic Call (Make sure Core Logic updated too)
+        response_text = _ai_strategist.generate_strategy_from_prompt(
+            user_prompt=payload.prompt, 
+            config=current_config
+        )
+        return {"response": response_text}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))        

core/strategist.py

@@ -64,25 +64,42 @@ class AIStrategist:
             print(f"--- Strategist Skill MOCK ERROR: {e}")
             return {"error": "An internal error occurred in the mock data generator."}
     
-    def generate_strategy_from_prompt(self, user_prompt: str) -> str:
+    
+    def generate_strategy_from_prompt(self, user_prompt: str, config=None) -> str:
         """
-        Generates a general strategy from a raw prompt.
+        Generates a strategy using Dynamic Config from Backend.
         """
-        print(f"--- Strategist Skill (General): Received prompt: '{user_prompt[:50]}...'")
+        print(f"--- Strategist Skill (General): Received prompt. Config: {config}")
+        
+        # 1. Temperature Setup (Default 0.75 if config missing)
+        temp = config.temperature if config else 0.75
+        
+        # 2. System Prompt Logic
+        final_prompt = user_prompt
+        
+        # Agar admin ne koi 'System Prompt' set kiya hai (Jaise "Be concise"), to use jod do
+        if config and config.system_prompt:
+            # Llama model format: [SYSTEM] instruction [USER] input
+            final_prompt = f"[SYSTEM]\n{config.system_prompt}\n\n[USER]\n{user_prompt}"
+
         try:
+            # 3. Call Llama with DYNAMIC Temp
             response = self.llm(
-                user_prompt,
+                final_prompt,
                 max_tokens=750,
-                temperature=0.75,
+                temperature=temp,  # ✅ Magic yahan hai!
                 stop=["User:", "Client:", "System:"],
             )
+            
             generated_text = response['choices'][0]['text'].strip()
-            print("--- Strategist Skill (General): Received response from LLM.")
+            print("--- Strategist Skill (General): Response Generated.")
             return generated_text
+            
         except Exception as e:
             print(f"--- Strategist Skill (General) ERROR: {e}")
             traceback.print_exc()
             return "An error occurred in the AI model while generating the strategy."
+        
 
     def generate_weekly_summary(self, metrics: Dict[str, Any]) -> str:
         """