Refactored

app.py

@@ -6,254 +6,1002 @@ Self-reflection, and Multi-path Plan Generator
 """
 
 import os
+import sys
 import time
 import json
-from typing import List, Dict, Any
-
-import gradio as gr
-from langchain_community.document_loaders import DirectoryLoader, PyPDFLoader
-from langchain.text_splitter import RecursiveCharacterTextSplitter
-from langchain_openai import OpenAIEmbeddings, ChatOpenAI
-from langchain_community.vectorstores import Chroma
-
-
-# =======================================
-# Configuration & Workflow Logging
-# =======================================
-
-api_key = os.getenv("OPENAI_API_KEY")
+from typing import List, Dict, Any, Optional
+
+try:
+    # Import required libraries
+    import gradio as gr
+    from langchain.agents import AgentExecutor, create_openai_tools_agent
+    from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+    from langchain_core.messages import AIMessage, HumanMessage, SystemMessage
+    from langchain_core.tools import BaseTool, StructuredTool, tool
+    from langchain_openai import ChatOpenAI
+    from langchain_community.vectorstores import Chroma
+    from langchain_openai import OpenAIEmbeddings
+    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)
+
+# Set up API Key
+api_key = os.environ.get("OPENAI_API_KEY")
 if not api_key:
     api_key = input("Please enter your OpenAI API key: ")
     os.environ["OPENAI_API_KEY"] = api_key
 
-WORKFLOW_LOG: List[Dict[str, Any]] = []
+# Global workflow log to track the execution flow
+WORKFLOW_LOG = []
 
-def log_workflow(step: str, details: Any = None):
+def log_workflow(step, details=None):
+    """Add a step to the workflow log"""
     timestamp = time.strftime("%H:%M:%S")
     entry = {"time": timestamp, "step": step}
-    if details is not None:
+    if details:
         entry["details"] = details
     WORKFLOW_LOG.append(entry)
     print(f"[{timestamp}] {step}{': ' + str(details) if details else ''}")
 
-def get_workflow_log() -> str:
+def get_workflow_log():
+    """Get the workflow log as formatted text"""
     if not WORKFLOW_LOG:
         return "No workflow steps recorded yet."
-    return "\n".join(
-        f"**[{e['time']}]** {e['step']}" + (f" — {e['details']}" if 'details' in e else '')
-        for e in WORKFLOW_LOG
-    )
-
-def clear_workflow_log():
-    WORKFLOW_LOG.clear()
 
+    log_text = "## Workflow Execution Log:\n\n"
+    for entry in WORKFLOW_LOG:
+        log_text += f"**[{entry['time']}]** {entry['step']}\n"
+        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"
+
+    return log_text
 
-# =======================================
-# RAG Setup: Preload and Index Documents
-# =======================================
-
-EMBEDDINGS = OpenAIEmbeddings()
-SPLITTER = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
-DOMAIN_VECTOR_STORES: Dict[str, Chroma] = {}
-
-for domain in ["banking", "credit", "budget", "currency", "loans", "career", "legal"]:
-    log_workflow("Indexing domain documents", domain)
-    docs = []
-
-    # Load .txt files
-    try:
-        loader_txt = DirectoryLoader(f"data/{domain}", glob="**/*.txt")
-        docs.extend(loader_txt.load())
-    except FileNotFoundError:
-        log_workflow("No text docs for domain", domain)
-
-    # Load .pdf files
-    data_path = f"data/{domain}"
-    if os.path.isdir(data_path):
-        for file in os.listdir(data_path):
-            if file.lower().endswith(".pdf"):
-                try:
-                    loader_pdf = PyPDFLoader(os.path.join(data_path, file))
-                    docs.extend(loader_pdf.load())
-                except Exception as e:
-                    log_workflow("Error loading PDF", {"file": file, "error": str(e)})
-
-    if not docs:
-        log_workflow("No documents loaded for domain", domain)
-
-    chunks = SPLITTER.split_documents(docs)
-    store = Chroma.from_documents(chunks, EMBEDDINGS, collection_name=domain)
-    DOMAIN_VECTOR_STORES[domain] = store
-    log_workflow("Domain indexed", domain)
+def clear_workflow_log():
+    """Clear the workflow log"""
+    global WORKFLOW_LOG
+    WORKFLOW_LOG = []
+
+# Data collector for international students
+class InternationalStudentDataCollector:
+    """Collects financial data for international students from different countries"""
+
+    def __init__(self):
+        """Initialize the data collector with a model for generating data"""
+        self.llm = ChatOpenAI(temperature=0.1, model="gpt-3.5-turbo")
+        self.cache = {}
+
+    def _get_data_with_caching(self, prompt_key, prompt):
+        """Get data with caching to avoid repeated API calls"""
+        log_workflow(f"Collecting data for {prompt_key}")
+
+        if prompt_key in self.cache:
+            log_workflow("Using cached data")
+            return self.cache[prompt_key]
+
+        try:
+            response = self.llm.invoke(prompt)
+            facts = [line.strip() for line in response.content.split('\n') if line.strip()]
+            self.cache[prompt_key] = facts
+            log_workflow(f"Collected {len(facts)} facts")
+            return facts
+        except Exception as e:
+            log_workflow("Error collecting data", str(e))
+            return [f"Error retrieving information: {str(e)}"]
+
+    def get_banking_data(self, country):
+        """Get banking information for international students from specific country"""
+        prompt_key = f"banking_{country.lower()}"
+        banking_prompt = f"""
+        Provide 5 specific, actionable facts about banking options for international students from {country} in the United States.
+        Focus on:
+        1. The best US banks that offer accounts for {country} students with minimal fees
+        2. Exact documentation requirements for {country} students to open an account
+        3. Special features available to international students from {country}
+        4. Precise fee structures and minimum balances for recommended accounts
+        5. Best options for international money transfers between {country} and US
+
+        Format as a list of factual, specific statements, one per line.
+        Be extremely specific and include bank names, exact documentation needed, and fee amounts where possible.
+        """
+
+        return self._get_data_with_caching(prompt_key, banking_prompt)
+
+    def get_credit_data(self, country):
+        """Get credit building information for international students from specific country"""
+        prompt_key = f"credit_{country.lower()}"
+        credit_prompt = f"""
+        Provide 5 specific, actionable facts about credit building options for international students from {country} in the United States.
+        Focus on:
+        1. Exact credit card options available to {country} students without US credit history (with specific bank names)
+        2. Precisely how {country} credit history can or cannot be used in the US (e.g., Nova Credit)
+        3. Detailed secured credit card requirements and deposit amounts for specific cards
+        4. Step-by-step strategies for building credit scores for {country} nationals
+        5. Specific credit-building pitfalls that {country} students should avoid
+
+        Format as a list of factual, specific statements, one per line.
+        Include exact credit card names, specific dollar amounts for deposits, and precise steps where possible.
+        """
+
+        return self._get_data_with_caching(prompt_key, credit_prompt)
+
+    def get_budget_data(self, country):
+        """Get budget management information for international students from specific country"""
+        prompt_key = f"budget_{country.lower()}"
+        budget_prompt = f"""
+        Provide 5 specific, actionable facts about budget management for international students from {country} in the United States.
+        Focus on:
+        1. Exact breakdown of typical monthly expenses for {country} students in the US (with dollar amounts)
+        2. Specific money transfer services popular with {country} students (with fee structures)
+        3. Detailed tax implications for {country} students with TA/RA stipends (including tax treaty benefits)
+        4. Names of specific budget apps or tools popular with {country} students
+        5. Step-by-step plan for managing a $2,500 monthly TA stipend, including saving for emergencies
+
+        Format as a list of factual, specific statements, one per line.
+        Include exact dollar amounts, percentages, and specific service names where possible.
+        """
+
+        return self._get_data_with_caching(prompt_key, budget_prompt)
+
+    def get_currency_data(self, country):
+        """Get currency exchange information for international students from specific country"""
+        prompt_key = f"currency_{country.lower()}"
+        currency_prompt = f"""
+        Provide 5 specific, actionable facts about currency exchange and international money transfers for {country} students in the US.
+        Focus on:
+        1. Current exchange rate trends between {country} currency and USD (with specific ranges)
+        2. Exact fee structures of money transfer services for {country}-US transfers (Wise, Remitly, etc.)
+        3. Specific regulatory considerations for moving money from {country} to US (limits, documentation)
+        4. Precise breakdown of hidden fees and exchange rate markups typical in {country}-US transfers
+        5. Step-by-step strategies for optimizing currency exchange for {country} students
+
+        Format as a list of factual, specific statements, one per line.
+        Include exact service names, fee percentages, and dollar amounts where possible.
+        """
+
+        return self._get_data_with_caching(prompt_key, currency_prompt)
+
+    def get_loan_data(self, country):
+        """Get student loan information for international students from specific country"""
+        prompt_key = f"loan_{country.lower()}"
+        loan_prompt = f"""
+        Provide 5 specific, actionable facts about student loan options for international students from {country} studying in the US.
+        Focus on:
+        1. Names of specific education loan providers in {country} for international study (with interest rates)
+        2. Exact US-based lenders that serve {country} students without US cosigners (Prodigy, MPOWER, etc.)
+        3. Precise interest rates and terms for various {country} student loan options
+        4. Specific collateral requirements for loans to {country} students (with dollar amounts)
+        5. Names of loan forgiveness or assistance programs available to {country} students
+
+        Format as a list of factual, specific statements, one per line.
+        Include exact lender names, interest rate percentages, and dollar amounts where possible.
+        """
+
+        return self._get_data_with_caching(prompt_key, loan_prompt)
+
+    def get_career_data(self, country):
+        """Get career financial planning information for international students from specific country"""
+        prompt_key = f"career_{country.lower()}"
+        career_prompt = f"""
+        Provide 5 specific, actionable facts about career financial planning for international students from {country} in the US.
+        Focus on:
+        1. Exact F-1 visa work restrictions and opportunities (with hour limits and eligible positions)
+        2. Detailed CPT/OPT regulations affecting {country} students (application timeline, costs)
+        3. Step-by-step financial planning for summer internships specifically for {country} students
+        4. Specific post-graduation work authorization financial considerations (with costs and timeline)
+        5. Precise salary negotiation strategies and benefits evaluation for {country} nationals
+
+        Format as a list of factual, specific statements, one per line.
+        Include exact hour limits, application fees, timeline durations, and dollar amounts where possible.
+        """
+
+        return self._get_data_with_caching(prompt_key, career_prompt)
+
+    def get_legal_data(self, country):
+        """Get legal financial information for international students from specific country"""
+        prompt_key = f"legal_{country.lower()}"
+        legal_prompt = f"""
+        Provide 5 specific, actionable facts about legal financial considerations for international students from {country} in the US.
+        Focus on:
+        1. Exact visa maintenance financial requirements for {country} students (with dollar amounts)
+        2. Specific tax treaty benefits between US and {country} (with article numbers and percentage rates)
+        3. Detailed FBAR and foreign account reporting requirements for {country} nationals ($10,000 threshold, etc.)
+        4. Precise financial documentation needed for visa renewals/applications (with dollar amounts)
+        5. Specific legal implications of different types of income for {country} students on F-1 visas
+
+        Format as a list of factual, specific statements, one per line.
+        Include exact dollar thresholds, tax treaty article numbers, and specific form names where possible.
+        """
+
+        return self._get_data_with_caching(prompt_key, legal_prompt)
 
 
 # =======================================
-# Knowledge Base (RAG Retrieval)
+# Knowledge Base (RAG Implementation)
 # =======================================
 
 class KnowledgeBase:
+    """RAG implementation for domain-specific knowledge retrieval"""
+
     def __init__(self, domain: str):
+        """Initialize the knowledge base for a specific domain"""
         self.domain = domain
-        self.retriever = DOMAIN_VECTOR_STORES[domain].as_retriever(search_kwargs={"k": 3})
+        self.vector_store = None
+        self.retriever = None
+        self.data_collector = InternationalStudentDataCollector()
+        self.embeddings = OpenAIEmbeddings()
+
+    def _initialize_for_country(self, country: str):
+        """Initialize the vector store for a specific country"""
+        domain_key = f"{self.domain}_{country.lower()}"
+        log_workflow(f"Initializing knowledge base", {"domain": self.domain, "country": country})
+
+        if self.vector_store is not None:
+            log_workflow("Using existing vector store")
+            return
+
+        # Get country-specific data from the data collector
+        if self.domain == "banking":
+            domain_texts = self.data_collector.get_banking_data(country)
+        elif self.domain == "credit":
+            domain_texts = self.data_collector.get_credit_data(country)
+        elif self.domain == "budget":
+            domain_texts = self.data_collector.get_budget_data(country)
+        elif self.domain == "currency":
+            domain_texts = self.data_collector.get_currency_data(country)
+        elif self.domain == "loans":
+            domain_texts = self.data_collector.get_loan_data(country)
+        elif self.domain == "career":
+            domain_texts = self.data_collector.get_career_data(country)
+        elif self.domain == "legal":
+            domain_texts = self.data_collector.get_legal_data(country)
+        else:
+            domain_texts = [f"General information for {self.domain} domain for {country} international students."]
+
+        log_workflow(f"Creating vector store with {len(domain_texts)} documents")
+
+        # Create text splitter for chunking
+        text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=100)
+        splits = text_splitter.split_text("\n\n".join(domain_texts))
+
+        # Create vector store with embeddings
+        try:
+            self.vector_store = Chroma.from_texts(
+                splits,
+                self.embeddings,
+                collection_name=domain_key
+            )
+
+            # Create retriever for similarity search
+            self.retriever = self.vector_store.as_retriever(
+                search_type="similarity",
+                search_kwargs={"k": 3}
+            )
+            log_workflow("Vector store created successfully")
+        except Exception as e:
+            log_workflow("Error creating vector store", str(e))
+            # We'll fall back to direct retrieval if vector storage fails
 
     def retrieve(self, query: str, country: str) -> List[str]:
-        log_workflow(f"Retrieving {self.domain} knowledge", {"query": query[:50], "country": country})
-        docs = self.retriever.get_relevant_documents(query)
-        snippets = [doc.page_content for doc in docs]
-        log_workflow(f"Retrieved {len(snippets)} snippets")
-        return snippets
+        """Retrieve relevant information using vector similarity search"""
+        log_workflow(f"RAG Pattern: Retrieving {self.domain} knowledge", {"query": query[:50], "country": country})
+
+        try:
+            # Initialize the vector store if needed
+            self._initialize_for_country(country)
+
+            if self.retriever:
+                # Use the retriever to find similar content
+                documents = self.retriever.get_relevant_documents(query)
+                results = [doc.page_content for doc in documents]
+                log_workflow(f"Retrieved {len(results)} relevant documents")
+                return results
+            else:
+                raise ValueError("Retriever not initialized properly")
+        except Exception as e:
+            log_workflow("Error in RAG retrieval, falling back to direct retrieval", str(e))
+            # Fallback to direct retrieval if vector storage fails
+            if self.domain == "banking":
+                return self.data_collector.get_banking_data(country)
+            elif self.domain == "credit":
+                return self.data_collector.get_credit_data(country)
+            elif self.domain == "budget":
+                return self.data_collector.get_budget_data(country)
+            elif self.domain == "currency":
+                return self.data_collector.get_currency_data(country)
+            elif self.domain == "loans":
+                return self.data_collector.get_loan_data(country)
+            elif self.domain == "career":
+                return self.data_collector.get_career_data(country)
+            elif self.domain == "legal":
+                return self.data_collector.get_legal_data(country)
+            else:
+                return [f"Information about {self.domain} for {country} international students."]
 
 
 # =======================================
-# Specialist Agents (Role-based Cooperation)
+# Domain Specialist Agents
 # =======================================
 
 class SpecialistAgent:
+    """Base class for specialist agents with domain expertise"""
+
     def __init__(self, name: str, domain: str, llm=None):
+        """Initialize a specialist agent with domain expertise"""
         self.name = name
-        self.kb = KnowledgeBase(domain)
-        self.llm = llm or ChatOpenAI(temperature=0.2)
+        self.domain = domain
+        self.knowledge_base = KnowledgeBase(domain)
+        self.llm = llm if llm else ChatOpenAI(temperature=0.2)
 
     def run(self, query: str, country: str) -> str:
-        log_workflow(f"{self.name}: analyzing", {"query": query[:50]})
-        snippets = self.kb.retrieve(query, country)
-        context = "\n".join(f"- {s}" for s in snippets)
+        """Run the specialist agent to get domain-specific advice"""
+        log_workflow(f"Role-based Cooperation: {self.name} analyzing query", {"query": query[:50]})
+
+        # Get country-specific knowledge using RAG
+        knowledge = self.knowledge_base.retrieve(query, country)
+
+        # Join the knowledge items with newlines
+        knowledge_text = "\n".join('- ' + item for item in knowledge)
+
+        # Prepare a detailed prompt with the knowledge and query
         prompt = f"""
