feat(ai): complete — NLP pipeline all 4 modules confirmed working

Confirmed test results:
- nlp_extractor: spaCy en_core_web_sm loaded, 11 entities from CAG sample
2 PERSON, 3 ORG, 2 MONEY, 2 GPE — all via spacy_ner
- benfords_analyzer: Test 1 chi=4.30 NORMAL, Test 2 chi=4170 ANOMALY
Logarithmic distribution correctly follows Benford expectation
- shadow_draft_detector: all-MiniLM-L6-v2 loaded via sentence-transformers
Test 1 semantic alignment 93.35 percent FLAGGED, Test 2 0.0 percent clear
- multilingual_ner: switched from gated ai4bharat/IndicNER to public
Davlan/bert-base-multilingual-cased-ner-hrl. Model extracted Hindi names
via real NER: PER raajesh kumar, PER priyaa sharmaa confirmed
English text correctly deferred to nlp_extractor spaCy pipeline

ai/benfords_analyzer.py

@@ -0,0 +1,183 @@
+import os
+import sys
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+import re
+import math
+from datetime import datetime
+from loguru import logger
+
+
+BENFORD_DISTRIBUTION = {
+    1: 0.30103,
+    2: 0.17609,
+    3: 0.12494,
+    4: 0.09691,
+    5: 0.07918,
+    6: 0.06695,
+    7: 0.05799,
+    8: 0.05115,
+    9: 0.04576,
+}
+
+SIGNIFICANCE_THRESHOLD = 15.507
+
+
+class BenfordsAnalyzer:
+
+    def __init__(self):
+        self.benford = BENFORD_DISTRIBUTION
+
+    def extract_numeric_values(self, text: str) -> list:
+        pattern = re.compile(
+            r"(?:Rs\.?|INR)?\s*([\d,]+(?:\.\d+)?)\s*"
+            r"(?:crore|lakh|cr|L|thousand)?",
+            re.IGNORECASE,
+        )
+        values = []
+        for match in pattern.finditer(text):
+            raw = match.group(1).replace(",", "")
+            try:
+                val = float(raw)
+                if val >= 1:
+                    values.append(val)
+            except ValueError:
+                continue
+        return values
+
+    def get_first_digit(self, value: float) -> int:
+        if value <= 0:
+            return 0
+        s = str(abs(value)).lstrip("0").replace(".", "")
+        return int(s[0]) if s else 0
+
+    def analyze(self, values: list) -> dict:
+        if len(values) < 20:
+            return {
+                "status":           "insufficient_data",
+                "sample_size":      len(values),
+                "minimum_required": 20,
+                "anomaly_detected": False,
+                "analyzed_at":      datetime.now().isoformat(),
+            }
+
+        digit_counts = {d: 0 for d in range(1, 10)}
+        for val in values:
+            d = self.get_first_digit(val)
+            if d in digit_counts:
+                digit_counts[d] += 1
+
+        n = sum(digit_counts.values())
+        chi_squared = 0.0
+        observed_dist = {}
+        for digit in range(1, 10):
+            observed     = digit_counts[digit]
+            expected     = self.benford[digit] * n
+            observed_pct = observed / n if n > 0 else 0
+            observed_dist[digit] = round(observed_pct, 5)
+            if expected > 0:
+                chi_squared += ((observed - expected) ** 2) / expected
+
+        anomalous_digits = []
+        for digit in range(1, 10):
+            observed_pct = observed_dist[digit]
+            expected_pct = self.benford[digit]
+            deviation    = abs(observed_pct - expected_pct)
+            if deviation > 0.05:
+                anomalous_digits.append({
+                    "digit":        digit,
+                    "observed_pct": round(observed_pct * 100, 2),
+                    "expected_pct": round(expected_pct * 100, 2),
+                    "deviation_pct":round(deviation * 100, 2),
+                })
+
+        anomaly_detected = chi_squared > SIGNIFICANCE_THRESHOLD
+
+        if anomaly_detected:
+            logger.warning(
+                f"[Benford] ANOMALY: chi-squared={chi_squared:.2f} "
+                f"(threshold={SIGNIFICANCE_THRESHOLD}) n={n}"
+            )
+        else:
+            logger.info(
+                f"[Benford] NORMAL: chi-squared={chi_squared:.2f} n={n}"
+            )
+
+        return {
+            "status":              "completed",
+            "sample_size":         n,
+            "chi_squared":         round(chi_squared, 4),
+            "significance_threshold": SIGNIFICANCE_THRESHOLD,
+            "anomaly_detected":    anomaly_detected,
+            "confidence":          "high" if n >= 100 else "moderate" if n >= 30 else "low",
+            "observed_distribution": observed_dist,
+            "expected_distribution": {d: round(v, 5) for d, v in self.benford.items()},
+            "anomalous_digits":    anomalous_digits,
+            "interpretation": (
+                "First-digit distribution deviates significantly from Benford's Law. "
+                "This is a statistical anomaly indicator warranting further review. "
+                "Possible causes include rounding of declared figures, threshold avoidance, "
+                "or systematic manipulation of values."
+                if anomaly_detected else
+                "First-digit distribution is consistent with Benford's Law. "
+                "No statistical anomaly detected in this dataset."
+            ),
+            "analyzed_at": datetime.now().isoformat(),
+        }
+
+    def analyze_affidavit_assets(self, asset_records: list) -> dict:
+        values = []
+        for record in asset_records:
+            raw = str(record.get("total_assets", "") or record.get("assets", ""))
+            extracted = self.extract_numeric_values(raw)
+            values.extend(extracted)
+
+        logger.info(
+            f"[Benford] Analyzing {len(values)} numeric values "
+            f"from {len(asset_records)} affidavit records"
+        )
+        result = self.analyze(values)
+        result["source"]      = "Election Commission of India candidate affidavits"
+        result["record_count"]= len(asset_records)
+        return result
+
+
+if __name__ == "__main__":
+    import random
+    print("=" * 55)
+    print("BharatGraph - Benford's Law Analyzer Test")
+    print("=" * 55)
+
+    analyzer = BenfordsAnalyzer()
+
+    print("\n  Test 1: Naturally distributed values (should pass)")
+    natural = []
+    for _ in range(200):
+        magnitude = random.uniform(0, 7)
+        val = 10 ** magnitude
+        natural.append(val)
+    result1 = analyzer.analyze(natural)
+    print(f"  Chi-squared: {result1['chi_squared']}")
+    print(f"  Anomaly:     {result1['anomaly_detected']}")
+
+    print("\n  Test 2: Manipulated values (clustered near thresholds)")
+    manipulated = []
+    for _ in range(100):
+        manipulated.append(random.uniform(990000, 999999))
+    for _ in range(100):
+        manipulated.append(random.uniform(9800000, 9999999))
+    result2 = analyzer.analyze(manipulated)
+    print(f"  Chi-squared: {result2['chi_squared']}")
+    print(f"  Anomaly:     {result2['anomaly_detected']}")
+
+    print("\n  Test 3: Affidavit asset analysis")
+    sample_records = [
+        {"name": "Candidate A", "total_assets": "Rs 45 lakh"},
+        {"name": "Candidate B", "total_assets": "Rs 1.2 crore"},
+        {"name": "Candidate C", "total_assets": "Rs 99 lakh"},
+    ]
+    result3 = analyzer.analyze_affidavit_assets(sample_records)
+    print(f"  Sample size: {result3['sample_size']}")
+    print(f"  Status:      {result3['status']}")
+
+    print("\nDone!")

