Refactored

app.py

@@ -1,215 +1,998 @@
+"""
+International Student Finance Portal
+A comprehensive financial advisory system for international students
+Implements 5 agent design patterns: RAG, Role-based Cooperation, Voting-based Cooperation,
+Self-reflection, and Multi-path Plan Generator
+"""
+
 import os
 import sys
 import time
 import json
 from typing import List, Dict, Any, Optional
 
-import gradio as gr
-from langchain_openai import ChatOpenAI
-from langchain_community.vectorstores import Chroma
-from langchain_openai import OpenAIEmbeddings
-from langchain.text_splitter import RecursiveCharacterTextSplitter
-
-# Load API key
-def get_api_key():
-    key = os.environ.get("OPENAI_API_KEY")
-    if not key:
-        key = input("Please enter your OpenAI API key: ")
-        os.environ["OPENAI_API_KEY"] = key
-    return key
-
-# Workflow log utilities
-WORKFLOW_LOG: List[Dict[str, Any]] = []
-
-def log_workflow(step: str, details: Any = None):
+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
+
+# Global workflow log to track the execution flow
+WORKFLOW_LOG = []
+
+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."
+
     log_text = "## Workflow Execution Log:\n\n"
-    for e in WORKFLOW_LOG:
-        log_text += f"**[{e['time']}]** {e['step']}\n"
-        if e.get('details'):
-            d = e['details']
-            if isinstance(d, dict):
-                short = {k: (v[:100] + '...' if isinstance(v, str) and len(v) > 100 else v)
-                         for k, v in d.items()}
-                log_text += f"```json\n{json.dumps(short, indent=2)}\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"{d}\n"
-    return log_text
+                log_text += f"{details}\n"
 
+    return log_text
 
 def clear_workflow_log():
+    """Clear the workflow log"""
     global WORKFLOW_LOG
     WORKFLOW_LOG = []
 
-# Placeholder: DataCollector, KnowledgeBase, and SpecialistAgents definitions here...
+# 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 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.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]:
+        """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."]
+
+
+# =======================================
+# 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.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:
+        """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)
+
+        # Prepare a detailed prompt with the knowledge and query
+        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:
+        {"\n".join('- ' + item for item in knowledge)}
+
+        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)
+
+
+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
+# 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 specialists
+        """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': CurrencyExchangeSpecialist(self.llm),
-            'loans': StudentLoanAdvisor(self.llm),
-            'career': CareerFinancePlanner(self.llm),
-            'legal': LegalFinanceAdvisor(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]:
-        prompt = f"Which domains for: {query}? Options: banking,credit,budget,currency,loans,career,legal"
-        try:
-            res = self.llm.invoke(prompt)
-            domains = [d.strip() for d in res.content.split(',')]
-        except:
-            domains = ['banking', 'budget']
-        return [d for d in domains if d in self.specialists]
-
-    def _generate_plans(self, query: str, constraints: str, country: str) -> Dict[str, str]:
-        plans: Dict[str, str] = {}
-        template = f"Goal: {query}\nConstraints: {constraints}\nCountry: {country}\nApproach: {{}}"
-        for tag, agent in [('conservative', self.specialists['budget']),
-                           ('balanced',    self.specialists['banking']),
-                           ('growth',      self.specialists['credit'])]:
-            log_workflow(f"Generating {tag} plan")
-            plans[tag] = agent.run(template.format(tag), country)
-        return plans
-
-    def _reflect_on_recommendation(self, recommendation: str, profile: Dict[str, Any]) -> str:
-        country = profile.get('home_country', 'unknown')
-        visa = profile.get('visa_type', 'unknown')
-        prompt = f"Reflect on compliance for {country}/{visa}: {recommendation}"
+        """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:
-            return self.specialists['legal'].run(prompt, country)
-        except:
-            return 'Reflection unavailable'
+            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 = {}
+
+        voting_prompt = f"""
+        As a financial advisor for international students from {country}, which of the following options would you recommend?
+
+        QUESTION: {question}
+
+        OPTIONS:
+        {"\n".join([f"{i+1}. {option}" for i, option in enumerate(options)])}
+
+        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 run(self, query: str, profile: Dict[str, Any]) -> str:
-        log_workflow('COORDINATOR start', {'query': query[:50]})
-        country = profile.get('home_country', 'unknown')
-        domains = self._identify_relevant_specialists(query)
+    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})
 
-        # 1. Collect specialist advice
-        advice = {d: self.specialists[d].run(query, country) for d in domains}
+        # 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:
 
-        # 2. Generate multi-path plans
-        constraints = json.dumps(profile)
-        plans = self._generate_plans(query, constraints, country)
+        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 = {}
 
-        # 3. Build the specialist advice section
-        specialist_lines: List[str] = []
-        for d, a in advice.items():
-            specialist_lines.append(f"--- {d.upper()} SPECIALIST ---")
-            specialist_lines.append(a[:1000])
-            specialist_lines.append("")
-        spec_section = "\n".join(specialist_lines).strip()
+        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')}
+        """
 
