Json returns

business_continuity.py

@@ -27,70 +27,8 @@ if GROQ_API_KEY:
     GROQ_API_KEY = GROQ_API_KEY.strip()
 
 logger.info(f"GROQ_API_KEY loaded: {'Yes' if GROQ_API_KEY else 'No'}")
-if GROQ_API_KEY:
-    logger.info(f"GROQ_API_KEY preview: {GROQ_API_KEY[:10]}...")
 
-# Model Setup with improved error handling
-def generate_response(system_prompt: str, user_message: str, max_retries: int = 3):
-    """Generate response from GROQ API with retry logic and comprehensive error handling"""
-    
-    if not GROQ_API_KEY:
-        logger.error("GROQ_API_KEY environment variable is not set")
-        raise Exception("GROQ_API_KEY environment variable is not set")
-    
-    logger.info("Initializing GROQ API client")
-    
-    for attempt in range(max_retries):
-        try:
-            logger.info(f"Attempt {attempt + 1}/{max_retries} - Making API call to GROQ")
-            
-            client = openai.OpenAI(
-                api_key=GROQ_API_KEY, 
-                base_url="https://api.groq.com/openai/v1", 
-                timeout=60.0  # Increased timeout
-            )
-            
-            response = client.chat.completions.create(
-                model="llama3-8b-8192",
-                messages=[
-                    {"role": "system", "content": system_prompt},
-                    {"role": "user", "content": user_message}
-                ],
-                temperature=0.2,  # Even lower for more consistent responses
-                max_tokens=3000,  # Increased further to avoid truncation
-                top_p=0.9,
-                frequency_penalty=0.0,
-                presence_penalty=0.0
-            )
-            
-            content = response.choices[0].message.content
-            logger.info(f"API call successful - Response length: {len(content) if content else 0}")
-            
-            if not content or content.strip() == "":
-                logger.warning(f"Empty response on attempt {attempt + 1}")
-                if attempt == max_retries - 1:
-                    raise Exception("Received empty response from GROQ API after all retries")
-                continue
-                
-            return content
-            
-        except openai.APITimeoutError as e:
-            logger.warning(f"Timeout error on attempt {attempt + 1}: {str(e)}")
-            if attempt == max_retries - 1:
-                raise Exception(f"GROQ API timeout after {max_retries} attempts: {str(e)}")
-                
-        except openai.APIError as e:
-            logger.error(f"GROQ API error on attempt {attempt + 1}: {str(e)}")
-            if attempt == max_retries - 1:
-                raise Exception(f"GROQ API error after {max_retries} attempts: {str(e)}")
-                
-        except Exception as e:
-            logger.error(f"Unexpected error on attempt {attempt + 1}: {str(e)}")
-            logger.error(f"Traceback: {traceback.format_exc()}")
-            if attempt == max_retries - 1:
-                raise Exception(f"GROQ API connection failed after {max_retries} attempts: {str(e)}")
-
-# Request Models with validation
+# Request Models
 class BusinessProcess(BaseModel):
     department: str = Field(..., min_length=1, max_length=100)
     sub_department: Optional[str] = Field(default="", max_length=100)
@@ -105,7 +43,7 @@ class BusinessContinuityRequest(BaseModel):
     business_process: BusinessProcess
     analysis_data: AnalysisData = Field(default_factory=lambda: AnalysisData())
 
-# Response Models
+# Response Model
 class RecoveryStrategiesResponse(BaseModel):
     success: bool
     people_unavailability_strategy: str
@@ -119,188 +57,143 @@ class RecoveryStrategiesResponse(BaseModel):
     message: str
     request_id: str = Field(default_factory=lambda: str(uuid.uuid4()))
 
-def validate_strategies_data(data: dict) -> dict:
-    """Validate and clean strategies data"""
-    logger.info("Validating strategies data")
-    
-    required_fields = [
-        "people_unavailability_strategy",
-        "people_reasoning",
-        "technology_data_unavailability_strategy", 
-        "technology_reasoning",
-        "site_unavailability_strategy",
-        "site_reasoning",
-        "third_party_vendors_unavailability_strategy",
-        "vendor_reasoning"
-    ]
-    
-    # Ensure all required fields exist and are strings
-    for field in required_fields:
-        if field not in data:
-            logger.warning(f"Missing field: {field}")
-            data[field] = "Strategy not generated - please retry request"
-        elif not isinstance(data[field], str):
-            logger.warning(f"Invalid type for field {field}: {type(data[field])}")
-            data[field] = str(data[field]) if data[field] is not None else "Strategy not generated"
-        elif len(data[field].strip()) == 0:
-            logger.warning(f"Empty field: {field}")
-            data[field] = "Strategy not generated - please retry request"
-    
-    logger.info("Data validation completed")
-    return data
+# Create router
+business_continuity_router = APIRouter()
 