ai/multilingual_ner.py

@@ -0,0 +1,164 @@
+import os
+import sys
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+import re
+from datetime import datetime
+from loguru import logger
+
+
+SUPPORTED_LANGUAGES = {
+    "hi": "Hindi",
+    "ta": "Tamil",
+    "te": "Telugu",
+    "kn": "Kannada",
+    "ml": "Malayalam",
+    "mr": "Marathi",
+    "bn": "Bengali",
+    "gu": "Gujarati",
+    "pa": "Punjabi",
+}
+
+INDICNER_MODEL = "Davlan/bert-base-multilingual-cased-ner-hrl"
+
+HINDI_TITLE_WORDS = [
+    "मंत्री", "सचिव", "मुख्यमंत्री", "राज्यपाल", "सांसद", "विधायक",
+    "अधिकारी", "निदेशक", "आयुक्त", "कलेक्टर",
+]
+
+
+class MultilingualNER:
+
+    def __init__(self):
+        self._pipeline = None
+        self._lang_detect = None
+        self._load_models()
+
+    def _load_models(self):
+        try:
+            from transformers import pipeline as hf_pipeline
+            self._pipeline = hf_pipeline(
+                "token-classification",
+                model=INDICNER_MODEL,
+                aggregation_strategy="simple",
+            )
+            logger.success(f"[MultilingualNER] Loaded {INDICNER_MODEL}")
+        except Exception as e:
+            logger.warning(f"[MultilingualNER] HuggingFace model not available: {e}")
+            logger.warning("[MultilingualNER] Using pattern-based fallback for Hindi")
+            self._pipeline = None
+
+    def detect_language(self, text: str) -> str:
+        devanagari = len(re.findall(r'[\u0900-\u097F]', text))
+        tamil_chars = len(re.findall(r'[\u0B80-\u0BFF]', text))
+        telugu_chars = len(re.findall(r'[\u0C00-\u0C7F]', text))
+
+        if devanagari > 5:
+            return "hi"
+        if tamil_chars > 5:
+            return "ta"
+        if telugu_chars > 5:
+            return "te"
+        return "en"
+
+    def extract_entities(self, text: str, language: str = None) -> list:
+        if not text or not text.strip():
+            return []
+
+        detected_lang = language or self.detect_language(text)
+        logger.info(
+            f"[MultilingualNER] Extracting from "
+            f"{SUPPORTED_LANGUAGES.get(detected_lang, detected_lang)} text"
+        )
+
+        if self._pipeline and detected_lang != "en":
+            return self._extract_with_model(text, detected_lang)
+        return self._extract_with_patterns(text, detected_lang)
+
+    def _extract_with_model(self, text: str, language: str) -> list:
+        try:
+            results = self._pipeline(text[:512])
+            entities = []
+            for r in results:
+                entities.append({
+                    "text":        r.get("word", ""),
+                    "label":       r.get("entity_group", ""),
+                    "score":       round(r.get("score", 0), 4),
+                    "language":    language,
+                    "model":       INDICNER_MODEL,
+                    "extracted_at":datetime.now().isoformat(),
+                })
+            logger.success(f"[MultilingualNER] Model extracted {len(entities)} entities")
+            return entities
+        except Exception as e:
+            logger.warning(f"[MultilingualNER] Model inference failed: {e}")
+            return self._extract_with_patterns(text, language)
+
+    def _extract_with_patterns(self, text: str, language: str) -> list:
+        entities = []
+
+        if language == "hi":
+            for title in HINDI_TITLE_WORDS:
+                pattern = re.compile(
+                    title + r"\s+([^\s।\n]{2,20}(?:\s+[^\s।\n]{2,20})?)"
+                )
+                for match in pattern.finditer(text):
+                    entities.append({
+                        "text":        match.group(1).strip(),
+                        "label":       "PERSON",
+                        "score":       0.7,
+                        "language":    language,
+                        "model":       "pattern_fallback",
+                        "extracted_at":datetime.now().isoformat(),
+                    })
+
+            amount_pattern = re.compile(
+                r"([\d,]+(?:\.\d+)?\s*(?:करोड़|लाख|हजार))"
+            )
+            for match in amount_pattern.finditer(text):
+                entities.append({
+                    "text":        match.group(1),
+                    "label":       "MONEY",
+                    "score":       0.9,
+                    "language":    language,
+                    "model":       "pattern_fallback",
+                    "extracted_at":datetime.now().isoformat(),
+                })
+
+        seen = set()
+        unique = []
+        for e in entities:
+            key = (e["text"].strip().lower(), e["label"])
+            if key not in seen and e["text"].strip():
+                seen.add(key)
+                unique.append(e)
+
+        logger.info(f"[MultilingualNER] Pattern fallback extracted {len(unique)} entities")
+        return unique
+
+
+if __name__ == "__main__":
+    print("=" * 55)
+    print("BharatGraph - Multilingual NER Test")
+    print("=" * 55)
+
+    ner = MultilingualNER()
+
+    samples = [
+        ("Hindi", "hi",
+         "मंत्री राजेश कुमार और सचिव प्रिया शर्मा ने 45 करोड़ रुपये की "
+         "अनियमितता की जांच का आदेश दिया।"),
+        ("English", "en",
+         "Minister Rajesh Kumar approved a contract worth Rs 45 crore "
+         "for ABC Infrastructure Private Limited."),
+    ]
+
+    for lang_name, lang_code, text in samples:
+        print(f"\n  [{lang_name}]")
+        print(f"  Text: {text[:80]}...")
+        entities = ner.extract_entities(text, lang_code)
+        print(f"  Extracted: {len(entities)} entities")
+        for e in entities[:4]:
+            print(f"    {e['label']}: {e['text']} (model={e['model']})")
+
+    print("\nDone!")

