Refactored

app.py

@@ -11,33 +11,26 @@ import time
 import json
 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
+import gradio as gr
+from langchain.document_loaders import DirectoryLoader, PyPDFLoader
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain.embeddings import OpenAIEmbeddings
+from langchain.vectorstores import Chroma
+from langchain_openai import ChatOpenAI
+
+# =======================================
+# Configuration & Workflow Logging
+# =======================================
+
+# Set OpenAI 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
 
-# Global workflow log to track the execution flow
-WORKFLOW_LOG = []
+WORKFLOW_LOG: List[Dict[str, Any]] = []
 
-def log_workflow(step, details=None):
-    """Add a step to the workflow log"""
+def log_workflow(step: str, details: Any = None):
     timestamp = time.strftime("%H:%M:%S")
     entry = {"time": timestamp, "step": step}
     if details:
@@ -45,963 +38,225 @@ def log_workflow(step, details=None):
     WORKFLOW_LOG.append(entry)
     print(f"[{timestamp}] {step}{': ' + str(details) if details else ''}")
 
-def get_workflow_log():
-    """Get the workflow log as formatted text"""
+def get_workflow_log() -> str:
     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']}\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
+    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():
-    """Clear the workflow log"""
-    global WORKFLOW_LOG
-    WORKFLOW_LOG = []
+    WORKFLOW_LOG.clear()
 
-# 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)
+# =======================================
+# Retrieval Augmented Generation (RAG) Setup
+# Preload and index domain-specific documents
+# =======================================
+
+EMBEDDINGS = OpenAIEmbeddings()
+SPLITTER = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
+
+# Initialize vector stores for each domain once
+DOMAIN_VECTOR_STORES: Dict[str, Chroma] = {}
+for domain in ["banking", "credit", "budget", "currency", "loans", "career", "legal"]:
+    log_workflow("Indexing domain documents", domain)
+    # Load text files
+    loader_txt = DirectoryLoader(f"data/{domain}/txt", glob="**/*.txt")
+    docs = loader_txt.load()
+    # Additionally load PDFs if present
+    pdf_path = f"data/{domain}/pdf"
+    if os.path.isdir(pdf_path):
+        loader_pdf = PyPDFLoader(pdf_path)
+        docs += loader_pdf.load()
+    chunks = SPLITTER.split_documents(docs)
+    store = Chroma.from_documents(chunks, EMBEDDINGS, collection_name=domain)
+    DOMAIN_VECTOR_STORES[domain] = store
+    log_workflow("Domain indexed", domain)
 
 
 # =======================================
 # Knowledge Base (RAG Implementation)
+# Uses preloaded vector stores
 # =======================================
 
 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.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
+        self.store = DOMAIN_VECTOR_STORES[domain]
+        self.retriever = self.store.as_retriever(search_kwargs={"k": 3})
 
     def retrieve(self, query: str, country: str) -> List[str]:
-        """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."]
+        log_workflow(f"RAG: retrieving {self.domain}", {"query": query[:50], "country": country})
+        docs = self.retriever.get_relevant_documents(query)
+        results = [doc.page_content for doc in docs]
+        log_workflow(f"RAG: retrieved {len(results)} snippets", None)
+        return results
 
 
 # =======================================
-# Domain Specialist Agents
+# Domain Specialist Agents (Role-based Cooperation)
 # =======================================
 
 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.domain = domain
-        self.knowledge_base = KnowledgeBase(domain)
-        self.llm = llm if llm else ChatOpenAI(temperature=0.2)
+        self.kb = KnowledgeBase(domain)
+        self.llm = llm or ChatOpenAI(temperature=0.2)
 
     def run(self, query: str, country: str) -> str:
-        """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
+        log_workflow(f"{self.name}: analyzing query", {"query": query[:50]})
+        snippets = self.kb.retrieve(query, country)
+        context = "\n".join(f"- {s}" for s in snippets)
         prompt = f"""
-        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)
-
-
-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)
-
-
-class StudentLoanAdvisor(SpecialistAgent):
-    """Specialist agent for student loan advice"""
-    def __init__(self, llm=None):
-        super().__init__(name="Student Loan Advisor", domain="loans", llm=llm)
+As a specialist {self.name} for international students from {country}, use the following references:
+{context}
 
+QUESTION:
+{query}
 
-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)
-
+Provide detailed, actionable advice:
+1. Specific product/service names 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 generated", len(resp.content))
+        return resp.content
 
-class LegalFinanceAdvisor(SpecialistAgent):
-    """Specialist agent for legal financial advice"""
-    def __init__(self, llm=None):
-        super().__init__(name="Legal Finance Advisor", domain="legal", llm=llm)
+# Instantiate each specialist
+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)
+CurrencyExchangeSpecialist = lambda llm=None: SpecialistAgent("Currency Exchange Specialist", "currency", llm)
+StudentLoanAdvisor = lambda llm=None: SpecialistAgent("Student Loan Advisor", "loans", llm)
+CareerFinancePlanner = lambda llm=None: SpecialistAgent("Career Finance Planner", "career", llm)
+LegalFinanceAdvisor = lambda llm=None: SpecialistAgent("Legal Finance Advisor", "legal", llm)
 
 
 # =======================================
-# Coordinator Agent (Central Agent)
+# Coordinator Agent (Central Orchestrator)
+# Implements Voting-based Cooperation, Multi-path Plan Generator, Self-reflection
 # =======================================
 
 class CoordinatorAgent:
-    """Central coordinator agent that orchestrates specialist agents"""
-
     def __init__(self, llm=None):
-        """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.llm = llm or ChatOpenAI(temperature=0.3)
         self.specialists = {
-            "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
+            "banking": BankingAdvisor(self.llm),
+            "credit": CreditBuilder(self.llm),
+            "budget": BudgetManager(self.llm),
+            "currency": CurrencyExchangeSpecialist(self.llm),
+            "loans": StudentLoanAdvisor(self.llm),
+            "career": CareerFinancePlanner(self.llm),
+            "legal": LegalFinanceAdvisor(self.llm)
         }
 
