initial commit

.gitignore

@@ -0,0 +1,56 @@
+# Byte-compiled / cache
+__pycache__/
+*.py[cod]
+*.pyo
+*.pyd
+*.so
+#assets
+assets/
+# Virtual environment
+venv/
+.env/
+.venv/
+ENV/
+env/
+*.env
+
+# Environment & secrets
+.env
+*.env.*
+*.secret
+secrets/
+
+# PyInstaller
+*.spec
+
+# Log files
+*.log
+logs/
+
+# Unit test / coverage
+.coverage
+.cache/
+.pytest_cache/
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+
+# IDEs and editors
+.vscode/
+.idea/
+*.sublime-project
+*.sublime-workspace
+
+# OS-generated files
+.DS_Store
+Thumbs.db
+ehthumbs.db
+desktop.ini
+
+# Python distribution
+build/
+dist/
+*.egg-info/
+*.egg
+

README.md

@@ -0,0 +1,108 @@
+
+# Falcon: Fake News Analysis and Language Comprehension for Online Neutrality
+
+**Falcon** is an advanced Gen AI-powered system designed to analyze, verify, and classify online claims to promote digital content neutrality. Leveraging state-of-the-art language models, it classifies user-submitted text, detects tone and intent, verifies facts using multiple data sources, and generates an informed verdict about claim credibility.
+
+---
+
+## Features
+
+* **Claim Classification**: Classifies input text into categories like Factual Claim, Opinion, Irrelevant Talk, or Vague/Incomplete.
+* **Tone and Intent Detection**: Analyzes the emotional tone and intent behind the claim (e.g., neutral, persuasive, humorous).
+* **Fact Verification**: Verifies factual claims by searching reliable sources like Google (via Serper API) and Wikipedia.
+* **Verdict Generation**: Produces a clear verdict on the claim’s truthfulness based on gathered evidence and reasoning.
+* **Fallback Language Model**: Uses OpenAI’s GPT-4 as the primary LLM and automatically switches to **Deepseek** as a fallback model to ensure high availability and robustness.
+* **Simple Web Interface**: Easy-to-use frontend using HTML, CSS, and JavaScript for seamless user interaction.
+* **FastAPI Backend**: Fast, lightweight API server handling all processing with asynchronous endpoints.
+
+---
+
+## Tech Stack
+
+* **Backend**: FastAPI (Python)
+* **Frontend**: HTML, CSS, JavaScript
+* **Language Models**: OpenAI GPT-4 (primary), Deepseek (fallback)
+* **APIs**: Serper API (Google Search), Wikipedia API
+* **Prompt Engineering**: Carefully crafted templates for accurate and reliable results
+* **Deployment**: Docker containerization (optional)
+
+---
+
+## Project Structure
+
+```
+falcon/
+├── backend/
+│   ├── api/
+│   │   ├── claims.py           # Claim classification logic
+│   │   ├── fact_check.py       # Fact verification logic
+│   │   ├── tone_intent.py      # Tone and intent detection logic
+│   ├── langchain_tools.py      # LangChain prompt templates and LLM wrappers
+│   ├── config.py               # API keys and config variables
+│   └── main.py                 # FastAPI app entry point
+├── frontend/
+│   ├── index.html              # Main UI page
+│   ├── assets/                 # CSS, JS, images
+├── Dockerfile                  # Docker container definition (optional)
+└── README.md                   # This file
+```
+
+---
+
+## Setup Instructions
+
+### Prerequisites
+
+* Python 3.9+
+* FastAPI
+* Uvicorn (ASGI server)
+* OpenAI API key
+* Serper API key
+* Deepseek API key (for fallback)
+
+### Installation
+
+1. Clone the repository:
+
+```bash
+git clone https://github.com/yourusername/falcon.git
+cd falcon
+```
+
+2. Create and activate a virtual environment:
+
+```bash
+python -m venv venv
+source venv/bin/activate   # On Windows: venv\Scripts\activate
+```
+
+3. Install dependencies:
+
+```bash
+pip install -r requirements.txt
+```
+
+4. Configure API keys in `backend/config.py`:
+
+```python
+OPENAI_API_KEY = "your_openai_api_key"
+SERPER_API_KEY = "your_serper_api_key"
+DEEPSEEK_API_KEY = "your_deepseek_api_key"
+```
+
+5. Run the FastAPI server:
+
+```bash
+uvicorn backend.main:app --port 8000
+```
+
+6. Open your browser and visit `http://localhost:8000` to use the Falcon app.
+
+---
+
+## Usage
+
+* Enter a claim or statement in the input form.
+* The system classifies the claim, detects tone and intent, performs fact verification if applicable, and returns a detailed verdict with supporting evidence.
+* The fallback model Deepseek is automatically used if GPT-4 is unavailable, ensuring consistent performance.
+

backend/api/claims.py

@@ -0,0 +1,79 @@
+from langchain.prompts import PromptTemplate
+from backend.langchain_tools import llm, deepseek_tool
+from langchain_core.runnables import RunnableSequence
+import json
+import re
+
+# Prompt Template
+claim_classification_prompt = PromptTemplate.from_template("""
+You are an expert language analyst trained to classify text-based user claims. Your task is to analyze a given piece of text and classify it into one of the following precise categories, based on meaning, structure, and intention:
+
+Classify the following text into one of these categories:
+1. Factual Claim – A statement that can be verified or disproven using evidence.
+2. Opinion – A personal belief or viewpoint that cannot be objectively proven.
+3. Misleading Claim – A statement that could mislead or distort facts.
+4. Exaggeration – A statement that overstates facts or makes things seem more dramatic.
+5. Factoid – A trivial, unverifiable claim that seems factual but lacks evidence.
+6. Question – A statement framed as a question, seeking information.
+7. Joke/Hyperbole – A statement made in jest or exaggeration, not to be taken literally.
+8. Testimonial/Personal Experience – A personal account or anecdote.
+9. Propaganda/Manipulative Claim – A claim designed to manipulate public opinion.
+
+Text: "{claim}"
+
+Respond in JSON format:
+{{
+  "category": "<one of the above categories>",
+  "reasoning": "<brief justification>"
+}}
+""")
+
+# Convert template to runnable chain
+claim_chain: RunnableSequence = claim_classification_prompt | llm
+
+# Store the prompt template string for fallback use
+prompt_template_str = claim_classification_prompt.template
+
+# Classification Function with fallback to DeepSeek-V3
+def classify_claim(claim_text: str) -> dict:
+    try:
+        # Try using the primary LLM model (OpenAI)
+        result = claim_chain.invoke({"claim": claim_text})
+        classification = json.loads(result.content.strip())
+
+        if 'category' not in classification or 'reasoning' not in classification:
+            raise ValueError("Invalid classification format received from the model.")
+
+        return classification
+
+    except Exception as e:
+        # If LLM fails, use DeepSeek-V3 as a fallback
+        try:
+            print(f"Error with LLM: {e}. Falling back to DeepSeek-V3.")
+
+            # Manually construct prompt text
+            deepseek_prompt = prompt_template_str.format(claim=claim_text)
+
+            # Call DeepSeek with input key "input"
+            deepseek_result = deepseek_tool.invoke({"input": deepseek_prompt})
+            print("Raw DeepSeek Output:", deepseek_result)
+
+            # Remove markdown-style code block if present
+            cleaned_output = re.sub(r"```(?:json)?\s*([\s\S]*?)\s*```", r"\1", deepseek_result.strip())
+
+            # Parse cleaned JSON
+            deepseek_classification = json.loads(cleaned_output)
+
+            if 'category' not in deepseek_classification or 'reasoning' not in deepseek_classification:
+                raise ValueError("Invalid classification format received from DeepSeek-V3.")
+
+            return deepseek_classification
+
+        except Exception as fallback_e:
+            return {"error": f"An error occurred with both LLM and DeepSeek-V3: {str(fallback_e)}"}
+
+# Example usage
+if __name__ == "__main__":
+    claim = "modi is prime minister"
+    result = classify_claim(claim)
+    print(result)

