sorted

app.py

@@ -50,11 +50,46 @@ def load_resources():
     return industry_index, industry_chunks, circular_index, circular_chunks
 industry_index, industry_chunks, circular_index, circular_chunks = load_resources()
 
-def retrieve_relevant_chunks(query, index, chunks, top_k=5):
+def retrieve_relevant_chunks(query, index, chunks, top_k=10):
     model = load_sentence_transformer()
     query_embedding = model.encode([query], convert_to_numpy=True)
     distances, indices = index.search(query_embedding, top_k)
-    retrieved_chunks = [chunks[i] for i in indices[0]]
+    
+    # Get more chunks initially and filter for relevance
+    retrieved_chunks = []
+    query_lower = query.lower()
+    
+    # Check if query is about general term loans vs share financing
+    is_general_loan_query = any(term in query_lower for term in [
+        'term loan', 'manufacturing', 'documentation requirement', 
+        'credit sanction', 'loan sanction', 'general lending'
+    ]) and not any(term in query_lower for term in [
+        'share', 'debenture', 'bond', 'equity', 'capital market'
+    ])
+    
+    for i, idx in enumerate(indices[0]):
+        chunk_text = str(chunks[idx]).lower()
+        
+        # If it's a general loan query, deprioritize share-related chunks
+        if is_general_loan_query and any(term in chunk_text for term in [
+            'advances against shares', 'debentures', 'bonds', 'capital market',
+            'shareholding', 'equity acquisition'
+        ]):
+            # Skip clearly irrelevant share-related chunks for general loan queries
+            continue
+            
+        retrieved_chunks.append(chunks[idx])
+        if len(retrieved_chunks) >= 5:  # Return top 5 relevant chunks
+            break
+    
+    # If we don't have enough chunks, add some of the skipped ones
+    if len(retrieved_chunks) < 3:
+        for idx in indices[0]:
+            if len(retrieved_chunks) >= 5:
+                break
+            if chunks[idx] not in retrieved_chunks:
+                retrieved_chunks.append(chunks[idx])
+    
     return retrieved_chunks
     
 def circular_compliance():
@@ -68,29 +103,28 @@ def circular_compliance():
         if user_query:
             relevant_chunks = retrieve_relevant_chunks(user_query, circular_index, circular_chunks)
             context = "\n".join(relevant_chunks)
-            prompt =  f"""
+            prompt = f"""
 You are an expert RBI compliance analyst. Based on the provided RBI Master Circular on Management of Advances:
+
 {context}
+
 Please analyze the following scenario for compliance:
 {user_query}
-Provide a detailed compliance analysis with the following structure:
-1. Compliance Status:
-- Clear statement whether the scenario is compliant or non-compliant
-- Level of certainty in the assessment
-2. Relevant Circular Details:
-- Specific section(s) and paragraph references
-- Direct quotes from applicable sections where relevant
-3. Detailed Analysis:
-- Breakdown of key compliance requirements
-- Calculation/numerical analysis if applicable
-- Specific points of compliance/non-compliance
-4. Additional Considerations:
-- Related requirements or obligations
-- Monitoring/reporting requirements if applicable
-5. Recommendation:
-- Clear guidance on what needs to be done for compliance
-- Specific steps to address any non-compliance
-Please provide definitive guidance based solely on the circular content, avoiding ambiguity or speculation.
+
+CRITICAL INSTRUCTIONS:
+- If the provided context is about share financing, debentures, bonds, or capital market exposures, and the query is about GENERAL TERM LOANS, clearly state that the retrieved information is not relevant to the query
+- Focus ONLY on requirements that apply to standard term loans to manufacturing/business entities  
+- Do NOT conflate share financing requirements with general term loan requirements
+- If the context doesn't contain information relevant to the specific query, state this clearly and indicate what type of information would be needed
+
+Provide analysis with this structure:
+1. Relevance Assessment: Is the provided context relevant to the query?
+2. Actual Requirements: What are the real requirements for this scenario based on relevant sections?
+3. Documentation: Specific documents actually required
+4. Approval Process: Required approvals and delegation levels
+5. Compliance Steps: Practical steps for compliance
+
+Base your response ONLY on information directly relevant to the query type.
 Response:
 """
             chat_completion = client.chat.completions.create(