Delete recommender

recommender/graph_retrieval_vectordb.py

@@ -1,226 +0,0 @@
-import google.generativeai as genai
-from neo4j import GraphDatabase
-import os
-import numpy as np
-import faiss
-from app 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

@@ -1,154 +0,0 @@
-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 app 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

@@ -1,215 +0,0 @@
-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