-As the {self.name} for {country} students, use these references:
-{context}
+        As a specialist {self.name} for international students, provide detailed, specific financial advice for a student from {country}.
+
+        STUDENT QUERY:
+        {query}
+
+        RELEVANT KNOWLEDGE FROM RAG:
+        {knowledge_text}
+
+        Provide extremely detailed, actionable advice addressing the query with these requirements:
+        1. Include specific bank/service/product names with exact fees or rates where applicable
+        2. Provide step-by-step instructions for any processes (account opening, credit building, etc.)
+        3. Include specific dollar amounts, percentages, and time frames
+        4. List exact documentation requirements where relevant
+        5. Address all aspects of the query related to your domain of {self.domain}
+
+        Format your response with clear sections, bullet points, and numbered steps.
+        """
+
+        try:
+            log_workflow(f"{self.name} generating advice")
+            response = self.llm.invoke(prompt)
+            advice = response.content
+            log_workflow(f"{self.name} generated advice", {"length": len(advice)})
+            return advice
+        except Exception as e:
+            log_workflow(f"Error in {self.name}", str(e))
+            return f"The {self.name} encountered an issue: {str(e)}"
+
+
+# Specialized agent implementations
+class BankingAdvisor(SpecialistAgent):
+    """Specialist agent for banking advice"""
+    def __init__(self, llm=None):
+        super().__init__(name="Banking Advisor", domain="banking", llm=llm)
 
-QUESTION:
-{query}
 
-Provide:
-1. Specific products and fees
-2. Step-by-step instructions
-3. Documentation requirements
-4. Exact dollar amounts and timeframes
-"""
-        log_workflow(f"{self.name}: generating advice")
-        resp = self.llm.invoke(prompt)
-        log_workflow(f"{self.name}: advice length", len(resp.content))
-        return resp.content
+class CreditBuilder(SpecialistAgent):
+    """Specialist agent for credit building advice"""
+    def __init__(self, llm=None):
+        super().__init__(name="Credit Builder", domain="credit", llm=llm)
+
 
