Upload 10 files

agents/chat.py

@@ -0,0 +1,68 @@
+import pandas as pd
+import google.generativeai as genai
+import os
+from data import eligibility_df
+
+#function for the chatbot functionality
+eligibility_lookup = {}
+for _, row in eligibility_df.iterrows():
+    card_name = row["Name"].strip()
+    eligibility_info = f"""
+        - Bank: {row['Bank']}
+        - Age: {row['Minimum Age']} to {row['Maximum Age']}
+        - Minimum Income: {row['Minimum Income (LPA)']} LPA
+        - Minimum Credit Score: {row['Minimum Credit Score']}
+        - Joining Fee: ₹{row['Joining fee']}
+        - Annual Fee: ₹{row['Annual fee']}
+    """
+    eligibility_lookup[card_name] = eligibility_info.strip()
+    
+# Function to handle chat interaction with Gemini
+def chat_with_gemini(user_query, user_message, chat_history, card_lookup): 
+    genai.configure(api_key=os.environ.get("api_key_4"))  
+    model4 = genai.GenerativeModel('gemini-1.5-flash-latest')
+    context = ""
+    for name, desc in list(card_lookup.items())[:5]:
+        eligibility_info = eligibility_lookup.get(name, "No eligibility or fee information available.")
+        full_desc = f"{desc}\n\nEligibility & Fees:\n{eligibility_info}"
+        context += f"{name}:\n{full_desc}\n\n"
+    recent_user_messages = [
+        msg["content"] for msg in chat_history if msg["role"] == "user"
+    ][-5:]
+
+    conversation = f"""
+        You are a helpful financial assistant. A user has already shared their overall credit card preferences.
+        
+        ### User’s Requirements:
+        {user_query}
+        
+        ### Credit Card Options:
+        {context}
+        
+        ### User's Follow-up Question:
+        {user_message}
+        
+        ### Recent User Messages:
+        {recent_user_messages}
+        
+        ### Instructions:
+        1. Answer the user's current question clearly and concisely.
+        2. Always consider the user's overall requirements above.
+        3. Use only the card descriptions provided. Do not assume or invent any card benefits.
+        4. If the user asks which card is best or suitable for their needs, use the user’s requirements above to select and explain.
+        5. Don't ask the user to restate their requirements — they're already provided above.
+    """
+    # print(conversation)
+    try:
+        response = model4.generate_content(conversation)
+        gemini_response = response.text
+
+        chat_history.append({"role": "user", "content": user_message})
+        chat_history.append({"role": "assistant", "content": gemini_response})
+
+    except Exception as e:
+        error_msg = "Error: Unable to retrieve response from Gemini. Please try again later."
+        chat_history.append({"role": "user", "content": user_message})
+        chat_history.append({"role": "assistant", "content": error_msg})
+
+    return chat_history, chat_history

agents/compare.py

@@ -0,0 +1,37 @@
+import pandas as pd
+import google.generativeai as genai
+import os
+
+#function to compare cards
+def compare_selected_cards(selected_names, card_lookup):
+    genai.configure(api_key=os.environ.get("api_key_4"))  
+    model4 = genai.GenerativeModel('gemini-1.5-flash-latest')
+    print(selected_names)
+    if not selected_names or len(selected_names) < 2:
+        return "<b style='color:red;'>Please select at least two cards to compare.</b>"
+
+    comparison_data = "\n\n".join([
+            f"{name}: {card_lookup.get(name)}" for name in selected_names
+        ])
+    prompt = (
+            f"Do not include extra symbols like (* or #), just generate a textual response maybe with numbers for points."
+            f"Compare the following credit cards based on their benefits. "
+            f"Keep the output short, structured, and very readable:\n\n"
+            f"{comparison_data}\n\n"
+            f"Use markdown format with clear section headers like 'Comparison' and 'Recommendation'. "
+            f"Present key differences as bullet points without using '*' symbols — use '-' instead. "
+            f"Make it crisp and avoid lengthy explanations. "
+            f"Conclude with a recommendation on which card suits which type of user."
+            f"DO NOT INCLUDE ANY SYMBOLS LIKE # OR *"
+    )
+    print("comparing")
+    try:
+        response = model4.generate_content(prompt)
+        return f"""
+            <div style='background-color: #f9fbe7; padding: 15px; border-radius: 10px; font-family: sans-serif;'>
+                <pre style='white-space: pre-wrap; font-size: 13px; color: #333;'>{response.text}</pre>
+            </div>
+            """
+    except Exception as e:
+        print("Comparison Error:", e)
+        return "<b style='color:red;'>Something went wrong while comparing. Please try again.</b>"

app.py

@@ -0,0 +1,3 @@
+from ui.gradio_interface import demo
+
+demo.launch(share=True)

data.py