backend/api/fact_check.py

@@ -0,0 +1,216 @@
+import os
+import json
+import requests
+from dotenv import load_dotenv
+from backend.langchain_tools import llm, deepseek_tool 
+import re
+from backend.api.claims import classify_claim
+from backend.api.tone_intent import detect_tone_and_intent
+from langchain.prompts import PromptTemplate
+from langchain_core.runnables import RunnableSequence
+import wikipedia
+import logging
+from bs4 import BeautifulSoup
+from sumy.parsers.plaintext import PlaintextParser
+from sumy.nlp.tokenizers import Tokenizer
+from sumy.summarizers.lsa import LsaSummarizer
+import nltk
+
+load_dotenv()
+
+SERPER_API_KEY = os.getenv("SERPER_API_KEY")
+USER_AGENT = {"User-Agent": "Mozilla/5.0"}
+
+# Initialising requests session to reuse connections
+session = requests.Session()
+session.headers.update(USER_AGENT)
+
+# nltk data for tokenization once
+nltk.download('punkt')
+
+logging.basicConfig(level=logging.INFO)
+
+fact_check_prompt = PromptTemplate.from_template("""
+You are an expert fact-checker. Your task is to determine whether the following claim is true or false based on the information available from external sources (Wikipedia and Google search). The claim has already been classified into categories and analyzed for tone/intent.
+
+Claim: "{claim}"
+Classification: "{classification}"
+Tone: "{tone}"
+Intent: "{intent}"
+Wikipedia Evidence: "{wikipedia_evidence}"
+Serper Evidence: "{serper_evidence}"
+
+Fact-checking Task:
+- Based on the evidence from Wikipedia and Serper search results, classify the claim as:
+  1. True
+  2. False
+  3. Uncertain (when there is insufficient evidence)
+
+Respond in JSON format:
+{{
+  "claim": "{claim}",
+  "classification": "{classification}",
+  "tone": "{tone}",
+  "intent": "{intent}",
+  "fact_check_result": "<True/False/Uncertain/Misleading/Exaggerated/Partially True/Inconclusive:: >",
+  "evidence": "<evidence supporting or contradicting the claim>",
+  "sources": [
+    {{
+      "source": "Wikipedia",
+      "url": "<url>"
+    }},
+    {{
+      "source": "Search result",
+      "url": "<serper_url>"
+    }},
+    {{
+      "source": "LLM",
+      "url": "<llm_inferred_url>"
+    }},
+    ...
+  ],
+  "reasoning": "<reasoning for the fact-checking result>"
+}}
+""")
+
+fact_check_chain = fact_check_prompt | llm
+
+# Wikipedia Search Function
+def search_wikipedia(query):
+    try:
+        results = wikipedia.search(query, results=5)
+        if not results:
+            return {"error": "No results found on Wikipedia."}
+        
+        summaries = []
+        for title in results:
+            try:
+                page = wikipedia.page(title)
+                summaries.append({
+                    "title": title, 
+                    "summary": page.summary, 
+                    "url": page.url
+                })
+            except wikipedia.exceptions.DisambiguationError as e:
+                summaries.append({"error": f"Disambiguation: {str(e)}"})
+            except Exception as e:
+                summaries.append({"error": str(e)})
+        return summaries
+    except Exception as e:
+        return {"error": str(e)}
+
+# Fetch search results from Serper API
+def fetch_search_results(query, sentences_count=3):
+    url = "https://google.serper.dev/search"
+    headers = {"X-API-KEY": SERPER_API_KEY}
+    data = {"q": query, "num": 10}
+
+    try:
+        response = session.post(url, json=data, headers=headers)
+        response.raise_for_status()
+        results = response.json()
+
+        if not results.get("organic"):
+            return "Error: No search results found."
+
+        sources = []
+        for result in results.get("organic", [])[:5]:  
+            source_url = result.get("url") or result.get("link")
+            sources.append(source_url)
+        
+        summary = fetch_and_summarize(sources[0], sentences_count) 
+        return summary, sources
+    except requests.exceptions.RequestException as e:
+        return f"Error fetching search results: {e}"
+
+# Summarize content from a Webpage
+def fetch_and_summarize(url, sentences_count=3):
+    try:
+        response = session.get(url, timeout=10)
+        response.raise_for_status()
+        soup = BeautifulSoup(response.text, "html.parser")
+        paragraphs = soup.find_all("p")
+        text = "\n".join([p.get_text() for p in paragraphs])
+
+        if not text.strip():
+            return "Error: No readable content found on the page."
+
+        return summarize_text(text, sentences_count)
+    except requests.exceptions.RequestException as e:
+        return f"Error: Failed to fetch webpage ({str(e)})"
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+# Summarize text using LsaSummarizer
+def summarize_text(text, sentences_count=3):
+    if not text.strip():
+        return "Error: No text provided for summarization."
+
+    parser = PlaintextParser.from_string(text, Tokenizer("english"))
+    summarizer = LsaSummarizer()
+    summary = summarizer(parser.document, sentences_count)
+
+    return " ".join(str(sentence) for sentence in summary)
+
+
+
+def fact_check_claim(claim_text: str) -> dict:
+    try:
+        classification = classify_claim(claim_text)
+        tone_intent = detect_tone_and_intent(claim_text)
+
+        classification_type = classification.get("category", "Unknown")
+        tone = tone_intent.get("tone", "Unknown")
+        intent = tone_intent.get("intent", "Unknown")
+
+        wikipedia_results = search_wikipedia(claim_text)
+        serper_summary, serper_sources = fetch_search_results(claim_text)
+
+        wikipedia_evidence = " ".join([r["summary"] for r in wikipedia_results if "summary" in r])
+
+        sources = []
+
+        for r in wikipedia_results:
+            if "url" in r:
+                sources.append({"source": "Wikipedia", "url": r["url"]})
+        for url in serper_sources:
+            sources.append({"source": "Serper", "url": url})
+
+        try:
+            fact_check_result = fact_check_chain.invoke({
+                "claim": claim_text,
+                "classification": classification_type,
+                "tone": tone,
+                "intent": intent,
+                "wikipedia_evidence": wikipedia_evidence,
+                "serper_evidence": serper_summary
+            })
+
+            result = json.loads(fact_check_result.content.strip())
+            result["sources"] = sources
+            return result
+
+        except Exception as primary_error:
+            logging.warning(f"Primary LLM failed: {primary_error}. Falling back to DeepSeek.")
+
+            deepseek_prompt = fact_check_prompt.template.format(
+                claim=claim_text,
+                classification=classification_type,
+                tone=tone,
+                intent=intent,
+                wikipedia_evidence=wikipedia_evidence,
+                serper_evidence=serper_summary
+            )
+
+            deepseek_result = deepseek_tool.invoke({"input": deepseek_prompt})
+            logging.info(f"Raw DeepSeek Output: {deepseek_result}")
+
+            cleaned_output = re.sub(r"```(?:json)?\s*([\s\S]*?)\s*```", r"\1", deepseek_result.strip())
+
+            result = json.loads(cleaned_output)
+            result["sources"] = sources
+            return result
+
+    except Exception as final_error:
+        logging.error(f"Total failure in fact_check_claim: {final_error}")
+        return {"error": f"Fact-checking failed due to: {str(final_error)}"}

