Update app.py

app.py

@@ -2,122 +2,248 @@ import gradio as gr
 import openai
 import os
 from dotenv import load_dotenv
+from typing import Dict, List
 
 # Load environment variables
 load_dotenv()
 
-# Initialize OpenAI (compatible with both old and new versions)
+# Initialize OpenAI
 try:
-    # Try new OpenAI client first
     from openai import OpenAI
     client = OpenAI(api_key=os.getenv("OPENAI_API_KEY").strip())
     new_openai = True
 except ImportError:
-    # Fall back to old version
     openai.api_key = os.getenv("OPENAI_API_KEY").strip()
     new_openai = False
 
-def analyze_text(text):
-    """Advanced forensic analysis with improved prompt and formatted output"""
+class ForensicAgent:
+    """Base class for forensic analysis agents"""
+    def __init__(self, role: str, expertise: str):
+        self.role = role
+        self.expertise = expertise
+        self.findings = []
     
-    expert_prompt = f"""
-    [ROLE]
-    You are Dr. Lexica, a world-renowned forensic linguistics expert specializing in AI/human text differentiation with 25 years of experience.
+    def analyze(self, text: str) -> Dict:
+        """Perform analysis and return findings"""
+        raise NotImplementedError
 
-    [ANALYSIS TASK]
-    Perform a comprehensive forensic analysis on the following text to determine its origin with maximum accuracy:
-
-    [TEXT TO ANALYZE]
-    {text}
-
-    [ANALYSIS FRAMEWORK]
-    1. **Stylometric Analysis**:
-       - Sentence structure complexity (human: varied, AI: uniform)
-       - Lexical sophistication (human: contextual, AI: textbook-like)
-       - Punctuation patterns (human: emotional, AI: formulaic)
-
-    2. **Cognitive Fingerprinting**:
-       - Presence of hedges ("maybe", "I think") → human
-       - Overconfidence markers ("clearly", "undoubtedly") → AI
-       - Personal anecdotes → human
-       - Generic statements → AI
-
-    3. **Semantic Forensics**:
-       - Metaphor density (human: 3-5 per 100 words, AI: 0-2)
-       - Contextual anchoring (human: specific references, AI: vague)
-       - Error patterns (human: typos, AI: semantic inconsistencies)
-
-    4. **Temporal Markers**:
-       - References to time/age (human: specific dates, AI: generic)
-       - Cultural references (human: nuanced, AI: stereotypical)
-
-    [REQUIRED OUTPUT FORMAT]
-    # 🕵️‍♂️ Forensic Text Analysis Report
-
-    ## 🔍 Verdict
-    **Origin:** {{Human/AI/Inconclusive}}  
-    **Confidence Level:** {{XX%}}  
-    **Detection Score:** {{X/10}}
-
-    ## 📊 Key Indicators
-    🟢 **Human Markers Found:**  
-    - {{Marker 1}}  
-    - {{Marker 2}}  
-
-    🔴 **AI Markers Found:**  
-    - {{Marker 1}}  
-    - {{Marker 2}}  
-
-    ## 🧐 Detailed Findings
-    ### 1️⃣ Stylometric Evidence
-    - {{Analysis point 1}}  
-    - {{Analysis point 2}}  
-
-    ### 2️⃣ Cognitive Patterns
-    - {{Analysis point 1}}  
-    - {{Analysis point 2}}  
+class StylometricAgent(ForensicAgent):
+    """Analyzes writing style characteristics"""
+    def __init__(self):
+        super().__init__("Dr. Styles", "Stylometric Analysis Expert")
+    
+    def analyze(self, text: str) -> Dict:
+        prompt = f"""
+        As a {self.role}, {self.expertise}, analyze this text for stylometric patterns:
+        
+        {text}
+        
+        Evaluate:
+        1. Sentence length variation (human: high, AI: low)
+        2. Lexical diversity (human: contextual, AI: generic)
+        3. Punctuation usage patterns
+        4. Paragraph structure complexity
+        
+        Return findings in this format:
+        {{
+            "verdict": "Human/AI/Uncertain",
+            "confidence": "0-100%",
+            "evidence": ["list", "of", "key", "findings"]
+        }}
+        """
+        return self._get_analysis(prompt)
+    
+    def _get_analysis(self, prompt: str) -> Dict:
+        try:
+            if new_openai:
+                response = client.chat.completions.create(
+                    model="gpt-4",
+                    messages=[
+                        {"role": "system", "content": f"You are {self.role}, {self.expertise}."},
+                        {"role": "user", "content": prompt}
+                    ],
+                    temperature=0.1,
+                    response_format={"type": "json_object"}
+                )
+                return eval(response.choices[0].message.content)
+            else:
+                response = openai.ChatCompletion.create(
+                    model="gpt-4",
+                    messages=[
+                        {"role": "system", "content": f"You are {self.role}, {self.expertise}."},
+                        {"role": "user", "content": prompt}
+                    ],
+                    temperature=0.1,
+                    response_format={"type": "json_object"}
+                )
+                return eval(response['choices'][0]['message']['content'])
+        except Exception as e:
+            return {"error": str(e)}
 
-    ### 3️⃣ Semantic Fingerprints
-    - {{Analysis point 1}}  
-    - {{Analysis point 2}}  
+class CognitiveAgent(ForensicAgent):
+    """Analyzes cognitive and psychological markers"""
+    def __init__(self):
+        super().__init__("Prof. Cognitus", "Cognitive Linguistics Specialist")
+    
+    def analyze(self, text: str) -> Dict:
+        prompt = f"""
+        As {self.role}, {self.expertise}, analyze this text for cognitive markers:
+        
+        {text}
+        
+        Evaluate:
+        1. Presence of hedging language ("perhaps", "I think")
+        2. Use of personal pronouns and anecdotes
+        3. Emotional expression patterns
+        4. Confidence markers ("undoubtedly", "clearly")
+        5. Metacognitive statements ("I'm not sure but...")
+        
+        Return findings in this format:
+        {{
+            "verdict": "Human/AI/Uncertain",
+            "confidence": "0-100%",
+            "evidence": ["list", "of", "key", "findings"]
+        }}
+        """
+        return self._get_analysis(prompt)
 
-    ## 💡 Expert Conclusion
-    {{3-4 sentence authoritative conclusion with final determination. Highlight any interesting nuances or exceptional cases.}}
+class SemanticAgent(ForensicAgent):
+    """Analyzes semantic and contextual patterns"""
+    def __init__(self):
+        super().__init__("Dr. Semantica", "Semantic Forensics Expert")
+    
+    def analyze(self, text: str) -> Dict:
+        prompt = f"""
+        As {self.role}, {self.expertise}, analyze this text for semantic patterns:
+        
+        {text}
+        
+        Evaluate:
+        1. Metaphor and idiom density
+        2. Contextual anchoring (specific vs vague references)
+        3. Temporal references (specific dates vs generic time)
+        4. Cultural reference depth
+        5. Error patterns (typos vs semantic inconsistencies)
+        
+        Return findings in this format:
+        {{
+            "verdict": "Human/AI/Uncertain",
+            "confidence": "0-100%",
+            "evidence": ["list", "of", "key", "findings"]
+        }}
+        """
+        return self._get_analysis(prompt)
 
-    ⚠️ **Disclaimer:** This analysis has {{confidence}}% accuracy based on current forensic linguistics models.
-    """
+class ForensicCrew:
+    """Orchestrates multiple forensic agents"""
+    def __init__(self):
+        self.agents = [
+            StylometricAgent(),
+            CognitiveAgent(),
+            SemanticAgent()
+        ]
+    
+    def analyze_text(self, text: str) -> str:
+        """Coordinate multi-agent analysis"""
+        if len(text.split()) < 30:
+            return "⚠️ Please provide at least 150 characters for accurate analysis."
+        
+        # Gather all agent findings
+        findings = [agent.analyze(text) for agent in self.agents]
+        
+        # Have the chief analyst synthesize the results
+        return self._synthesize_findings(text, findings)
+    
+    def _synthesize_findings(self, text: str, findings: List[Dict]) -> str:
+        """Have a chief analyst compile the final report"""
+        synthesis_prompt = f"""
+        [TEXT UNDER ANALYSIS]
+        {text}
+        
+        [AGENT FINDINGS]
+        {findings}
+        
+        As Chief Forensic Analyst Dr. Lexica, synthesize these findings into a comprehensive report:
+        
+        # 🕵️‍♂️ Forensic Text Analysis Report (CrewAI Approach)
+        
+        ## 🔍 Composite Verdict
+        **Origin:** {{Human/AI/Inconclusive}}  
+        **Confidence Level:** {{XX%}}  
+        
+        ## 📊 Agent Consensus
+        {self._format_agent_summary(findings)}
+        
+        ## 🧐 Detailed Findings
+        ### 1️⃣ Stylometric Evidence
+        {{Summary of stylometric findings}}
+        
+        ### 2️⃣ Cognitive Patterns
+        {{Summary of cognitive findings}}
+        
+        ### 3️⃣ Semantic Fingerprints
+        {{Summary of semantic findings}}
+        
+        ## 💡 Expert Conclusion
+        {{3-4 sentence authoritative conclusion synthesizing all evidence}}
+        
+        ⚠️ **Disclaimer:** This analysis combines multiple forensic techniques with {self._calculate_confidence(findings)}% consensus confidence.
+        """
+        
+        try:
+            if new_openai:
+                response = client.chat.completions.create(
+                    model="gpt-4",
+                    messages=[
+                        {"role": "system", "content": "You are Dr. Lexica, Chief Forensic Analyst."},
+                        {"role": "user", "content": synthesis_prompt}
+                    ],
+                    temperature=0.1,
+                    max_tokens=800
+                )
+                return response.choices[0].message.content
+            else:
+                response = openai.ChatCompletion.create(
+                    model="gpt-4",
+                    messages=[
+                        {"role": "system", "content": "You are Dr. Lexica, Chief Forensic Analyst."},
+                        {"role": "user", "content": synthesis_prompt}
+                    ],
+                    temperature=0.1,
+                    max_tokens=800
+                )
+                return response['choices'][0]['message']['content']
+        except Exception as e:
+            return f"🔴 Analysis failed. Error: {str(e)}"
+    
+    def _format_agent_summary(self, findings: List[Dict]) -> str:
+        """Format agent findings for the report"""
+        summary = []
+        agent_names = ["Stylometric Analyst", "Cognitive Linguist", "Semantic Expert"]
+        
+        for idx, finding in enumerate(findings):
+            if "error" in finding:
+                summary.append(f"🔴 {agent_names[idx]}: Error - {finding['error']}")
+            else:
+                verdict = finding.get("verdict", "Unknown")
+                confidence = finding.get("confidence", "0%")
+                summary.append(f"🔵 {agent_names[idx]}: {verdict} ({confidence} confidence)")
+        
+        return "\n".join(summary)
+    
+    def _calculate_confidence(self, findings: List[Dict]) -> int:
+        """Calculate average confidence from valid agent responses"""
+        valid = [int(f.get("confidence", "0%").strip('%')) for f in findings if "error" not in f]
+        return sum(valid) // len(valid) if valid else 0
 