@@ -0,0 +1,39 @@
+import json
+import pandas as pd
+
+#for adding bank name to the cards in the graph
+eligibility_df = pd.read_csv("cards_eligibility_updated.csv")
+card_to_bank = dict(zip(eligibility_df['Name'], eligibility_df['Bank']))
+
+# Loading credit card data
+df = pd.read_csv("credit_card_data_updated.csv")
+card_descriptions = dict(zip(df["name"], df["description"]))
+
+# Loading all 55 cards for comparison feature
+df_all_cards = pd.read_csv("credit_card_data_updated.csv") 
+all_card_names = df_all_cards["name"].tolist()
+all_card_lookup = dict(zip(df_all_cards["name"], df_all_cards["description"]))
+    
+with open('for_graph_construction_(expanded labels).json') as f:
+    card_feature_data = json.load(f)
+
+card_features_lookup = {
+    card['card_name']: set(card['features'])
+    for card in card_feature_data
+}
+
+
+#function for the chatbot functionality
+eligibility_lookup = {}
+for _, row in eligibility_df.iterrows():
+    card_name = row["Name"].strip()
+    eligibility_info = f"""
+        - Bank: {row['Bank']}
+        - Age: {row['Minimum Age']} to {row['Maximum Age']}
+        - Minimum Income: {row['Minimum Income (LPA)']} LPA
+        - Minimum Credit Score: {row['Minimum Credit Score']}
+        - Joining Fee: ₹{row['Joining fee']}
+        - Annual Fee: ₹{row['Annual fee']}
+    """
+    eligibility_lookup[card_name] = eligibility_info.strip()
+    

intent_classification/fd_classification.py

@@ -0,0 +1,21 @@
+import google.generativeai as genai
+import os
+
+#for intent classification
+def find_intent(user_query: str) -> bool:
+    genai.configure(api_key=os.environ.get("api_key_2"))  
+    model2 = genai.GenerativeModel('gemini-1.5-flash-latest')
+    prompt = f"""
+        You are a helpful assistant. A user has asked the following question or made the following request:
+        
+        "{user_query}"
+        
+        Determine ONLY whether this query is likely about FD-based (fixed deposit backed) credit cards.
+        These cards typically do not require a credit score, are suited for users with low income, users who are new to credit cards/beginners, who have no/low credit score or students.
+        
+        Respond with just "true" or "false" depending on whether the user's query is about such cards.
+        No explanation, no extra words — just true or false.
+    """
+    response = model2.generate_content(prompt)
+    result = response.text.strip().lower()
+    return result == "true"

intent_classification/retrieval_classification.py

@@ -0,0 +1,80 @@
+import google.generativeai as genai
+import pandas as pd
+import os
+import json
+from data import df_all_cards
+
+#handling intent classification for retrieval
+def handle_query_classification(user_query):
+    genai.configure(api_key=os.environ.get("api_key_1"))  
+    model1 = genai.GenerativeModel('gemini-1.5-flash-latest')
+    prompt = f"""
+        You are a smart financial assistant.
+        
+        ### User's Query:
+        {user_query}
+        
+        ### Task:
+        Classify the user's intent into one of the following categories:
+        1. "retrieve" → If the user is asking for card suggestions, recommendations, or showing cards (e.g., "suggest a card", "need a travel card") OR if they mention their lifestyle, income, spending, or needs (e.g., travel, shopping, fuel, rewards, luxury).
+        2. "specific" → If the user is asking about a particular credit card by name (even if the word "card" is not used). Examples: "Tell me about HDFC Regalia", "Is SBI Elite good?".
+        3. "no_retrieval" → ONLY if the query is generic (e.g., “What is credit score?”), casual chit-chat (e.g., “Hi”), or doesn’t mention any lifestyle, financial needs, or specific card names.
+
+        
+        Respond ONLY in the following JSON format:
+        If intent is "no_retrieval", you MUST include a helpful 'response' field.
+        If intent is "retrieve" or "specific", do NOT include any response or explanation.
+        
+        Respond in this exact format:
+        {{
+          "intent": "retrieve" | "specific" | "no_retrieval",
+          "response": "Only include this if intent is 'no_retrieval'"
+        }}
+        
+        """
+
+    raw_response = model1.generate_content(prompt).text.strip()
+
+    # Clean any markdown formatting if present
+    if raw_response.startswith("```"):
+        raw_response = raw_response.strip("`").strip()
+        if raw_response.startswith("json"):
+            raw_response = raw_response[len("json"):].strip()
+
+    try:
+        parsed = json.loads(raw_response)
+        return parsed
+    except Exception as e:
+        print("JSON parsing error:", e)
+        print("Raw response from LLM:", raw_response)
+        raise
+# result = handle_query_classification("Want to optimize my spending – travel often, premium hotels, and online shopping.")
+# if result["intent"] == "no_retrieval":
+#     print(result['response'])
+
+#passing the card mentioned in the user query
+def find_matching_card(user_query):
+    lowered_query = user_query.lower()
+    for _, row in df_all_cards.iterrows():
+        if row["name"].lower() in lowered_query:
+            return row.to_dict()
+    return None
+
+
+#for queries enquiring about a card
+def generate_card_response_with_context(user_query, card_info):
+    genai.configure(api_key=os.environ.get("api_key_1"))  
+    model1 = genai.GenerativeModel('gemini-1.5-flash-latest')
+    prompt = f"""
+You are a helpful financial assistant. A user has asked about a specific credit card.
+
+Card Name: {card_info.get('name')}
+Description: {card_info.get('description')}
+
+User's Question: {user_query}
+
+Please provide a concise, relevant answer using the above card context.
+"""
+    response = model1.generate_content(prompt)
+    return response.text.strip()
+

recommender/graph_retrieval_vectordb.py