backend/api/tone_intent.py

@@ -0,0 +1,82 @@
+from langchain.prompts import PromptTemplate
+from backend.langchain_tools import llm, deepseek_tool  
+from langchain_core.runnables import RunnableSequence
+import json
+import logging
+import re
+
+logging.basicConfig(level=logging.INFO)
+
+# Prompt Template
+tone_intent_prompt = PromptTemplate.from_template("""
+You are an expert language analyst trained to detect the tone and intent of a given piece of text. Your task is to analyze the text and determine both its tone and intent from the following predefined categories:
+
+Tone Categories:
+1. Neutral
+2. Sarcastic
+3. Clickbait
+4. Propaganda
+5. Aggressive / Toxic
+6. Persuasive
+7. Humorous
+
+Intent Categories:
+1. To Inform
+2. To Persuade
+3. To Deceive
+4. To Express Emotion
+5. To Incite Hate
+6. To Promote Agenda
+
+Text: "{text}"
+
+Respond in JSON format:
+{{
+  "tone": "<one of: Neutral, Sarcastic, Clickbait, Propaganda, Aggressive / Toxic, Persuasive, Humorous>",
+  "intent": "<one of: To Inform, To Persuade, To Deceive, To Express Emotion, To Incite Hate, To Promote Agenda>",
+  "reasoning": "<brief justification for tone and intent>"
+}}
+""")
+
+# RunnableSequence
+tone_intent_chain = tone_intent_prompt | llm
+
+# Store the prompt string for fallback
+prompt_template_str = tone_intent_prompt.template
+
+# Detection function with fallback to DeepSeek-V3
+def detect_tone_and_intent(text: str) -> dict:
+    try:
+        result = tone_intent_chain.invoke({"text": text})
+        detection = json.loads(result.content.strip())
+
+        if 'tone' not in detection or 'intent' not in detection or 'reasoning' not in detection:
+            logging.error(f"Unexpected response format: {result.content.strip()}")
+            return {"error": "Response format is incorrect. Missing required fields."}
+
+        return detection
+
+    except Exception as e:
+        logging.error(f"Error with primary model (LLM): {str(e)}. Falling back to DeepSeek-V3.")
+
+        try:
+            # Create prompt manually for DeepSeek
+            deepseek_prompt = prompt_template_str.format(text=text)
+
+            deepseek_result = deepseek_tool.invoke({"input": deepseek_prompt})
+            logging.info(f"Raw DeepSeek Output: {deepseek_result}")
+
+            cleaned_output = re.sub(r"```(?:json)?\s*([\s\S]*?)\s*```", r"\1", deepseek_result.strip())
+
+            deepseek_detection = json.loads(cleaned_output)
+
+            if 'tone' not in deepseek_detection or 'intent' not in deepseek_detection or 'reasoning' not in deepseek_detection:
+                logging.error(f"Unexpected format from DeepSeek-V3: {cleaned_output}")
+                return {"error": "Response format from DeepSeek-V3 is incorrect. Missing required fields."}
+
+            return deepseek_detection
+
+        except Exception as fallback_e:
+            logging.error(f"Error with both LLM and DeepSeek-V3: {str(fallback_e)}")
+            return {"error": f"An error occurred with both LLM and DeepSeek-V3: {str(fallback_e)}"}
+

backend/api/verdict.py

@@ -0,0 +1,56 @@
+from backend.api.claims import classify_claim
+from backend.api.tone_intent import detect_tone_and_intent
+from backend.api.fact_check import fact_check_claim
+import json
+
+# final verdict function
+def get_final_verdict(claim_text: str) -> dict:
+    try:
+        # Classify the claim
+        classification = classify_claim(claim_text)
+        classification_type = classification.get("category", "Unknown")
+
+        # If the claim is not a factual claim, return an early verdict
+        if classification_type != "Factual Claim":
+            return {
+                "claim": claim_text,
+                "classification": classification_type,
+                "verdict": "Claim is not factual.",
+                "reasoning": "The claim does not fall under factual category. It is an opinion, irrelevant, or vague."
+            }
+
+        # Detect the tone of the claim
+        tone_intent = detect_tone_and_intent(claim_text)
+        tone = tone_intent.get("tone", "Unknown")
+
+        # If the tone is positive (Neutral, Persuasive, Humorous), proceed to fact-check
+        if tone in ["Neutral", "Persuasive", "Humorous"]:
+            fact_check_result = fact_check_claim(claim_text)
+            
+            # Fact-checking results
+            verdict = fact_check_result.get("fact_check_result", "Unknown")
+            evidence = fact_check_result.get("evidence", "No evidence available.")
+            sources = fact_check_result.get("sources", [])
+            reasoning = fact_check_result.get("reasoning", "No reasoning available.")
+            
+            return {
+                "claim": claim_text,
+                "classification": classification_type,
+                "tone": tone,
+                "fact_check_result": verdict,
+                "evidence": evidence,
+                "sources": sources,
+                "reasoning": reasoning
+            }
+        else:
+            return {
+                "claim": claim_text,
+                "classification": classification_type,
+                "tone": tone,
+                "verdict": "Claim has a non-positive tone.",
+                "reasoning": "The claim's tone is considered negative or misleading, hence not processed for fact-checking."
+            }
+
+    except Exception as e:
+        return {"error": f"An error occurred while processing the claim: {str(e)}"}
+

backend/config.py

@@ -0,0 +1,17 @@
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+SERPER_API_KEY = os.getenv("SERPER_API_KEY")
+TOGETHER_API_KEY = os.getenv("TOGETHER_API_KEY")
+
+if not OPENAI_API_KEY:
+    raise ValueError("OPENAI_API_KEY is not set in environment variables or .env file")
+if not SERPER_API_KEY:
+    raise ValueError("SERPER_API_KEY is not set in environment variables or .env file")
+if not TOGETHER_API_KEY:
+    raise ValueError("TOGETHER_API_KEY is not set in environment variables or .env file")
+
+

backend/langchain_tools.py