ai/nlp_extractor.py

@@ -0,0 +1,184 @@
+import os
+import sys
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+import re
+from datetime import datetime
+from loguru import logger
+
+
+ENTITY_LABELS = {"PERSON", "ORG", "GPE", "MONEY", "DATE", "LAW"}
+
+MONETARY_PATTERN = re.compile(
+    r"(?:Rs\.?|INR|rupees?)\s*[\d,]+(?:\.\d+)?\s*(?:crore|lakh|thousand|cr|L)?",
+    re.IGNORECASE,
+)
+
+HONORIFICS = re.compile(
+    r"\b(?:Shri|Smt|Dr|Prof|Sri|Mr|Mrs|Ms|Hon|Adv|Er)\.?\s+",
+    re.IGNORECASE,
+)
+
+
+class NLPExtractor:
+
+    def __init__(self):
+        self._nlp = None
+        self._load_model()
+
+    def _load_model(self):
+        try:
+            import spacy
+            self._nlp = spacy.load("en_core_web_sm")
+            logger.success("[NLP] spaCy en_core_web_sm loaded")
+        except Exception as e:
+            logger.warning(f"[NLP] spaCy model not available: {e}")
+            logger.warning("[NLP] Run: python -m spacy download en_core_web_sm")
+            self._nlp = None
+
+    def extract_entities(self, text: str, source_document: str = "") -> list:
+        if not text or not text.strip():
+            return []
+
+        entities = []
+
+        monetary = MONETARY_PATTERN.findall(text)
+        for m in monetary:
+            entities.append({
+                "text":        m.strip(),
+                "label":       "MONEY",
+                "confidence":  "pattern_match",
+                "source_doc":  source_document,
+                "extracted_at":datetime.now().isoformat(),
+            })
+
+        if self._nlp:
+            doc = self._nlp(text[:100000])
+            for ent in doc.ents:
+                if ent.label_ not in ENTITY_LABELS:
+                    continue
+                clean_text = HONORIFICS.sub("", ent.text).strip()
+                if len(clean_text) < 3:
+                    continue
+                entities.append({
+                    "text":        clean_text,
+                    "label":       ent.label_,
+                    "confidence":  "spacy_ner",
+                    "source_doc":  source_document,
+                    "extracted_at":datetime.now().isoformat(),
+                })
+        else:
+            person_pattern = re.compile(
+                r"\b([A-Z][a-z]+(?:\s+[A-Z][a-z]+){1,3})\b"
+            )
+            for match in person_pattern.finditer(text):
+                name = match.group(1)
+                if len(name.split()) >= 2:
+                    entities.append({
+                        "text":        name,
+                        "label":       "PERSON",
+                        "confidence":  "regex_fallback",
+                        "source_doc":  source_document,
+                        "extracted_at":datetime.now().isoformat(),
+                    })
+
+        seen = set()
+        unique = []
+        for e in entities:
+            key = (e["text"].lower(), e["label"])
+            if key not in seen:
+                seen.add(key)
+                unique.append(e)
+
+        logger.info(
+            f"[NLP] Extracted {len(unique)} entities from "
+            f"'{source_document or 'text'}' "
+            f"({len([e for e in unique if e['label']=='PERSON'])} persons, "
+            f"{len([e for e in unique if e['label']=='ORG'])} orgs, "
+            f"{len([e for e in unique if e['label']=='MONEY'])} amounts)"
+        )
+        return unique
+
+    def extract_from_cag_report(self, report_text: str,
+                                 report_title: str = "") -> dict:
+        entities = self.extract_entities(report_text, report_title)
+        amounts  = [e for e in entities if e["label"] == "MONEY"]
+        persons  = [e for e in entities if e["label"] == "PERSON"]
+        orgs     = [e for e in entities if e["label"] == "ORG"]
+        locations= [e for e in entities if e["label"] == "GPE"]
+
+        return {
+            "report_title":  report_title,
+            "total_entities":len(entities),
+            "persons":       persons,
+            "organisations": orgs,
+            "locations":     locations,
+            "monetary":      amounts,
+            "all_entities":  entities,
+            "extracted_at":  datetime.now().isoformat(),
+        }
+
+    def resolve_against_graph(self, entities: list, driver) -> list:
+        resolved = []
+        if not driver:
+            return entities
+
+        with driver.session() as session:
+            for entity in entities:
+                if entity["label"] not in ("PERSON", "ORG"):
+                    resolved.append({**entity, "graph_match": None})
+                    continue
+
+                label = "Politician" if entity["label"] == "PERSON" else "Company"
+                row = session.run(
+                    f"""
+                    MATCH (n:{label})
+                    WHERE toLower(n.name) CONTAINS toLower($name)
+                    RETURN n.id AS id, n.name AS name
+                    LIMIT 1
+                    """,
+                    name=entity["text"]
+                ).single()
+
+                resolved.append({
+                    **entity,
+                    "graph_match": {
+                        "id":   row["id"],
+                        "name": row["name"],
+                    } if row else None,
+                })
+        return resolved
+
+
+if __name__ == "__main__":
+    print("=" * 55)
+    print("BharatGraph - NLP Extractor Test")
+    print("=" * 55)
+
+    extractor = NLPExtractor()
+
+    sample_text = """
+    The Comptroller and Auditor General of India has flagged irregularities
+    in the implementation of MGNREGA scheme in Karnataka. Minister Rajesh Kumar
+    and senior IAS officer Priya Sharma were found responsible for the diversion
+    of Rs 45.6 crore from the Rural Development Ministry. ABC Infrastructure
+    Private Limited received contracts worth Rs 120 crore without proper tender.
+    The funds were disbursed between January 2021 and March 2023.
+    """
+
+    result = extractor.extract_from_cag_report(sample_text, "CAG Report Sample")
+    print(f"\n  Total entities extracted: {result['total_entities']}")
+    print(f"  Persons:       {len(result['persons'])}")
+    print(f"  Organisations: {len(result['organisations'])}")
+    print(f"  Monetary:      {len(result['monetary'])}")
+    print(f"  Locations:     {len(result['locations'])}")
+
+    if result["persons"]:
+        print(f"\n  Sample persons:")
+        for p in result["persons"][:3]:
+            print(f"    {p['text']} ({p['confidence']})")
+    if result["monetary"]:
+        print(f"\n  Amounts found:")
+        for m in result["monetary"][:3]:
+            print(f"    {m['text']}")
+    print("\nDone!")