+class BudgetManager(SpecialistAgent):
+    """Specialist agent for budget management advice"""
+    def __init__(self, llm=None):
+        super().__init__(name="Budget Manager", domain="budget", llm=llm)
+
+
+class CurrencyExchangeSpecialist(SpecialistAgent):
+    """Specialist agent for currency exchange advice"""
+    def __init__(self, llm=None):
+        super().__init__(name="Currency Exchange Specialist", domain="currency", llm=llm)
 
-# Instantiate specialists
-BankingAdvisor = lambda llm=None: SpecialistAgent("Banking Advisor", "banking", llm)
-CreditBuilder = lambda llm=None: SpecialistAgent("Credit Builder", "credit", llm)
-BudgetManager = lambda llm=None: SpecialistAgent("Budget Manager", "budget", llm)
-CurrencySpecialist = lambda llm=None: SpecialistAgent("Currency Specialist", "currency", llm)
-LoanAdvisor = lambda llm=None: SpecialistAgent("Student Loan Advisor", "loans", llm)
-CareerPlanner = lambda llm=None: SpecialistAgent("Career Planner", "career", llm)
-LegalAdvisor = lambda llm=None: SpecialistAgent("Legal Advisor", "legal", llm)
+
+class StudentLoanAdvisor(SpecialistAgent):
+    """Specialist agent for student loan advice"""
+    def __init__(self, llm=None):
+        super().__init__(name="Student Loan Advisor", domain="loans", llm=llm)
+
+
+class CareerFinancePlanner(SpecialistAgent):
+    """Specialist agent for career financial planning advice"""
+    def __init__(self, llm=None):
+        super().__init__(name="Career Finance Planner", domain="career", llm=llm)
+
+
+class LegalFinanceAdvisor(SpecialistAgent):
+    """Specialist agent for legal financial advice"""
+    def __init__(self, llm=None):
+        super().__init__(name="Legal Finance Advisor", domain="legal", llm=llm)
 
 
 # =======================================