@@ -0,0 +1,110 @@
+from langchain_openai import ChatOpenAI  
+from langchain.agents import Tool
+from langchain_community.utilities import WikipediaAPIWrapper
+import requests
+import os
+from backend.config import OPENAI_API_KEY, SERPER_API_KEY
+
+llm = ChatOpenAI(
+    model="gpt-3.5-turbo",                
+    temperature=0,                
+    openai_api_key=OPENAI_API_KEY  
+)
+
+
+import wikipedia
+from langchain.tools import Tool
+
+def search_wikipedia(query):
+    try:
+        results = wikipedia.search(query, results=10)  # Fetch top 10 results
+        if not results:
+            return {"error": "No results found on Wikipedia."}
+        
+        summaries = []
+        for title in results:
+            try:
+                page = wikipedia.page(title)
+                summary = page.summary
+                url = page.url
+                summaries.append({"title": title, "summary": summary, "url": url})
+            except wikipedia.exceptions.DisambiguationError as e:
+                summaries.append({"error": f"Disambiguation: {str(e)}"})
+            except wikipedia.exceptions.HTTPTimeoutError:
+                summaries.append({"error": "Wikipedia request timed out."})
+            except Exception as e:
+                summaries.append({"error": str(e)})
+        return summaries
+    except Exception as e:
+        return {"error": str(e)}
+
+# Define the Wikipedia Tool
+wiki_tool = Tool.from_function(
+    func=search_wikipedia,
+    name="WikipediaAPI",
+    description="Fetch summaries from Wikipedia based on search query"
+)
+
+
+from langchain.tools import Tool
+
+def fetch_search_results(query):
+    url = "https://google.serper.dev/search"
+    headers = {
+        "X-API-KEY": SERPER_API_KEY,
+        "Content-Type": "application/json"
+    }
+    
+    data = {
+        "q": query,
+        "num": 10  
+    }
+
+    try:
+        response = requests.post(url, json=data, headers=headers)
+        if response.status_code == 200:
+            return response.json()
+        else:
+            return {"error": f"Serper API error: {response.status_code}"}
+    except requests.exceptions.RequestException as e:
+        return {"error": f"Request failed: {str(e)}"}
+
+# Define the Serper Tool
+serper_tool = Tool.from_function(
+    func=fetch_search_results,
+    name="SerperAPI",
+    description="Search the web using the Serper API"
+)
+
+
+from together import Together
+from backend.config import TOGETHER_API_KEY  
+
+client = Together(api_key=TOGETHER_API_KEY)
+
+def deepseek_v3_query(query):
+    try:
+        response = client.chat.completions.create(
+            model="deepseek-ai/DeepSeek-V3",  # DeepSeek-V3 model from Together
+            messages=[{"role": "user", "content": query}],
+            stream=True
+        )
+
+        result = ""
+        for token in response:
+            if hasattr(token, 'choices'):
+                result += token.choices[0].delta.content
+        return result
+    except Exception as e:
+        return {"error": f"DeepSeek-V3 API error: {str(e)}"}
+
+# Define the DeepSeek-V3 Tool
+deepseek_tool = Tool.from_function(
+    func=deepseek_v3_query,
+    name="DeepSeekV3",
+    description="Query DeepSeek-V3 AI model from Together for advanced text completions"
+)
+
+
+# 5. Group tools together
+search_tools = [wiki_tool, serper_tool, deepseek_tool]

backend/langchain_tools1.py

@@ -0,0 +1,114 @@
+from langchain_openai import ChatOpenAI  # Corrected import
+from langchain.agents import Tool
+from langchain_community.utilities import WikipediaAPIWrapper
+import requests
+import os
+from backend.config import OPENAI_API_KEY, SERPER_API_KEY
+
+# 1. Setup OpenAI Chat Model (using GPT-4)
+llm = ChatOpenAI(
+    model="gpt-3.5-turbo",                
+    temperature=0,                
+    openai_api_key=OPENAI_API_KEY  
+)
+
+# 2. Wikipedia Tool for Fact-Checking
+import wikipedia
+from langchain.tools import Tool
+
+def search_wikipedia(query):
+    try:
+        results = wikipedia.search(query, results=10)  # Fetch top 10 results
+        if not results:
+            return {"error": "No results found on Wikipedia."}
+        
+        summaries = []
+        for title in results:
+            try:
+                page = wikipedia.page(title)
+                summary = page.summary
+                url = page.url
+                summaries.append({"title": title, "summary": summary, "url": url})
+            except wikipedia.exceptions.DisambiguationError as e:
+                summaries.append({"error": f"Disambiguation: {str(e)}"})
+            except wikipedia.exceptions.HTTPTimeoutError:
+                summaries.append({"error": "Wikipedia request timed out."})
+            except Exception as e:
+                summaries.append({"error": str(e)})
+        return summaries
+    except Exception as e:
+        return {"error": str(e)}
+
+# Define the Wikipedia Tool
+wiki_tool = Tool.from_function(
+    func=search_wikipedia,
+    name="WikipediaAPI",
+    description="Fetch summaries from Wikipedia based on search query"
+)
+
+
+# 3. Serper Search Tool (Google-like Search)
+from langchain.tools import Tool
+
+def fetch_search_results(query):
+    url = "https://google.serper.dev/search"
+    headers = {
+        "X-API-KEY": SERPER_API_KEY,
+        "Content-Type": "application/json"
+    }
+    
+    data = {
+        "q": query,
+        "num": 10  # Get 10 results
+    }
+
+    try:
+        response = requests.post(url, json=data, headers=headers)
+        if response.status_code == 200:
+            return response.json()
+        else:
+            return {"error": f"Serper API error: {response.status_code}"}
+    except requests.exceptions.RequestException as e:
+        return {"error": f"Request failed: {str(e)}"}
+
+# Define the Serper Tool
+serper_tool = Tool.from_function(
+    func=fetch_search_results,
+    name="SerperAPI",
+    description="Search the web using the Serper API"
+)
+
+
+# 4. DeepSeek-V3 Tool (Integration with Together API)
+from together import Together
+from backend.config import TOGETHER_API_KEY  # Ensure you have this in your .env or config file
+
+# Initialize Together client with the API key
+client = Together(api_key=TOGETHER_API_KEY)
+
+def deepseek_v3_query(query):
+    try:
+        response = client.chat.completions.create(
+            model="deepseek-ai/DeepSeek-V3",  # DeepSeek-V3 model from Together
+            messages=[{"role": "user", "content": query}],
+            stream=True
+        )
+
+        result = ""
+        for token in response:
+            if hasattr(token, 'choices'):
+                result += token.choices[0].delta.content
+        return result
+    except Exception as e:
+        return {"error": f"DeepSeek-V3 API error: {str(e)}"}
+
+# Define the DeepSeek-V3 Tool
+deepseek_tool = Tool.from_function(
+    func=deepseek_v3_query,
+    name="DeepSeekV3",
+    description="Query DeepSeek-V3 AI model from Together for advanced text completions"
+)
+
+
+# 5. Group tools together
+search_tools = [wiki_tool, serper_tool, deepseek_tool]

backend/main.py

@@ -0,0 +1,61 @@
+
+from fastapi import FastAPI, Form, Request
+from fastapi.responses import HTMLResponse
+from fastapi.templating import Jinja2Templates
+from backend.api.fact_check import fact_check_claim  
+from backend.api.claims import classify_claim
+from backend.api.tone_intent import detect_tone_and_intent
+import json
+
+app = FastAPI()
+
+
+
+# Jinja2 templates for rendering HTML pages
+templates = Jinja2Templates(directory="frontend")
+from pathlib import Path
+from fastapi.staticfiles import StaticFiles
+
+BASE_DIR = Path(__file__).resolve().parent
+STATIC_DIR = BASE_DIR.parent / "frontend" / "assets"
+app.mount("/static", StaticFiles(directory=STATIC_DIR), name="static")
+
+
+@app.get("/", response_class=HTMLResponse)
+async def read_root(request: Request):
+    return templates.TemplateResponse("index.html", {"request": request})
+
+@app.post("/process_claim")
+async def process_claim(claim: str = Form(...)):
+    # Classify the claim
+    classification = classify_claim(claim)
+    classification_type = classification.get("category", "Unknown")
+
+    # Detect the tone and intent of the claim
+    tone_intent = detect_tone_and_intent(claim)
+    tone = tone_intent.get("tone", "Unknown")
+    intent = tone_intent.get("intent", "Unknown")
+
+    # fact-check the claim if it's factual and tone is positive
+    if classification_type in ["Factual Claim", "Misleading Claim", "Factoid"]  and tone in ["Neutral", "Persuasive", "Humorous"]:
+        fact_check_result = fact_check_claim(claim)
+        verdict = fact_check_result.get("fact_check_result", "Unknown")
+        evidence = fact_check_result.get("evidence", "No evidence available.")
+        sources = fact_check_result.get("sources", [])
+        reasoning = fact_check_result.get("reasoning", "No reasoning available.")
+    else:
+        verdict = "Not Fact-Checked"
+        evidence = "Claim is either not factual or has a non-positive tone."
+        sources = []
+        reasoning = "The claim either isn’t factual or has a misleading tone, hence skipped from fact-checking."
+
+    return {
+        "claim": claim,
+        "classification": classification_type,
+        "tone": tone,
+        "intent": intent,
+        "fact_check_result": verdict,
+        "evidence": evidence,
+        "sources": sources,
+        "reasoning": reasoning
+    }

