Refactored

app.py

@@ -13,10 +13,16 @@ import threading
 from typing import List, Dict, Any, Optional
 from functools import lru_cache
 
-import gradio as gr
-from langchain_openai import ChatOpenAI, OpenAIEmbeddings
-from langchain_community.vectorstores import Chroma
-from langchain.text_splitter import RecursiveCharacterTextSplitter
+try:
+    # Import required libraries
+    import gradio as gr
+    from langchain_openai import ChatOpenAI, OpenAIEmbeddings
+    from langchain_community.vectorstores import Chroma
+    from langchain.text_splitter import RecursiveCharacterTextSplitter
+except ImportError as e:
+    print(f"Error importing required libraries: {e}")
+    print("Please install required packages: pip install -r requirements.txt")
+    sys.exit(1)
 
 # =======================================
 # API Key & Workflow Logging
@@ -43,10 +49,24 @@ def clear_workflow_log():
 
 
 def get_workflow_log() -> str:
-    return "\n".join(
-        f"**[{e['time']}]** {e['step']}" + (f" — {e['details']}" if 'details' in e else '')
-        for e in WORKFLOW_LOG
-    )
+    if not WORKFLOW_LOG:
+        return "No workflow steps recorded yet."
+
+    log_text = "## Workflow Execution Log:\n\n"
+    for entry in WORKFLOW_LOG:
+        log_text += f"**[{entry['time']}]** {entry['step']}"
+        if 'details' in entry and entry['details']:
+            details = entry['details']
+            if isinstance(details, dict):
+                for k, v in details.items():
+                    if isinstance(v, str) and len(v) > 100:
+                        details[k] = v[:100] + "..."
+                log_text += f"``````\n"
+            else:
+                log_text += f"{details}\n"
+        log_text += "\n"
+
+    return log_text
 
 # =======================================
 # Tax Regulation Database
@@ -153,8 +173,6 @@ KB_INSTANCES: Dict[str, 'KnowledgeBase'] = {}
 COMMON_COUNTRIES = ["India", "China"]
 DOMAINS = ["banking", "credit", "tax"]
 
-# Placeholder for class KnowledgeBase declaration
-
 # =======================================
 # RAG Knowledge Base
 # =======================================
@@ -258,9 +276,102 @@ class CoordinatorAgent:
         self.specialists = {
             "banking": BankingAdvisor(),
             "credit":  CreditBuilder(),
-            "tax":      TaxSpecialist()
+            "tax":     TaxSpecialist()
         }
 