@@ -0,0 +1,226 @@
+import google.generativeai as genai
+from neo4j import GraphDatabase
+import os
+import numpy as np
+import faiss
+from data import card_descriptions,eligibility_df
+
+#neo4j credentials
+NEO4J_URI = os.environ.get("NEO4J_URI")
+NEO4J_USER = os.environ.get("NEO4J_USER")
+NEO4J_PASS = os.environ.get("NEO4J_PASS")
+driver = GraphDatabase.driver(NEO4J_URI, auth=(NEO4J_USER, NEO4J_PASS))
+
+#generating cypher query
+def generate_cypher(user_query, query_intent, include_cobranded):
+    genai.configure(api_key='AIzaSyAHoi9xbYAThtjXlyF_IKFtruoWYoUCjJQ')  
+    model3 = genai.GenerativeModel('gemini-1.5-flash-latest')
+    print("inside cypher query gen")
+
+    context_note = f"""
+        Contextual Flags:
+        - FD Card intent: {query_intent}
+        - Include co-branded cards: {include_cobranded}
+    """
+
+    cypher_prompt = f"""
+        You are an expert Neo4j Cypher query generator.
+        
+        Given a user’s question, graph schema, and **contextual flags**, generate the correct Cypher query. The query should return only the cards `c`.
+        
+        ONLY output the Cypher query. Do NOT explain anything.
+        
+        ---
+        
+        Graph Schema:
+        - Nodes:
+          - (Card): Properties = name, bank_name, card_type, premium, co_branded
+          - (Feature): Properties = name
+        - Relationships:
+          - (Card)-[:HAS_FEATURE]->(Feature)
+          
+        Feature Inclusion Rules:
+        - Only include relevant features based on user query.
+        - Forex markup fee and foreign transaction fee are the same.
+        - If FD Card intent is true then include the features if the query contains any and also include “General Cashback” or “General Reward Points”
+        - Don’t add “General Cashback” or “General Reward Points” if it is not required.
+        - If fuel is mentioned, include both `Fuel Benefits` and `Fuel Surcharge Waiver`.
+        - **ALWAYS** match features using: `f.name IN [...]` — even if there is only **one** feature.
+        
+        
+        Valid values:
+        - card_type: 'FD Card' or 'Regular'
+        - premium: true (no concept of false — just include it if applicable)
+        - co_branded: true (no concept of false — just include it if applicable)
+        
+        MANDATORY Condition Rules:
+        - If FD Card intent is true → include: `c.card_type = 'FD Card'`
+        - Else → include: `c.card_type = 'Regular'`
+        - If the query is based on beginners or students or people with no or low credit history then use FD Card.
+        - If the query uses words like "premium", "elite", "luxury", "exclusive", "infinia", "black", etc. → include: `AND c.premium = true`
+        - If the query includes low spending, without high spending or budget → include: `(c.premium IS NULL OR c.premium = false)`
+        - If include co-branded is false → include: `AND (c.co_branded IS NULL OR c.co_branded = false)`
+        - Use exact values for `bank_name` as in the database: ["SBI", "HDFC", "Axis", "ICICI", "YES", "HSBC", "IDFC", "American Express", "SMB", "Federal Bank", "AU Bank", "IDBI", "Kotak Mahindra Bank","IndusInd","RBL"]
+        - Do not add bank after the name of the bank if it is not mentioned in the datase list.
+        - These conditions are **MANDATORY**. If they apply, include them in the `WHERE` clause. Do not skip them.
+        
+        ---
+        
+        Available features:
+          "General Cashback", "Fuel Surcharge Waiver", "Fuel Benefits", "Welcome Bonus",
+          "Airport Lounge Access", "General Reward Points", "Domestic Travel Benefits",
+          "Movie Benefits", "Flight Discounts", "International Travel Benefits",
+          "Hotel Benefits", "Dining Benefits", "Daily Spends (Grocery)", "Railway Benefits",
+          "Travel Benefits", "Railway Lounge", "Insurance", "Utility",
+          "E-commerce Platform Benefits", "Air Miles", "Spa Access Benefits",
+          "Lifestyle & Luxury Perks", "Golf Access & Perks", "Online Shopping Benefits",
+          "UPI Transaction Support", "Health Benefits", "EMI Conversion Options",
+          "No Forex Markup Fee", "Roadside Assistance", "Rupay Network Support",Super Premium Cards
+        
+        ---
+        
+        Few-shot Examples:
+        
+        User Query: Show premium cards with airport lounge access  
+        Cypher:
+        MATCH (c:Card)-[:HAS_FEATURE]->(f:Feature)
+        WHERE f.name IN ["Airport Lounge Access"]
+          AND c.card_type = 'Regular'
+          AND c.premium = true
+        RETURN c
+        
+        User Query: I want FD cards with spa access and golf perks  
+        Cypher:
+        MATCH (c:Card)-[:HAS_FEATURE]->(f:Feature)
+        WHERE f.name IN ["Spa Access Benefits", "Golf Access & Perks"]
+          AND c.card_type = 'FD Card'
+        RETURN c
+        
+        User Query: Cards that support UPI but are not co-branded  
+        Cypher:
+        MATCH (c:Card)-[:HAS_FEATURE]->(f:Feature)
+        WHERE f.name IN ["UPI Transaction Support"]
+          AND c.card_type = 'Regular'
+          AND (c.co_branded IS NULL OR c.co_branded = false)
+        RETURN c
+        
+        ---
+        
+        {context_note}
+        
+        User Query: {user_query}  
+        Cypher:
+    """
+
+    response = model3.generate_content(cypher_prompt.strip())
+    cypher_code = response.text.strip()
+
+    if cypher_code.startswith("```cypher"):
+        cypher_code = cypher_code[len("```cypher"):].strip()
+    elif cypher_code.startswith("```"):
+        cypher_code = cypher_code[len("```"):].strip()
+    if cypher_code.endswith("```"):
+        cypher_code = cypher_code[:-3].strip()
+
+    return cypher_code
+
+#generating embeddings (run only once)
+def chunk_text(text, chunk_size=1):
+    sentences = text.split("; ")
+    return ["; ".join(sentences[i:i+chunk_size]) for i in range(0, len(sentences), chunk_size)]
+
+def get_gemini_embeddings(text_list):
+    embeddings = []
+    print("Generating embeddings with Gemini...")
+    for text in text_list:
+        response = genai.embed_content(
+            model=model_name,
+            content=text,
+            task_type="RETRIEVAL_DOCUMENT")
+        embeddings.append(np.array(response["embedding"], dtype=np.float32))
+    return np.vstack(embeddings)
+
+# Chunk all card descriptions 
+chunk_texts = []
+chunk_name_mapping = {}
+for card_idx, (card_name, desc) in enumerate(card_descriptions.items()):
+    chunks = chunk_text(desc)
+    for chunk in chunks:
+        chunk_index = len(chunk_texts)
+        chunk_texts.append(chunk)
+        chunk_name_mapping[chunk_index] = card_name
+        
+genai.configure(api_key=os.environ.get("api_key_2"))
+model_name = "models/text-embedding-004"
+
+#Generating embeddings
+chunk_embeddings = get_gemini_embeddings(chunk_texts)
+faiss.normalize_L2(chunk_embeddings)
+
+print(f"Prepared {len(chunk_texts)} total chunks and embeddings.")
+
+#eligibility filter
+def eligibility_filter(cards, user_income, user_cibil, user_age,min_joining_fee, max_joining_fee,
+                            min_annual_fee, max_annual_fee): 
+    eligible_cards = []
+    print("inside filter")
+    for card_name in cards:
+        # print(eligibility_df.columns)
+
+        eligibility = eligibility_df[eligibility_df["Name"] == card_name]
+        
+        if not eligibility.empty:
+            min_income = eligibility.iloc[0]["Minimum Income (LPA)"]
+            min_cibil = eligibility.iloc[0]["Minimum Credit Score"]
+            min_age = eligibility.iloc[0]["Minimum Age"]
+            max_age = eligibility.iloc[0]["Maximum Age"]
+            joining_fee=eligibility.iloc[0]["Joining fee"]
+            annual_fee=eligibility.iloc[0]["Annual fee"]
+            if (user_income >= min_income and 
+                user_cibil >= min_cibil and 
+                min_age <= user_age <= max_age and
+                min_joining_fee<=joining_fee<=max_joining_fee and
+                min_annual_fee<=annual_fee<=max_annual_fee):
+                eligible_cards.append(card_name)
+
+    return eligible_cards
+
+
+
+#function for retrieving cards from knowledge graph
+class Neo4jConnectionError(Exception):
+    pass
+
+def run_cypher_query(user_query, query, use_eligibility, user_income, user_cibil, user_age,
+                     min_joining_fee, max_joining_fee, min_annual_fee, max_annual_fee):
+    
+    try:
+        with driver.session() as session:
+
+            result = session.run(query)
+            matched_cards = [record["c"] for record in result]
+            filtered_cards = [card["name"] for card in matched_cards]
+
+    except Exception as e:
+        raise Neo4jConnectionError("Failed to connect to the Neo4j database.") from e
+
+    if use_eligibility:
+        filtered_cards = eligibility_filter(filtered_cards, user_income, user_cibil, user_age,
+                                            min_joining_fee, max_joining_fee,
+                                            min_annual_fee, max_annual_fee)
+    
+    # for card in filtered_cards:
+    #     print("error")
+    #     print(card["name"])
+    relevant_indexes = [i for i, name in chunk_name_mapping.items() if name in filtered_cards]
+    filtered_embeddings = chunk_embeddings[relevant_indexes]
+    filtered_texts = [chunk_texts[i] for i in relevant_indexes]
+    filtered_mapping = {i: chunk_name_mapping[idx] for i, idx in enumerate(relevant_indexes)}
+
+    # Build FAISS index
+    dim = filtered_embeddings.shape[1]
+    faiss_index = faiss.IndexFlatIP(dim)
+    faiss_index.add(filtered_embeddings)
+
+    print(f"FAISS index created with {len(filtered_embeddings)} filtered chunks.")
+    return faiss_index, filtered_mapping

