Create app.py

app.py

@@ -0,0 +1,471 @@
+import gradio as gr
+import os
+import logging
+import pandas as pd
+from typing import Dict, Any, Tuple, Optional
+
+# Import fact-checking utilities
+from utils import (
+    load_verified_facts,
+    fact_check_claim,
+)
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------#
+#  Gradio Fact-Checking Application
+# ---------------------------------------------------------------------------#
+
+# Global state for database initialization
+DATABASE_INITIALIZED = False
+
+
+def initialize_database() -> str:
+    """Initialize the verified facts database."""
+    global DATABASE_INITIALIZED
+
+    logger.info("Database initialization requested")
+
+    if os.path.exists("faiss_index_facts"):
+        DATABASE_INITIALIZED = True
+        logger.info("Database already exists at faiss_index_facts/")
+        return """
+> ## ✅ Database Ready
+>
+> The fact database is **already initialized** and loaded successfully.
+>
+> 📁 **Location:** `faiss_index_facts/`
+
+<br>
+
+**🎯 Next Step:** Go to the **Fact Check** tab to start verifying claims!
+"""
+
+    try:
+        logger.info("Starting database initialization process")
+        status_msg = load_verified_facts()
+        DATABASE_INITIALIZED = True
+        logger.info("Database initialized successfully")
+        return f"""
+> ## ✅ Initialization Complete
+>
+> {status_msg}
+
+<br>
+
+**Status:** 🟢 Ready to verify claims
+
+**🎯 Next Step:** Switch to the **Fact Check** tab to start using the system!
+"""
+    except Exception as e:
+        logger.exception("Database initialization failed")
+        return f"""
+> ## ❌ Initialization Failed
+>
+> **Error Message:**
+> ```
+> {str(e)}
+> ```
+
+<br>
+
+**🔧 Troubleshooting Steps:**
+
+1. ✓ Ensure `verified_facts_db.csv` exists in your project directory
+2. ✓ Verify your `TOGETHER_API_KEY` is set in the `.env` file
+3. ✓ Check your internet connection (required for embedding API)
+4. ✓ Make sure all dependencies are installed: `pip install -r requirements.txt`
+
+<br>
+
+💡 **Need Help?** Check the README.md for detailed setup instructions.
+"""
+
+
+def load_sample_claims() -> list:
+    """Load sample claims from CSV file."""
+    logger.info("Loading sample claims")
+    sample_claims = []
+
+    if os.path.exists("social_media_feed.csv"):
+        try:
+            logger.debug("Reading sample claims from CSV")
+            df = pd.read_csv("social_media_feed.csv")
+            # Handle different column names
+            if 'claim' in df.columns:
+                sample_claims = df['claim'].tolist()[:10]  # First 10 claims
+                logger.info(f"Loaded {len(sample_claims)} sample claims from 'claim' column")
+            elif 'text' in df.columns:
+                sample_claims = df['text'].tolist()[:10]
+                logger.info(f"Loaded {len(sample_claims)} sample claims from 'text' column")
+        except Exception as e:
+            logger.warning(f"Failed to load sample claims from CSV: {str(e)}")
+
+    # Default samples if CSV not available
+    if not sample_claims:
+        logger.info("Using default sample claims")
+        sample_claims = [
+            "The Indian government has announced free electricity to all farmers starting July 2025.",
+            "India's GDP growth rate reached 8.2% in Q1 2024.",
+            "The Reserve Bank of India has reduced interest rates by 2% this month.",
+        ]
+
+    return sample_claims
+
+
+def format_result(result: Dict[str, Any]) -> str:
+    """Format fact-checking results for display."""
+
+    # Verdict with emoji
+    verdict = result.get('verdict', 'Unknown')
+    verdict_emoji = {
+        'Likely True': '✅',
+        'Likely False': '❌',
+        'Unverifiable': '🤷‍♂️',
+        'Unknown': '❓'
+    }.get(verdict, '❓')
+
+    # Confidence indicator
+    confidence = result.get('confidence', 'unknown')
+    confidence_emoji = {
+        'high': '🟢',
+        'medium': '🟡',
+        'low': '🔴'
+    }.get(confidence, '⚪')
+
+    # Build output markdown
+    output = "# 📊 Fact-Check Results\n\n"
+    output += f"> ## {verdict_emoji} Verdict: **{verdict}**\n"
+    output += f">\n"
+    output += f"> **Confidence Level:** {confidence_emoji} {confidence.capitalize()}\n\n"
+
+    # Extracted claim (if different from input)
+    extracted_claim = result.get('extracted_claim', '')
+    original_input = result.get('original_input', '')
+
+    if extracted_claim and extracted_claim != original_input:
+        output += f"### 🎯 Extracted Claim\n"
+        output += f"> {extracted_claim}\n\n"
+
+    # Entities found
+    entities = result.get('entities_found', [])
+    if entities:
+        output += f"### 🏷️ Key Entities Detected\n"
+        entity_list = [f"**{e['text']}** ({e['type']})" for e in entities[:5]]
+        output += ", ".join(entity_list) + "\n\n"
+
+    # Reasoning
+    output += f"### 💭 Reasoning\n"
+    reasoning = result.get('reasoning', 'No reasoning provided')
+    output += f"> {reasoning}\n\n"
+
+    # Evidence from verified sources
+    output += "### 📚 Evidence from Verified Sources\n\n"
+    evidence_details = result.get('evidence_details', [])
+
+    if evidence_details:
+        for i, evidence in enumerate(evidence_details, 1):
+            similarity_pct = evidence['similarity'] * 100
+            output += f"#### Evidence #{i}\n"
+            output += f"**Similarity Score:** {similarity_pct:.1f}%\n\n"
+            output += f"> {evidence['fact']}\n\n"
+            metadata = evidence.get('metadata', {})
+            output += f"- 📰 **Source:** {metadata.get('source', 'Unknown')}\n"
+            output += f"- 📅 **Date:** {metadata.get('date', 'Unknown')}\n"
+            output += f"- 🏷️ **Category:** {metadata.get('category', 'General')}\n"
+
+            # Display extracted entities from database fact
+            entities_dict = metadata.get('entities_dict', {})
+            if entities_dict and any(entities_dict.values()):
+                output += f"- 🏷️ **Entities Found:** "
+                entity_parts = []
+                if entities_dict.get('organizations'):
+                    entity_parts.append(f"Orgs: {', '.join(entities_dict['organizations'][:3])}")
+                if entities_dict.get('locations'):
+                    entity_parts.append(f"Locations: {', '.join(entities_dict['locations'][:3])}")
+                if entities_dict.get('dates'):
+                    entity_parts.append(f"Dates: {', '.join(entities_dict['dates'][:3])}")
+                if entities_dict.get('percentages'):
+                    entity_parts.append(f"Percentages: {', '.join(entities_dict['percentages'][:2])}")
+
+                if entity_parts:
+                    output += " | ".join(entity_parts)
+                else:
+                    output += "None"
+                output += "\n"
+
+            output += "\n"
+    else:
+        output += "> ⚠️ No relevant evidence found in the database\n\n"
+
+    # Evidence used by LLM
+    evidence_used = result.get('evidence_used', [])
+    if evidence_used and evidence_used != ['']:
+        output += "<br>\n\n"
+        output += "### 🎯 Evidence Cited by AI\n\n"
+        for i, ev in enumerate(evidence_used, 1):
+            output += f"{i}. {ev}\n"
+        output += "\n"
+
+    # Error information (if any)
+    if 'error' in result:
+        output += f"\n⚠️ **Note:** {result['error']}\n"
+
+    return output
+
+
+def check_fact(claim: str) -> str:
+    """Check a fact claim and return formatted results."""
+    global DATABASE_INITIALIZED
+
+    logger.info(f"Fact-check requested for claim: {claim[:100]}...")
+
+    # Check if database is initialized
+    if not DATABASE_INITIALIZED:
+        if os.path.exists("faiss_index_facts"):
+            DATABASE_INITIALIZED = True
+            logger.info("Database auto-detected and marked as initialized")
+        else:
+            logger.warning("Database not initialized - prompting user")
+            return "❌ **Error:** Please initialize the fact database first using the button in the Configuration tab."
+
+    # Check if claim is provided
+    if not claim or not claim.strip():
+        logger.warning("Empty claim provided")
+        return "⚠️ **Warning:** Please enter a claim to verify."
+
+    try:
+        logger.info("Running fact-checking pipeline")
+        # Run fact-checking pipeline
+        result = fact_check_claim(claim)
+
+        logger.info(f"Fact-check completed with verdict: {result.get('verdict', 'Unknown')}")
+        # Format and return results
+        return format_result(result)
+
+    except Exception as e:
+        logger.exception("Error during fact-checking in app layer")
+        return f"❌ **Error during fact-checking:** {str(e)}"
+
+
+def use_sample_claim(sample_dropdown: str) -> str:
+    """Return the selected sample claim."""
+    if sample_dropdown and sample_dropdown != "-- Select a sample claim --":
+        return sample_dropdown
+    return ""
+
+
+# ---------------------------------------------------------------------------#
+#  Gradio Interface
+# ---------------------------------------------------------------------------#
+
+def create_interface():
+    """Create and configure the Gradio interface."""
+
+    # Load sample claims
+    sample_claims = load_sample_claims()
+    sample_options = ["-- Select a sample claim --"] + sample_claims
+
+    # Create Gradio Blocks interface
+    with gr.Blocks(title="Fact-Checker") as demo:
+
+        gr.Markdown("# 🔍 Fact-Checker")
+        gr.Markdown("*Verify claims against trusted sources using AI-powered analysis*")
+
+        with gr.Tabs():
+
+            # Main Fact-Checking Tab
+            with gr.Tab("📝 Fact Check"):
+
+                with gr.Row():
+                    with gr.Column(scale=3):
+                        claim_input = gr.Textbox(
+                            label="Enter claim to verify",
+                            placeholder="Example: India's GDP growth rate reached 8.2% in Q1 2024.",
+                            lines=4,
+                            max_lines=10
+                        )
+
+                    with gr.Column(scale=1):
+                        sample_dropdown = gr.Dropdown(
+                            choices=sample_options,
+                            label="📋 Sample Claims",
+                            value="-- Select a sample claim --"
+                        )
+                        use_sample_btn = gr.Button("📝 Use This Sample", size="sm")
+
+                check_btn = gr.Button("🔍 Check Fact", variant="primary", size="lg")
+
+                result_output = gr.Markdown(
+                    value="""
+> ## 👋 Welcome to Fact-Checker!
+>
+> Get started by entering a claim or selecting a sample from the dropdown.
+>
+> ### 🚀 How to Use:
+>
+> 1. **Enter a claim** in the text box above (or select a sample)
+> 2. **Click "Check Fact"** to analyze the claim
+> 3. **Review results** with AI-generated verdict, confidence, and evidence
+
+<br>
+
+💡 **Tip:** Make sure the database is initialized in the Configuration tab before checking facts!
+
+Results will appear here after you check your first claim.
+"""
+                )
+
+                # Button actions
+                check_btn.click(
+                    fn=check_fact,
+                    inputs=[claim_input],
+                    outputs=[result_output]
+                )
+
+                use_sample_btn.click(
+                    fn=use_sample_claim,
+                    inputs=[sample_dropdown],
+                    outputs=[claim_input]
+                )
+
+            # Configuration Tab
+            with gr.Tab("⚙️ Configuration"):
+                gr.Markdown("""
+## 🗄️ Database Initialization
+
+Initialize the verified facts database to enable fact-checking capabilities.
+""")
+
+                init_btn = gr.Button(
+                    "🔄 Initialize Fact Database",
+                    variant="primary",
+                    size="lg"
+                )
+
+                init_output = gr.Markdown(
+                    value="""
+> ## 📋 Ready to Initialize
+>
+> Click the **Initialize Fact Database** button above to:
+>
+> - 📥 Load verified facts from `verified_facts_db.csv`
+> - 🔄 Generate embeddings using Together AI
+> - 💾 Create FAISS vector index for semantic search
+> - ✅ Enable fact-checking capabilities
+
+<br>
+
+💡 **Note:** This is a one-time setup process (unless you delete the `faiss_index_facts` folder).
+"""
+                )
+
+                init_btn.click(
+                    fn=initialize_database,
+                    inputs=[],
+                    outputs=[init_output]
+                )
+
+                gr.Markdown("<br><br>")
+
+                gr.Markdown("""
+## ℹ️ Quick Guide
+
+> ### 📝 Steps to Verify a Claim:
+>
+> 1. **Initialize** the database using the button above (one-time setup)
+> 2. **Navigate** to the "Fact Check" tab
+> 3. **Enter** a claim or select a sample from the dropdown
+> 4. **Click** "Check Fact" to run the verification
+> 5. **Review** the AI-generated verdict with evidence and reasoning
+
+<br>
+
+> ### 🎯 Understanding Results:
+>
+> **Verdict Types:**
+> - ✅ **Likely True** — Evidence supports the claim
+> - ❌ **Likely False** — Evidence contradicts the claim
+> - 🤷‍♂️ **Unverifiable** — Insufficient or conflicting evidence
+>
+> **Confidence Indicators:**
+> - 🟢 **High** — Strong evidence match with verified facts
+> - 🟡 **Medium** — Moderate evidence alignment
+> - 🔴 **Low** — Weak or minimal evidence found
+""")
+
+            # About Tab
+            with gr.Tab("ℹ️ About"):
+                gr.Markdown("""
+                # About Fact-Checker
+
+                This AI-powered fact-checking system verifies claims from news and social media against a database of verified facts using Retrieval-Augmented Generation (RAG).
+
+                ## How It Works
+
+                1. **Claim Extraction**: Uses spaCy NLP to extract key claims and entities
+                2. **Fact Retrieval**: Searches for similar verified facts using FAISS vector database
+                3. **LLM Classification**: Uses Meta-Llama-3.1-8B to classify claims with reasoning
+                4. **Structured Output**: Provides verdict, confidence, evidence, and reasoning
+
+                ## Technology Stack
+
+                - **NLP**: spaCy (en_core_web_sm)
+                - **Embeddings**: BAAI/bge-base-en-v1.5
+                - **Vector DB**: FAISS
+                - **LLM**: Meta-Llama-3.1-8B-Instruct-Turbo (via Together AI)
+                - **UI**: Gradio
+
+                ## Source Code
+
+                This project demonstrates:
+                - Retrieval-Augmented Generation (RAG)
+                - Object-Oriented Programming (SOLID principles)
+                - Prompt Engineering
+                - Production ML System Design
+                """)
+
+        gr.Markdown("---")
+        gr.Markdown("*Built with ❤️ using Gradio, LangChain, and Together AI*")
+
+    return demo
+
+
+# ---------------------------------------------------------------------------#
+#  Main Entry Point
+# ---------------------------------------------------------------------------#
+
+if __name__ == "__main__":
+    logger.info("=" * 60)
+    logger.info("Starting Fact-Checker application")
+    logger.info("=" * 60)
+
+    # Auto-initialize database on startup (for HuggingFace Spaces deployment)
+    if not os.path.exists("faiss_index_facts"):
+        print("🔄 Auto-initializing fact database...")
+        logger.info("Auto-initializing fact database on startup")
+        try:
+            status = initialize_database()
+            print("✅ Database initialized successfully")
+            logger.info("Auto-initialization completed successfully")
+        except Exception as e:
+            print(f"⚠️ Database initialization failed: {str(e)}")
+            logger.error(f"Auto-initialization failed: {str(e)}")
+            print("💡 You can manually initialize from the Configuration tab")
+    else:
+        print("✅ Database already initialized")
+        logger.info("Database detected at startup")
+        DATABASE_INITIALIZED = True
+
+    logger.info("Creating Gradio interface")
+    demo = create_interface()
+
+    logger.info("Launching Gradio app on port 7860")
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        show_error=True
+    )
+    logger.info("Application shutdown")