Upload 20 files

QUICK_START.md

@@ -0,0 +1,173 @@
+# Quick Start: Enhanced RAG Responses
+
+## TL;DR
+
+Your RAG responses are now **more explanatory and context-aware**. Test it:
+
+```bash
+python test_enhanced_responses.py
+```
+
+---
+
+## What Changed?
+
+### Before
+```
+❌ Generic bullet points
+❌ Intimidating legal language  
+❌ No practical guidance
+❌ Inline citations disrupt flow
+```
+
+### After
+```
+✅ Structured explanations (Simple → Detailed → Example → Takeaways)
+✅ Persona-aware (Student, Business, Employee contexts)
+✅ Conversational, supportive tone
+✅ Citations at end, not inline
+```
+
+---
+
+## Test It Now
+
+### Option 1: Quick Test
+```bash
+python test_enhanced_responses.py
+```
+Tests the student question you mentioned.
+
+### Option 2: Test All Personas
+```bash
+python test_enhanced_responses.py --all
+```
+Tests student, business, employee, and general questions.
+
+### Option 3: Custom Question
+```bash
+python rag_pipeline.py --source data --question "Your question here"
+```
+
+---
+
+## Example Output
+
+**Question:** "As a student, what do I need to know about the new tax law?"
+
+**You'll now get:**
+
+```
+**Simple Answer:**
+The new tax law creates a Student Education Loan Fund starting in 2030.
+
+**What It Means for You:**
+[Student-focused explanation]
+
+**How It Works:**
+[Clear breakdown]
+
+**Timeline:**
+[When it matters]
+
+**Practical Example:**
+[Real scenario]
+
+**Key Takeaways:**
+✅ [Actionable point 1]
+✅ [Actionable point 2]
+✅ [Actionable point 3]
+
+(Source citations)
+```
+
+---
+
+## Files You Got
+
+1. **`persona_prompts.py`** - Persona detection logic
+2. **`test_enhanced_responses.py`** - Test script
+3. **`ENHANCEMENT_SUMMARY.md`** - Overview (read this)
+4. **`BEFORE_AFTER_COMPARISON.md`** - Visual examples
+5. **`RESPONSE_ENHANCEMENT_GUIDE.md`** - Full technical docs
+6. **`QUICK_START.md`** - This file
+
+---
+
+## How It Works
+
+```
+User Question
+    ↓
+Detect Persona (student/business/employee/general)
+    ↓
+Adapt System Prompt
+    ↓
+Retrieve Relevant Documents
+    ↓
+Generate Structured Response
+    ↓
+Enhanced Answer
+```
+
+---
+
+## Novel Approaches Used
+
+1. **Contextual Layering** - Progressive information disclosure
+2. **Persona Detection** - Auto-adapt to user context
+3. **Narrative Structure** - Story-based explanations
+4. **Citation Optimization** - End of sections, not inline
+
+---
+
+## Configuration
+
+### Disable if Needed
+```python
+# In rag_pipeline.py, line 39
+_HAS_PERSONA = False  # Reverts to generic responses
+```
+
+### Add New Persona
+```python
+# In persona_prompts.py
+PERSONA_PROMPTS["your_persona"] = {
+    "system_suffix": "Your custom instructions...",
+    "keywords": ["keyword1", "keyword2"]
+}
+```
+
+---
+
+## Troubleshooting
+
+**Q: Persona not detected?**  
+A: Add more keywords to `persona_prompts.py`
+
+**Q: Responses too long?**  
+A: Reduce `max_tokens` in RAGPipeline init
+
+**Q: Want old format back?**  
+A: Set `_HAS_PERSONA = False`
+
+---
+
+## Next Steps
+
+1. ✅ **Test it:** `python test_enhanced_responses.py`
+2. 📊 **Compare:** Check output vs your current response
+3. 🔧 **Customize:** Edit personas in `persona_prompts.py`
+4. 🚀 **Deploy:** Use in production when satisfied
+
+---
+
+## Support
+
+- **Examples:** `BEFORE_AFTER_COMPARISON.md`
+- **Technical:** `RESPONSE_ENHANCEMENT_GUIDE.md`
+- **Overview:** `ENHANCEMENT_SUMMARY.md`
+
+---
+
+**Start here:** `python test_enhanced_responses.py`

rag_pipeline.py

@@ -40,6 +40,13 @@ try:
 except ImportError:
     _HAS_PERSONA = False
 