-# Coordinator Agent (Voting, Multi-path, Self-reflection)
+# Coordinator Agent (Central Agent)
 # =======================================
 
 class CoordinatorAgent:
+    """Central coordinator agent that orchestrates specialist agents"""
+
     def __init__(self, llm=None):
-        self.llm = llm or ChatOpenAI(temperature=0.3)
+        """Initialize the coordinator agent"""
+        self.llm = llm if llm else ChatOpenAI(temperature=0.3)
+
+        # Initialize specialist agents
+        self.banking_advisor = BankingAdvisor(self.llm)
+        self.credit_builder = CreditBuilder(self.llm)
+        self.budget_manager = BudgetManager(self.llm)
+        self.currency_specialist = CurrencyExchangeSpecialist(self.llm)
+        self.loan_advisor = StudentLoanAdvisor(self.llm)
+        self.career_planner = CareerFinancePlanner(self.llm)
+        self.legal_advisor = LegalFinanceAdvisor(self.llm)
+
+        # Map domains to specialists
         self.specialists = {
-            "banking": BankingAdvisor(self.llm),
-            "credit": CreditBuilder(self.llm),
-            "budget": BudgetManager(self.llm),
-            "currency": CurrencySpecialist(self.llm),
-            "loans": LoanAdvisor(self.llm),
-            "career": CareerPlanner(self.llm),
-            "legal": LegalAdvisor(self.llm)
+            "banking": self.banking_advisor,
+            "credit": self.credit_builder,
+            "budget": self.budget_manager,
+            "currency": self.currency_specialist,
+            "loans": self.loan_advisor,
+            "career": self.career_planner,
+            "legal": self.legal_advisor
+        }
+
+    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)
+        - budget (Budget Manager: expense tracking, savings, stipend management)
+        - currency (Currency Exchange Specialist: exchange rates, money transfers)
+        - loans (Student Loan Advisor: educational loans, repayment strategies)
+        - career (Career Finance Planner: internships, CPT/OPT, job preparation)
+        - legal (Legal Finance Advisor: visa regulations, tax implications)
+
+        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 budget domain if query mentions stipend or expenses
+            if "budget" not in valid_domains and ("stipend" in query.lower() or "expense" in query.lower()):
+                valid_domains.append("budget")
+
+            # Add legal domain if query mentions tax or visa
+            if "legal" not in valid_domains and ("tax" in query.lower() or "visa" in query.lower()):
+                valid_domains.append("legal")
+
+            # Add career domain if query mentions internship, CPT, or OPT
+            if "career" not in valid_domains and any(term in query.lower() for term in ["internship", "cpt", "opt"]):
+                valid_domains.append("career")
+
+            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", "budget"]
+            if "credit" in query.lower():
+                default_domains.append("credit")
+            return default_domains
+
+    def _conduct_vote(self, question: str, options: List[str], country: str) -> Dict[str, Any]:
+        """Implement voting-based cooperation between specialists"""
+        log_workflow("Voting-based Cooperation: Specialists voting on options",
+                    {"question": question[:50], "options": options})
+
+        voting_results = {option: 0 for option in options}
+        specialist_votes = {}
+
+        # Create options text separately
+        options_text = "\n".join([f"{i+1}. {option}" for i, option in enumerate(options)])
+
+        voting_prompt = f"""
+        As a financial advisor for international students from {country}, which of the following options would you recommend?
+
+        QUESTION: {question}
+
+        OPTIONS:
+        {options_text}
+
+        Analyze the options carefully, then respond with ONLY the number of your recommendation (e.g., "1" or "2").
+        """
+
+        # Select appropriate specialists for voting
+        relevant_domains = self._identify_relevant_specialists(question)
+        for domain in relevant_domains:
+            specialist = self.specialists[domain]
+            try:
+                response = self.llm.invoke(voting_prompt)
+                vote_text = response.content.strip()
+
+                # Try to extract a number from the response
+                vote = None
+                for i, option in enumerate(options):
+                    if str(i+1) in vote_text:
+                        vote = options[i]
+                        break
+
+                if vote is None and len(options) > 0:
+                    vote = options[0]  # Default to first option if parsing fails
+
+                if vote in voting_results:
+                    voting_results[vote] += 1
+                    specialist_votes[domain] = vote
+                    log_workflow(f"{domain.capitalize()} voted for: {vote}")
+            except Exception as e:
+                log_workflow(f"Error during voting from {domain}", str(e))
+
+        # Find the winner
+        winner = max(voting_results.items(), key=lambda x: x[1]) if voting_results else (options[0], 0)
+
+        log_workflow(f"Voting complete, winner determined",
+                    {"winner": winner[0], "vote_count": winner[1]})
+
+        return {
+            "winner": winner[0],
+            "votes": voting_results,
+            "specialist_votes": specialist_votes
         }
 
