Update app.py

app.py

@@ -1,171 +1,103 @@
-# -*- coding: utf-8 -*-
-from crewai import Agent, Task, Crew
-from langchain_openai import ChatOpenAI
-import os
 import gradio as gr
-from typing import Tuple
+import openai
+import os
+from dotenv import load_dotenv
 
-# Initialize the LLM - Using GPT-4o-mini for cost-effectiveness
-llm = ChatOpenAI(
-    model='gpt-4-0125-preview',  # GPT-4 Turbo (most cost-effective while powerful)
-    temperature=0.3,  # Lower temperature for more deterministic results
-)
+# Load environment variables
+load_dotenv()
+openai.api_key = os.getenv("OPENAI_API_KEY")  # Set in .env file
 
-def setup_agents() -> Tuple[Agent, Agent, Agent]:
-    """Setup and return the three analysis agents with enhanced prompts"""
+def analyze_text(text):
+    """Advanced analysis using a sophisticated prompt"""
     
-    # 📝 Enhanced Linguistic Pattern Analyzer
-    pattern_analyzer = Agent(
-        role='Senior Linguistic Forensic Analyst',
-        goal='Detect subtle linguistic markers that distinguish human from AI writing',
-        backstory=(
-            "You're a leading expert in forensic linguistics with 15 years experience "
-            "analyzing writing styles. You specialize in identifying subtle patterns in "
-            "word choice, sentence structure, and rhetorical devices that reveal authorship."
-        ),
-        llm=llm,
-        verbose=True
-    )
+    expert_prompt = f"""
+    [ROLE]
+    You are Dr. Textoria, a forensic linguistics expert with 20 years of experience in authorship attribution.
+    Your task is to analyze the following text to determine if it was written by a human or AI.
 
-    # 🔍 Enhanced Coherence Evaluator
-    coherence_evaluator = Agent(
-        role='Cognitive Flow Specialist',
-        goal='Evaluate text for natural human thought progression vs algorithmic patterns',
-        backstory=(
-            "With a PhD in cognitive linguistics, you've published numerous papers on "
-            "how humans naturally organize thoughts in writing. You can spot the "
-            "overly-perfect structure of AI text versus organic human flow."
-        ),
-        llm=llm,
-        verbose=True
-    )
-
-    # 🧠 Enhanced Verdict Compiler
-    verdict_compiler = Agent(
-        role='Chief Detection Analyst',
-        goal='Synthesize all evidence into a weighted, probabilistic assessment',
-        backstory=(
-            "As head of the AI Detection Task Force, you've developed proprietary "
-            "algorithms that combine multiple linguistic dimensions into accurate "
-            "authorship attribution models with confidence scoring."
-        ),
-        llm=llm,
-        verbose=True
-    )
-
-    return pattern_analyzer, coherence_evaluator, verdict_compiler
-
-def analyze_text(input_text: str) -> str:
-    """Analyze text with enhanced tasks and multi-stage verification"""
+    [ANALYSIS CRITERIA]
+    1. Stylometric Features:
+       - Sentence length variation (human: high, AI: low)
+       - Lexical diversity (human: medium-high, AI: very high or very low)
+       - Punctuation patterns (human: irregular, AI: formulaic)
+    
+    2. Cognitive Markers:
+       - Hedges ("perhaps", "maybe") - common in humans
+       - Boosters ("clearly", "obviously") - common in AI
+       - Self-references ("I think", "in my experience")
     
-    # Setup agents
-    pattern_analyzer, coherence_evaluator, verdict_compiler = setup_agents()
+    3. Semantic Features:
+       - Contextual anchoring (human: specific, AI: generic)
+       - Metaphor density (human: moderate, AI: low)
+       - Error patterns (human: typos, AI: coherence breaks)
 
-    # Enhanced Task 1 - Deep Linguistic Analysis
-    task1 = Task(
-        description=(
-            f"Conduct a thorough forensic analysis of this text:\n\n{input_text}\n\n"
-            "Examine: \n"
-            "1. Word rarity and sophistication distribution\n"
-            "2. Pronoun frequency and referential coherence\n"
-            "3. Sentence length variability\n"
-            "4. Presence of idiosyncratic phrasing\n"
-            "5. Burstiness in writing rhythm\n"
-            "Provide specific metrics and comparative analysis."
-        ),
-        expected_output=(
-            "A detailed 4-5 sentence report with:\n"
-            "- Specific linguistic patterns identified\n"
-            "- Statistical observations\n"
-            "- Comparative human/AI likelihood percentages"
-        ),
-        agent=pattern_analyzer
-    )
+    [TEXT TO ANALYZE]
+    {text}
 
-    # Enhanced Task 2 - Cognitive Flow Analysis
-    task2 = Task(
-        description=(
-            f"Analyze the cognitive flow of this text:\n\n{input_text}\n\n"
-            "Evaluate:\n"
-            "1. Idea progression naturalness\n"
-            "2. Contextual depth maintenance\n"
-            "3. Argumentative thread consistency\n"
-            "4. Error patterns (humans make different types)\n"
-            "5. Self-correction frequency"
-        ),
-        expected_output=(
-            "A 4-5 sentence evaluation with:\n"
-            "- Flow consistency score (1-10)\n"
-            "- Notable cognitive patterns\n"
-            "- Human/AI probability estimate"
-        ),
-        agent=coherence_evaluator,
-        depends_on=[task1]
-    )
+    [OUTPUT FORMAT]
+    ## Forensic Analysis Report
+    **Verdict:** {{Human/AI/Uncertain}}
+    **Confidence:** {{XX%}}
 
-    # Enhanced Task 3 - Weighted Verdict
-    task3 = Task(
-        description=(
-            "Synthesize all forensic evidence into a final verdict.\n"
-            "Consider:\n"
-            "1. Linguistic analysis confidence\n"
-            "2. Cognitive flow scores\n"
-            "3. Statistical deviations from human norms\n"
-            "4. Known AI generation patterns\n\n"
-            "Provide a confidence-weighted conclusion."
-        ),
-        expected_output=(
-            "A comprehensive 5-6 line report containing:\n"
-            "- Final determination (Human/AI)\n"
-            "- Confidence percentage (0-100%)\n"
-            "- Key supporting evidence\n"
-            "- Limitations/uncertainties noted"
-        ),
-        agent=verdict_compiler,
-        depends_on=[task1, task2]
-    )
+    ### Key Evidence:
+    1. {{Most significant marker}}
+    2. {{Secondary marker}}
+    3. {{Tertiary marker}}
 
-    # Create and run the Crew with execution timeout
-    crew = Crew(
-        agents=[pattern_analyzer, coherence_evaluator, verdict_compiler],
-        tasks=[task1, task2, task3],
-        memory=True,  # Enable agent memory for context
-        verbose=2  # Detailed execution logging
-    )
+    **Diagnostic Notes:**
+    - {{Interesting observation 1}}
+    - {{Interesting observation 2}}
+
+    **Final Assessment:**
+    {{3-4 sentence expert conclusion}}
+    """
 
     try:
-        result = crew.kickoff(inputs={'input_text': input_text})
-        return result
+        response = openai.ChatCompletion.create(
+            model="gpt-4",
+            messages=[
+                {"role": "system", "content": "You are a forensic text analysis expert."},
+                {"role": "user", "content": expert_prompt}
+            ],
+            temperature=0.2,
+            max_tokens=400
+        )
+        return response.choices[0].message.content
     except Exception as e:
-        return f"Analysis failed: {str(e)}"
+        return f"Error: {str(e)}"
 
-# Enhanced Gradio Interface
-iface = gr.Interface(
-    fn=analyze_text,
-    inputs=gr.Textbox(
-        label="📝 Text to Analyze",
-        placeholder="Paste any text to check if it was written by human or AI...",
-        lines=7
-    ),
-    outputs=gr.Textbox(
-        label="🔍 Analysis Result",
-        lines=10,
-        interactive=False
-    ),
-    title="🤖 Advanced AI Text Detector",
-    description=(
-        "This forensic analysis tool examines writing patterns to determine "
-        "if text was likely written by a human or AI. "
-        "Uses multi-agent analysis with GPT-4o-mini for cost-effective accuracy."
-    ),
-    examples=[
-        ["The quick brown fox jumps over the lazy dog. This simple sentence contains all letters of the English alphabet."],
-        ["While the geopolitical ramifications of decentralized governance structures remain contested, their ontological underpinnings suggest..."],
-        ["I was walking down the street when I saw this cute dog. It made me remember my childhood pet, Sparky, who always..."]
-    ],
-    allow_flagging="never",
-    theme="soft"
-)
+# Gradio Interface
+with gr.Blocks(theme=gr.themes.Soft()) as app:
+    gr.Markdown("# 🔍 Advanced AI/Human Text Analyzer")
+    gr.Markdown("Detect AI-generated content using forensic linguistics")
+    
+    with gr.Row():
+        input_text = gr.Textbox(label="Input Text", lines=5, placeholder="Paste text here (min 100 characters)...")
+        output_text = gr.Markdown(label="Analysis Report")
+    
+    with gr.Row():
+        analyze_btn = gr.Button("Analyze", variant="primary")
+        clear_btn = gr.Button("Clear")
+    
+    examples = gr.Examples(
+        examples=[
+            ["The quick brown fox jumps over the lazy dog. This simple sentence contains all letters of the English alphabet."],
+            ["As I walked through the park yesterday, the crisp autumn leaves crunched beneath my feet, reminding me of childhood visits to my grandmother's house in Vermont."],
+            ["While large language models demonstrate impressive capabilities in text generation, their outputs often lack the subtle cognitive markers characteristic of human authorship."]
+        ],
+        inputs=input_text
+    )
+    
+    analyze_btn.click(
+        fn=analyze_text,
+        inputs=input_text,
+        outputs=output_text
+    )
+    
+    clear_btn.click(
+        fn=lambda: ("", ""),
+        inputs=None,
+        outputs=[input_text, output_text]
+    )
 
-if __name__ == "__main__":
-    iface.launch()
+app.launch()