recommender/recommender.py

@@ -0,0 +1,154 @@
+import ast
+import re
+import pd
+import tempfile
+import os
+from intent_classification.fd_classification import find_intent
+from intent_classification.retrieval_classification import handle_query_classification,find_matching_card,generate_card_response_with_context
+from recommender.retrieval_ranking import generate_multi_queries,convert_to_direct_query_gradio,retrieve_and_rank_cards,generate_credit_card_recommendation_gemini,cross_encoder
+from data import eligibility_lookup,card_features_lookup
+from recommender.graph_retrieval_vectordb import generate_cypher,run_cypher_query,Neo4jConnectionError
+
+#function to pass the retrieved cards and generated response to the UI
+def recommend_cards_gradio(user_query, preferences, income, cibil, age,
+                           min_joining_fee, max_joining_fee,
+                           min_annual_fee, max_annual_fee,
+                           use_eligibility=True,include_cobranded=True):
+    try:
+        # print(user_query)
+        if(user_query):
+            result = handle_query_classification(user_query)
+
+            if result["intent"] == "no_retrieval":
+                return (
+                    f"<div style='background-color:#e3f2fd;padding:20px;border-radius:10px;'>"
+                    f"<pre style='white-space:pre-wrap;font-size:13px;color:#212121;'>{result['response']}</pre></div>",
+                    [["No retrieval required", "Answered using LLM"]],
+                    None,
+                    [],
+                    {},
+                    "Answered without retrieval"
+                )
+            elif result["intent"] == "specific":
+                matched_card = find_matching_card(user_query)
+                if matched_card:
+                    gemini_answer = generate_card_response_with_context(user_query, matched_card)
+                    card_name = matched_card["name"]
+                    card_desc = matched_card["description"]
+                    card_lookup = {card_name: card_desc}
+            
+                    # Constructing eligibility info if available
+                    eligibility_info = eligibility_lookup.get(card_name, "No eligibility or fee information available.")
+                    chat_history_entry = f"{card_name}:\n{card_desc}\n\nEligibility & Fees:\n{eligibility_info}"
+            
+                    return (
+                        f"<div style='background-color:#fffde7;padding:20px;border-radius:10px;'>"
+                        f"<pre style='white-space:pre-wrap;font-size:13px;color:#212121;'>{gemini_answer}</pre></div>",
+                        [["Specific card detected", card_name]],
+                        None,
+                        [],
+                        card_lookup,
+                        user_query 
+                    )
+                else:
+                    return (
+                        "<b style='color:red;'>Card mentioned not found in database.</b>",
+                        [["Card not found", "Try another card name."]],
+                        None,
+                        [],
+                        {},
+                        "Card not found"
+                    )
+        direct_query = convert_to_direct_query_gradio(user_query, preferences)
+        queries = generate_multi_queries(direct_query)
+
+        if cibil < 700 and use_eligibility:
+            query_intent = True
+        else:
+            query_intent = find_intent(user_query)
+            print(query_intent)
+        cypher_query = generate_cypher(direct_query, query_intent,include_cobranded)
+        print("Generated Cypher:\n", cypher_query)
+
+        try:
+            faiss_index, filtered_mapping = run_cypher_query(
+                user_query, cypher_query, use_eligibility,
+                income, cibil, age,
+                min_joining_fee, max_joining_fee,
+                min_annual_fee, max_annual_fee
+            )
+        except Neo4jConnectionError as graph_err:
+            return (
+                "<b style='color:red;'>Graph database connection failed. Please try again later.</b>",
+                [["Graph database error", str(graph_err)]],
+                None,
+                [],
+                {},
+                "Graph DB connection error"
+            )
+
+        cards = retrieve_and_rank_cards(faiss_index, filtered_mapping, direct_query, queries, top_k=10)
+        gemini_summary = generate_credit_card_recommendation_gemini(user_query, direct_query, cards)
+
+        if not cards:
+            return (
+                "<b style='color:red;'>No eligible cards found.</b>",
+                [["No eligible cards found", "Please try a different query or check your input values."]],
+                None,
+                [],
+                {},
+                "No eligible card found"
+            )
+
+        match = re.search(r"f\.name IN (\[.*?\])", cypher_query)
+        query_features = set(ast.literal_eval(match.group(1))) if match else set()
+
+        card_rows = []
+        for score, card in sorted(
+            zip(cross_encoder.predict([[direct_query, card["description"]] for card in cards]), cards),
+            reverse=True,
+            key=lambda x: x[0]
+        ):
+            card_name = card["name"]
+            card_desc = card["description"]
+            matched_features = query_features.intersection(card_features_lookup.get(card_name, set()))
+            feature_str = ", ".join(matched_features) if matched_features else "None"
+            card_rows.append([card_name, feature_str, card_desc])
+
+        
+        card_names = [row[0] for row in card_rows]
+        card_lookup = {row[0]: row[2] for row in card_rows}
+        top_card_html = f"""
+            <div style="
+                background-color: #fff3e0;
+                color: #212121;
+                border-radius: 16px;
+                padding: 20px;
+                border: 2px solid #ffa726;
+                box-shadow: 2px 2px 8px rgba(0,0,0,0.1);
+                margin-bottom: 16px;
+                font-family: sans-serif;
+                font-size: 8px;
+            ">
+                <pre style="white-space: pre-wrap; font-size: 13px; color: #212121;">{gemini_summary}</pre>
+            </div>
+        """
+
+        df_cards = pd.DataFrame(card_rows, columns=["Card Name", "Matched Features", "Description"])
+        filename = "recommended_cards.csv"
+        temp_dir = tempfile.gettempdir()
+        file_path = os.path.join(temp_dir, filename)
+        df_cards.to_csv(file_path, index=False)
+        
+        return top_card_html, card_rows, file_path, card_names, card_lookup, direct_query
+
+    except Exception as e:
+        print("Error:", e)
+        return (
+            "An unexpected error occurred. Please try again in a few minutes.",
+            [["Something went wrong", "Please try again."]],
+            None,
+            [],
+            {},
+            "Unexpected error occurred, please try again in a while"
+        )

