new added

src/streamlit_app.py

@@ -1,40 +1,744 @@
-import altair as alt
-import numpy as np
-import pandas as pd
 import streamlit as st
+import json
+import re
+import difflib
+from PIL import Image
+import base64
+import os
 
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+# =========================================================
+# PAGE CONFIG
+# =========================================================
+st.set_page_config(
+    page_title="GEN AI Record Level Matching",
+    page_icon="🔍",
+    layout="wide",
+    initial_sidebar_state="collapsed"
+)
+
+# =========================================================
+# CUSTOM CSS
+# =========================================================
+st.markdown("""
+<style>
+    [data-testid="stAppViewContainer"], [data-testid="stApp"], .stApp {
+        background-color: #f0f2f5 !important;
+        color: #333 !important;
+    }
+    .main { background-color: #f0f2f5; }
+    .stAppDeployButton, .stMainMenu, #MainMenu,
+    [data-testid="stToolbarActions"], [data-testid="stStatusWidget"] {
+        display: none !important;
+    }
+    header[data-testid="stHeader"] { background: transparent !important; }
+    .block-container { padding-top: 2rem !important; padding-bottom: 2rem !important; }
+    .header-title {
+        text-align: center; color: #5B4E8B; font-size: 28px;
+        font-weight: 600; margin-bottom: 10px;
+    }
+    .header-subtitle {
+        text-align: center; color: #666; font-size: 14px; margin-bottom: 30px;
+    }
+    .logo-title-container {
+        display: flex; align-items: center; justify-content: center;
+        gap: 15px; margin-bottom: 10px;
+    }
+    .record-header {
+        color: #612383; font-size: 26px; font-weight: 700;
+        margin-bottom: 25px; padding-bottom: 12px;
+        border-bottom: 3px solid;
+        border-image: linear-gradient(90deg, #612383, #E9592E, #F5A700) 1;
+    }
+    .section-card {
+        background: white; border-radius: 12px;
+        box-shadow: 0 2px 8px rgba(0,0,0,0.08);
+        margin-bottom: 20px; overflow: hidden;
+    }
+    .section-header-gradient {
+        background: linear-gradient(90deg, #612383 0%, #E9592E 100%);
+        color: white; padding: 14px 20px; font-size: 14px;
+        font-weight: 600; text-transform: uppercase; letter-spacing: 0.5px;
+        display: flex; align-items: center; gap: 10px;
+    }
+    .section-content { padding: 20px; }
+    .stTextInput > div > div > input {
+        background-color: #fafbfc !important; color: #333 !important;
+        border: 1px solid #e1e4e8 !important; border-radius: 8px !important;
+        padding: 10px 14px !important; font-size: 14px !important;
+    }
+    .stTextInput > div > div > input:focus {
+        border-color: #E9592E !important;
+        box-shadow: 0 0 0 3px rgba(233,89,46,0.1) !important;
+    }
+    .stTextInput label { color: #555 !important; font-size: 13px !important; font-weight: 500 !important; }
+    .subsection-label { color: #666; font-size: 13px; font-weight: 500; margin-bottom: 12px; }
+    div[data-testid="stButton"] button:not([kind="primary"]):not([kind="secondary"]) {
+        width: 36px !important; height: 36px !important; min-width: 36px !important;
+        padding: 0 !important; border-radius: 6px !important; font-size: 18px !important;
+        background-color: white !important; color: #612383 !important;
+        border: 1px solid #d0d7de !important;
+    }
+    button[kind="primary"] {
+        background: linear-gradient(90deg, #612383 0%, #E9592E 100%) !important;
+        color: white !important; border: none !important; border-radius: 10px !important;
+        padding: 16px 32px !important; font-size: 16px !important; font-weight: 600 !important;
+        box-shadow: 0 4px 12px rgba(97,35,131,0.25) !important;
+        text-transform: uppercase; letter-spacing: 0.5px; height: auto !important;
+    }
+    button[kind="secondary"] {
+        background: linear-gradient(90deg, #612383 0%, #E9592E 100%) !important;
+        color: white !important; border: none !important; border-radius: 10px !important;
+        padding: 12px 24px !important; font-size: 13px !important; font-weight: 600 !important;
+        min-width: 140px !important; height: auto !important;
+        box-shadow: 0 4px 12px rgba(97,35,131,0.25) !important;
+        text-transform: uppercase; letter-spacing: 0.5px;
+    }
+    .result-box {
+        background: white !important; border-radius: 12px !important;
+        padding: 25px !important; margin-top: 30px !important;
+        box-shadow: 0 4px 16px rgba(0,0,0,0.1) !important;
+        border-top: 4px solid;
+        border-image: linear-gradient(90deg, #612383, #E9592E, #F5A700) 1;
+    }
+    .result-header { color: #612383; font-size: 18px; font-weight: 600; margin-bottom: 15px; }
+    .section-divider { border: none; border-top: 1px solid #e1e4e8; margin: 20px 0; }
+    div[data-testid="stExpander"] summary { color: #333 !important; font-weight: 600 !important; }
+    div[data-testid="stExpander"] summary svg { stroke: #333 !important; }
+    .address-title { font-weight: 600; color: #612383; font-size: 14px; }
+    ::placeholder { color: #666 !important; opacity: 1 !important; }
+    [data-testid="stJson"], [data-testid="stCodeBlock"] {
+        background-color: #ffffff !important; color: #333333 !important;
+        border: 1px solid #e1e4e8 !important; border-radius: 8px !important;
+    }
+    div[data-testid="stRadio"] label { color: #333 !important; font-size: 14px !important; font-weight: 500 !important; }
+    div[data-testid="stRadio"] > label:first-child { color: #222 !important; font-size: 15px !important; font-weight: 600 !important; }
+    div[data-testid="stRadio"] div[role="radiogroup"] label[data-baseweb="radio"] div:first-child {
+        border-color: #612383 !important;
+    }
+    div[data-testid="stRadio"] div[role="radiogroup"] label[data-baseweb="radio"] div:first-child div {
+        background-color: #612383 !important;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# =========================================================
+# SESSION STATE
+# =========================================================
+MAX_FIELDS = 20
+
+defaults = {
+    'address_ids_r1': [0], 'address_ids_r2': [0],
+    'phone_ids_r1': [0], 'phone_ids_r2': [0],
+    'email_ids_r1': [0], 'email_ids_r2': [0],
+    'custom_fields_r1': [], 'custom_fields_r2': [],
+}
+for k, v in defaults.items():
+    if k not in st.session_state:
+        st.session_state[k] = v
+
+# =========================================================
+# PURE PYTHON MATCHING LOGIC (no external ML libs)
+# =========================================================
+
+def normalize_text(text):
+    if not text:
+        return ""
+    return re.sub(r"\s+", " ", str(text).strip().lower())
+
+def fuzzy_ratio(a, b):
+    """Simple fuzzy ratio using difflib (0-100)"""
+    if not a or not b:
+        return 0
+    return int(difflib.SequenceMatcher(None, a, b).ratio() * 100)
+
+def token_sort_ratio(a, b):
+    """Token sort ratio - sort words before comparing"""
+    if not a or not b:
+        return 0
+    a_sorted = " ".join(sorted(a.split()))
+    b_sorted = " ".join(sorted(b.split()))
+    return fuzzy_ratio(a_sorted, b_sorted)
+
+def name_similarity(a, b):
+    """Compare two name strings"""
+    if not a and not b:
+        return -1  # both missing
+    if not a or not b:
+        return 0
+    a, b = normalize_text(a), normalize_text(b)
+    r1 = fuzzy_ratio(a, b)
+    r2 = token_sort_ratio(a, b)
+    return max(r1, r2)
+
+def match_names(name1, fn1, ln1, mn1, name2, fn2, ln2, mn2):
+    """Match full name records, returns dict with percent scores"""
+
+    def build_full(name, fn, mn, ln):
+        parts = [p for p in [fn, mn, ln] if p and p.strip()]
+        if parts:
+            return " ".join(parts)
+        return name or ""
+
+    full1 = normalize_text(build_full(name1, fn1, mn1, ln1) or name1 or "")
+    full2 = normalize_text(build_full(name2, fn2, mn2, ln2) or name2 or "")
+
+    full_score = name_similarity(full1, full2) if (full1 or full2) else -1
+
+    fn_score = name_similarity(normalize_text(fn1), normalize_text(fn2)) if (fn1 or fn2) else -1
+    mn_score = name_similarity(normalize_text(mn1), normalize_text(mn2)) if (mn1 or mn2) else -1
+    ln_score = name_similarity(normalize_text(ln1), normalize_text(ln2)) if (ln1 or ln2) else -1
+
+    return {
+        "full_name_percent": full_score,
+        "firstname_percent": fn_score,
+        "middlename_percent": mn_score,
+        "lastname_percent": ln_score,
+    }
+
+def match_single(a, b):
+    """Generic single field name/text matching"""
+    if not a and not b:
+        return -1
+    return name_similarity(normalize_text(a), normalize_text(b))
+
+def match_addresses(addrs1, addrs2):
+    """Match lists of addresses, return best score"""
+    valid1 = [normalize_text(a) for a in addrs1 if a and a.strip()]
+    valid2 = [normalize_text(a) for a in addrs2 if a and a.strip()]
+    if not valid1 and not valid2:
+        return -1
+    if not valid1 or not valid2:
+        return 0
+    best = 0
+    for a1 in valid1:
+        for a2 in valid2:
+            s = max(fuzzy_ratio(a1, a2), token_sort_ratio(a1, a2))
+            if s > best:
+                best = s
+    return best
+
+def normalize_phone(p):
+    if not p:
+        return ""
+    return re.sub(r"[^\d]", "", str(p))
+
+def compare_phones(phones1, phones2):
+    v1 = [normalize_phone(p) for p in phones1 if p and normalize_phone(p)]
+    v2 = [normalize_phone(p) for p in phones2 if p and normalize_phone(p)]
+    if not v1 and not v2:
+        return -1
+    if not v1 or not v2:
+        return 0
+    for p1 in v1:
+        for p2 in v2:
+            if p1 == p2 or p1[-10:] == p2[-10:]:
+                return 100
+    return 0
+
+def compare_emails(emails1, emails2):
+    v1 = [e.strip().lower() for e in emails1 if e and e.strip()]
+    v2 = [e.strip().lower() for e in emails2 if e and e.strip()]
+    if not v1 and not v2:
+        return -1
+    if not v1 or not v2:
+        return 0
+    for e1 in v1:
+        for e2 in v2:
+            if e1 == e2:
+                return 100
+    return 0
+
+def compare_exact(a, b):
+    if not a and not b:
+        return -1
+    if not a or not b:
+        return 0
+    return 100 if normalize_text(a) == normalize_text(b) else 0
+
+def standardize_city(city):
+    if not city:
+        return ""
+    return re.sub(r"\s+", " ", str(city).strip().upper())
+
+def standardize_state(state):
+    if not state:
+        return ""
+    return re.sub(r"\s+", " ", str(state).strip().upper())
+
+def standardize_dob(dob):
+    if not dob:
+        return ""
+    dob = dob.strip()
+    # Try to normalize to YYYY-MM-DD
+    for fmt in [r"(\d{4})[/-](\d{2})[/-](\d{2})", r"(\d{2})[/-](\d{2})[/-](\d{4})"]:
+        m = re.match(fmt, dob)
+        if m:
+            g = m.groups()
+            if len(g[0]) == 4:
+                return f"{g[0]}-{g[1]}-{g[2]}"
+            else:
+                return f"{g[2]}-{g[1]}-{g[0]}"
+    return dob
+
+def normalize_gender(val):
+    if not val:
+        return None
+    s = str(val).strip().lower()
+    if s in ['m', 'male', 'men', 'man']:
+        return 'MALE'
+    if s in ['f', 'female', 'women', 'woman']:
+        return 'FEMALE'
+    return s.upper()
+
+def score_to_label(score, field):
+    """Convert numeric score to display value"""
+    if score == -1:
+        return "missing value"
+    return round(float(score), 2)
+
+def get_dynamic_fields(record, prefix):
+    fields = []
+    i = 0
+    while True:
+        key = f"{prefix}{i}"
+        if key in record:
+            fields.append(record.get(key))
+            i += 1
+        else:
+            break
+    return fields
+
+def is_valid(val):
+    return val and str(val).strip() not in ["", "-", " ", "NA", "N/A", "NULL"]
+
+def evaluate_rules(scores):
+    """Simple rule-based overall decision"""
+    numeric_scores = {k: v for k, v in scores.items() if isinstance(v, (int, float)) and v != -1}
+    missing = {k: v for k, v in scores.items() if v == "missing value" or v == -1}
+
+    if not numeric_scores:
+        return "UNABLE TO DETERMINE", "Insufficient data to make a determination."
+
+    # Strong identifiers
+    strong_ids = ["AADHAR", "PAN", "PASSPORTID", "LICENSEID", "VOTERID"]
+    for sid in strong_ids:
+        if scores.get(sid) == 100:
+            return "MATCH", f"Strong identifier match on {sid}."
+
+    # Name + DOB + phone
+    name_score = scores.get("NAME", scores.get("FIRSTNAME", 0))
+    if isinstance(name_score, str):
+        name_score = 0
+
+    high_matches = sum(1 for k, v in numeric_scores.items() if isinstance(v, (int, float)) and v >= 80)
+    total_evaluated = len(numeric_scores)
+
+    if total_evaluated == 0:
+        return "UNABLE TO DETERMINE", "No fields to compare."
+
+    match_ratio = high_matches / total_evaluated
+
+    if match_ratio >= 0.7:
+        return "MATCH", f"{high_matches}/{total_evaluated} fields matched at ≥80%."
+    elif match_ratio >= 0.4:
+        return "POSSIBLE MATCH", f"{high_matches}/{total_evaluated} fields matched at ≥80%."
+    else:
+        return "NO MATCH", f"Only {high_matches}/{total_evaluated} fields matched at ≥80%."
+
+def match_records(r1, r2):
+    """Full matching pipeline"""
+
+    # Name matching
+    name_result = match_names(
+        r1.get("name"), r1.get("firstname"), r1.get("lastname"), r1.get("middlename"),
+        r2.get("name"), r2.get("firstname"), r2.get("lastname"), r2.get("middlename")
+    )
+
+    # Address matching
+    r1_addrs = get_dynamic_fields(r1, "addressline_")
+    r2_addrs = get_dynamic_fields(r2, "addressline_")
+    address_score = match_addresses(r1_addrs, r2_addrs)
+
+    # Phone
+    r1_phones = get_dynamic_fields(r1, "phone_")
+    r2_phones = get_dynamic_fields(r2, "phone_")
+    phone_score = compare_phones(r1_phones, r2_phones)
+
+    # Email
+    r1_emails = get_dynamic_fields(r1, "email_")
+    r2_emails = get_dynamic_fields(r2, "email_")
+    email_score = compare_emails(r1_emails, r2_emails)
+
+    # City / State / Zipcode
+    r1_cities = [standardize_city(c) for c in get_dynamic_fields(r1, "city_") if is_valid(c)]
+    r2_cities = [standardize_city(c) for c in get_dynamic_fields(r2, "city_") if is_valid(c)]
+    r1_states = [standardize_state(s) for s in get_dynamic_fields(r1, "state_") if is_valid(s)]
+    r2_states = [standardize_state(s) for s in get_dynamic_fields(r2, "state_") if is_valid(s)]
+    r1_zips = get_dynamic_fields(r1, "zipcode_")
+    r2_zips = get_dynamic_fields(r2, "zipcode_")
+
+    city_score = -1
+    if r1_cities or r2_cities:
+        city_score = 100 if any(c1 == c2 for c1 in r1_cities for c2 in r2_cities) else 0
+
+    state_score = -1
+    if r1_states or r2_states:
+        state_score = 100 if any(s1 == s2 for s1 in r1_states for s2 in r2_states) else 0
+
+    zipcode_score = compare_exact(
+        next((z for z in r1_zips if is_valid(z)), None),
+        next((z for z in r2_zips if is_valid(z)), None)
+    ) if (r1_zips or r2_zips) else -1
+
+    # Exact fields
+    def safe_exact(k1, k2=None):
+        k2 = k2 or k1
+        return compare_exact(r1.get(k1), r2.get(k2))
+
+    g1 = normalize_gender(r1.get("gender"))
+    g2 = normalize_gender(r2.get("gender"))
+    if not g1 and not g2:
+        gender_score = -1
+    elif g1 and g2:
+        gender_score = 100 if g1 == g2 else 0
+    else:
+        gender_score = 0
+
+    results = {
+        "GENDER": gender_score,
+        "NAME": name_result["full_name_percent"],
+        "FIRSTNAME": name_result["firstname_percent"],
+        "MIDDLENAME": name_result["middlename_percent"],
+        "LASTNAME": name_result["lastname_percent"],
+        "SPOUSENAME": match_single(r1.get("spousename"), r2.get("spousename")),
+        "MOTHERNAME": match_single(r1.get("mothername"), r2.get("mothername")),
+        "FATHERNAME": match_single(r1.get("fathername"), r2.get("fathername")),
+        "COMPANYNAME": match_single(r1.get("companyname"), r2.get("companyname")),
+        "PARENTCOMPANYNAME": match_single(r1.get("parentcompanyname"), r2.get("parentcompanyname")),
+        "AADHAR": safe_exact("AADHAR"),
+        "PAN": safe_exact("pan"),
+        "LICENSEID": safe_exact("licenseid"),
+        "PASSPORTID": safe_exact("passportid"),
+        "VOTERID": safe_exact("voterid"),
+        "BIRTHDATE": compare_exact(r1.get("dob"), r2.get("dob")),
+        "PHONE": phone_score,
+        "EMAIL": email_score,
+        "ADDRESSLINE": address_score,
+        "CITY": city_score,
+        "STATE": state_score,
+        "ZIPCODE": zipcode_score,
+    }
+
+    # Custom fields
+    known = {"name","firstname","middlename","lastname","spousename","mothername",
+             "fathername","dob","gender","AADHAR","pan","licenseid","passportid",
+             "voterid","companyname","parentcompanyname"}
+    dyn_prefixes = ("zipcode_","city_","state_","phone_","email_","addressline_")
+
+    all_keys = set(r1.keys()) | set(r2.keys())
+    for key in all_keys:
+        ks = str(key)
+        if ks in known:
+            continue
+        if any(ks.startswith(p) for p in dyn_prefixes):
+            continue
+        v1, v2 = r1.get(key), r2.get(key)
+        if v1 or v2:
+            results[ks.upper()] = compare_exact(v1, v2)
+
+    return results
+
+# =========================================================
+# UI HELPERS
+# =========================================================
+def preprocess_text(text):
+    if not text:
+        return ""
+    return re.sub(r"\s+", " ", text.strip())
+
+def create_section_card(title, icon_svg, content_func, *args, **kwargs):
+    st.markdown(f'''
+    <div class="section-card">
+        <div class="section-header-gradient">{icon_svg} {title}</div>
+        <div class="section-content">
+    ''', unsafe_allow_html=True)
+    result = content_func(*args, **kwargs)
+    st.markdown('</div></div>', unsafe_allow_html=True)
+    return result
+
+ICONS = {
+    "user": '<svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M20 21v-2a4 4 0 0 0-4-4H8a4 4 0 0 0-4 4v2"></path><circle cx="12" cy="7" r="4"></circle></svg>',
+    "id": '<svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><rect x="3" y="4" width="18" height="16" rx="2"></rect><line x1="16" y1="2" x2="16" y2="6"></line><line x1="8" y1="2" x2="8" y2="6"></line><line x1="3" y1="10" x2="21" y2="10"></line></svg>',
+    "map": '<svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><polygon points="3 6 9 3 15 6 21 3 21 18 15 21 9 18 3 21"></polygon></svg>',
+    "phone": '<svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M22 16.92v3a2 2 0 0 1-2.18 2 19.79 19.79 0 0 1-8.63-3.07 19.5 19.5 0 0 1-6-6 19.79 19.79 0 0 1-3.07-8.67A2 2 0 0 1 4.11 2h3a2 2 0 0 1 2 1.72c.127.96.361 1.903.7 2.81a2 2 0 0 1-.45 2.11L8.09 9.91a16 16 0 0 0 6 6l1.27-1.27a2 2 0 0 1 2.11-.45c.907.339 1.85.573 2.81.7A2 2 0 0 1 22 16.92z"></path></svg>',
+    "briefcase": '<svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><rect x="2" y="7" width="20" height="14" rx="2" ry="2"></rect><path d="M16 21V5a2 2 0 0 0-2-2h-4a2 2 0 0 0-2 2v16"></path></svg>'
+}
+
+# =========================================================
+# SECTION CONTENT FUNCTIONS
+# =========================================================
+
+def name_fields_content(record_num, prefix=""):
+    col1, col2 = st.columns(2)
+    with col1:
+        full_name = st.text_input("Full Name", key=f"{prefix}name_{record_num}", placeholder="Enter full name")
+    with col2:
+        first_name = st.text_input("First Name", key=f"{prefix}firstname_{record_num}", placeholder="Enter first name")
+    col1, col2 = st.columns(2)
+    with col1:
+        middle_name = st.text_input("Middle Name", key=f"{prefix}middlename_{record_num}", placeholder="Enter middle name")
+    with col2:
+        last_name = st.text_input("Last Name", key=f"{prefix}lastname_{record_num}", placeholder="Enter last name")
+    col1, col2 = st.columns(2)
+    with col1:
+        mother_name = st.text_input("Mother's Name", key=f"{prefix}mothername_{record_num}", placeholder="Enter mother's name")
+    with col2:
+        father_name = st.text_input("Father's Name", key=f"{prefix}fathername_{record_num}", placeholder="Enter father's name")
+    col1, col2 = st.columns(2)
+    with col1:
+        spouse_name = st.text_input("Spouse's Name", key=f"{prefix}spousename_{record_num}", placeholder="Enter spouse's name")
+    with col2:
+        other_name = st.text_input("Other Name", key=f"{prefix}othername_{record_num}", placeholder="Enter other name")
+    col1, col2 = st.columns(2)
+    with col1:
+        dob = st.text_input("Date of Birth", key=f"{prefix}dob_{record_num}", placeholder="YYYY-MM-DD")
+    with col2:
+        gender = st.text_input("Gender", key=f"{prefix}gender_{record_num}", placeholder="Male/Female/Other")
+    return {
+        "name": full_name, "firstname": first_name, "middlename": middle_name,
+        "lastname": last_name, "mothername": mother_name, "fathername": father_name,
+        "spousename": spouse_name, "othername": other_name, "gender": gender, "dob": dob
+    }
+
+def identifier_fields_content(record_num, prefix=""):
+    col1, col2 = st.columns(2)
+    with col1:
+        aadhar = st.text_input("Aadhar Number", key=f"{prefix}taxid_{record_num}", placeholder="Enter Aadhar number")
+    with col2:
+        pan = st.text_input("PAN Number", key=f"{prefix}pan_{record_num}", placeholder="Enter PAN number")
+    col1, col2 = st.columns(2)
+    with col1:
+        license_id = st.text_input("License Number", key=f"{prefix}licenseid_{record_num}", placeholder="Enter license number")
+    with col2:
+        passport = st.text_input("Passport Number", key=f"{prefix}passportid_{record_num}", placeholder="Enter passport number")
+    col1, _ = st.columns(2)
+    with col1:
+        voter_id = st.text_input("Voter ID", key=f"{prefix}voterid_{record_num}", placeholder="Enter voter ID")
+
+    st.markdown('<div class="subsection-label" style="margin-top:15px;">Custom Fields</div>', unsafe_allow_html=True)
+
+    custom_fields = st.session_state[f"custom_fields_{prefix.strip('_')}"]
+    custom_data = {}
+
+    for idx, field in enumerate(custom_fields):
+        col_c1, col_c2, col_rem = st.columns([5, 5, 1])
+        with col_c1:
+            field_name = st.text_input(f"Field Name {idx+1}", value=field.get('name', ''),
+                key=f"{prefix}custom_name_{idx}_{record_num}", placeholder="Field Name")
+            custom_fields[idx]['name'] = field_name
+        with col_c2:
+            field_val = st.text_input(f"Field Value {idx+1}", value=field.get('value', ''),
+                key=f"{prefix}custom_val_{idx}_{record_num}", placeholder="Value")
+            custom_fields[idx]['value'] = field_val
+            if field_name:
+                custom_data[field_name] = field_val
+        with col_rem:
+            st.write("")
+            st.write("")
+            if st.button("−", key=f"{prefix}remove_custom_{idx}_{record_num}"):
+                custom_fields.pop(idx)
+                st.rerun()
+
+    if st.button("+ ADD FIELD", key=f"{prefix}add_custom_{record_num}", type="secondary"):
+        custom_fields.append({'name': '', 'value': ''})
+        st.rerun()
+
+    result = {"AADHAR": aadhar, "pan": pan, "licenseid": license_id, "passportid": passport, "voterid": voter_id}
+    result.update(custom_data)
+    return result
+
+def address_item_content(record_num, addr_id, prefix=""):
+    address_line = st.text_input("Street Address", key=f"{prefix}addressline_{addr_id}_{record_num}", placeholder="Street, Building, Area")
+    city = st.text_input("City", key=f"{prefix}city_{addr_id}_{record_num}", placeholder="Enter city")
+    state = st.text_input("State", key=f"{prefix}state_{addr_id}_{record_num}", placeholder="Enter state")
+    pincode = st.text_input("Pincode", key=f"{prefix}zipcode_{addr_id}_{record_num}", placeholder="6-digit postal code")
+    return {
+        f"addressline_{addr_id}": address_line,
+        f"city_{addr_id}": city,
+        f"state_{addr_id}": state,
+        f"zipcode_{addr_id}": pincode,
+    }
+
+def addresses_section_content(record_num, prefix=""):
+    ids_key = f"address_ids_{prefix.strip('_')}"
+    ids = st.session_state[ids_key]
+    addresses = {}
+    col_title, col_add = st.columns([6, 1])
+    with col_title:
+        st.markdown('<div class="subsection-label">Manage Addresses</div>', unsafe_allow_html=True)
+    with col_add:
+        if len(ids) < MAX_FIELDS:
+            if st.button("＋", key=f"{prefix}add_address_{record_num}"):
+                ids.append(max(ids) + 1 if ids else 0)
+                st.rerun()
+    for idx, addr_id in enumerate(ids):
+        header_cols = st.columns([8, 1])
+        with header_cols[0]:
+            header_text = f"Address {addr_id + 1}" if addr_id > 0 else "Primary Address"
+            st.markdown(f"<div class='address-title'>{header_text}</div>", unsafe_allow_html=True)
+        with header_cols[1]:
+            if len(ids) > 1:
+                if st.button("−", key=f"{prefix}remove_address_{addr_id}_{record_num}"):
+                    ids.remove(addr_id)
+                    st.rerun()
+        addr_data = address_item_content(record_num, addr_id, prefix)
+        addresses.update(addr_data)
+        if idx < len(ids) - 1:
+            st.markdown("<hr style='margin:20px 0;border:none;border-top:1px solid #e1e4e8;'>", unsafe_allow_html=True)
+    return addresses
+
+def contact_section_content(record_num, prefix=""):
+    contacts = {}
+    r = prefix.strip("_")
+    phone_ids = st.session_state[f"phone_ids_{r}"]
+    email_ids = st.session_state[f"email_ids_{r}"]
+
+    st.markdown('<div class="subsection-label">📞 Phone Numbers</div>', unsafe_allow_html=True)
+    for i, phone_id in enumerate(phone_ids):
+        cols = st.columns([8, 1, 1])
+        with cols[0]:
+            phone_val = st.text_input(f"Phone {phone_id+1}", key=f"{prefix}phone_{phone_id}_{record_num}",
+                placeholder="Enter phone number", label_visibility="collapsed")
+            contacts[f"phone_{phone_id}"] = phone_val
+        with cols[1]:
+            if len(phone_ids) < MAX_FIELDS:
+                if st.button("＋", key=f"{prefix}add_phone_{phone_id}_{record_num}"):
+                    st.session_state[f"phone_ids_{r}"].append(max(phone_ids) + 1 if phone_ids else 0)
+                    st.rerun()
+        with cols[2]:
+            if len(phone_ids) > 1:
+                if st.button("−", key=f"{prefix}remove_phone_{phone_id}_{record_num}"):
+                    st.session_state[f"phone_ids_{r}"].remove(phone_id)
+                    st.rerun()
+
+    st.markdown('<hr class="section-divider">', unsafe_allow_html=True)
+    st.markdown('<div class="subsection-label">✉️ Email Addresses</div>', unsafe_allow_html=True)
+
+    for i, email_id in enumerate(email_ids):
+        cols = st.columns([8, 1, 1])
+        with cols[0]:
+            email_val = st.text_input(f"Email {email_id+1}", key=f"{prefix}email_{email_id}_{record_num}",
+                placeholder="Enter email address", label_visibility="collapsed")
+            contacts[f"email_{email_id}"] = email_val
+        with cols[1]:
+            if len(email_ids) < MAX_FIELDS:
+                if st.button("＋", key=f"{prefix}add_email_{email_id}_{record_num}"):
+                    st.session_state[f"email_ids_{r}"].append(max(email_ids) + 1 if email_ids else 0)
+                    st.rerun()
+        with cols[2]:
+            if len(email_ids) > 1:
+                if st.button("−", key=f"{prefix}remove_email_{email_id}_{record_num}"):
+                    st.session_state[f"email_ids_{r}"].remove(email_id)
+                    st.rerun()
+    return contacts
+
+def other_details_content(record_num, prefix=""):
+    col1, col2 = st.columns(2)
+    with col1:
+        company = st.text_input("Company Name", key=f"{prefix}companyname_{record_num}", placeholder="Enter company name")
+    with col2:
+        parent_company = st.text_input("Parent Company Name", key=f"{prefix}parentcompanyname_{record_num}", placeholder="Enter parent company name")
+    return {"companyname": company, "parentcompanyname": parent_company}
+
+# =========================================================
+# MAIN
+# =========================================================
+def main():
+    st.markdown('''
+    <div class="logo-title-container">
+        <div style="font-size:36px;">🔍</div>
+        <div class="header-title">Record Level Matching Using Transformer based Models</div>
+    </div>
+    ''', unsafe_allow_html=True)
+    st.markdown('<div class="header-subtitle">Enter details for two records below and click "Run Record Match" to see the matching result</div>', unsafe_allow_html=True)
+
+    # Mode selector (UI only — Embedding is the only functional mode here)
+    mode_col1, _ = st.columns([4, 6])
+    with mode_col1:
+        matching_mode = st.radio(
+            "Matching Mode",
+            ["Embedding Mode", "LLM Mode"],
+            key="matching_mode",
+            horizontal=True,
+            help="Embedding: Fuzzy/Token-based matching | LLM Mode: Requires external LLM server (unavailable in standalone)"
+        )
+
+    if matching_mode == "LLM Mode":
+        st.warning("⚠️ LLM Mode requires an external vLLM server. Falling back to Embedding (fuzzy) matching for standalone use.")
+
+    col1, col2 = st.columns(2)
+
+    with col1:
+        st.markdown('<div class="record-header">Record 1</div>', unsafe_allow_html=True)
+        r1_names = create_section_card("Personal Details", ICONS["user"], name_fields_content, 1, "r1_")
+        r1_identifiers = create_section_card("Equalities", ICONS["id"], identifier_fields_content, 1, "r1_")
+        r1_addresses = create_section_card("Address Details", ICONS["map"], addresses_section_content, 1, "r1_")
+        r1_contacts = create_section_card("Contact Information", ICONS["phone"], contact_section_content, 1, "r1_")
+        r1_other = create_section_card("Employment Details", ICONS["briefcase"], other_details_content, 1, "r1_")
+
+    with col2:
+        st.markdown('<div class="record-header">Record 2</div>', unsafe_allow_html=True)
+        r2_names = create_section_card("Personal Details", ICONS["user"], name_fields_content, 2, "r2_")
+        r2_identifiers = create_section_card("Equalities", ICONS["id"], identifier_fields_content, 2, "r2_")
+        r2_addresses = create_section_card("Address Details", ICONS["map"], addresses_section_content, 2, "r2_")
+        r2_contacts = create_section_card("Contact Information", ICONS["phone"], contact_section_content, 2, "r2_")
+        r2_other = create_section_card("Employment Details", ICONS["briefcase"], other_details_content, 2, "r2_")
+
+    if st.button("🚀 Run Record Match", type="primary", use_container_width=True):
+        r1 = {**r1_names, **r1_identifiers, **r1_addresses, **r1_contacts, **r1_other}
+        r2 = {**r2_names, **r2_identifiers, **r2_addresses, **r2_contacts, **r2_other}
+
+        # Pre-process
+        def process(r):
+            out = {}
+            for k, v in r.items():
+                k_str = str(k)
+                if k_str == "dob":
+                    out[k_str] = standardize_dob(v or "")
+                elif k_str.startswith("city_"):
+                    out[k_str] = standardize_city(v) if v else None
+                elif k_str.startswith("state_"):
+                    out[k_str] = standardize_state(v) if v else None
+                else:
+                    out[k_str] = preprocess_text(v) if isinstance(v, str) else v
+            return out
+
+        r1p = process(r1)
+        r2p = process(r2)
+
+        with st.spinner("Matching records..."):
+            raw_scores = match_records(r1p, r2p)
+
+            def fmt(v):
+                if v == -1:
+                    return "missing value"
+                return round(float(v), 2)
+
+            field_scores = {k: fmt(v) for k, v in raw_scores.items()}
+            overall_decision, reason = evaluate_rules(raw_scores)
+
+            result = {
+                "overall_decision": overall_decision,
+                "reason": reason,
+                "field_scores": field_scores,
+            }
+
+        st.markdown('''
+        <div class="result-box">
+            <div class="result-header">📊 Matching Result (JSON)</div>
+        </div>
+        ''', unsafe_allow_html=True)
+        st.json(result, expanded=True)
+
+if __name__ == "__main__":
+    main()