feat(pivot): Finsight Knowledge Graph & Reconciliation

Author: Anandb71

backend/app/main.py

@@ -9,7 +9,7 @@
 
 from app.core.config import get_settings
 from app.api import router as api_router
-from app.sockets import setup_websocket_routes
+from app.sockets import router as websocket_router
 
 
 def create_app() -> FastAPI:
@@ -37,8 +37,8 @@ def create_app() -> FastAPI:
     # Include REST API routes
     app.include_router(api_router)
 
-    # Register WebSocket routes
-    setup_websocket_routes(app)
+    # Include WebSocket routes
+    app.include_router(websocket_router)
 
     @app.get("/")
     async def root():

backend/app/services/audio_processor.py

@@ -1,171 +1,99 @@
-"""
-FinShield - Audio Processor Service
 
-THIS IS SREEDEV'S FILE - Implement real audio processing logic here.
-
-Interface for real-time audio chunk processing.
-Current implementation is a mock that returns dummy data.
-Replace with Hotfoot Audio integration.
-"""
-
-from abc import ABC, abstractmethod
-from typing import Any, Dict, List, Optional
 import random
+from typing import Dict, Any, List
+# from app.services.audio_processor import AudioProcessorBase  # Assuming interface exists
 
-
-class AudioProcessorBase(ABC):
-    """
-    Abstract base class for audio processing.
-    
-    Sreedev: Implement your Hotfoot Audio integration by:
-    1. Creating a new class that inherits from this
-    2. Implementing the abstract methods
-    3. Updating get_audio_processor() to return your class
-    """
-
-    @abstractmethod
-    async def process_chunk(self, audio_bytes: bytes) -> Dict[str, Any]:
-        """
-        Process a single audio chunk in real-time.
-        
-        Args:
-            audio_bytes: Raw audio data (Int16 PCM format)
-            
-        Returns:
-            Dict with:
-            - risk_score: float (0.0 - 1.0)
-            - threat_level: str ("safe", "low", "medium", "high", "critical")
-            - flags: List[str] (detected issues)
-            - transcript_snippet: Optional[str]
-        """
-        pass
-
-    @abstractmethod
-    async def start_session(self, session_id: str) -> bool:
-        """Initialize a new analysis session."""
-        pass
-
-    @abstractmethod
-    async def end_session(self, session_id: str) -> Dict[str, Any]:
-        """
-        End session and get final analysis.
-        
-        Returns:
-            Complete session analysis with aggregated results
-        """
-        pass
-
-    @abstractmethod
-    async def get_transcript(self, session_id: str) -> Optional[str]:
-        """Get full transcript for a session."""
-        pass
-
-
-class MockAudioProcessor(AudioProcessorBase):
-    """
-    Mock implementation for development/demo.
-    
-    TODO (Sreedev): Replace this with HotfootAudioProcessor
-    """
-
-    SAMPLE_FLAGS = [
-        "Urgency language detected",
-        "Request for sensitive information",
-        "Authority impersonation attempt",
-        "Pressure tactics identified",
-        "Suspicious callback request",
-    ]
-
+class MockAudioProcessor:
     def __init__(self):
-        self.sessions: Dict[str, Dict] = {}
         self._chunk_count = 0
+        self._transcript_segments = [
+            "Hello, am I speaking with Mr. Anand?",
+            "This is calling from the Card Protection Department regarding your Visa ending in 4521.",
+            "We have detected a suspicious transaction of Rs. 50,000 on your account.",
+            "If this was not you, we need to verify your identity immediately to block it.",
+            "Please confirm your date of birth for verification based on our records from 1990.",
+            "Do not hang up, or your account will be debit frozen within 15 minutes.",
+            "To reverse the charge, I need you to download the QuickSupport app now.",
+            "Rest assured, this is a secure line monitored by the RBI fraud prevention unit.",
+            "Just tell me the OTP you received to cancel the transaction of Rs. 50,000.",
+            "Why are you hesitating? Do you want to lose your money, sir?",
+        ]
+        
+        # Scenarios
+        self.scenarios = {
+            "SAFE": {
+                "risk_base": 0.05,
+                "intent": "GRIEVANCE",
+                "stress": 0.12,
+                "transcript": [
+                    "Hello, this is verified support.", 
+                    "How can I help you with your query today?",
+                    "I see you have a dispute about a charge.",
+                    "Let me check that for you right now.",
+                    "Okay, I can see the transaction of Rs. 500.",
+                    "I will raise a ticket for this refund.",
+                    "It should reflect in 3-5 business days.",
+                    "Is there anything else I can help you with?",
+                    "Thank you for banking with us.",
+                    "Have a wonderful day."
+                ]
+            },
+            "SCAM": {
+                "risk_base": 0.95,
+                "intent": "THREAT / FRAUD",
+                "stress": 0.85,
+                "transcript": self._transcript_segments
+            },
+            "SUSPICIOUS": {
+                "risk_base": 0.45,
+                "intent": "COLLECTION",
+                "stress": 0.55,
+                "transcript": [
+                   "Hello, calling about your pending dues.",
+                   "You have missed the payment of Rs. 12,000.",
+                   "When can we expect this payment to be cleared?",
+                   "If you delay, there will be a penalty charge.",
+                   "We might have to send an agent to your address.",
+                   "Please make the payment by tomorrow 5 PM.",
+                   "This will affect your CIBIL score negatively.",
+                   "We are offering a settlement if you pay now.",
+                   "Do not ignore these calls, sir.",
+                   "Pay immediately to avoid legal action."
+                ]
+            }
+        }
+        
+        self.current_scenario = "SCAM" # Default for now, can be changed via "Wizard" injection potentially
 
     async def process_chunk(self, audio_bytes: bytes) -> Dict[str, Any]:
-        """
-        Mock processing - returns simulated risk analysis.
-        
-        In production, this would:
-        1. Send audio to Hotfoot Audio API
-        2. Get real-time transcription
-        3. Analyze for fraud patterns
-        4. Return actual risk scores
-        """
         self._chunk_count += 1
-        chunk_size = len(audio_bytes)
 
-        # Simulate varying risk based on chunk count (demo effect)
-        # Risk increases slightly over time to show dynamic behavior
-        base_risk = 0.1
-        dynamic_risk = min(0.1, (self._chunk_count % 50) * 0.002)
-        random_variation = random.uniform(-0.05, 0.15)
+        # Determine scenario based on external injection (not implemented here yet, just random or fixed)
+        # For demo, let's rotate or stick to one. 
+        # Actually, let's pick a segment based on chunk count.
 
-        risk_score = min(1.0, max(0.0, base_risk + dynamic_risk + random_variation))
+        scenario_data = self.scenarios.get(self.current_scenario, self.scenarios["SCAM"])
+        transcript_list = scenario_data["transcript"]
 
-        # Determine threat level
-        if risk_score < 0.2:
-            threat_level = "safe"
-        elif risk_score < 0.4:
-            threat_level = "low"
-        elif risk_score < 0.6:
-            threat_level = "medium"
-        elif risk_score < 0.8:
-            threat_level = "high"
-        else:
-            threat_level = "critical"
+        # Loop through transcript
+        idx = (self._chunk_count - 1) % len(transcript_list)
+        transcript_text = transcript_list[idx]
 
-        # Occasionally add flags for demo
-        flags = []
-        if risk_score > 0.3 and random.random() > 0.7:
-            flags = random.sample(self.SAMPLE_FLAGS, min(2, int(risk_score * 3)))
+        # Mock Logic
+        risk_score = scenario_data["risk_base"] + random.uniform(-0.05, 0.05)
+        risk_score = max(0.0, min(1.0, risk_score))
 
         return {
             "risk_score": round(risk_score, 3),
-            "threat_level": threat_level,
-            "flags": flags,
-            "transcript_snippet": None,  # Would contain real transcription
-            "chunk_size": chunk_size,
-            "processing_ms": random.randint(5, 25),  # Simulated latency
+            "threat_level": "critical" if risk_score > 0.8 else ("high" if risk_score > 0.6 else "safe"),
+            "flags": ["Urgency Detected", "Financial Threat"] if risk_score > 0.6 else [],
+            "transcript_snippet": transcript_text, # SENDING TRANSCRIPT NOW
+            "intent": scenario_data["intent"],
+            "stress_score": scenario_data["stress"],
+            "chunk_size": len(audio_bytes),
         }
 
-    async def start_session(self, session_id: str) -> bool:
-        """Start a new mock session."""
-        self.sessions[session_id] = {
-            "started_at": "now",
-            "chunks": 0,
-            "total_risk": 0.0,
-        }
-        self._chunk_count = 0
-        return True
-
-    async def end_session(self, session_id: str) -> Dict[str, Any]:
-        """End mock session with summary."""
-        session = self.sessions.pop(session_id, {})
-        return {
-            "session_id": session_id,
-            "total_chunks": session.get("chunks", 0),
-            "average_risk": session.get("total_risk", 0) / max(1, session.get("chunks", 1)),
-            "final_verdict": "Analysis complete",
-        }
-
-    async def get_transcript(self, session_id: str) -> Optional[str]:
-        """Mock transcript."""
-        return "[Mock transcript - Hotfoot Audio integration pending]"
-
-
-# ============================================================================
-# FACTORY FUNCTION - Update this to use real implementation
-# ============================================================================
-
-def get_audio_processor() -> AudioProcessorBase:
-    """
-    Get audio processor instance.
-    
-    TODO (Sreedev): When Hotfoot Audio is ready, change to:
-    
-    from app.core.config import get_settings
-    settings = get_settings()
-    if settings.hotfoot_audio_api_key:
-        return HotfootAudioProcessor(api_key=settings.hotfoot_audio_api_key)
-    return MockAudioProcessor()
-    """
-    return MockAudioProcessor()
+    def set_scenario(self, scenario_name: str):
+        if scenario_name in self.scenarios:
+            self.current_scenario = scenario_name
+            self._chunk_count = 0 # Reset transcript loop