frontend/index.html

@@ -0,0 +1,802 @@
+<html lang="en">
+
+<head>
+    <meta charset="utf-8" />
+    <meta name="description"
+        content="FALCON is an AI-powered tool for verifying the authenticity of claims. Check if a claim is factual, misleading, or opinion-based using trusted data sources.">
+    <meta name="keywords"
+        content="AI fact-checking, claim verification, fake news detection, NLP models, fact-checking tool, verify claims">
+
+    <meta content="width=device-width, initial-scale=1" name="viewport" />
+    <title>FALCON - Fake news Analysis and Language Comprehension for Online Neutrality </title>
+    <script src="https://cdn.tailwindcss.com"></script>
+    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;600&display=swap" rel="stylesheet" />
+    <link href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/5.15.3/css/all.min.css" rel="stylesheet" />
+    <style>
+        html {
+            scroll-behavior: smooth;
+        }
+
+        body {
+            font-family: "Inter", sans-serif;
+            background-color: #0c1a36;
+            /* dark blue background */
+            color: #ffffff;
+            /* white text */
+            min-height: 100vh;
+            display: flex;
+            flex-direction: column;
+        }
+
+        /* Fade-in animation */
+        .fade-in {
+            animation: fadeIn 0.8s ease forwards;
+            opacity: 0;
+        }
+
+        @keyframes fadeIn {
+            to {
+                opacity: 1;
+            }
+        }
+
+        /* Stylish button hover and focus */
+        button,
+        a.button-link {
+            position: relative;
+            overflow: hidden;
+            transition: color 0.3s ease;
+            z-index: 0;
+        }
+
+        button::before,
+        a.button-link::before {
+            content: "";
+            position: absolute;
+            top: 50%;
+            left: 50%;
+            width: 0;
+            height: 300%;
+            background: #2563eb;
+            transform: translate(-50%, -50%) rotate(45deg);
+            transition: width 0.4s ease;
+            z-index: -1;
+            border-radius: 12px;
+        }
+
+        button:hover::before,
+        button:focus::before,
+        a.button-link:hover::before,
+        a.button-link:focus::before {
+            width: 250%;
+        }
+
+        button:hover,
+        button:focus,
+        a.button-link:hover,
+        a.button-link:focus {
+            color: #dbeafe;
+            outline: none;
+            box-shadow: 0 0 12px #3b82f6;
+        }
+
+        /* Input and textarea focus glow */
+        input:focus,
+        textarea:focus {
+            box-shadow: 0 0 8px #3b82f6;
+            border-color: #3b82f6;
+            background-color: #142a5c;
+            color: #ffffff;
+        }
+
+        /* Scrollbar styling for result panel */
+        .result-scrollbar::-webkit-scrollbar {
+            height: 6px;
+        }
+
+        .result-scrollbar::-webkit-scrollbar-track {
+            background: #142a5c;
+            border-radius: 3px;
+        }
+
+        .result-scrollbar::-webkit-scrollbar-thumb {
+            background: #3b82f6;
+            border-radius: 3px;
+        }
+
+        /* Override Tailwind default whites for backgrounds and borders */
+        header,
+        footer,
+        section.bg-white {
+            background-color: #142a5c;
+            /* darker blue slate */
+        }
+
+        header {
+            box-shadow: 0 2px 15px rgb(59 130 246 / 0.6);
+        }
+
+        footer {
+            border-top-color: #1e3a8a;
+        }
+
+        section.bg-white {
+            box-shadow: 0 4px 25px rgb(59 130 246 / 0.6);
+        }
+
+        input,
+        button,
+        textarea {
+            background-color: #0c1a36;
+            border-color: #3b82f6;
+            color: #ffffff;
+        }
+
+        input::placeholder,
+        textarea::placeholder {
+            color: #a5b4fc;
+        }
+
+        /* Result section styled like other sections */
+        #result {
+            background-color: #142a5c;
+            border-radius: 1rem;
+            box-shadow: 0 4px 25px rgb(59 130 246 / 0.6);
+            padding: 2.5rem 3rem;
+            max-width: 920px;
+            margin-left: auto;
+            margin-right: auto;
+            opacity: 0;
+            pointer-events: none;
+            transition: opacity 0.5s ease;
+            color: #dbeafe;
+            font-family: "Inter", sans-serif;
+        }
+
+        #result.visible {
+            opacity: 1;
+            pointer-events: auto;
+        }
+
+        #result h2 {
+            font-size: 2rem;
+            font-weight: 700;
+            margin-bottom: 1.5rem;
+            color: #bfdbfe;
+            text-align: center;
+            user-select: none;
+        }
+
+        #result p {
+            font-size: 1rem;
+            line-height: 1.6;
+            margin-bottom: 1rem;
+            user-select: text;
+        }
+
+        #result p span.font-semibold {
+            color: #93c5fd;
+            font-weight: 600;
+        }
+
+        /* Link styling in result */
+        #sources a {
+            color: #bfdbfe;
+            font-weight: 600;
+            transition: color 0.3s ease;
+        }
+
+        #sources a:hover,
+        #sources a:focus {
+            color: #60a5fa;
+            outline: none;
+            text-decoration: underline;
+        }
+
+        /* Header nav link underline on hover with animation */
+        nav a {
+            position: relative;
+            padding-bottom: 0.25rem;
+            color: #ffffff;
+            font-weight: 600;
+            transition: color 0.3s ease;
+        }
+
+        nav a::after {
+            content: "";
+            position: absolute;
+            width: 0%;
+            height: 3px;
+            bottom: 0;
+            left: 0;
+            background: linear-gradient(90deg, #3b82f6, #60a5fa);
+            transition: width 0.4s cubic-bezier(0.4, 0, 0.2, 1);
+            border-radius: 3px;
+        }
+
+        nav a:hover,
+        nav a:focus {
+            color: #60a5fa;
+            outline: none;
+        }
+
+        nav a:hover::after,
+        nav a:focus::after {
+            width: 100%;
+        }
+
+        /* Loading animation - rotating rings */
+        #loadingScreen {
+            background-color: #0c1a36;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            z-index: 50;
+        }
+
+        .loader {
+            position: relative;
+            width: 64px;
+            height: 64px;
+            animation: rotate 1.5s linear infinite;
+        }
+
+        .loader div {
+            position: absolute;
+            border: 4px solid transparent;
+            border-top-color: #3b82f6;
+            border-radius: 50%;
+            animation: spin 1s ease-in-out infinite;
+        }
+
+        .loader div:nth-child(1) {
+            width: 64px;
+            height: 64px;
+            top: 0;
+            left: 0;
+            animation-delay: -0.2s;
+        }
+
+        .loader div:nth-child(2) {
+            width: 48px;
+            height: 48px;
+            top: 8px;
+            left: 8px;
+            border-top-color: #60a5fa;
+            animation-delay: -0.4s;
+        }
+
+        .loader div:nth-child(3) {
+            width: 32px;
+            height: 32px;
+            top: 16px;
+            left: 16px;
+            border-top-color: #93c5fd;
+            animation-delay: -0.6s;
+        }
+
+        @keyframes rotate {
+            100% {
+                transform: rotate(360deg);
+            }
+        }
+
+        @keyframes spin {
+
+            0%,
+            100% {
+                transform: rotate(0deg);
+            }
+
+            50% {
+                transform: rotate(180deg);
+            }
+        }
+
+        /* Form error styling */
+        #error {
+            color: #f87171;
+            font-weight: 600;
+            user-select: none;
+        }
+
+        /* Input and button width */
+        #formSection form input[type="text"] {
+            max-width: 900px;
+            width: 100%;
+        }
+
+        #formSection form button {
+            max-width: 900px;
+            width: 100%;
+        }
+
+        #formSection {
+            max-width: 920px;
+        }
+
+        /* Responsive adjustments */
+        @media (max-width: 1024px) {
+            #formSection {
+                max-width: 100%;
+                padding-left: 1.5rem;
+                padding-right: 1.5rem;
+            }
+
+            #result {
+                max-width: 100%;
+                padding-left: 1.5rem;
+                padding-right: 1.5rem;
+            }
+        }
+
+        /* Loading overlay for analyze button */
+        #analyzeLoadingOverlay {
+            position: absolute;
+            inset: 0;
+            background: rgba(14, 42, 94, 0.7);
+            border-radius: 0.5rem;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            pointer-events: none;
+            opacity: 0;
+            transition: opacity 0.3s ease;
+            z-index: 10;
+        }
+
+        #analyzeLoadingOverlay.visible {
+            opacity: 1;
+            pointer-events: auto;
+        }
+
+        /* Spinner for analyze button */
+        .btn-spinner {
+            border: 3px solid transparent;
+            border-top-color: #60a5fa;
+            border-radius: 50%;
+            width: 24px;
+            height: 24px;
+            animation: spinBtn 1s linear infinite;
+        }
+
+        @keyframes spinBtn {
+            0% {
+                transform: rotate(0deg);
+            }
+
+            100% {
+                transform: rotate(360deg);
+            }
+        }
+
+        /* Position relative for button container */
+        .button-container {
+            position: relative;
+            display: inline-block;
+            width: 100%;
+        }
+    </style>
+</head>
+
+<body class="flex flex-col min-h-screen">
+    <!-- Loading Screen -->
+    <div aria-label="Loading animation" class="fixed inset-0 flex justify-center items-center" id="loadingScreen">
+        <div class="loader" aria-hidden="true">
+            <div></div>
+            <div></div>
+            <div></div>
+        </div>
+    </div>
+
+    <!-- Header -->
+    <header aria-label="Primary Navigation" class="w-full bg-[#142a5c] shadow-md sticky top-0 z-40" role="banner">
+        <nav aria-label="Main navigation"
+            class="max-w-7xl mx-auto px-6 sm:px-8 lg:px-12 flex items-center justify-between h-18">
+            <a aria-label="FALCON Home"
+                class="flex items-center space-x-3 focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-indigo-500"
+                href="#home">
+                <img alt="FALCON logo "
+                    class="w-50 h-50 rounded-md" height="64" loading="lazy" src="/static/falcon-logo.svg" width="100" />
+
+                <span class="text-3xl font-extrabold select-none text-white tracking-wide">FALCON</span>
+            </a>
+            <button aria-controls="primary-navigation" aria-expanded="false"
+                class="sm:hidden text-white focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-indigo-500"
+                id="navToggle">
+                <svg aria-hidden="true" class="w-7 h-7" fill="none" stroke="currentColor" viewBox="0 0 24 24"
+                    xmlns="http://www.w3.org/2000/svg">
+                    <path d="M4 8h16M4 16h16" stroke-linecap="round" stroke-linejoin="round" stroke-width="2"></path>
+                </svg>
+                <span class="sr-only">Toggle navigation menu</span>
+            </button>
+            <ul class="hidden sm:flex space-x-10 font-medium text-lg" id="primary-navigation">
+                <li>
+                    <a class="hover:text-[#60a5fa] focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-indigo-500 rounded"
+                        href="#home">Home</a>
+                </li>
+                <li>
+                    <a class="hover:text-[#60a5fa] focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-indigo-500 rounded"
+                        href="#about">About Us</a>
+                </li>
+                <li>
+                    <a class="hover:text-[#60a5fa] focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-indigo-500 rounded"
+                        href="#contact">Contact Us</a>
+                </li>
+            </ul>
+        </nav>
+        <!-- Mobile menu -->
+        <div aria-label="Mobile navigation menu" class="sm:hidden bg-[#142a5c] border-t border-blue-900 hidden"
+            id="mobileMenu" role="menu">
+            <ul class="flex flex-col space-y-2 px-6 py-4 font-medium text-lg">
+                <li>
+                    <a class="block py-2 hover:text-[#60a5fa] focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-indigo-500 rounded"
+                        href="#home" role="menuitem">Home</a>
+                </li>
+                <li>
+                    <a class="block py-2 hover:text-[#60a5fa] focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-indigo-500 rounded"
+                        href="#about" role="menuitem">About Us</a>
+                </li>
+                <li>
+                    <a class="block py-2 hover:text-[#60a5fa] focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-indigo-500 rounded"
+                        href="#contact" role="menuitem">Contact Us</a>
+                </li>
+            </ul>
+        </div>
+    </header>
+
+    <!-- Main Content -->
+    <main class="flex-grow max-w-7xl mx-auto px-6 sm:px-8 lg:px-12 py-12 fade-in" id="mainContent" tabindex="-1">
+        <!-- Home Section -->
+        <section id="home" class="mb-20">
+            <div class="bg-[#142a5c] rounded-xl shadow-lg p-10 flex flex-col items-center text-center space-y-6">
+                <h1 class="text-5xl font-extrabold select-none leading-tight text-white drop-shadow-lg">
+                    FALCON : AI-Powered Claim Fact-Checker
+                </h1>
+                <p class="max-w-3xl text-lg text-blue-200">
+                    Instantly verify the accuracy of claims with FALCON, an advanced AI-powered fact-checking tool.
+                    Powered by NLP and trusted data sources, FALCON helps detect factual, misleading, or opinion-based
+                    content with ease.
+                </p><img alt="FALCON logo"
+                    class=" rounded-md" height="64" loading="lazy" src="/static/falcon-logo.svg" width="200" />
+                <a href="#formSection"
+                    class="button-link inline-block bg-transparent border-2 border-[#3b82f6] text-white font-semibold rounded-md py-3 px-8 transition focus:outline-none focus:ring-4 focus:ring-[#2563eb]"
+                    title="Start fact-checking claims now">
+                    Start Fact-Checking
+                </a>
+            </div>
+        </section>
+
+
+        <!-- Form Section -->
+        <section id="formSection" aria-labelledby="formTitle"
+            class="bg-[#142a5c] rounded-xl shadow-lg p-8 sm:p-10 mx-auto mb-20 max-w-[920px]">
+            <h2 class="sr-only" id="formTitle">Check your claim</h2>
+            <form class="space-y-6" id="claimForm" novalidate>
+                <label class="block text-white font-semibold text-lg mb-2" for="claim">Enter a Claim (max 350
+                    characters):</label>
+                <input aria-describedby="charCount"
+                    class="w-full rounded-md border border-[#3b82f6] px-4 py-3 text-white placeholder-blue-300 focus:outline-none focus:ring-2 focus:ring-[#60a5fa] focus:border-[#60a5fa] transition"
+                    id="claim" maxlength="350" name="claim" placeholder="Type your claim here..." required type="text"
+                    spellcheck="false" autocomplete="off" />
+                <p aria-atomic="true" aria-live="polite" class="text-sm text-blue-300 select-none" id="charCount">
+                    350 characters remaining
+                </p>
+                <div class="button-container">
+                    <button aria-label="Check Claim"
+                        class="button-link w-full bg-transparent border-2 border-[#3b82f6] text-white font-semibold rounded-md py-3 transition focus:outline-none focus:ring-4 focus:ring-[#2563eb] flex justify-center items-center space-x-3"
+                        type="submit">
+                        <span>Check Claim</span>
+                    </button>
+                    <div id="analyzeLoadingOverlay" aria-hidden="true" class="rounded-md">
+                        <div class="btn-spinner" aria-label="Loading"></div>
+                    </div>
+                </div>
+            </form>
+        </section>
+
+        <!-- Result Section -->
+        <section aria-atomic="true" aria-live="polite" id="result" tabindex="0" aria-label="Fact check result output"
+            class="mb-20">
+            <h2>Result</h2>
+            <div class="space-y-4">
+                <p><span class="font-semibold">Claim:</span> <span id="claimText"></span></p>
+                <p><span class="font-semibold">Classification:</span> <span id="classification"></span></p>
+                <p><span class="font-semibold">Tone:</span> <span id="tone"></span></p>
+                <p><span class="font-semibold">Intent:</span> <span id="intent"></span></p>
+                <p><span class="font-semibold">Fact-Check Result:</span> <span id="factCheckResult"></span></p>
+                <p><span class="font-semibold">Evidence:</span> <span id="evidence"></span></p>
+                <p><span class="font-semibold">Sources:</span> <span id="sources" class="underline"></span></p>
+                <p><span class="font-semibold">Reasoning:</span> <span id="reasoning"></span></p>
+            </div>
+        </section>
+
+        <section id="about" class="bg-[#142a5c] rounded-xl shadow-lg p-10 max-w-4xl mx-auto mb-20"
+            aria-labelledby="aboutTitle">
+            <h2 id="aboutTitle" class="text-3xl font-semibold mb-6 text-center select-none text-white drop-shadow-md">
+                About Us</h2>
+            <div class="flex flex-col sm:flex-row sm:space-x-10 items-center sm:items-start">
+                <!-- Icons & Short Descriptions -->
+                <div class="flex space-x-6 mb-8 sm:mb-0 justify-center sm:justify-start w-full sm:w-auto">
+                    <div class="flex flex-col items-center space-y-3 text-white drop-shadow-md max-w-xs">
+                        <i class="fas fa-robot fa-3x"></i>
+                        <p class="text-center">AI-powered fake news detection</p>
+                    </div>
+                    <div class="flex flex-col items-center space-y-3 text-white drop-shadow-md max-w-xs">
+                        <i class="fas fa-shield-alt fa-3x"></i>
+                        <p class="text-center">Reliable, trustworthy fact-checking</p>
+                    </div>
+                    <div class="flex flex-col items-center space-y-3 text-white drop-shadow-md max-w-xs">
+                        <i class="fas fa-users fa-3x"></i>
+                        <p class="text-center">Committed to transparency & accuracy</p>
+                    </div>
+                </div>
+                <!-- Short Description Text -->
+                <div class="text-blue-100 max-w-xl text-center sm:text-left">
+                    <p>
+                        FALCON is an AI-powered fact-checking platform designed to quickly verify claims, detect
+                        misinformation,
+                        and provide users with reliable results. It uses AI-driven analysis to classify claims, assess
+                        tone and intent,
+                        and fact-check the information based on trusted sources.
+                    </p>
+                    <p class="mt-4">
+                        Our goal is to empower users with accurate, timely information, helping to build a more
+                        informed, responsible society
+                        by combating fake news and misinformation effectively.
+                    </p>
+                    <p class="mt-4">
+                        FALCON is developed by <strong>Saksham Pathak</strong>, a student currently pursuing his
+                        Master's degree at IIIT Lucknow.
+                    </p>
+                </div>
+
+
+            </div>
+        </section>
+
+
+
+
+        <!-- Contact Us Section -->
+        <section id="contact" class="bg-[#142a5c] rounded-xl shadow-lg p-10 max-w-3xl mx-auto mb-20"
+            aria-labelledby="contactTitle">
+            <h2 id="contactTitle" class="text-3xl font-semibold mb-6 text-center select-none text-white drop-shadow-md">
+                Contact Us
+            </h2>
+            <form id="contactForm" class="space-y-6" novalidate>
+                <div>
+                    <label for="name" class="block mb-2 font-semibold text-white">Name</label>
+                    <input type="text" id="name" name="name" placeholder="Your name" required
+                        class="w-full rounded-md border border-[#3b82f6] px-4 py-3 text-white placeholder-blue-300 focus:outline-none focus:ring-2 focus:ring-[#60a5fa] focus:border-[#60a5fa] transition"
+                        spellcheck="false" autocomplete="off" />
+                </div>
+                <div>
+                    <label for="email" class="block mb-2 font-semibold text-white">Email</label>
+                    <input type="email" id="email" name="email" placeholder="yourname@gmail.com" required
+                        class="w-full rounded-md border border-[#3b82f6] px-4 py-3 text-white placeholder-blue-300 focus:outline-none focus:ring-2 focus:ring-[#60a5fa] focus:border-[#60a5fa] transition"
+                        spellcheck="false" autocomplete="off" />
+                </div>
+                <div>
+                    <label for="message" class="block mb-2 font-semibold text-white">Message</label>
+                    <textarea id="message" name="message" rows="4" placeholder="Your message" required
+                        class="w-full rounded-md border border-[#3b82f6] px-4 py-3 text-white placeholder-blue-300 focus:outline-none focus:ring-2 focus:ring-[#60a5fa] focus:border-[#60a5fa] transition resize-none"
+                        spellcheck="false"></textarea>
+                </div>
+                <button type="submit"
+                    class="button-link w-full bg-transparent border-2 border-[#3b82f6] text-white font-semibold rounded-md py-3 transition focus:outline-none focus:ring-4 focus:ring-[#2563eb]">
+                    Send Message
+                </button>
+            </form>
+            <div class="mt-8 text-center text-blue-300 select-none drop-shadow-md">
+                <p>If you have any questions or inquiries about FALCON or need assistance with using the platform, feel
+                    free to reach out to us.</p>
+                <p class="mt-4">Email: <a href="mailto:msa24021@iiit.ac.in"
+                        class="text-[#60a5fa]">msa24021@iiit.ac.in</a></p>
+                <p>Location: Saksham Pathak, IIIT Lucknow, India</p>
+            </div>
+        </section>
+    </main>
+
+    <!-- Footer -->
+    <footer class="bg-[#142a5c] border-t border-blue-900 py-8 select-none" role="contentinfo">
+        <div
+            class="max-w-7xl mx-auto px-6 sm:px-8 lg:px-12 flex flex-col sm:flex-row justify-between items-center space-y-4 sm:space-y-0">
+            <p class="text-blue-300 text-sm drop-shadow-md">© FALCON : AI-Powered Fake News Detector </p>
+            <div class="flex space-x-6 text-blue-300 hover:text-[#60a5fa] transition-colors drop-shadow-md">
+                <a aria-label="LinkedIn"
+                    class="text-xl focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-indigo-500 rounded"
+                    href="https://www.linkedin.com/in/sakshampathak" rel="noopener noreferrer" target="_blank">
+                    <i class="fab fa-linkedin-in"></i>
+                </a>
+                <a aria-label="GitHub"
+                    class="text-xl focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-indigo-500 rounded"
+                    href="https://github.com/parthmax2" rel="noopener noreferrer" target="_blank"><i
+                        class="fab fa-github"></i></a>
+                <a aria-label="Twitter"
+                    class="text-xl focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-indigo-500 rounded"
+                    href="https://twitter.com/Parthamx__" rel="noopener noreferrer" target="_blank"><i
+                        class="fab fa-twitter"></i></a>
+                <a aria-label="Instagram"
+                    class="text-xl focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-indigo-500 rounded"
+                    href="https://instagram.com/parthmax_" rel="noopener noreferrer" target="_blank"><i
+                        class="fab fa-instagram"></i></a>
+            </div>
+        </div>
+        <div class="text-blue-200 text-sm mt-4 text-center">
+            <p>Developed by <a href="https://instagram.com/parthmax_"
+                    class="hover:text-[#60a5fa]"><strong>Parthamx</strong></a></p>
+        </div>
+
+
+        <p class="text-blue-300 text-sm mt-4 text-center">Follow us on social media for the latest updates!</p>
+
+    </footer>
+
+
+
+
+    <script>
+        // Mobile nav toggle
+        const navToggle = document.getElementById("navToggle");
+        const mobileMenu = document.getElementById("mobileMenu");
+        navToggle.addEventListener("click", () => {
+            const expanded =
+                navToggle.getAttribute("aria-expanded") === "true" || false;
+            navToggle.setAttribute("aria-expanded", !expanded);
+            mobileMenu.classList.toggle("hidden");
+        });
+
+        // Loading screen fade out after page load
+        window.addEventListener("load", () => {
+            const loadingScreen = document.getElementById("loadingScreen");
+            setTimeout(() => {
+                loadingScreen.style.opacity = "0";
+                loadingScreen.style.transition = "opacity 0.5s ease";
+                setTimeout(() => {
+                    loadingScreen.style.display = "none";
+                    // Focus main content for accessibility
+                    document.getElementById("mainContent").focus();
+                }, 500);
+            }, 1200);
+        });
+
+        // Character count update
+        const claimInput = document.getElementById("claim");
+        const charCount = document.getElementById("charCount");
+        claimInput.addEventListener("input", () => {
+            const length = claimInput.value.length;
+            const remaining = 350 - length;
+            charCount.textContent = remaining + " characters remaining";
+            if (remaining <= 0) {
+                charCount.classList.add("text-red-600");
+                charCount.classList.remove("text-blue-300");
+            } else {
+                charCount.classList.remove("text-red-600");
+                charCount.classList.add("text-blue-300");
+            }
+        });
+
+        // Form submission and result display with loading overlay on button
+        const form = document.getElementById("claimForm");
+        const resultSection = document.getElementById("result");
+        const errorDiv = document.createElement("div");
+        errorDiv.id = "error";
+        errorDiv.setAttribute("role", "alert");
+        errorDiv.setAttribute("aria-live", "assertive");
+        errorDiv.className =
+            "mt-6 max-w-3xl mx-auto font-semibold text-center select-none text-red-600";
+        form.after(errorDiv);
+        errorDiv.style.display = "none";
+
+        const analyzeLoadingOverlay = document.getElementById("analyzeLoadingOverlay");
+        const submitBtn = form.querySelector("button[type=submit]");
+
+        form.addEventListener("submit", async (e) => {
+            e.preventDefault();
+
+            const claimText = claimInput.value.trim();
+
+            if (claimText.length === 0) {
+                errorDiv.textContent = "Please enter a claim.";
+                errorDiv.style.display = "block";
+                resultSection.classList.remove("visible");
+                return;
+            }
+
+            if (claimText.length > 350) {
+                errorDiv.textContent = "Claim exceeds 350 characters!";
+                errorDiv.style.display = "block";
+                resultSection.classList.remove("visible");
+                return;
+            }
+
+            errorDiv.style.display = "none";
+
+            // Show loading overlay on button
+            submitBtn.disabled = true;
+            analyzeLoadingOverlay.classList.add("visible");
+            submitBtn.querySelector("span").textContent = "Checking...";
+
+            try {
+                const response = await fetch("/process_claim", {
+                    method: "POST",
+                    body: new URLSearchParams({ claim: claimText }),
+                    headers: {
+                        "Content-Type": "application/x-www-form-urlencoded", 
+                        "ngrok-skip-browser-warning": "true"
+                    },
+                });
+
+                if (!response.ok) {
+                    throw new Error("Network response was not ok");
+                }
+
+                const data = await response.json();
+
+                if (data.error) {
+                    errorDiv.textContent = data.error;
+                    errorDiv.style.display = "block";
+                    resultSection.classList.remove("visible");
+                } else {
+                    errorDiv.style.display = "none";
+
+                    // Populate result fields
+                    document.getElementById("claimText").textContent = data.claim || "N/A";
+                    document.getElementById("classification").textContent =
+                        data.classification || "N/A";
+                    document.getElementById("tone").textContent = data.tone || "N/A";
+                    document.getElementById("intent").textContent = data.intent || "N/A";
+                    document.getElementById("factCheckResult").textContent =
+                        data.fact_check_result || "N/A";
+                    document.getElementById("evidence").textContent = data.evidence || "N/A";
+
+                    if (Array.isArray(data.sources) && data.sources.length > 0) {
+                        const sourcesContainer = document.getElementById("sources");
+                        sourcesContainer.innerHTML = "";
+                        data.sources.forEach((s, index) => {
+                            const a = document.createElement("a");
+                            a.href = s.url;
+                            a.target = "_blank";
+                            a.rel = "noopener noreferrer";
+                            a.className = "hover:text-[#60a5fa] focus:outline-none focus:ring-2 focus:ring-indigo-500 rounded";
+                            a.textContent = s.source;
+                            sourcesContainer.appendChild(a);
+                            if (index < data.sources.length - 1) {
+                                sourcesContainer.appendChild(document.createTextNode(", "));
+                            }
+                        });
+                    } else {
+                        document.getElementById("sources").textContent = "N/A";
+                    }
+
+                    document.getElementById("reasoning").textContent = data.reasoning || "N/A";
+
+                    // Show result with fade-in
+                    resultSection.classList.add("visible");
+                    resultSection.focus();
+                }
+            } catch (error) {
+                errorDiv.textContent = "An error occurred. Please try again later.";
+                errorDiv.style.display = "block";
+                resultSection.classList.remove("visible");
+            } finally {
+                submitBtn.disabled = false;
+                analyzeLoadingOverlay.classList.remove("visible");
+                submitBtn.querySelector("span").textContent = "Check Claim";
+            }
+        });
+
+        // Contact form submission (dummy)
+        const contactForm = document.getElementById("contactForm");
+        contactForm.addEventListener("submit", (e) => {
+            e.preventDefault();
+            alert(
+                "Thank you for reaching out! We will contact you soon. "
+            );
+            contactForm.reset();
+        });
+    </script>
+</body>
+
+</html>

test.py

@@ -0,0 +1,7 @@
+from backend.api.fact_check import fact_check_claim
+
+
+if __name__ == "__main__":
+    sample_text = "Modi is a great leader who changed India forever!"
+    result = fact_check_claim(sample_text)
+    print(result)