Fix graph db connection failed bug

recommender/graph_retrieval_vectordb.py

@@ -1,226 +1,232 @@
-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.")
+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 = None
+
+def get_driver():
+    global _driver
+    if _driver is None:
+        _driver = GraphDatabase.driver(NEO4J_URI, auth=(NEO4J_USER, NEO4J_PASS))
+    return _driver
+
+#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 get_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