-    try:
-        if new_openai:
-            response = client.chat.completions.create(
-                model="gpt-3.5-turbo",  # Fixed model ID
-                messages=[
-                    {"role": "system", "content": "You are a forensic text analysis AI specializing in detecting AI-generated content with extreme precision."},
-                    {"role": "user", "content": expert_prompt}
-                ],
-                temperature=0.1,
-                max_tokens=500
-            )
-            return response.choices[0].message.content
-        else:
-            response = openai.ChatCompletion.create(
-                model="gpt-3.5-turbo",  # Fixed model ID
-                messages=[
-                    {"role": "system", "content": "You are a forensic text analysis AI specializing in detecting AI-generated content with extreme precision."},
-                    {"role": "user", "content": expert_prompt}
-                ],
-                temperature=0.1,
-                max_tokens=500
-            )
-            return response['choices'][0]['message']['content']
-    except Exception as e:
-        return f"🔴 Analysis failed. Error: {str(e)}"
+# Initialize the forensic crew
+crew = ForensicCrew()
 
-# Gradio Interface with enhanced UI
+# Gradio Interface
 with gr.Blocks(theme=gr.themes.Soft(primary_hue="emerald")) as app:
     gr.Markdown("""
-    # 🔬 AI/Human Text Forensic Analyzer
-    *Uncover the true origin of any text using advanced linguistic forensics*
+    # 🔬 AI/Human Text Forensic Analyzer (CrewAI Approach)
+    *Multi-agent forensic analysis combining stylometric, cognitive, and semantic techniques*
     """)
     
     with gr.Row():
@@ -131,10 +257,9 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="emerald")) as app:
                 clear_btn = gr.Button("🔄 Clear")
         
         with gr.Column():
-            output_text = gr.Markdown(label="📜 Analysis Report", 
+            output_text = gr.Markdown(label="📜 CrewAI Analysis Report", 
                                     elem_id="output_panel")
     
-    # Improved examples showcasing different text types
     gr.Examples(
         examples=[
             ["Walking through the old cobblestone streets of Prague last summer, I was struck by how the golden light of dusk made the ancient buildings look like they were glowing from within - a memory that still makes me smile months later."],
@@ -147,7 +272,7 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="emerald")) as app:
     )
     
     analyze_btn.click(
-        fn=analyze_text,
+        fn=crew.analyze_text,
         inputs=input_text,
         outputs=output_text
     )