-        # 4. Prepare plan snippets
-        cons = plans['conservative'][:1000]
-        bal  = plans['balanced'][:1000]
-        gro  = plans['growth'][:1000]
+        plans = self._generate_plans(query, constraints, country)
+
+        # 4. Synthesize the collected advice and plans into a coherent response
+        log_workflow("Synthesizing comprehensive response")
 
-        # 5. Compose synthesis prompt without inline backslashes in expressions
         synthesis_prompt = f"""
-As coordinator, synthesize advice and plans.
+        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}
+        QUERY:
+        {query}
 
-SPECIALIST ADVICE:
-{spec_section}
+        SPECIALIST ADVICE:
+        {"\n".join([f"--- {domain.upper()} SPECIALIST ---\n{advice[:1000]}\n" for domain, advice in specialist_advice.items()])}
 
-FINANCIAL APPROACHES:
---- CONSERVATIVE ---
-{cons}
+        FINANCIAL APPROACHES:
+        --- CONSERVATIVE APPROACH ---
+        {plans.get('conservative', 'No conservative plan available.')[:1000]}
 
---- BALANCED ---
-{bal}
+        --- BALANCED APPROACH ---
+        {plans.get('balanced', 'No balanced plan available.')[:1000]}
 
---- GROWTH ---
-{gro}
+        --- GROWTH-ORIENTED APPROACH ---
+        {plans.get('growth', 'No growth-oriented plan available.')[:1000]}
 
-Include detailed steps, names, amounts, timelines.
-""".strip()
+        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)
 
-        log_workflow('Synthesizing response')
-        synth = self.llm.invoke(synthesis_prompt).content
+        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
 
-        # 6. Final prompt via concatenation to avoid f-string backslash issues
-        reflection = self._reflect_on_recommendation(synth, profile)
-        final_prompt = synth + "\n\nLEGAL REFLECTION:\n" + reflection
-        log_workflow('Finalizing response')
-        return self.llm.invoke(final_prompt).content
 
 # =======================================
-# Gradio Interface
+# Main Portal Interface
 # =======================================
+
 class FinancePortal:
+    """Main interface for the International Student Finance Portal"""
+
     def __init__(self):
-        get_api_key()
+        """Initialize the finance portal with a coordinator agent"""
         self.coordinator = CoordinatorAgent()
-        self.profiles: Dict[str, Any] = {}
+        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 register(self, pid: str, prof: Dict[str, Any]):
-        self.profiles[pid] = prof
+    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 get_profile(self, pid: str) -> Optional[Dict[str, Any]]:
-        return self.profiles.get(pid)
+    def handle_query(self, student_id: str, query: str) -> str:
+        """Process a student query"""
+        profile = self.get_student_profile(student_id)
 
-    def handle(self, pid: str, query: str) -> str:
-        prof = self.get_profile(pid)
-        if not prof:
-            return 'Provide profile first.'
+        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()
-        response = self.coordinator.run(query, prof)
-        return response + "\n\n---\n\n" + get_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():
+    """Create the Gradio interface for the finance portal"""
     portal = FinancePortal()
 
-    def submit(query, country, visa, uni, fund, info):
-        pid = 'user'
-        portal.register(pid, {
-            'home_country': country,
-            'visa_type': visa,
-            'university': uni,
-            'funding': fund,
-            'additional_info': info
-        })
-        return portal.handle(pid, query)
-
-    with gr.Blocks() as demo:
-        gr.Markdown('# International Student Finance Portal')
-        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/Family','Scholarship','TA/RA','Loan','Other'], label='Funding')
-        info    = gr.Textbox(label='Additional Info')
-        query   = gr.Textbox(label='Your Financial Question', lines=4)
-        btn     = gr.Button('Get Advice')
-        out     = gr.Markdown()
-
-        btn.click(fn=submit,
-                  inputs=[query, country, visa, uni, fund, info],
-                  outputs=out)
+    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.
+            """)
+
     return demo
 
-if __name__ == '__main__':
-    print('Starting Finance Portal...')
-    get_api_key()
-    app = create_interface()
-    app.launch()
+# 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()