Update app.py

app.py

@@ -1,447 +1,96 @@
+from flask import Flask, render_template, request, jsonify
 import os
-import re
-import requests
-from urllib.parse import urlparse
-import gradio as gr
-import json
-from typing import Dict, List, Tuple
 import time
-
-# Initialize OpenAI client with error handling
-try:
-    from openai import OpenAI
-    api_key = os.getenv("OPENAI_API_KEY")
-    if not api_key:
-        raise ValueError("OPENAI_API_KEY environment variable is not set")
-    client = OpenAI(api_key=api_key)
-except Exception as e:
-    print(f"Error initializing OpenAI client: {e}")
-    client = None
-
-class ScamVerifierAgent:
-    def __init__(self):
-        self.model = "gpt-4o-mini"
-        self.temperature = 0.3
-        
-    def extract_claims_and_urls(self, text: str) -> Dict:
-        """Agent 1: Extract claims, URLs, and key information from the input"""
-        if client is None:
-            return {"error": "OpenAI client not initialized. Please check your API key."}
-            
-        prompt = f"""
-        You are a claim extraction agent. Analyze the following text and extract:
-        1. All URLs found in the text
-        2. Key claims being made (offers, promises, threats, urgency indicators)
-        3. Contact information (phone numbers, emails, social media handles)
-        4. Red flag indicators (urgency language, too-good-to-be-true offers, threats)
-        5. The main topic/context of the message
-
-        Text to analyze: "{text}"
-
-        Return your analysis in this JSON format:
-        {{
-            "urls": ["list of URLs"],
-            "claims": ["list of key claims"],
-            "contact_info": ["list of contact details"],
-            "red_flags": ["list of suspicious elements"],
-            "main_topic": "brief description of what this is about",
-            "urgency_level": "low/medium/high"
-        }}
-        """
-        
-        try:
-            response = client.chat.completions.create(
-                model=self.model,
-                temperature=self.temperature,
-                messages=[{"role": "user", "content": prompt}]
-            )
-            
-            content = response.choices[0].message.content
-            # Try to extract JSON from the response
-            json_match = re.search(r'\{.*\}', content, re.DOTALL)
-            if json_match:
-                return json.loads(json_match.group())
-            else:
-                # Fallback parsing
-                return {"error": "Could not parse extraction results", "raw": content}
-        except Exception as e:
-            return {"error": f"Extraction failed: {str(e)}"}
-
-    def verify_claims(self, extracted_data: Dict) -> Dict:
-        """Agent 2: Verify claims and check URLs"""
-        claims = extracted_data.get("claims", [])
-        urls = extracted_data.get("urls", [])
-        
-        verification_results = {
-            "url_analysis": [],
-            "claim_verification": [],
-            "overall_risk_score": 0
-        }
-        
-        # Analyze URLs
-        for url in urls[:3]:  # Limit to first 3 URLs
-            url_result = self._analyze_url(url)
-            verification_results["url_analysis"].append(url_result)
-        
-        # Verify claims using LLM knowledge
-        if claims:
-            claim_verification = self._verify_claims_with_llm(claims, extracted_data.get("main_topic", ""))
-            verification_results["claim_verification"] = claim_verification
-        
-        # Calculate risk score
-        verification_results["overall_risk_score"] = self._calculate_risk_score(
-            extracted_data, verification_results
+from crewai import Agent, Task, Crew
+from langchain_openai import ChatOpenAI
+
+app = Flask(__name__)
+
+# Ensure API key is set in environment
+os.getenv("OPENAI_API_KEY")  # Enter your OpenAI API key or set it via env var
+
+def run_scam_analysis(message_content):
+    if not message_content.strip():
+        return "❗ Please enter a message or URL to analyze."
+
+    loading_messages = [
+        "🛡️ Initializing AI security team...",
+        "🔍 Claim Extractor analyzing suspicious content...",
+        "⚖️ Fact Checker verifying claims and patterns...",
+        "📋 Safety Advisor preparing guidance report...",
+        "🚨 Generating comprehensive scam analysis..."
+    ]
+
+    try:
+        llm = ChatOpenAI(model_name="gpt-4o-mini", temperature=0.1)
+
+        extractor_agent = Agent(
+            role="Claim Extractor",
+            goal="Extract key claims, offers, and suspicious elements from messages or URLs",
+            backstory="Expert at parsing and identifying key claims in potentially fraudulent messages.",
+            llm=llm,
+            verbose=False
         )
-        
-        return verification_results
-
-    def _analyze_url(self, url: str) -> Dict:
-        """Analyze a single URL for suspicious characteristics"""
-        analysis = {
-            "url": url,
-            "domain_age": "unknown",
-            "ssl_status": "unknown",
-            "suspicious_patterns": [],
-            "risk_level": "low"
-        }
-        
-        try:
-            parsed = urlparse(url)
-            domain = parsed.netloc.lower()
-            
-            # Check for suspicious patterns
-            suspicious_patterns = [
-                "bit.ly", "tinyurl", "t.co", "shortened",
-                "secure-", "verify-", "update-", "confirm-",
-                "urgent", "limited", "expired", "suspended"
-            ]
-            
-            found_patterns = [pattern for pattern in suspicious_patterns if pattern in domain or pattern in url.lower()]
-            analysis["suspicious_patterns"] = found_patterns
-            
-            # Simple risk assessment
-            if found_patterns:
-                analysis["risk_level"] = "high" if len(found_patterns) > 2 else "medium"
-            
-            # Check if domain looks legitimate
-            legit_domains = ["amazon", "ebay", "paypal", "microsoft", "google", "apple", "facebook", "instagram"]
-            if any(legit in domain for legit in legit_domains):
-                # But check for typosquatting
-                if not any(domain.endswith(f".{legit}.com") or domain == f"{legit}.com" for legit in legit_domains):
-                    analysis["suspicious_patterns"].append("possible_typosquatting")
-                    analysis["risk_level"] = "high"
-                else:
-                    analysis["risk_level"] = "low"
-            
-        except Exception as e:
-            analysis["error"] = str(e)
-            analysis["risk_level"] = "medium"
-        
-        return analysis
-
-    def _verify_claims_with_llm(self, claims: List[str], topic: str) -> Dict:
-        """Use LLM to verify claims against common knowledge"""
-        if client is None:
-            return {"error": "OpenAI client not initialized"}
-            
-        prompt = f"""
-        You are a fact-checking agent. Analyze these claims in the context of "{topic}" and identify which ones are likely false, misleading, or use common scam tactics.
-
-        Claims to verify:
-        {json.dumps(claims, indent=2)}
-
-        For each claim, assess:
-        1. Likelihood it's legitimate (high/medium/low)
-        2. Common scam tactic indicators
-        3. Whether it uses urgency, fear, or greed manipulation
-
-        Respond in JSON format:
-        {{
-            "claim_assessments": [
-                {{
-                    "claim": "the claim text",
-                    "legitimacy": "high/medium/low",
-                    "scam_indicators": ["list of red flags"],
-                    "explanation": "brief explanation"
-                }}
-            ],
-            "overall_assessment": "overall legitimacy assessment"
-        }}
-        """
-        
-        try:
-            response = client.chat.completions.create(
-                model=self.model,
-                temperature=self.temperature,
-                messages=[{"role": "user", "content": prompt}]
-            )
-            
-            content = response.choices[0].message.content
-            json_match = re.search(r'\{.*\}', content, re.DOTALL)
-            if json_match:
-                return json.loads(json_match.group())
-            else:
-                return {"error": "Could not parse verification results"}
-        except Exception as e:
-            return {"error": f"Verification failed: {str(e)}"}
-
-    def _calculate_risk_score(self, extracted_data: Dict, verification_results: Dict) -> int:
-        """Calculate overall risk score (0-100)"""
-        score = 0
-        
-        # Red flags from extraction
-        red_flags = len(extracted_data.get("red_flags", []))
-        score += min(red_flags * 15, 45)
-        
-        # Urgency level
-        urgency = extracted_data.get("urgency_level", "low")
-        if urgency == "high":
-            score += 25
-        elif urgency == "medium":
-            score += 15
-        
-        # URL analysis
-        for url_analysis in verification_results.get("url_analysis", []):
-            if url_analysis.get("risk_level") == "high":
-                score += 20
-            elif url_analysis.get("risk_level") == "medium":
-                score += 10
-        
-        # Claim verification
-        claim_verification = verification_results.get("claim_verification", {})
-        assessments = claim_verification.get("claim_assessments", [])
-        for assessment in assessments:
-            if assessment.get("legitimacy") == "low":
-                score += 15
-            elif assessment.get("legitimacy") == "medium":
-                score += 8
-        
-        return min(score, 100)
 
-    def generate_explanation(self, extracted_data: Dict, verification_results: Dict) -> str:
-        """Agent 3: Generate human-friendly explanation and recommendations"""
-        if client is None:
-            return "Error: OpenAI client not initialized. Please check your API key configuration."
-            
-        risk_score = verification_results.get("overall_risk_score", 0)
-        
-        prompt = f"""
-        You are an AI assistant helping users understand potential scams. Based on this analysis, create a clear, helpful explanation for a non-technical user.
-
-        Analysis Data:
-        - Risk Score: {risk_score}/100
-        - Extracted Data: {json.dumps(extracted_data, indent=2)}
-        - Verification Results: {json.dumps(verification_results, indent=2)}
-
-        Create a response with:
-        1. Overall assessment (Is this likely a scam?)
-        2. Key warning signs found
-        3. Specific recommendations for next steps
-        4. General tips to stay safe
-
-        Keep it conversational, clear, and actionable. Use emojis sparingly for clarity.
-        """
-        
-        try:
-            response = client.chat.completions.create(
-                model=self.model,
-                temperature=self.temperature,
-                messages=[{"role": "user", "content": prompt}]
-            )
-            
-            return response.choices[0].message.content
-        except Exception as e:
-            return f"Error generating explanation: {str(e)}"
-
-def analyze_message(message_text: str) -> Tuple[str, str, Dict]:
-    """Main function to analyze a message"""
-    if not message_text.strip():
-        return "Please enter a message or URL to analyze.", "", {}
-    
-    # Check if OpenAI client is available
-    if client is None:
-        return "❌ Error: OpenAI API not configured", "Please ensure OPENAI_API_KEY is set correctly in your environment.", {}
-    
-    agent = ScamVerifierAgent()
-    
-    # Step 1: Extract claims and information
-    extracted_data = agent.extract_claims_and_urls(message_text)
-    
-    if "error" in extracted_data:
-        return f"Analysis Error: {extracted_data['error']}", "", extracted_data
-    
-    # Step 2: Verify claims and URLs
-    verification_results = agent.verify_claims(extracted_data)
-    
-    # Step 3: Generate explanation
-    explanation = agent.generate_explanation(extracted_data, verification_results)
-    
-    risk_score = verification_results.get("overall_risk_score", 0)
-    
-    # Create risk level indicator
-    if risk_score >= 70:
-        risk_indicator = "🚨 HIGH RISK - Likely Scam"
-        risk_color = "red"
-    elif risk_score >= 40:
-        risk_indicator = "⚠️ MEDIUM RISK - Be Cautious"
-        risk_color = "orange"
-    else:
-        risk_indicator = "✅ LOW RISK - Appears Safe"
-        risk_color = "green"
-    
-    # Format technical details
-    tech_details = f"""
-**Risk Score:** {risk_score}/100
-
-**Extracted Information:**
-- URLs Found: {len(extracted_data.get('urls', []))}
-- Claims Identified: {len(extracted_data.get('claims', []))}
-- Red Flags: {len(extracted_data.get('red_flags', []))}
-- Urgency Level: {extracted_data.get('urgency_level', 'Unknown')}
+        verifier_agent = Agent(
+            role="Fact Checker",
+            goal="Verify claims and assess scam probability using heuristic rules and pattern matching",
+            backstory="Cybersecurity expert who specializes in identifying scam patterns.",
+            llm=llm,
+            verbose=False
+        )
 
-**Key Red Flags:**
-{chr(10).join(f"• {flag}" for flag in extracted_data.get('red_flags', []))}
+        explainer_agent = Agent(
+            role="Safety Advisor",
+            goal="Provide clear, actionable guidance to users about potential scams",
+            backstory="Digital safety educator who explains complex security issues simply.",
+            llm=llm,
+            verbose=False
+        )
 
-**URLs Analyzed:**
-{chr(10).join(f"• {url['url']} - Risk: {url['risk_level']}" for url in verification_results.get('url_analysis', []))}
-    """
-    
-    return risk_indicator, explanation, {"technical_details": tech_details, "risk_score": risk_score}
+        extract_task = Task(
+            description=f"Analyze and extract suspicious elements from: {message_content}",
+            expected_output="Structured summary of extracted claims, suspicious elements, and language patterns",
+            agent=extractor_agent
+        )
 
-# Custom CSS for better styling
-css = """
-.gradio-container {
-    max-width: 900px !important;
-    margin: auto !important;
-}
+        verify_task = Task(
+            description="Risk assessment with scam probability score, red flags, and evidence",
+            expected_output="Risk assessment with scam probability score, red flags, and evidence",
+            agent=verifier_agent,
+            context=[extract_task]
+        )
 
-.risk-high {
-    background-color: #fee !important;
-    border-left: 4px solid #dc2626 !important;
-    padding: 10px !important;
-}
+        explain_task = Task(
+            description="User-friendly safety report with clear recommendations and next steps",
+            expected_output="User-friendly safety report with clear recommendations and next steps",
+            agent=explainer_agent,
+            context=[extract_task, verify_task]
+        )
 
-.risk-medium {
-    background-color: #fef3cd !important;
-    border-left: 4px solid #f59e0b !important;
-    padding: 10px !important;
-}
+        crew = Crew(
+            agents=[extractor_agent, verifier_agent, explainer_agent],
+            tasks=[extract_task, verify_task, explain_task],
+            verbose=False,
+            process="sequential"
+        )
 
-.risk-low {
-    background-color: #d1fae5 !important;
-    border-left: 4px solid #059669 !important;
-    padding: 10px !important;
-}
+        result = crew.kickoff()
+        return str(result)
 
-.header-text {
-    text-align: center !important;
-    color: #1f2937 !important;
-    margin-bottom: 20px !important;
-}
+    except Exception as e:
+        return f"❌ Scam analysis failed: {str(e)}"
 
-.footer-text {
-    text-align: center !important;
-    color: #6b7280 !important;
-    font-size: 14px !important;
-    margin-top: 20px !important;
-}
-"""
+@app.route("/")
+def index():
+    return render_template("index.html")
 
-# Create Gradio interface
-with gr.Blocks(css=css, title="Scam-Signal Verifier") as app:
-    # Check API status
-    api_status = "✅ OpenAI API Connected" if client else "❌ OpenAI API Not Connected"
-    api_color = "green" if client else "red"
-    
-    gr.HTML(f"""
-    <div class="header-text">
-        <h1>🛡️ Scam-Signal Verifier</h1>
-        <p>Protect yourself from phishing and fake ads with AI-powered analysis</p>
-        <p style="color: {api_color}; font-size: 14px; margin-top: 5px;">{api_status}</p>
-    </div>
-    """)
-    
-    with gr.Row():
-        with gr.Column(scale=2):
-            message_input = gr.Textbox(
-                label="Enter suspicious message or URL",
-                placeholder="Paste the suspicious message, email, or URL here...",
-                lines=6,
-                max_lines=10
-            )
-            
-            analyze_btn = gr.Button("🔍 Analyze for Scams", variant="primary", size="lg")
-            
-            gr.HTML("""
-            <div style="margin-top: 15px; padding: 10px; background-color: #f3f4f6; border-radius: 5px;">
-                <h4>💡 What this tool can analyze:</h4>
-                <ul style="margin: 5px 0; padding-left: 20px;">
-                    <li>Suspicious text messages or emails</li>
-                    <li>Social media posts or ads</li>
-                    <li>URLs and links</li>
-                    <li>Marketplace listings</li>
-                    <li>Investment or money-making offers</li>
-                </ul>
-            </div>
-            """)
-    
-    with gr.Row():
-        with gr.Column():
-            risk_output = gr.Textbox(
-                label="🎯 Risk Assessment",
-                interactive=False,
-                lines=1
-            )
-            
-            explanation_output = gr.Textbox(
-                label="📋 Detailed Analysis & Recommendations",
-                interactive=False,
-                lines=12,
-                max_lines=20
-            )
-    
-    with gr.Row():
-        with gr.Column():
-            with gr.Accordion("🔧 Technical Details", open=False):
-                tech_details = gr.Textbox(
-                    label="Technical Analysis",
-                    interactive=False,
-                    lines=10
-                )
-    
-    # Event handlers
-    def process_analysis(message):
-        if not message.strip():
-            return "Please enter a message to analyze.", "", ""
-        
-        try:
-            risk_indicator, explanation, details = analyze_message(message)
-            tech_info = details.get("technical_details", "No technical details available.")
-            return risk_indicator, explanation, tech_info
-        except Exception as e:
-            error_msg = f"Analysis failed: {str(e)}"
-            return error_msg, error_msg, error_msg
-    
-    analyze_btn.click(
-        process_analysis,
-        inputs=[message_input],
-        outputs=[risk_output, explanation_output, tech_details]
-    )
-    
-    # Auto-analyze on Enter key
-    message_input.submit(
-        process_analysis,
-        inputs=[message_input],
-        outputs=[risk_output, explanation_output, tech_details]
-    )
-    
-    gr.HTML("""
-    <div class="footer-text">
-        <p>⚠️ This tool provides guidance but cannot guarantee 100% accuracy. Always use your judgment and consult official sources when in doubt.</p>
-        <p>🚨 If you believe you've encountered a scam, report it to local authorities and relevant platforms.</p>
-    </div>
-    """)
+@app.route("/analyze", methods=["POST"])
+def analyze():
+    data = request.get_json()
+    message = data.get("message", "")
+    result = run_scam_analysis(message)
+    return jsonify({"result": result})
 
-# Launch the app
 if __name__ == "__main__":
-    app.launch(server_name="0.0.0.0", server_port=7860)
+    app.run(host="0.0.0.0", port=7860)