+# Tax calculator for accurate arithmetic
+try:
+    from tax_calculator import TaxCalculator
+    _HAS_TAX_CALC = True
+except ImportError:
+    _HAS_TAX_CALC = False
+
 # Optional hybrid and rerankers
 from langchain_community.retrievers import BM25Retriever
 from langchain.retrievers import EnsembleRetriever
@@ -342,6 +349,12 @@ class RAGPipeline:
                 print(f"Could not load cross-encoder reranker: {e}")
                 self.reranker = None
 
+        # Initialize tax calculator for accurate arithmetic
+        self.tax_calculator = None
+        if _HAS_TAX_CALC:
+            self.tax_calculator = TaxCalculator()
+            print("Tax calculator loaded - calculations will use real arithmetic")
+
         self.chain = self._build_chain()
         print("RAG pipeline ready")
 
@@ -458,13 +471,6 @@ class RAGPipeline:
             "3) **Make it real**: Always include a relatable example or scenario that shows how this actually plays out.\n"
             "4) **Give them clear takeaways**: 2-3 specific points they can remember or act on.\n"
             "\n"
-            "Citation Guidelines:\n"
-            "- Group ALL citations at the very end under a \"Sources\" or \"Want to dive deeper?\" section\n"
-            "- Format: \"Nigeria Tax Act 2025, Section [X]\" or \"Tax Administration Guidelines, Chapter [Y]\"\n"
-            "- NEVER use document filenames (like \"Journal_Nigeria-Tax-Bill.pdf\") - reference the actual law/chapter instead\n"
-            "- Don't interrupt your explanation with citations - let it flow naturally\n"
-            "- Only use information from the provided context\n"
-            "\n"
             "Tone - This is Critical:\n"
             "- Write like you're explaining this to someone who's never dealt with this before\n"
             "- Use \"you\" and \"your\" to make it personal\n"
@@ -474,6 +480,7 @@ class RAGPipeline:
             "- Be genuine and understanding: \"I know tax stuff can be confusing, but here's what you need to know...\"\n"
             "- If something doesn't apply to them, be clear: \"This won't affect you, but...\"\n"
             "- Make it conversational and natural - like explaining to a friend, not reading from a legal document\n"
+            "- Always encourage questions and provide reassurance: \"Feel free to ask if anything is unclear!\"\n"
         )
         
         # Add persona-specific context if available
@@ -626,15 +633,61 @@ class RAGPipeline:
         })
         return final
 
+    # -------- Question validation --------
+
+    def _is_tax_related_question(self, question: str) -> bool:
+        """
+        Check if the question is related to Nigerian tax law.
+        Uses a fast LLM call to classify the question.
+        """
+        # Fast keyword check first (avoid LLM call if obviously tax-related)
+        tax_keywords = [
+            'tax', 'paye', 'vat', 'cit', 'wht', 'income', 'revenue',
+            'levy', 'duty', 'assessment', 'filing', 'return', 'deduction',
+            'allowance', 'relief', 'exemption', 'taxable', 'naira', '₦',
+            'firs', 'lirs', 'pension', 'nhf', 'company', 'business',
+            'employer', 'employee', 'salary', 'profit', 'turnover'
+        ]
+
+        q_lower = question.lower()
+        if any(keyword in q_lower for keyword in tax_keywords):
+            return True
+
+        # If no keywords, use LLM to classify (fast check)
+        classifier_prompt = ChatPromptTemplate.from_template(
+            "You are a question classifier for a Nigerian tax law assistant.\n\n"
+            "Is the following question related to Nigerian tax law, taxation, tax administration, "
+            "tax calculations, or tax compliance?\n\n"
+            "Question: {question}\n\n"
+            "Answer ONLY with 'YES' or 'NO'. Nothing else."
+        )
+
+        try:
+            response = (classifier_prompt | self.llm | StrOutputParser()).invoke({"question": question})
+            return response.strip().upper().startswith("YES")
+        except Exception:
+            # If classification fails, err on the side of allowing the question
+            return True
+
     # -------- Task routing --------
 
-    @staticmethod
-    def _route(question: str) -> str:
+    def _route(self, question: str) -> str:
+        """Route question to appropriate handler."""
         q = question.lower()
+
+        # Check if this is a calculation question first (highest priority)
+        if self.tax_calculator and self.tax_calculator.is_calculation_question(question):
+            return "calculate"
+
+        # Then check for summarization
         if re.search(r"\bchapter\b|\bsection\b|\bpart\s+[ivxlcdm]+\b|^summari[sz]e\b", q):
             return "summarize"