-    def identify_specialists(self, query: str) -> List[str]:
-        q = query.lower()
-        domains = []
-        if any(k in q for k in ["bank", "account"]):
-            domains.append("banking")
-        if "credit" in q:
-            domains.append("credit")
-        if any(k in q for k in ["budget", "stipend"]):
-            domains.append("budget")
-        if any(k in q for k in ["transfer", "exchange"]):
-            domains.append("currency")
-        if "loan" in q:
-            domains.append("loans")
-        if any(k in q for k in ["cpt", "opt", "internship"]):
-            domains.append("career")
-        if any(k in q for k in ["tax", "visa"]):
-            domains.append("legal")
-        return list(dict.fromkeys(domains)) or ["banking", "budget"]
-
-    def vote(self, question: str, options: List[str]) -> str:
-        votes = {opt: 0 for opt in options}
-        for domain in self.identify_specialists(question):
-            prompt = f"Which option for '{question}'? Options: {options}"
-            resp = self.llm.invoke(prompt).content.strip()
-            for i, opt in enumerate(options, start=1):
-                if str(i) in resp:
-                    votes[opt] += 1
-        winner = max(votes, key=votes.get)
-        log_workflow("Voting result", votes)
-        return winner
-
-    def generate_plans(self, goal: str, profile: Dict[str, Any]) -> Dict[str, str]:
+    def _generate_plans(self, financial_goal: str, constraints: str, country: str) -> Dict[str, str]:
+        """Implement Multi-path Plan Generator pattern"""
+        log_workflow("Multi-path Plan Generator: Creating financial plans",
+                    {"goal": financial_goal[:50], "country": country})
+
+        # Create prompts for different risk approaches
+        planning_prompt_template = f"""
+        As a financial advisor for international students from {country}, create a {{approach}} financial strategy for:
+
+        GOAL: {financial_goal}
+
+        CONSTRAINTS: {constraints}
+
+        Your {{approach}} strategy should include:
+        1. Detailed step-by-step actions with timeline
+        2. Specific financial products/services with exact names and costs
+        3. Precise breakdown of benefits and risks
+        4. Expected outcomes with realistic numbers
+        5. Mitigation strategies for potential challenges
+
+        Format with clear headings, bullet points, and numbered steps.
+        Include specific bank names, service providers, dollar amounts, and time frames.
+        """
+
         plans = {}