ai/shadow_draft_detector.py

@@ -0,0 +1,208 @@
+import os
+import sys
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+import re
+from datetime import datetime
+from loguru import logger
+
+
+ALIGNMENT_THRESHOLD = 65.0
+
+STOPWORDS = {
+    "the","a","an","and","or","but","in","on","at","to","for","of","with",
+    "by","from","is","are","was","were","be","been","being","have","has",
+    "had","do","does","did","will","would","could","should","may","might",
+    "shall","can","that","this","these","those","it","its","their","which",
+}
+
+
+class ShadowDraftDetector:
+
+    def __init__(self):
+        self._model = None
+        self._load_model()
+
+    def _load_model(self):
+        try:
+            from sentence_transformers import SentenceTransformer, util
+            self._model = SentenceTransformer("all-MiniLM-L6-v2")
+            self._util  = util
+            logger.success("[ShadowDraft] sentence-transformers loaded: all-MiniLM-L6-v2")
+        except Exception as e:
+            logger.warning(f"[ShadowDraft] sentence-transformers not available: {e}")
+            logger.warning("[ShadowDraft] Using token overlap fallback")
+            self._model = None
+
+    def _tokenize(self, text: str) -> set:
+        tokens = re.findall(r"\b[a-z]{3,}\b", text.lower())
+        return {t for t in tokens if t not in STOPWORDS}
+
+    def _jaccard_similarity(self, text_a: str, text_b: str) -> float:
+        tokens_a = self._tokenize(text_a)
+        tokens_b = self._tokenize(text_b)
+        if not tokens_a or not tokens_b:
+            return 0.0
+        intersection = len(tokens_a & tokens_b)
+        union        = len(tokens_a | tokens_b)
+        return round((intersection / union) * 100, 2) if union > 0 else 0.0
+
+    def _semantic_similarity(self, text_a: str, text_b: str) -> float:
+        try:
+            import torch
+            emb_a = self._model.encode(text_a, convert_to_tensor=True)
+            emb_b = self._model.encode(text_b, convert_to_tensor=True)
+            score = self._util.cos_sim(emb_a, emb_b).item()
+            return round(score * 100, 2)
+        except Exception as e:
+            logger.warning(f"[ShadowDraft] Semantic similarity failed: {e}")
+            return self._jaccard_similarity(text_a, text_b)
+
+    def split_into_sections(self, text: str, max_length: int = 500) -> list:
+        sentences = re.split(r"(?<=[.!?])\s+", text)
+        sections  = []
+        current   = ""
+        for sentence in sentences:
+            if len(current) + len(sentence) <= max_length:
+                current += " " + sentence
+            else:
+                if current.strip():
+                    sections.append(current.strip())
+                current = sentence
+        if current.strip():
+            sections.append(current.strip())
+        return sections
+
+    def compare(self, submission_text: str, bill_text: str,
+                submission_name: str = "Submission",
+                bill_name: str = "Bill") -> dict:
+        logger.info(
+            f"[ShadowDraft] Comparing '{submission_name}' "
+            f"against '{bill_name}'"
+        )
+
+        submission_sections = self.split_into_sections(submission_text)
+        bill_sections       = self.split_into_sections(bill_text)
+
+        if not submission_sections or not bill_sections:
+            return {
+                "status":          "insufficient_text",
+                "alignment_score": 0.0,
+                "flagged":         False,
+            }
+
+        matched_pairs = []
+        for sub_sec in submission_sections:
+            if len(sub_sec.split()) < 5:
+                continue
+            best_score = 0.0
+            best_bill  = ""
+            for bill_sec in bill_sections:
+                if len(bill_sec.split()) < 5:
+                    continue
+                if self._model:
+                    score = self._semantic_similarity(sub_sec, bill_sec)
+                else:
+                    score = self._jaccard_similarity(sub_sec, bill_sec)
+                if score > best_score:
+                    best_score = score
+                    best_bill  = bill_sec
+            if best_score >= 40.0:
+                matched_pairs.append({
+                    "submission_section": sub_sec[:200],
+                    "bill_section":       best_bill[:200],
+                    "similarity_score":   best_score,
+                    "method": "semantic" if self._model else "token_overlap",
+                })
+
+        matched_pairs.sort(key=lambda x: x["similarity_score"], reverse=True)
+
+        if matched_pairs:
+            top_scores = [p["similarity_score"] for p in matched_pairs[:5]]
+            alignment_score = round(sum(top_scores) / len(top_scores), 2)
+        else:
+            alignment_score = 0.0
+
+        effective_threshold = (
+            ALIGNMENT_THRESHOLD if self._model
+            else ALIGNMENT_THRESHOLD * 0.6
+        )
+        flagged = alignment_score >= effective_threshold
+
+        if flagged:
+            logger.warning(
+                f"[ShadowDraft] HIGH ALIGNMENT: {alignment_score:.1f}% "
+                f"between '{submission_name}' and '{bill_name}'"
+            )
+        else:
+            logger.info(
+                f"[ShadowDraft] Alignment: {alignment_score:.1f}% "
+                f"(threshold={ALIGNMENT_THRESHOLD}%)"
+            )
+
+        return {
+            "submission_name":  submission_name,
+            "bill_name":        bill_name,
+            "alignment_score":  alignment_score,
+            "threshold":        ALIGNMENT_THRESHOLD,
+            "flagged":          flagged,
+            "matched_sections": len(matched_pairs),
+            "top_matches":      matched_pairs[:5],
+            "interpretation": (
+                f"High semantic alignment ({alignment_score:.1f}%) detected between "
+                "the corporate submission and the legislative text. This is a structural "
+                "indicator that the submission's language may have influenced the final "
+                "bill text. This is an analytical observation, not a legal finding."
+                if flagged else
+                f"Alignment score ({alignment_score:.1f}%) is below the threshold "
+                f"({ALIGNMENT_THRESHOLD}%). No significant semantic overlap detected."
+            ),
+            "analyzed_at": datetime.now().isoformat(),
+        }
+
+
+if __name__ == "__main__":
+    print("=" * 55)
+    print("BharatGraph - Shadow Draft Detector Test")
+    print("=" * 55)
+
+    detector = ShadowDraftDetector()
+
+    corporate_submission = """
+    We propose that all digital payment service providers should be exempted
+    from the transaction levy when the transaction value is below fifty thousand
+    rupees. Further, the regulatory authority should provide a grace period of
+    eighteen months for existing operators to achieve compliance with the new
+    data localisation requirements.
+    """
+
+    bill_text_similar = """
+    Digital payment service providers shall be exempt from transaction levy
+    for amounts below fifty thousand rupees. Existing operators shall have
+    eighteen months to achieve compliance with data localisation requirements
+    as specified under this Act.
+    """
+
+    bill_text_different = """
+    The government shall establish a committee to review taxation policy for
+    agricultural produce. All farmers with land holdings below two hectares
+    shall receive a subsidy on crop insurance premiums.
+    """
+
+    print("\n  Test 1: High alignment expected")
+    result1 = detector.compare(
+        corporate_submission, bill_text_similar,
+        "Industry Body Submission", "Payment Regulation Bill"
+    )
+    print(f"  Score:   {result1['alignment_score']}%")
+    print(f"  Flagged: {result1['flagged']}")
+
+    print("\n  Test 2: Low alignment expected")
+    result2 = detector.compare(
+        corporate_submission, bill_text_different,
+        "Industry Body Submission", "Agriculture Bill"
+    )
+    print(f"  Score:   {result2['alignment_score']}%")
+    print(f"  Flagged: {result2['flagged']}")
+
+    print("\nDone!")

requirements.txt

@@ -11,3 +11,5 @@ schedule>=1.2.0
 fastapi>=0.110.0
 uvicorn>=0.27.0
 neo4j>=5.14.0
+spacy>=3.7.0
+sentence-transformers>=2.6.0