-    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]:
+        # heuristic-based domain selection
+        domains = []
+        q = query.lower()
+        if any(k in q for k in ["account", "bank"]): 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 _conduct_vote(self, question: str, options: List[str], country: str) -> str:
+        log_workflow("Voting cooperation: voting on options", {"options": options})
+        votes = {opt:0 for opt in options}
+        for domain in self._identify_specialists(question):
+            prompt = f"Which option for question '{question}'? {json.dumps(options)}"
+            resp = self.llm.invoke(prompt).content.strip()
+            for i,opt in enumerate(options):
+                if str(i+1) in resp:
+                    votes[opt]+=1
+        winner = max(votes, key=votes.get)
+        log_workflow("Voting result", {"winner": winner, "votes": votes})
+        return winner
+
+    def _generate_plans(self, goal: str, constraints: str, country: str) -> Dict[str,str]:
+        log_workflow("Generating multi-path plans", None)
+        approaches = {
+            "conservative": BudgetManager(self.llm),
+            "balanced": BankingAdvisor(self.llm),
+            "growth": CreditBuilder(self.llm)
         }
-
-    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 name, agent in approaches.items():
+            prompt = f"Create {name} plan for goal: {goal} with {constraints}"
+            plans[name] = agent.run(prompt, country)
+        return plans
 
-        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')}
-        """
+    def _self_reflect(self, advice: str, profile: Dict[str,Any]) -> str:
+        log_workflow("Self-reflection: checking legal compliance", None)
+        prompt = f"Review and refine advice for profile {profile}: {advice}"
+        return LegalFinanceAdvisor(self.llm).run(prompt, profile.get("home_country",""))
 
+    def run(self, query: str, profile: Dict[str, Any]) -> str:
+        clear_workflow_log()
+        log_workflow("Coordinator: processing", {"query": query})
+        country = profile.get("home_country","unknown")
+        # 1. Role-based advice
+        advices = {}
+        for d in self._identify_specialists(query):
+            advices[d] = self.specialists[d].run(query, country)
+        # 2. Multi-path plans
+        constraints = json.dumps(profile)
         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
-
+        # 3. Synthesize
+        synthesis = "".join([f"---{d.upper()}---\n{txt}\n" for d,txt in advices.items()])
+        synthesis += "---PLANS---\n" + json.dumps(plans)
+        log_workflow("Synthesis done", None)
+        # 4. Self-reflection
+        final = self._self_reflect(synthesis, profile)
+        # 5. Return with workflow
+        return final + "\n\n---\n" + get_workflow_log()
 
 # =======================================
 # 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
+        self.profiles: Dict[str,Dict[str,Any]] = {}
 
-    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 register(self, uid: str, profile: Dict[str,Any]):
+        self.profiles[uid] = profile
 
-    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 handle_query(self, uid: str, query: str) -> str:
+        profile = self.profiles.get(uid)
+        if not profile or not query:
+            return "Provide profile and question."
+        return self.coordinator.run(query, profile)
 
 
 def create_interface():
-    """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."
-
-        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_type,
-            "university": university,
-            "funding": funding,
-            "additional_info": additional_info
-        }
-
-        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.
-            """)
-
+    def _handler(q, country, visa, uni, fund, info):
+        uid = "user"
+        portal.register(uid,{"home_country":country,"visa_type":visa,"university":uni,"funding":fund,"additional_info":info})
+        return portal.handle_query(uid,q)
+    with gr.Blocks() as demo:
+        # Inputs
+        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)
     return demo
 
-# If this is the main script being run
 if __name__ == "__main__":
-    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()
+    create_interface().launch()