recommender/retrieval_ranking.py

@@ -0,0 +1,215 @@
+import numpy as np
+import faiss
+from collections import defaultdict
+import os
+import google.generativeai as genai
+from sentence_transformers import CrossEncoder
+
+# Function to generate direct query using Gemini
+def convert_to_direct_query_gradio(user_query,preferences):
+    genai.configure(api_key=os.environ.get("api_key_2"))  
+    model2 = genai.GenerativeModel('gemini-1.5-flash-latest')
+    
+    preferences_text = ""
+    if preferences:
+        preferences_text = "User selected preferences: " + ", ".join(preferences) + "."
+    # Prompt with examples for indirect-to-direct conversion
+    prompt = f"""
+        You are an AI assistant that refines user queries to make them optimized for information retrieval while keeping the original intent.  
+    
+        Instructions:  
+        - Identify the main focus from the query.  
+        - Reformat the query in a structured way for better retrieval.  
+        - Ensure the most important feature appears first.  
+        - Use precise keywords that match credit card benefits.  
+        - Include the preferences also in the final query.  
+        - Do NOT introduce new benefits not mentioned by the user.  
+        - If the user uses vague terms like "vacation", interpret it as travel-related benefits including: airport lounge access, international/domestic travel, hotel benefits, forex waiver.  
+        - If the query includes terms like "beginner", "entry-level", or "low credit score", include essential features such as cashback, reward points, and basic offers.  
+        - If the query is empty, generate a useful retrieval-focused query based solely on preferences.  
+        
+        Examples:  
+    
+        Example 1  
+        - User Query: "I drive a lot for work and want a credit card with good fuel rewards and travel perks."  
+        - Optimized Query: "Category: Fuel Rewards | Best credit cards for high fuel spending with maximum rewards & fuel surcharge waiver. Travel perks preferred but secondary."  
+    
+        Example 2  
+        - User Query: "I mostly shop online and want a card that gives high cashback on e-commerce purchases. Food delivery perks would be nice."  
+        - Optimized Query: "Category: Online Shopping | Credit cards with best cashback on e-commerce platforms like Amazon, Flipkart. Food delivery benefits secondary."  
+    
+        Example 3  
+        - User Query: "I eat out a lot and also order food from Swiggy/Zomato. I want the best dining discounts and food delivery cashback."  
+        - Optimized Query: "Category: Dining & Food Delivery | Top credit cards offering the best dining discounts at restaurants and cashback on Swiggy/Zomato orders."  
+    
+        Now, optimize the following preferences and user query:  
+    
+        Preferences: "{preferences_text}"
+        User Query: "{user_query}"  
+    """
+
+    print("rewriting")
+    response = model2.generate_content(prompt)
+
+    print(response.text)
+    return response.text
+
+# Function to generate multiple focused subqueries from a user query
+def generate_multi_queries(direct_query, n=3):
+    genai.configure(api_key=os.environ.get("api_key_2"))  
+    model2 = genai.GenerativeModel('gemini-1.5-flash-latest')
+    prompt = f"""
+    The following is a detailed credit card search query:
+    "{direct_query}"
+    Generate {n} distinct subqueries that **collectively cover all the important features** from the original query.
+    Each subquery should emphasize a **different combination** of the features (e.g., lounge access, travel insurance, low foreign transaction fees, hotel discounts, etc.).
+    Keep the same format: "Category: ... | ...". Make sure all features from the original query are represented across the {n} queries.
+    Output only the subqueries, one per line. Do not include any explanations, numbering, or formatting — just plain queries separated by newline characters.
+    """
+    response = model2.generate_content(prompt)
+    # print(response.text)
+    queries = [q.strip() for q in response.text.strip().split('\n') if q.strip()]
+
+    return queries
+
+#retrieval 
+#Cross-Encoder Model
+cross_encoder = CrossEncoder("cross-encoder/ms-marco-MiniLM-L6-v2")
+
+def rerank_cards_mini(query, cards, top_n=5):
+    card_descriptions = [card["description"] for card in cards]
+    query_card_pairs = [[query, desc] for desc in card_descriptions]
+    scores = cross_encoder.predict(query_card_pairs)
+
+    #Normalizing
+    if len(scores) == 0 or (max(scores) - min(scores)) == 0:
+        scores = [1.0] * len(cards)
+    else:
+        scores = np.array(scores)
+        scores = (scores - scores.min()) / (scores.max() - scores.min())
+
+    # Sort cards by descending score
+    ranked_cards = sorted(zip(scores, cards), key=lambda x: x[0], reverse=True)
+    top_cards = [card for _, card in ranked_cards[:top_n]]
+
+    return top_cards
+    
+def retrieve_relevant_cards(user_query, index, chunk_name_mapping, df, top_k=15):
+    genai.configure(api_key=os.environ.get("api_key_2"))
+    model_name = "models/text-embedding-004"
+    print(f"\nUser Query: {user_query}")
+
+    # Generate and normalize query embedding
+    query_embedding = genai.embed_content(
+        model=model_name,
+        content=user_query,
+        task_type="RETRIEVAL_QUERY"
+    )["embedding"]
+    # query_embedding=model.encode(user_query)
+    query_embedding = np.array(query_embedding, dtype=np.float32)
+    faiss.normalize_L2(query_embedding.reshape(1, -1))
+
+    # Search FAISS index for top-k chunks
+    D, I = index.search(np.expand_dims(query_embedding, axis=0), top_k * 5)
+    similarity_scores = D[0]
+
+    # Map chunks back to unique card names with highest similarity per card
+    card_similarity = defaultdict(float)
+    card_dict = {card["name"]: card for card in df.to_dict(orient="records")}
+    unique_cards = {}
+
+    for i, chunk_idx in enumerate(I[0]):
+        if chunk_idx == -1:
+            continue
+        card_name = chunk_name_mapping[chunk_idx]
+        if card_name not in unique_cards or similarity_scores[i] > card_similarity[card_name]:
+            card_similarity[card_name] = similarity_scores[i]
+            unique_cards[card_name] = {
+                "name": card_name,
+                "description": card_dict[card_name]["description"],
+                "similarity": similarity_scores[i]
+            }
+
+    # Sort by similarity and take top_k
+    ordered_cards = sorted(unique_cards.values(), key=lambda x: x["similarity"], reverse=True)[:top_k]
+
+    print("\nTop Recommended Cards:")
+    for card in ordered_cards:
+        print(f"- {card['name']} (Similarity: {card['similarity']:.4f})")
+
+    return ordered_cards
+
+def retrieve_and_rank_cards(faiss_index,filtered_mapping,direct_query, queries, top_k=10):
+    all_retrieved=[]
+    for query in queries:
+            results = retrieve_relevant_cards(
+                query, faiss_index, filtered_mapping, df, 10
+            )
+    
+            reranked_cards = results[:5]
+            
+            all_retrieved.extend(reranked_cards)
+    
+    # Removing duplicates
+    seen = set()
+    unique_cards = []
+    for card in all_retrieved:
+        if card["name"] not in seen:
+            seen.add(card["name"])
+            unique_cards.append(card)
+    if not unique_cards:
+        return unique_cards
+    reranked_cards = rerank_cards_mini(direct_query, unique_cards, top_n=5)
+    return reranked_cards
+
+
+def generate_credit_card_recommendation_gemini(indirect_query,user_query,retrieved_cards, max_new_tokens=500):
+    genai.configure(api_key=os.environ.get("api_key_3"))  
+    model3 = genai.GenerativeModel('gemini-1.5-flash-latest')
+    print("using gemini")
+    if not retrieved_cards:
+        return "Unfortunately, no credit cards match your eligibility criteria."
+    for card in retrieved_cards:
+        print(f"Name: {card['name']}")
+        print(f"Description: {card['description']}\n")
+        
+    # Formatting retrieved cards for input context
+    cards_info = "\n\n".join([
+        f"{card['name']}\n"
+        f"- Description: {card['description']}\n\n"
+        for card in retrieved_cards
+    ])
+
+    # Gemini Prompt
+    gemini_prompt = f"""
+        You are a financial analyst specializing in credit cards and rewards optimization. 
+        Your task is to analyze and select the best credit card based on user priorities.
+        
+        ### User's Query:
+        {indirect_query+user_query}
+        
+        ### Available Credit Cards:
+        {cards_info}
+        
+        ### Instructions:
+        1️ Analyze the user's need from the given query .  
+        2️ Select the best card based on that primary need and only from the details present in the desctiption.Do not include details which are not explicitly mentioned. 
+        3️ Explain why it's the best choice (list benefits concisely).  
+        4 Do not assume and include benefits or features which is nor explicitly mentioned in the card description.
+        5 Mention the benefits only if it explicitly mentioned in the card description and if it is not mentioned just skip it and do not mention anything about it.
+        6 Do not include extra symbols like * or #, just generate a textual response maybe with numbers for points.
+        7️ If the user mentions they need FD-based cards or cards for students or if they have low credit score, assume all the provided cards are FD-based. Just compare them based on benefits and choose the best one.
+        8 If user asks for fd based cards and the descriptions do not mention it just pick a best card from the given list.
+        
+        ### Expected Output Format:
+        Best Card: [Card Name] 
+        Why It’s the Best:  
+        1️ [Primary Benefit] : [Explanation]  
+        2️ [Additional Perks] : [Explanation]  
+        3️ [Final Justification] : [Why it's the best fit]  
+    """
+
+    # Generate response using Gemini
+    response = model3.generate_content(gemini_prompt)
+
+    return response.text