-        for approach, agent in [
-            ("conservative", BudgetManager(self.llm)),
-            ("balanced", BankingAdvisor(self.llm)),
-            ("growth", CreditBuilder(self.llm))
-        ]:
-            prompt = f"Create {approach} strategy for '{goal}' with constraints: {profile}"
-            plans[approach] = agent.run(prompt, profile.get("home_country", ""))
-        return plans
-
-    def self_reflect(self, synthesis: str, profile: Dict[str, Any]) -> str:
-        prompt = f"Review and improve advice for {profile}: {synthesis}"
-        return LegalAdvisor(self.llm).run(prompt, profile.get("home_country", ""))
-
-    def run(self, query: str, profile: Dict[str, Any]) -> str:
-        clear_workflow_log()
-        log_workflow("Coordinator: start processing", {"query": query[:50]})
-        specialists = self.identify_specialists(query)
-        advices = {d: self.specialists[d].run(query, profile.get("home_country", "")) for d in specialists}
-        plans = self.generate_plans(query, profile)
-        synthesis = "".join(f"---{d.upper()}---\n{txt}\n" for d, txt in advices.items())
-        synthesis += f"---PLANS---\n{json.dumps(plans, indent=2)}"
-        log_workflow("Synthesis complete")
-        final_advice = self.self_reflect(synthesis, profile)
-        return final_advice + "\n\n---\n" + get_workflow_log()
+
+        try:
+            # Create conservative plan using Budget Manager
+            log_workflow("Generating conservative plan")
+            conservative_prompt = planning_prompt_template.format(approach="CONSERVATIVE (lowest risk)")
+            plans["conservative"] = self.budget_manager.run(conservative_prompt, country)
+
+            # Create balanced plan using Banking Advisor
+            log_workflow("Generating balanced plan")
+            balanced_prompt = planning_prompt_template.format(approach="BALANCED (moderate risk/reward)")
+            plans["balanced"] = self.banking_advisor.run(balanced_prompt, country)
+
+            # Create growth plan using Credit Builder
+            log_workflow("Generating growth plan")
+            growth_prompt = planning_prompt_template.format(approach="GROWTH-ORIENTED (higher potential returns)")
+            plans["growth"] = self.credit_builder.run(growth_prompt, country)
+
+            log_workflow("All plans generated successfully")
+            return plans
+        except Exception as e:
+            log_workflow("Error generating financial plans", str(e))
+            return {
+                "conservative": f"Error generating conservative plan: {str(e)}",
+                "balanced": f"Error generating balanced plan: {str(e)}",
+                "growth": f"Error generating growth plan: {str(e)}"
+            }
+
+    def _reflect_on_recommendation(self, recommendation: str, student_profile: Dict[str, Any]) -> str:
+        """Implement Self-reflection pattern"""
+        country = student_profile.get("home_country", "unknown")
+        visa_type = student_profile.get("visa_type", "unknown")
+
+        log_workflow("Self-reflection: Reviewing recommendations",
+                    {"country": country, "visa_type": visa_type})
+
+        reflection_prompt = f"""
+        As a Legal Financial Advisor for international students, evaluate this financial recommendation:
+
+        STUDENT PROFILE:
+        Home Country: {country}
+        Visa Type: {visa_type}
+        University: {student_profile.get('university', 'unknown')}
+        Funding: {student_profile.get('funding', 'unknown')}
+        Additional Info: {student_profile.get('additional_info', 'none')}
+
+        RECOMMENDATION:
+        {recommendation}
+
+        Please reflect on:
+        1. Does this recommendation fully comply with {visa_type} visa restrictions?
+        2. Is the advice properly tailored to {country} students' unique circumstances?
+        3. Are there any assumptions that might not apply to international students?
+        4. Could any part of this advice create legal/immigration issues?
+        5. Is the recommendation practical given typical international student constraints?
+        6. Does it address all aspects of the original query completely?
+
+        Provide a detailed assessment with specific recommendations for improvement.
+        """
+
+        try:
+            log_workflow("Generating legal reflection")
+            reflection = self.legal_advisor.run(reflection_prompt, country)
+            log_workflow("Reflection complete")
+            return reflection
+        except Exception as e:
+            log_workflow("Error during self-reflection", str(e))
+            return f"Unable to complete self-reflection due to an error: {str(e)}"
+
+    def run(self, query: str, student_profile: Dict[str, Any]) -> str:
+        """Orchestrate the specialist agents to create a comprehensive response"""
+        log_workflow("COORDINATOR: Processing new query", {"query": query[:100]})
+
+        country = student_profile.get("home_country", "unknown")
+
+        # 1. Analyze the query to identify which specialists to consult
+        relevant_domains = self._identify_relevant_specialists(query)
+
+        # 2. Collect advice from relevant specialists
+        specialist_advice = {}
+        for domain in relevant_domains:
+            if domain in self.specialists:
+                specialist = self.specialists[domain]
+                advice = specialist.run(query, country)
+                specialist_advice[domain] = advice
+
+        # 3. Generate multi-path financial plans for the query
+        constraints = f"""
+        Home Country: {country}
+        Visa Type: {student_profile.get('visa_type', 'F-1')}
+        University: {student_profile.get('university', 'unknown')}
+        Funding: {student_profile.get('funding', 'unknown')}
+        Additional Info: {student_profile.get('additional_info', 'none')}
+        """
+
+        plans = self._generate_plans(query, constraints, country)
+
+        # 4. Synthesize the collected advice and plans into a coherent response
+        log_workflow("Synthesizing comprehensive response")
+
+        # Create the specialist advice text separately
+        specialist_advice_text = "\n".join([f"--- {domain.upper()} SPECIALIST ---\n{advice[:1000]}\n" for domain, advice in specialist_advice.items()])
+
+        synthesis_prompt = f"""
+        As the coordinator for an International Student Finance Portal, synthesize specialist advice and financial plans into a comprehensive response.
+
+        STUDENT:
+        - Home Country: {country}
+        - Visa Type: {student_profile.get('visa_type', 'F-1')}
+        - University: {student_profile.get('university', 'unknown')}
+        - Funding: {student_profile.get('funding', 'unknown')}
+        - Additional Info: {student_profile.get('additional_info', 'none')}
+
+        QUERY:
+        {query}
+
+        SPECIALIST ADVICE:
+        {specialist_advice_text}
+
+        FINANCIAL APPROACHES:
+        --- CONSERVATIVE APPROACH ---
+        {plans.get('conservative', 'No conservative plan available.')[:1000]}
+
+        --- BALANCED APPROACH ---
+        {plans.get('balanced', 'No balanced plan available.')[:1000]}
+
+        --- GROWTH-ORIENTED APPROACH ---
+        {plans.get('growth', 'No growth-oriented plan available.')[:1000]}
+
+        Create a detailed response with:
+        1. PART 1: Direct answers to each specific aspect of the query - banking, credit, stipend management, etc.
+        2. PART 2: Multiple financial approaches (conservative, balanced, growth-oriented)
+
+        Each section must be extremely detailed with:
+        - Specific bank/service names
+        - Exact documentation requirements
+        - Step-by-step processes
+        - Precise dollar amounts
+        - Concrete timelines
+
+        Format with clear headings, bullet points, and numbered steps.
+        """
+
+        try:
+            # Generate the synthesized response
+            log_workflow("Generating final synthesized response")
+            synthesis_response = self.llm.invoke(synthesis_prompt)
+
+            # 5. Self-reflection (check for international student appropriateness)
+            log_workflow("Performing self-reflection")
+            reflection = self._reflect_on_recommendation(synthesis_response.content, student_profile)
+
+            # 6. Final response with reflection incorporated
+            log_workflow("Creating final response with reflection incorporated")
+            final_prompt = f"""
+            Revise this financial advice based on legal reflection:
+
+            ORIGINAL ADVICE:
+            {synthesis_response.content}
+
+            LEGAL REFLECTION:
+            {reflection}
+
+            Create a final version that:
+            1. Incorporates all legal considerations
+            2. Maintains the comprehensive nature of the original advice
+            3. Addresses EVERY aspect of the original query specifically and in detail:
+               - Bank account setup (specific banks, fees, documents)
+               - Credit building (specific cards, exact steps)
+               - Money transfers (exact services, fees, processes)
+               - Stipend management (precise budget breakdown)
+               - Tax implications (specific treaty benefits, forms)
+               - CPT/internship planning (exact timeline, requirements)
+            4. Includes all three financial approaches (conservative, balanced, growth)
+
+            Format with clear headings, bullet points, and numbered steps.
+            """
+
+            log_workflow("Generating final response")
+            final_response = self.llm.invoke(final_prompt)
+            log_workflow("Response generation complete")
+
+            # Return both the response and the workflow log
+            return final_response.content
+        except Exception as e:
+            log_workflow("Error in coordinator synthesis", str(e))
+
+            # Fallback response if synthesis fails
+            fallback = "## Financial Advice Summary\n\n"
+            for domain, advice in specialist_advice.items():
+                domain_name = domain.replace("_", " ").title()
+                fallback += f"### {domain_name} Advice\n{advice[:500]}...\n\n"
+
+            fallback += "\n## Multiple Financial Approaches\n\n"
+            for approach, plan in plans.items():
+                approach_name = approach.replace("_", " ").title()
+                fallback += f"### {approach_name} Approach\n{plan[:500]}...\n\n"
+
+            return fallback
 
 
 # =======================================