-def generate_fallback_response(request: BusinessContinuityRequest, error_msg: str = "") -> RecoveryStrategiesResponse:
-    """Generate fallback response when API fails"""
-    logger.info("Generating fallback response")
-    
-    process_name = request.business_process.process_name
-    department = request.business_process.department
+def call_groq_api(prompt: str, user_message: str):
+    """Simple function to call GROQ API"""
+    if not GROQ_API_KEY:
+        logger.error("GROQ_API_KEY environment variable is not set")
+        raise Exception("GROQ_API_KEY not configured")
     
-    return RecoveryStrategiesResponse(
-        success=True,
-        people_unavailability_strategy=f"Implement cross-training programs for critical roles in {process_name}, maintain updated emergency contact lists, and establish clear succession planning. Create detailed process documentation and implement job rotation to reduce single points of failure.",
-        people_reasoning=f"Cross-training and succession planning are essential for {process_name} in {department} to ensure continuity when key personnel are unavailable.",
-        
-        technology_data_unavailability_strategy=f"Establish automated backup systems for {process_name} data, implement redundant infrastructure with failover capabilities, and maintain disaster recovery procedures. Conduct regular backup testing and ensure secure off-site data replication.",
-        technology_reasoning=f"Robust backup and redundancy systems are critical for {process_name} to minimize downtime and ensure rapid recovery from technology failures.",
-        
-        site_unavailability_strategy=f"Identify and prepare alternative work locations for {process_name} operations, enable comprehensive remote work capabilities, and establish emergency communication protocols. Maintain emergency supplies and equipment at backup locations.",
-        site_reasoning=f"Alternative work arrangements ensure {process_name} can continue operating when primary {department} facilities are inaccessible.",
+    try:
+        client = openai.OpenAI(
+            api_key=GROQ_API_KEY, 
+            base_url="https://api.groq.com/openai/v1", 
+            timeout=60.0
+        )
         
-        third_party_vendors_unavailability_strategy=f"Develop relationships with backup vendors for {process_name} critical services, maintain emergency supplier contacts, and establish contingency contracts. Regularly assess vendor reliability and maintain strategic inventory buffers.",
-        vendor_reasoning=f"Vendor diversification and contingency planning reduce supply chain risks for {process_name} and ensure continuity of essential external services.",
+        response = client.chat.completions.create(
+            model="llama3-8b-8192",
+            messages=[
+                {"role": "system", "content": prompt},
+                {"role": "user", "content": user_message}
+            ],
+            temperature=0.1,
+            max_tokens=1500
+        )
         
-        message=f"Fallback strategies generated due to API processing error: {error_msg}" if error_msg else "Fallback strategies generated"
-    )
+        return response.choices[0].message.content
+    except Exception as e:
+        logger.error(f"API call failed: {str(e)}")
+        raise Exception(f"API call failed: {str(e)}")
 
-# Business Continuity Router
-business_continuity_router = APIRouter()
+def create_error_response(request_id: str, error_message: str) -> RecoveryStrategiesResponse:
+    """Create a simple error response"""
+    return RecoveryStrategiesResponse(
+        success=False,
+        people_unavailability_strategy="Error: Strategy not generated",
+        people_reasoning="Error: Reasoning not generated",
+        technology_data_unavailability_strategy="Error: Strategy not generated",
+        technology_reasoning="Error: Reasoning not generated",
+        site_unavailability_strategy="Error: Strategy not generated",
+        site_reasoning="Error: Reasoning not generated",
+        third_party_vendors_unavailability_strategy="Error: Strategy not generated",
+        vendor_reasoning="Error: Reasoning not generated",
+        message=f"Error: {error_message}",
+        request_id=request_id
+    )
 
 @business_continuity_router.post("/api/business-continuity/generate-recovery-strategies", response_model=RecoveryStrategiesResponse)
 def generate_recovery_strategies(request: BusinessContinuityRequest):
-    """
-    Generate comprehensive business continuity recovery strategies for a business process
-    """
+    """Generate business continuity recovery strategies"""
     request_id = str(uuid.uuid4())
-    logger.info(f"Request {request_id}: Starting recovery strategies generation")
-    logger.info(f"Request {request_id}: Process - {request.business_process.process_name}")
-    logger.info(f"Request {request_id}: Department - {request.business_process.department}")
+    logger.info(f"Request {request_id}: Starting for {request.business_process.process_name}")
+    
+    # Basic input validation
+    if not request.business_process.process_name.strip():
+        raise HTTPException(status_code=400, detail="Process name cannot be empty")
+    if not request.business_process.department.strip():
+        raise HTTPException(status_code=400, detail="Department cannot be empty")
     
     try:
-        # Validate input
-        if not request.business_process.process_name.strip():
-            logger.error(f"Request {request_id}: Empty process name")
-            raise HTTPException(status_code=400, detail="Process name cannot be empty")
-            
-        if not request.business_process.department.strip():
-            logger.error(f"Request {request_id}: Empty department")
-            raise HTTPException(status_code=400, detail="Department cannot be empty")
-        
-        system_prompt = """You are an expert business continuity consultant. Your task is to generate specific, actionable recovery strategies for business processes.
-
-**CRITICAL INSTRUCTIONS:**
-1.  **MUST** respond with a single, valid JSON object and nothing else.
-2.  The JSON object must be the only content in your response. Do not include any text, explanations, or markdown formatting (like ```json) before or after the JSON object.
-3.  Ensure the JSON is perfectly formed with correct syntax, including matching curly braces, quoted keys, and properly escaped string values.
-4.  Each strategy must be 2-3 detailed sentences with specific, actionable steps.
-5.  Each reasoning must be 1-2 sentences explaining why the strategy fits the specific process.
+        # Create system prompt - simplified and direct
+        system_prompt = """You are a business continuity expert. Your response must be a valid JSON object only.
+Follow this exact format:
 
-**Required JSON format (no deviations allowed):**
-```json
 {
-  "people_unavailability_strategy": "Detailed strategy for handling personnel unavailability with specific steps.",
-  "people_reasoning": "Clear explanation of why this strategy suits this specific process.",
-  "technology_data_unavailability_strategy": "Comprehensive strategy for technology and data failures with actionable steps.",
-  "technology_reasoning": "Explanation of why this technology strategy is appropriate for this process.",
-  "site_unavailability_strategy": "Detailed strategy for site/facility unavailability with specific actions.",
-  "site_reasoning": "Why this site strategy is suitable for this specific process.",
-  "third_party_vendors_unavailability_strategy": "Comprehensive strategy for vendor/supplier disruptions.",
-  "vendor_reasoning": "Why this vendor strategy is appropriate for this process."
+  "people_unavailability_strategy": "Strategy for when key staff are unavailable (2 sentences).",
+  "people_reasoning": "Why this strategy works for this process (1 sentence).",
+  "technology_data_unavailability_strategy": "Strategy for system failures (2 sentences).",
+  "technology_reasoning": "Why this technology strategy works (1 sentence).",
+  "site_unavailability_strategy": "Strategy for site unavailability (2 sentences).",
+  "site_reasoning": "Why this site strategy works (1 sentence).",
+  "third_party_vendors_unavailability_strategy": "Strategy for supplier disruptions (2 sentences).",
+  "vendor_reasoning": "Why this vendor strategy works (1 sentence)."
 }
-```"""
-
-        user_message = f"""Generate business continuity recovery strategies for this specific process:
 
-PROCESS DETAILS:
-- Process Name: {request.business_process.process_name}
-- Department: {request.business_process.department}
-- Sub-Department: {request.business_process.sub_department or 'Not specified'}
-- Description: {request.business_process.process_description}
+Do not include any other text or formatting in your response."""
 
-ANALYSIS DATA:
-- Impact Analysis: {json.dumps(request.analysis_data.impact_analysis) if request.analysis_data.impact_analysis else 'Not provided'}
-- Minimum Operating Requirements: {json.dumps(request.analysis_data.minimum_operating_requirements) if request.analysis_data.minimum_operating_requirements else 'Not provided'}
+        # Create user message - simplified
+        user_message = f"""Generate business continuity strategies for:
+Process: {request.business_process.process_name}
+Department: {request.business_process.department}
+Description: {request.business_process.process_description}"""
 
-Generate comprehensive recovery strategies for these four scenarios:
-1. Key personnel unavailability
-2. Technology/data system failures
-3. Primary site/facility unavailability  
-4. Critical third-party vendor/supplier disruptions
-
-Focus on actionable, specific strategies tailored to this exact process and department context."""
-
-        logger.info(f"Request {request_id}: Making API call to GROQ")
-        
-        # Get response from API
-        api_response = generate_response(system_prompt, user_message)
-        
-        if not api_response:
-            logger.error(f"Request {request_id}: Empty API response")
-            return generate_fallback_response(request, "Empty API response")
-        
-        logger.info(f"Request {request_id}: API response received, length: {len(api_response)}")
+        # Call API
+        try:
+            api_response = call_groq_api(system_prompt, user_message)
+            logger.info(f"Request {request_id}: Received API response")
+        except Exception as e:
+            logger.error(f"Request {request_id}: API call failed - {str(e)}")
+            return create_error_response(request_id, "API error")
         