+
+        # Then check for structured extraction
         if re.search(r"\bextract\b|\blist\b|\btable\b|\brate\b|\bband\b|\bthreshold\b|\ballowance\b|\brelief\b", q):
             return "extract"
+
+        # Default to QA
         return "qa"
 
     # Stub for a future extractor chain - currently route extractor requests to QA chain with strict rules
@@ -643,23 +696,67 @@ class RAGPipeline:
 
     def query(self, question: str, verbose: bool = False) -> str:
         """Route and answer the question with persona-aware responses."""
+        # First, check if question is tax-related
+        if not self._is_tax_related_question(question):
+            return (
+                "**I'm Káàntà AI - Your Nigerian Tax Assistant**\n\n"
+                "I specialize in answering questions about Nigerian tax law, including:\n"
+                "• Personal Income Tax (PAYE)\n"
+                "• Company Income Tax (CIT)\n"
+                "• Value Added Tax (VAT)\n"
+                "• Tax calculations and brackets\n"
+                "• Tax filing and compliance\n"
+                "• Tax reliefs and exemptions\n\n"
+                "Your question doesn't seem to be related to Nigerian taxation. "
+                "I can only help with tax-related questions based on the Nigeria Tax Act and Tax Administration documents.\n\n"
+                "**Try asking me:**\n"
+                "• \"How much tax will I pay on a monthly income of ₦X?\"\n"
+                "• \"What are the personal income tax rates in Nigeria?\"\n"
+                "• \"What is PAYE and how does it work?\"\n"
+                "• \"What tax reliefs are available for individuals?\"\n\n"
+                "Feel free to ask any tax-related question!"
+            )
+
+        # Route the question
+        task = self._route(question)
+
         if verbose:
-            print(f"\nRetrieving relevant documents...")
-            docs = self._retrieve(question)
-            print(f"Found {len(docs)} relevant chunks:")
-            for i, doc in enumerate(docs[:20], 1):
-                source = doc.metadata.get("source", "Unknown")
-                page = doc.metadata.get("page", "Unknown")
-                preview = doc.page_content[:150].replace("\n", " ")
-                print(f"  [{i}] {source} (page {page}): {preview}...")
-            print()
-            
+            print(f"\nTask type: {task}")
+
+            if task == "calculate":
+                print("Using tax calculator for accurate arithmetic\n")
+            else:
+                print(f"\nRetrieving relevant documents...")
+                docs = self._retrieve(question)
+                print(f"Found {len(docs)} relevant chunks:")
+                for i, doc in enumerate(docs[:20], 1):
+                    source = doc.metadata.get("source", "Unknown")
+                    page = doc.metadata.get("page", "Unknown")
+                    preview = doc.page_content[:150].replace("\n", " ")
+                    print(f"  [{i}] {source} (page {page}): {preview}...")
+                print()
+
             # Show detected persona if available
             if _HAS_PERSONA:
                 persona = detect_persona(question)
                 print(f"Detected persona: {persona}\n")
 
-        task = self._route(question)
+        # Handle calculation questions with tax calculator
+        if task == "calculate":
+            if self.tax_calculator:
+                try:
+                    answer = self.tax_calculator.answer_calculation_question(question)
+                    if answer:
+                        return answer
+                    else:
+                        # Fallback to regular QA if extraction failed
+                        task = "qa"
+                except Exception as e:
+                    print(f"Warning: Tax calculation failed: {e}")
+                    print("Falling back to regular QA chain\n")
+                    task = "qa"
+
+        # Handle other task types
         if task == "summarize":
             return self._summarize_chapter(question)
         elif task == "extract":
@@ -671,6 +768,12 @@ class RAGPipeline:
 
 
 def main():