-# Gradio Interface
+# Main Portal Interface
 # =======================================
 
+class FinancePortal:
+    """Main interface for the International Student Finance Portal"""
+
+    def __init__(self):
+        """Initialize the finance portal with a coordinator agent"""
+        self.coordinator = CoordinatorAgent()
+        self.student_profiles = {}
+
+    def register_student(self, student_id: str, profile: Dict[str, Any]):
+        """Register a new student profile"""
+        self.student_profiles[student_id] = profile
+
+    def get_student_profile(self, student_id: str) -> Optional[Dict[str, Any]]:
+        """Get a student's profile"""
+        return self.student_profiles.get(student_id)
+
+    def handle_query(self, student_id: str, query: str) -> str:
+        """Process a student query"""
+        profile = self.get_student_profile(student_id)
+
+        if not profile:
+            return "Please provide your profile information first."
+
+        if not query or query.strip() == "":
+            return "Please enter a specific financial question."
+
+        log_workflow(f"Processing query for student {student_id}", {"query": query[:50]})
+
+        # Clear workflow log for new query
+        clear_workflow_log()
+
+        try:
+            # Process the query with the coordinator
+            response = self.coordinator.run(query, profile)
+
+            # Get the workflow log
+            workflow_log = get_workflow_log()
+
+            # Combine the response and workflow log
+            full_response = f"{response}\n\n---\n\n{workflow_log}"
+
+            return full_response
+        except Exception as e:
+            log_workflow(f"Error handling query", str(e))
+
+            # Return the error with the workflow log
+            workflow_log = get_workflow_log()
+            return f"I encountered an error while processing your request: {str(e)}\n\n---\n\n{workflow_log}"
+
+
 def create_interface():
-    portal = CoordinatorAgent()
+    """Create the Gradio interface for the finance portal"""
+    portal = FinancePortal()
+
+    def handle_query(query, country, visa_type, university, funding, additional_info):
+        """Handler for query submission"""
+        if not query or query.strip() == "":
+            return "Please enter a financial question."
 
-    def handler(query, country, visa, uni, fund, info):
+        if not country:
+            return "Please select your home country."
+
+        if not visa_type:
+            return "Please select your visa type."
+
+        # Create a composite student profile
+        student_id = "current_user"
         profile = {
             "home_country": country,
-            "visa_type": visa,
-            "university": uni,
-            "funding": fund,
-            "additional_info": info
+            "visa_type": visa_type,
+            "university": university,
+            "funding": funding,
+            "additional_info": additional_info
         }
-        return portal.run(query, profile)
 