-        # Clean and parse JSON
+        # Parse JSON response with safer approach
         try:
-            logger.info(f"Request {request_id}: Raw API response length: {len(api_response)}")
-            logger.info(f"Request {request_id}: Raw response first 200 chars: {api_response[:200]}")
-            logger.info(f"Request {request_id}: Raw response last 200 chars: {api_response[-200:]}")
-            
+            # First try direct parsing
             strategies_data = json.loads(api_response)
-            logger.info(f"Request {request_id}: JSON parsing successful")
+            logger.info(f"Request {request_id}: Successfully parsed JSON")
+        except json.JSONDecodeError:
+            logger.warning(f"Request {request_id}: Direct JSON parsing failed, trying to clean response")
             
-        except (json.JSONDecodeError, ValueError) as e:
-            logger.error(f"Request {request_id}: JSON parsing failed - {str(e)}")
-            logger.error(f"Request {request_id}: Raw response preview: {api_response[:300]}...")
-            return generate_fallback_response(request, f"JSON parsing failed: {str(e)}")
+            # Clean the response - look for JSON inside any markdown or text
+            try:
+                # Try to find JSON pattern
+                json_match = re.search(r'({[\s\S]*?})(?:\s*$|\n)', api_response)
+                if json_match:
+                    json_text = json_match.group(1)
+                    strategies_data = json.loads(json_text)
+                    logger.info(f"Request {request_id}: Successfully parsed JSON after cleaning")
+                else:
+                    raise ValueError("Could not find JSON in response")
+            except Exception as e:
+                logger.error(f"Request {request_id}: JSON parsing failed after cleaning - {str(e)}")
+                logger.error(f"Request {request_id}: Raw response preview: {api_response[:300]}")
+                return create_error_response(request_id, "Could not parse API response")
         
-        # Validate the parsed data
-        try:
-            strategies_data = validate_strategies_data(strategies_data)
-            
-            response = RecoveryStrategiesResponse(
-                success=True,
-                people_unavailability_strategy=strategies_data["people_unavailability_strategy"],
-                people_reasoning=strategies_data["people_reasoning"],
-                technology_data_unavailability_strategy=strategies_data["technology_data_unavailability_strategy"],
-                technology_reasoning=strategies_data["technology_reasoning"],
-                site_unavailability_strategy=strategies_data["site_unavailability_strategy"],
-                site_reasoning=strategies_data["site_reasoning"],
-                third_party_vendors_unavailability_strategy=strategies_data["third_party_vendors_unavailability_strategy"],
-                vendor_reasoning=strategies_data["vendor_reasoning"],
-                message="Successfully generated comprehensive recovery strategies",
-                request_id=request_id
-            )
-            
-            logger.info(f"Request {request_id}: Successfully generated strategies")
-            return response
-            
-        except Exception as e:
-            logger.error(f"Request {request_id}: Data validation failed - {str(e)}")
-            return generate_fallback_response(request, f"Data validation failed: {str(e)}")
+        # Safely get fields with fallbacks
+        return RecoveryStrategiesResponse(
+            success=True,
+            people_unavailability_strategy=strategies_data.get("people_unavailability_strategy", "Strategy not generated"),
+            people_reasoning=strategies_data.get("people_reasoning", "Reasoning not generated"),
+            technology_data_unavailability_strategy=strategies_data.get("technology_data_unavailability_strategy", "Strategy not generated"),
+            technology_reasoning=strategies_data.get("technology_reasoning", "Reasoning not generated"),
+            site_unavailability_strategy=strategies_data.get("site_unavailability_strategy", "Strategy not generated"),
+            site_reasoning=strategies_data.get("site_reasoning", "Reasoning not generated"),
+            third_party_vendors_unavailability_strategy=strategies_data.get("third_party_vendors_unavailability_strategy", "Strategy not generated"),
+            vendor_reasoning=strategies_data.get("vendor_reasoning", "Reasoning not generated"),
+            message="Successfully generated recovery strategies",
+            request_id=request_id
+        )
             
     except HTTPException:
         # Re-raise HTTP exceptions
         raise
-        
     except Exception as e:
         logger.error(f"Request {request_id}: Unexpected error - {str(e)}")
-        logger.error(f"Request {request_id}: Traceback: {traceback.format_exc()}")
-        
-        # Return fallback response instead of raising HTTP error
-        return generate_fallback_response(request, f"Unexpected error: {str(e)}")
+        logger.error(f"Traceback: {traceback.format_exc()}")
+        return create_error_response(request_id, "An unexpected error occurred")
 
-# Health check endpoint
 @business_continuity_router.get("/api/business-continuity/health")
 def health_check():
     """Health check endpoint"""