+    # Fix encoding for Windows console
+    if sys.platform == 'win32':
+        import io
+        sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8', errors='replace')
+        sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding='utf-8', errors='replace')
+
     parser = argparse.ArgumentParser(
         description="Enhanced RAG pipeline with hybrid retrieval, reranking, and chapter summarization",
         formatter_class=argparse.RawDescriptionHelpFormatter,

tax_calculator.py

@@ -0,0 +1,357 @@
+"""
+Tax calculation engine with real Python arithmetic.
+Handles Nigerian personal income tax calculations accurately.
+"""
+
+import re
+from typing import Dict, List, Tuple, Optional
+from dataclasses import dataclass
+
+
+@dataclass
+class TaxBracket:
+    """Represents a single tax bracket."""
+    lower: float
+    upper: float
+    rate: float
+
+    def __repr__(self):
+        return f"₦{self.lower:,.0f} - ₦{self.upper:,.0f}: {self.rate*100:.0f}%"
+
+
+@dataclass
+class TaxCalculation:
+    """Results of a tax calculation."""
+    annual_income: float
+    annual_tax: float
+    monthly_income: float
+    monthly_tax: float
+    effective_rate: float
+    breakdown: List[Dict[str, float]]
+
+    def format_summary(self) -> str:
+        """Format a human-readable summary."""
+        lines = []
+        lines.append("**Tax Calculation Summary**\n")
+        lines.append(f"**Monthly Income:** ₦{self.monthly_income:,.2f}")
+        lines.append(f"**Monthly Tax:** ₦{self.monthly_tax:,.2f}")
+        lines.append(f"**Take-home pay:** ₦{self.monthly_income - self.monthly_tax:,.2f}\n")
+
+        lines.append(f"**Annual Income:** ₦{self.annual_income:,.2f}")
+        lines.append(f"**Annual Tax:** ₦{self.annual_tax:,.2f}")
+        lines.append(f"**Effective Tax Rate:** {self.effective_rate:.2f}%\n")
+
+        lines.append("**How we calculated this:**")
+        for item in self.breakdown:
+            if item['tax'] > 0:
+                lines.append(
+                    f"  • ₦{item['bracket_start']:,.0f} - ₦{item['bracket_end']:,.0f} "
+                    f"at {item['rate']*100:.0f}%: "
+                    f"₦{item['taxable']:,.2f} × {item['rate']*100:.0f}% = ₦{item['tax']:,.2f}"
+                )
+            else:
+                lines.append(
+                    f"  • ₦{item['bracket_start']:,.0f} - ₦{item['bracket_end']:,.0f} "
+                    f"at {item['rate']*100:.0f}%: TAX-FREE"
+                )
+
+        return "\n".join(lines)
+
+
+# Nigerian Personal Income Tax Brackets (2025)
+NIGERIA_TAX_BRACKETS = [
+    TaxBracket(0, 800_000, 0.00),           # 0% - TAX FREE
+    TaxBracket(800_000, 3_000_000, 0.15),   # 15%
+    TaxBracket(3_000_000, 12_000_000, 0.18), # 18%
+    TaxBracket(12_000_000, 25_000_000, 0.21), # 21%
+    TaxBracket(25_000_000, 50_000_000, 0.23), # 23%
+    TaxBracket(50_000_000, float('inf'), 0.25), # 25%
+]
+
+
+class TaxCalculator:
+    """Calculates Nigerian personal income tax."""
+
+    def __init__(self, brackets: List[TaxBracket] = None):
+        """Initialize calculator with tax brackets."""
+        self.brackets = brackets or NIGERIA_TAX_BRACKETS
+
+    def calculate_annual_tax(self, annual_income: float) -> TaxCalculation:
+        """
+        Calculate tax on annual income using real arithmetic.
+
+        Args:
+            annual_income: Annual income in Naira
+
+        Returns:
+            TaxCalculation with detailed breakdown
+        """
+        if annual_income < 0:
+            raise ValueError("Income cannot be negative")
+
+        total_tax = 0.0
+        breakdown = []
+        remaining_income = annual_income
+
+        for bracket in self.brackets:
+            if remaining_income <= 0:
+                break
+
+            # Calculate taxable amount in this bracket
+            bracket_lower = bracket.lower
+            bracket_upper = min(bracket.upper, annual_income)
+
+            # How much income falls in this bracket?
+            taxable_in_bracket = min(
+                remaining_income,
+                bracket_upper - bracket_lower
+            )
+
+            # Calculate tax for this bracket
+            tax_in_bracket = taxable_in_bracket * bracket.rate
+            total_tax += tax_in_bracket
+
+            # Record breakdown
+            breakdown.append({
+                'bracket_start': bracket_lower,
+                'bracket_end': bracket_upper if bracket_upper != float('inf') else annual_income,
+                'rate': bracket.rate,
+                'taxable': taxable_in_bracket,
+                'tax': tax_in_bracket
+            })
+
+            remaining_income -= taxable_in_bracket
+
+            # Stop if we've reached the income amount
+            if annual_income <= bracket_upper:
+                break
+
+        effective_rate = (total_tax / annual_income * 100) if annual_income > 0 else 0
+
+        return TaxCalculation(
+            annual_income=annual_income,
+            annual_tax=total_tax,
+            monthly_income=annual_income / 12,
+            monthly_tax=total_tax / 12,
+            effective_rate=effective_rate,
+            breakdown=breakdown
+        )
+
+    def calculate_from_monthly(self, monthly_income: float) -> TaxCalculation:
+        """Calculate tax from monthly income."""
+        annual_income = monthly_income * 12
+        return self.calculate_annual_tax(annual_income)
+
+    def extract_income_from_question(self, question: str) -> Optional[Tuple[float, str]]:
+        """
+        Extract income amount and period from question.
+
+        Returns:
+            Tuple of (amount, period) where period is 'monthly' or 'annual'
+            or None if not found
+        """
+        q = question.lower()
+
+        # Remove common currency symbols and words
+        q = q.replace('₦', '').replace('naira', '').replace(',', '')
+
+        # Patterns for income extraction (order matters - check annual first!)
+        # Note: commas already removed from q before matching
+        patterns = [
+            # Annual patterns first - check before monthly defaults
+            # "5000000 per year" or "5000000 annually"
+            (r'(\d+(?:\.\d+)?)\s*(?:per|a|each|every)?\s*(?:year|annum)', 'annual'),
+            (r'(\d+(?:\.\d+)?)\s*(?:/year|yearly|annually)', 'annual'),
+            # "annual income of 5000000" or "income of 5000000 per year"
+            (r'annual\s+income\s+(?:of\s+)?(\d+(?:\.\d+)?)', 'annual'),
+            (r'income\s+(?:of\s+)?(\d+(?:\.\d+)?)\s+(?:per|a)\s+year', 'annual'),
+
+            # Monthly patterns
+            # "75000 per month" or "75000 per month"
+            (r'(\d+(?:\.\d+)?)\s*(?:per|a|each|every)?\s*month', 'monthly'),
+            # "75000 monthly" or "75000/month"
+            (r'(\d+(?:\.\d+)?)\s*(?:/month|monthly)', 'monthly'),
+            # "earning 75000" (assume monthly if not specified)
+            (r'earning\s+(\d+(?:\.\d+)?)', 'monthly'),
+            # "I earn 75000" (assume monthly)
+            (r'earn(?:ing)?\s+(\d+(?:\.\d+)?)', 'monthly'),
+            # "salary of 75000" (assume monthly)
+            (r'salary\s+(?:of\s+)?(\d+(?:\.\d+)?)', 'monthly'),
+            # "income of 75000" (default to monthly if no period specified)
+            (r'income\s+(?:of\s+)?(\d+(?:\.\d+)?)', 'monthly'),
+        ]
+
+        for pattern, period in patterns:
+            match = re.search(pattern, q)
+            if match:
+                try:
+                    amount = float(match.group(1))
+                    return (amount, period)
+                except (ValueError, IndexError):
+                    continue
+
+        return None
+
+    def is_calculation_question(self, question: str) -> bool:
+        """
+        Detect if question is asking for a tax calculation.
+
+        Returns:
+            True if question requires calculation
+        """
+        q = question.lower()
+
+        # Calculation indicators (more comprehensive patterns)
+        calc_patterns = [
+            r'how much.*tax',          # "how much tax will I pay" or "how much tax"
+            r'calculate.*tax',         # "calculate my tax"
+            r'what.*tax.*pay',         # "what tax will I pay"
+            r'what.*tax.*owe',         # "what tax do I owe"
+            r'tax.*calculation',       # "tax calculation"
+            r'compute.*tax',           # "compute tax"
+            r'my tax',                 # "what's my tax"
+            r'tax liability',          # "tax liability"
+            r'tax.*amount',            # "tax amount"
+            r'pay.*tax',               # "will I pay tax"
+            r'tax.*deduct',            # "tax deduction"
+            r'how much.*pay',          # "how much will I pay" (in context of income)
+            r'what.*pay.*month',       # "what will I pay per month"
+            r'how much.*month.*tax',   # "how much per month as tax"
+        ]
+
+        # Must also contain income information
+        has_income = self.extract_income_from_question(question) is not None
+
+        # Check if any calculation pattern matches
+        has_calc_intent = any(re.search(pattern, q) for pattern in calc_patterns)
+
+        return has_calc_intent and has_income
+
+    def answer_calculation_question(self, question: str) -> str:
+        """
+        Answer a tax calculation question with accurate arithmetic.
+
+        Args:
+            question: User's question
+
+        Returns:
+            Formatted answer with calculation
+        """
+        # Extract income
+        extraction = self.extract_income_from_question(question)
+
+        if not extraction:
+            return None
+
+        amount, period = extraction
+
+        # Calculate tax
+        if period == 'monthly':
+            result = self.calculate_from_monthly(amount)
+        else:
+            result = self.calculate_annual_tax(amount)
+
+        # Validate result
+        if result.annual_tax > result.annual_income:
+            raise ValueError(
+                f"VALIDATION ERROR: Calculated tax (₦{result.annual_tax:,.2f}) "
+                f"exceeds income (₦{result.annual_income:,.2f})!"
+            )
+
+        if result.effective_rate > 100:
+            raise ValueError(
+                f"VALIDATION ERROR: Effective tax rate ({result.effective_rate:.2f}%) exceeds 100%!"
+            )
+
+        # Format answer
+        answer_parts = []
+
+        answer_parts.append("**Bottom Line:**")
+        answer_parts.append(
+            f"On an income of ₦{result.monthly_income:,.2f} per month "
+            f"(₦{result.annual_income:,.2f} per year), you'll pay **₦{result.monthly_tax:,.2f} per month** "
+            f"in personal income tax. That's ₦{result.annual_tax:,.2f} per year.\n"
+        )
+
+        answer_parts.append(result.format_summary())
+
+        answer_parts.append("\n**Important Notes:**")
+        answer_parts.append("• The first ₦800,000 of your annual income is completely tax-free")
+        answer_parts.append("• Nigeria uses a progressive tax system - you only pay higher rates on income above each threshold")
+        answer_parts.append("• This calculation is for personal income tax only (PAYE)")
+        answer_parts.append("• Additional deductions may apply: pension (8%), NHF (2.5% if applicable), NHIS, etc.")
+
+        answer_parts.append("\n**Next Steps:**")
+        answer_parts.append("• Check your payslip to verify your employer is deducting the correct amount")
+        answer_parts.append("• Keep records of your tax payments for annual filing")
+        answer_parts.append("• Consult a tax professional for personalized advice on deductions and reliefs")
+
+        return "\n".join(answer_parts)
+
+
+# Convenience functions
+def calculate_tax(income: float, period: str = 'annual') -> TaxCalculation:
+    """
+    Quick tax calculation.
+
+    Args:
+        income: Income amount in Naira
+        period: 'monthly' or 'annual'
+
+    Returns:
+        TaxCalculation object
+    """
+    calc = TaxCalculator()
+    if period == 'monthly':
+        return calc.calculate_from_monthly(income)
+    else:
+        return calc.calculate_annual_tax(income)
+
+
+def format_tax_brackets() -> str:
+    """Format tax brackets for display."""
+    lines = ["**Nigerian Personal Income Tax Brackets (2025)**\n"]
+    for bracket in NIGERIA_TAX_BRACKETS:
+        if bracket.upper == float('inf'):
+            lines.append(f"Above ₦{bracket.lower:,.0f}: {bracket.rate*100:.0f}%")
+        else:
+            lines.append(f"₦{bracket.lower:,.0f} - ₦{bracket.upper:,.0f}: {bracket.rate*100:.0f}%")
+    return "\n".join(lines)
+
+
+if __name__ == "__main__":
+    # Test with the example from the user
+    import sys
+    if sys.platform == 'win32':
+        # Fix encoding for Windows console
+        import io
+        sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8', errors='replace')
+
+    print("Testing Tax Calculator\n")
+    print("=" * 80)
+
+    calc = TaxCalculator()
+
+    # Test case 1: N75,000/month
+    print("\nTest 1: N75,000 per month")
+    print("-" * 80)
+    result = calc.calculate_from_monthly(75_000)
+    print(result.format_summary())
+
+    # Test case 2: Extract from question
+    print("\n\nTest 2: Extract and calculate from question")
+    print("-" * 80)
+    question = "I am earning 75,000 per month, how much will I pay per month as tax"
+    answer = calc.answer_calculation_question(question)
+    print(answer)
+
+    # Test case 3: High income
+    print("\n\nTest 3: N10,000,000 per year")
+    print("-" * 80)
+    result = calc.calculate_annual_tax(10_000_000)
+    print(result.format_summary())
+
+    # Test validation
+    print("\n\nTest 4: Tax bracket display")
+    print("-" * 80)
+    print(format_tax_brackets())