-    with gr.Blocks() as demo:
-        country = gr.Dropdown(["", "India", "China", "Brazil", "Other"], label="Home Country")
-        visa = gr.Dropdown(["", "F-1", "J-1", "M-1", "Other"], label="Visa Type")
-        uni = gr.Textbox(label="University")
-        fund = gr.Dropdown(["", "Self", "Scholarship", "TA/RA", "Loan", "Other"], label="Funding")
-        info = gr.Textbox(label="Additional Info")
-        query = gr.Textbox(label="Question", lines=3)
-        btn = gr.Button("Get Advice")
-        out = gr.Markdown()
-
-        btn.click(handler, inputs=[query, country, visa, uni, fund, info], outputs=out)
+        portal.register_student(student_id, profile)
+        return portal.handle_query(student_id, query)
+
+    # Create Gradio interface
+    with gr.Blocks(title="International Student Finance Portal") as demo:
+        gr.Markdown("# International Student Finance Portal")
+        gr.Markdown("Get personalized financial advice tailored for international graduate students with visible workflow.")
+
+        with gr.Row():
+            with gr.Column(scale=2):
+                country = gr.Dropdown(
+                    label="Home Country",
+                    choices=["", "India", "China", "Brazil", "Other"],
+                    value=""
+                )
+                visa_type = gr.Dropdown(
+                    label="Visa Type",
+                    choices=["", "F-1", "J-1", "M-1", "Other"],
+                    value=""
+                )
+                university = gr.Textbox(
+                    label="University",
+                    placeholder="e.g., Stanford University"
+                )
+                funding = gr.Dropdown(
+                    label="Primary Funding Source",
+                    choices=["", "Self/Family", "Scholarship", "TA/RA Position", "Education Loan", "Other"],
+                    value=""
+                )
+                additional_info = gr.Textbox(
+                    label="Additional Information (Optional)",
+                    placeholder="Program, expected duration, family situation, etc."
+                )
+
+                # Predefined query templates
+                query_templates = gr.Dropdown(
+                    label="Common Questions (Select or type your own below)",
+                    choices=[
+                        "",
+                        "How do I open a bank account as an international student?",
+                        "What's the best way to build credit in the US?",
+                        "How should I manage my TA/RA stipend?",
+                        "What are my options for sending/receiving money from home?",
+                        "How do CPT/OPT affect my financial situation?",
+                        "What student loan options are available to me?",
+                        "How should I budget for living expenses in the US?",
+                        "I just arrived in the US from India on an F-1 visa to start my PhD program at MIT with a teaching assistantship. I need advice on opening a bank account with minimal fees, building credit from scratch since I have no US history, sending money between India and the US at the best rates, managing my $2,500 monthly TA stipend while saving for emergencies, and understanding tax implications under the US-India tax treaty. Also, how should I financially prepare for a potential CPT internship next summer?"
+                    ],
+                    value=""
+                )
+
+                query = gr.Textbox(
+                    label="Your Financial Question",
+                    placeholder="Type your financial question here...",
+                    lines=4
+                )
+
+                # Update query box when template is selected
+                query_templates.change(
+                    fn=lambda x: x if x else "",
+                    inputs=query_templates,
+                    outputs=query
+                )
+
+                submit_btn = gr.Button("Get Financial Advice", variant="primary")
+                clear_btn = gr.Button("Reset")
+
+            with gr.Column(scale=3):
+                # Use a textbox with markdown enabled
+                with gr.Group():
+                    gr.Markdown("### Your Personalized Financial Advice")
+                    response = gr.Markdown()
+
+                    # Add a loading message while waiting for response
+                    submit_btn.click(
+                        fn=lambda: "## Processing Your Query\n\nConsulting specialist advisors and generating multiple financial approaches...\n\nPlease wait a moment as this may take up to a minute.",
+                        inputs=None,
+                        outputs=response,
+                        queue=False
+                    )
+
+        # Handle main query submission
+        submit_btn.click(
+            fn=handle_query,
+            inputs=[query, country, visa_type, university, funding, additional_info],
+            outputs=response,
+            queue=True
+        )
+
+        # Handle reset button
+        clear_btn.click(
+            fn=lambda: (
+                "",
+                "",
+                "",
+                "",
+                "",
+                "",
+                ""
+            ),
+            inputs=None,
+            outputs=[query, country, visa_type, university, funding, additional_info, response]
+        )
+
+        # Feature explanation section
+        with gr.Accordion("How This System Works", open=False):
+            gr.Markdown("""
+            ### Financial Advisory Features
+
+            This portal uses advanced AI with multiple agent design patterns to provide personalized financial guidance:
+
+            1. **Retrieval Augmented Generation (RAG)**: Uses vector embeddings to retrieve country-specific financial knowledge
+
+            2. **Role-based Cooperation**: Specialized agents collaborate based on their domain expertise
+               - Banking Advisor: Account setup, transfers, banking documentation
+               - Credit Builder: Credit cards, credit history building, credit scores
+               - Budget Manager: Expense tracking, savings goals, stipend management
+               - Currency Exchange Specialist: International transfers, exchange rates
+               - Student Loan Advisor: Loan options, repayment strategies
+               - Career Finance Planner: CPT/OPT financial planning, internships
+               - Legal Finance Advisor: Visa compliance, tax treaties, reporting requirements
+
+            3. **Voting-based Cooperation**: Specialists vote on recommendations when multiple options exist
+
+            4. **Self-reflection**: Legal/visa compliance check on all financial advice
+
+            5. **Multi-path Plan Generator**: Different financial strategies based on risk tolerance
+
+            The workflow log at the bottom of each response shows you exactly which components ran and in what order.
+            """)
 
     return demo
 
-
+# If this is the main script being run
 if __name__ == "__main__":
-    create_interface().launch()
+    print("Starting International Student Finance Portal with Visible Workflow...")
+    print("This implementation tests all components and shows the workflow in real-time.")
+    interface = create_interface()
+    interface.launch()