+    def _identify_relevant_specialists(self, query: str) -> List[str]:
+        """Identify which specialists are relevant to the query"""
+        log_workflow("Analyzing query to identify relevant specialists")
+
+        relevance_prompt = f"""
+        Based on this financial query from an international student:
+        "{query}"
+
+        Which of the following specialist advisors should be consulted? Choose only the relevant ones.
+        - banking (Banking Advisor: bank accounts, account types, transfers, documentation)
+        - credit (Credit Builder: credit cards, credit scores, credit history)
+        - tax (Tax Specialist: income taxes, tax treaties, FBAR, tax forms)
+
+        Return a comma-separated list of ONLY the relevant domain codes (e.g., "banking,credit").
+        """
+
+        try:
+            response = self.llm.invoke(relevance_prompt)
+            domains = [domain.strip().lower() for domain in response.content.split(',')]
+            valid_domains = [domain for domain in domains if domain in self.specialists]
+
+            # Add tax domain if query mentions tax
+            if "tax" not in valid_domains and "tax" in query.lower():
+                valid_domains.append("tax")
+
+            log_workflow("Identified relevant specialists", {"domains": valid_domains})
+            return valid_domains
+        except Exception as e:
+            log_workflow("Error identifying specialists", str(e))
+            # Default to essential domains if there's an error
+            default_domains = ["banking"]
+            if "tax" in query.lower():
+                default_domains.append("tax")
+            if "credit" in query.lower():
+                default_domains.append("credit")
+            return default_domains
+
+    def process_query(self, query: str, country: str) -> str:
+        """Process a query from an international student"""
+        log_workflow("Processing query", {"query": query, "country": country})
+
+        # Identify relevant specialists
+        relevant_domains = self._identify_relevant_specialists(query)
+
+        # Get advice from each relevant specialist
+        specialist_advice = {}
+        for domain in relevant_domains:
+            specialist = self.specialists[domain]
+            advice = specialist.run(query, country)
+            specialist_advice[domain] = advice
+
+        # Synthesize advice from specialists
+        final_advice = self._synthesize_advice(query, country, specialist_advice)
+
+        return final_advice
+
+    def _synthesize_advice(self, query: str, country: str, specialist_advice: Dict[str, str]) -> str:
+        """Synthesize advice from multiple specialists into a coherent response"""
+        log_workflow("Synthesizing advice from specialists")
+
+        # Create a consolidated advice text
+        advice_sections = []
+        for domain, advice in specialist_advice.items():
+            advice_sections.append(f"## {domain.capitalize()} Advice\n\n{advice}")
+
+        consolidated_advice = "\n\n".join(advice_sections)
+
+        synthesis_prompt = f"""
+        As a financial advisor for international students, synthesize this specialist advice into a coherent response.
+
+        STUDENT QUERY:
+        {query}
+
+        COUNTRY:
+        {country}
+
+        SPECIALIST ADVICE:
+        {consolidated_advice}
+
+        Create a comprehensive, well-organized response that integrates all relevant advice.
+        Begin with a summary of key recommendations, then provide detailed sections for each area.
+        """
+
+        try:
+            response = self.llm.invoke(synthesis_prompt)
+            final_advice = response.content
+            log_workflow("Synthesized final advice", {"length": len(final_advice)})
+            return final_advice
+        except Exception as e:
+            log_workflow("Error synthesizing advice", str(e))
+            # Fallback to concatenated advice
+            return "# Financial Advice Summary\n\n" + consolidated_advice
+
     def run(self, query: str, profile: Dict[str,Any]) -> str:
         clear_workflow_log()
         country = profile.get("home_country", "unknown")
@@ -285,29 +396,40 @@ class CoordinatorAgent:
         )
         try:
             plans_resp = self.llm.invoke(plans_prompt)
-            plans = json.loads(plans_resp.content)
+            plans_text = plans_resp.content
+            # Clean up the response to ensure it's valid JSON
+            plans_text = plans_text.strip()
+            if plans_text.startswith("```json"):
+                plans_text = plans_text.split("```json")[1]
+            if plans_text.endswith("```"):
+                plans_text = plans_text.split("```")[0]
+            plans = json.loads(plans_text)
         except Exception as e:
             log_workflow("Error generating multi-path plans", str(e))
-            plans = {"conservative": "...", "balanced": "...", "growth": "..."}
+            plans = {
+                "conservative": "Conservative investment strategy focusing on safety",
+                "balanced": "Balanced approach with moderate risk and return",
+                "growth": "Growth-oriented strategy with higher risk and potential return"
+            }
 
         # 3. Build the formatted output using a string builder approach
         lines: List[str] = []
         lines.append("# Your Personalized Financial Advice")
         for domain, text in advice_map.items():
             lines.append(f"## {domain.capitalize()}")
-            for paragraph in text.split(" "):
-                for line in paragraph.split(" "):
-                    lines.append("    " + line)
-                lines.append("")
+            for paragraph in text.split("\n\n"):  # Split by paragraphs
+                lines.append(paragraph)
+                lines.append("")  # Add empty line between paragraphs
 
         lines.append("## Multi-Path Plans")
-        lines.append("```json")
+        lines.append("```")
         lines.append(json.dumps(plans, indent=2))
         lines.append("```")
 
         formatted = "\n".join(lines)
         log_workflow("Synthesis complete")
-        return formatted + " " + get_workflow_log()
+        return f"{formatted}\n\n---\n\n{get_workflow_log()}"
+
 
 
 # =======================================