ui/gradio_interface.py

@@ -0,0 +1,160 @@
+import gradio as gr
+from agents.chat import chat_with_gemini
+from agents.compare import compare_selected_cards
+from data import all_card_names,all_card_lookup
+from recommender.recommender import recommend_cards_gradio
+
+# Interface with Tabs
+with gr.Blocks() as demo:
+    gr.Markdown("# Credit Card Recommender")
+    gr.Markdown("Get personalized credit card suggestions based on your lifestyle and eligibility.")
+
+    with gr.Tabs():
+        
+        with gr.Tab(" Get Recommendations"):
+            with gr.Row():
+                user_query = gr.Textbox(
+                    label="Enter your query",
+                    info="E.g., 'Best cards for international travel' or 'I want cashback cards with lounge access'"
+                )
+                preferences = gr.CheckboxGroup(
+                    choices=["Cashback", "Travel Rewards", "Fuel Benefits", "International Lounge access",
+                            "Domestic Lounge access", "Railway benefits", "Dining", "Shopping"],
+                    label="Credit card categories:",
+                    info="Select the features or benefits you want from your credit card"
+                )
+
+            with gr.Accordion("Eligibility filters menu", open=False):
+                with gr.Row():
+                    income = gr.Slider(
+                        minimum=1, maximum=60, step=1,
+                        label="Annual Income (LPA) Minimum requirement is 2.5",
+                        info="Helps filter cards based on your income eligibility (in Lakhs Per Annum)"
+                    )
+                    cibil = gr.Slider(
+                        minimum=300, maximum=900, step=10,
+                        label="CIBIL Score",
+                        info="Most of the cards requires a credit score of 700+"
+                    )
+                    age = gr.Slider(
+                        minimum=18, maximum=75, step=1,
+                        label="Age",
+                        info="Some cards have minimum and maximum age eligibility"
+                    )
+
+                with gr.Row():
+                    min_joining_fee = gr.Number(
+                        label="Min Joining Fee (₹)", value=0,
+                        info="Minimum one-time fee to get the card"
+                    )
+                    max_joining_fee = gr.Number(
+                        label="Max Joining Fee (₹)", value=150000,
+                        info="Maximum one-time fee to get the card"
+                    )
+
+                with gr.Row():
+                    min_annual_fee = gr.Number(
+                        label="Min Annual Fee (₹)", value=0,
+                        info="Minimum yearly fee to be paid"
+                    )
+                    max_annual_fee = gr.Number(
+                        label="Max Annual Fee (₹)", value=150000,
+                        info="Maximum yearly fee to be paid"
+                    )
+
+            with gr.Row():
+                use_eligibility = gr.Checkbox(
+                    label="Apply Eligibility Filter", value=False,
+                    info="Enable this to get recommendations of the cards only for which you are eligible for"
+                )
+                include_cobranded = gr.Checkbox(
+                    label="Include Co-branded Cards", value=True,
+                    info="Include cards that are co-branded with airlines, retailers, etc."
+                )
+
+            submit_btn = gr.Button("Recommend Cards", variant='primary')
+
+            top_card_html = gr.HTML()
+            card_df = gr.Dataframe(headers=["Card Name", "Matched Features", "Description"])
+            card_file = gr.File(label="Download Full Recommendations (CSV)")
+
+        with gr.Tab(" Compare Cards"):
+            gr.Markdown("### Compare Recommended Cards")
+            compare_checkboxes = gr.CheckboxGroup(
+                choices=[], label="Select 2 or more cards to compare",
+                info="Pick 2+ cards from the recommended list to see a comparison"
+            )
+            compare_output = gr.HTML(value="<div style='min-height:100px'></div>", visible=True)
+            compare_btn = gr.Button("Compare Selected Cards", variant='primary')
+
+            gr.Markdown("### Compare Any Cards from Full List")
+            full_compare_dropdown = gr.Dropdown(
+                choices=all_card_names, multiselect=True, label="Select any 2+ cards",
+                info="Manually compare any cards from the full database"
+            )
+            full_compare_btn = gr.Button("Compare Selected Cards", variant='primary')
+            full_compare_output = gr.HTML(value="<div style='min-height:100px'></div>", visible=True)
+
+        with gr.Tab(" Ask Follow-up Questions"):
+            gr.Markdown("### Ask any follow-up question ")
+            chatbot = gr.Chatbot(type='messages')
+            user_query_for_chat = gr.Textbox(
+                label="Enter your question",
+                info="Ask follow-ups like 'Which card has better travel insurance?' or 'Which card has less annual fee'"
+            )
+            submit_query_btn = gr.Button("Submit Query", variant='primary')
+
+    card_names_state = gr.State()
+    card_lookup_state = gr.State()
+    chat_history = gr.State([]) 
+    query = gr.State([])
+
+    def wrapped_recommend_cards(user_query, preferences, income, cibil, age, min_joining_fee, max_joining_fee,
+                        min_annual_fee, max_annual_fee, use_eligibility,include_cobranded):
+        top_html, df, file, card_names, card_lookup, direct_query = recommend_cards_gradio(
+            user_query, preferences, income, cibil, age, min_joining_fee, max_joining_fee,
+            min_annual_fee, max_annual_fee, use_eligibility,include_cobranded
+        )
+        df_label = f"Found {len(card_names)} cards"
+        return top_html, gr.update(value=df, label=df_label), file, card_names, card_lookup, gr.update(choices=card_names, value=[]), direct_query
+
+    submit_btn.click(
+        fn=wrapped_recommend_cards,
+        inputs=[user_query, preferences, income, cibil, age, min_joining_fee, max_joining_fee,
+                min_annual_fee, max_annual_fee, use_eligibility,include_cobranded],
+        outputs=[top_card_html, card_df, card_file, card_names_state, card_lookup_state, compare_checkboxes,query]
+    )
+
+    compare_btn.click(
+        fn=compare_selected_cards,
+        inputs=[compare_checkboxes, card_lookup_state],
+        outputs=compare_output
+    )
+
+    full_compare_btn.click(
+        fn=lambda selected: compare_selected_cards(selected, all_card_lookup),
+        inputs=[full_compare_dropdown],
+        outputs=full_compare_output
+    )
+
+    submit_query_btn.click(
+        fn=chat_with_gemini, 
+        inputs=[query,user_query_for_chat, chat_history, card_lookup_state],
+        outputs=[chatbot, chat_history]
+    ).then(
+        lambda: gr.update(value=""),
+        inputs=[],
+        outputs=[user_query_for_chat]
+    )
+    
+    #for submitting using enter button
+    user_query_for_chat.submit(
+        fn=chat_with_gemini,
+        inputs=[query, user_query_for_chat, chat_history, card_lookup_state],
+        outputs=[chatbot, chat_history],
+        show_progress=True
+    ).then(
+        lambda: gr.update(value=""),
+        inputs=[],
+        outputs=[user_query_for_chat]
+    )