USER (WhatsApp/Discord)
    │
    ▼
┌─────────────────────────────────┐
│  BOT SERVER (FastAPI)            │
│  Receives messages, routes to    │
│  Claude via MCP orchestrator     │
└───────────┬─────────────────────┘
            │
            ▼
┌─────────────────────────────────┐
│  MCP HUB (orchestrates 3 MCPs)   │
│                                   │
│  ┌──────────┐ ┌──────────┐ ┌──────────┐
│  │Database   │ │ API MCP  │ │Template  │
│  │MCP        │ │          │ │MCP       │
│  │           │ │ FBR tax  │ │          │
│  │Business   │ │ SECP     │ │Response  │
│  │records,   │ │ market   │ │templates │
│  │user prefs │ │ data,    │ │invoices  │
│  │usage logs │ │ PKR/USD  │ │contracts │
│  └──────────┘ └──────────┘ └──────────┘
│                                   │
└───────────┬─────────────────────┘
            │
            ▼
┌─────────────────────────────────┐
│  CLAUDE SONNET (decision-making) │
│  Understands user intent,        │
│  calls appropriate MCP tools,    │
│  generates responses              │
└─────────────────────────────────┘

# mcps/database_mcp.py
from mcp.server import Server
from mcp.types import Tool
import sqlite3

server = Server("business-db")

@server.tool()
async def save_business(name: str, ntn: str, industry: str, city: str):
    """Save a business profile to the database."""
    conn = sqlite3.connect("businesses.db")
    conn.execute(
        "INSERT OR REPLACE INTO businesses (name, ntn, industry, city) VALUES (?, ?, ?, ?)",
        (name, ntn, industry, city)
    )
    conn.commit()
    return {"status": "saved", "business": name}

@server.tool()
async def get_business(ntn: str):
    """Retrieve a business profile by NTN number."""
    conn = sqlite3.connect("businesses.db")
    row = conn.execute("SELECT * FROM businesses WHERE ntn = ?", (ntn,)).fetchone()
    if row:
        return {"name": row[0], "ntn": row[1], "industry": row[2], "city": row[3]}
    return {"error": "Business not found"}

@server.tool()
async def log_usage(user_id: str, action: str, tier: str):
    """Log user actions for analytics and billing."""
    conn = sqlite3.connect("businesses.db")
    conn.execute(
        "INSERT INTO usage_log (user_id, action, tier, timestamp) VALUES (?, ?, ?, datetime('now'))",
        (user_id, action, tier)
    )
    conn.commit()
    return {"logged": True}

# mcps/api_mcp.py
@server.tool()
async def calculate_tax(annual_income: float, tax_year: int = 2026):
    """Calculate Pakistan income tax based on FBR slabs."""
    slabs = [
        (600000, 0),        # Up to 6 lakh: 0%
        (1200000, 0.025),   # 6-12 lakh: 2.5%
        (2400000, 0.125),   # 12-24 lakh: 12.5%
        (3600000, 0.225),   # 24-36 lakh: 22.5%
        (6000000, 0.275),   # 36-60 lakh: 27.5%
        (float('inf'), 0.35) # Above 60 lakh: 35%
    ]
    tax = 0
    remaining = annual_income
    prev_limit = 0
    for limit, rate in slabs:
        taxable = min(remaining, limit - prev_limit)
        tax += taxable * rate
        remaining -= taxable
        prev_limit = limit
        if remaining <= 0:
            break
    return {
        "annual_income": annual_income,
        "tax_amount": round(tax),
        "effective_rate": f"{(tax/annual_income)*100:.1f}%",
        "monthly_tax": round(tax / 12)
    }

@server.tool()
async def gst_calculator(amount: float, gst_rate: float = 0.17):
    """Calculate GST (17% standard rate in Pakistan)."""
    gst = amount * gst_rate
    return {
        "base_amount": amount,
        "gst_rate": f"{gst_rate*100}%",
        "gst_amount": round(gst),
        "total_with_gst": round(amount + gst)
    }

# mcps/template_mcp.py
@server.tool()
async def generate_invoice(
    business_name: str, client_name: str,
    items: list, ntn: str
):
    """Generate a professional invoice with Pakistani tax compliance."""
    subtotal = sum(item["amount"] for item in items)
    gst = subtotal * 0.17
    total = subtotal + gst

    invoice = f"""
    ╔══════════════════════════════════════╗
    ║           TAX INVOICE                 ║
    ╠══════════════════════════════════════╣
    ║ From: {business_name}                ║
    ║ NTN:  {ntn}                          ║
    ║ To:   {client_name}                  ║
    ║ Date: {datetime.now().strftime('%d-%m-%Y')}    ║
    ╠══════════════════════════════════════╣"""

    for item in items:
        invoice += f"\n    ║ {item['description']:<25} PKR {item['amount']:>8,} ║"

    invoice += f"""
    ╠══════════════════════════════════════╣
    ║ Subtotal:                 PKR {subtotal:>8,} ║
    ║ GST (17%):                PKR {gst:>8,.0f} ║
    ║ TOTAL:                    PKR {total:>8,.0f} ║
    ╚══════════════════════════════════════╝"""

    return {"invoice_text": invoice, "total": total}

# bot.py
import discord
import anthropic
import json

client = discord.Client(intents=discord.Intents.default())
claude = anthropic.Anthropic()

SYSTEM_PROMPT = """You are the Karachi Business Bot — an AI assistant
helping Pakistani businesses with registration, tax, market analysis,
and document generation.

You have access to these tools:
- save_business: Store business details
- get_business: Look up business by NTN
- calculate_tax: Pakistan income tax calculation
- gst_calculator: GST calculation
- generate_invoice: Create tax-compliant invoices
- log_usage: Track user actions

Always respond in a professional but friendly tone.
Use PKR for all amounts. Reference Pakistani laws and regulations.
If unsure about tax law, recommend consulting a registered tax advisor."""

@client.event
async def on_message(message):
    if message.author == client.user:
        return

    user_query = message.content
    user_id = str(message.author.id)

    # Determine tier (check database for subscription)
    tier = await check_user_tier(user_id)

    if tier == "free" and await daily_limit_reached(user_id):
        await message.reply(
            "You've reached your free tier limit (10 queries/day). "
            "Upgrade to Pro for unlimited access: PKR 1,500/month"
        )
        return

    # Query Claude with MCP tools
    response = claude.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=1000,
        system=SYSTEM_PROMPT,
        tools=get_mcp_tools(),  # Load tool definitions from MCP servers
        messages=[{"role": "user", "content": user_query}]
    )

    # Handle tool use if Claude wants to call an MCP
    if response.stop_reason == "tool_use":
        tool_result = await execute_mcp_tool(response)
        # Send tool result back to Claude for final response
        final = claude.messages.create(
            model="claude-sonnet-4-6",
            max_tokens=1000,
            system=SYSTEM_PROMPT,
            messages=[
                {"role": "user", "content": user_query},
                {"role": "assistant", "content": response.content},
                {"role": "user", "content": [{"type": "tool_result", **tool_result}]}
            ]
        )
        await message.reply(final.content[0].text)
    else:
        await message.reply(response.content[0].text)

    # Log usage
    await log_usage(user_id, "query", tier)

client.run(DISCORD_TOKEN)

DEPLOYMENT ARCHITECTURE:

┌─────────────────────┐
│ Railway/Render       │ ← Bot server ($5/month)
│ Python + Discord.py  │
└──────────┬──────────┘
           │
┌──────────┴──────────┐
│ MCP Servers          │ ← Same server or separate
│ (3 processes)        │    (PM2 manages all)
└──────────┬──────────┘
           │
┌──────────┴──────────┐
│ PostgreSQL           │ ← Supabase free tier or
│ (Vercel Postgres)    │    Railway PostgreSQL
└─────────────────────┘

DEPLOYMENT STEPS:

1. Push code to GitHub (never commit .env)
2. Create Railway project → connect GitHub repo
3. Set environment variables:
   DISCORD_TOKEN=...
   ANTHROPIC_API_KEY=sk-ant-...
   DATABASE_URL=postgresql://...
4. Configure build: pip install -r requirements.txt
5. Configure start: python bot.py
6. Enable auto-deploy on push
7. Set up health check endpoint (/health)
8. Configure Sentry for error tracking
9. Set up UptimeRobot for uptime monitoring ($0)
10. Test with 10 real queries from your phone

FREE TIER:
├── 10 queries/day
├── Basic tax calculations
├── Simple business guidance
├── Target: 100,000 users (brand awareness)
└── Cost to serve: ~$0.001/query × 10 × 100K = $1,000/month

PRO TIER (PKR 1,500/month or $5/month):
├── Unlimited queries
├── Invoice generation
├── Market analysis reports
├── Priority response
├── Target: 1,000 paying users
└── Revenue: $5,000/month

BUSINESS TIER (PKR 15,000/month or $50/month):
├── Everything in Pro
├── Custom document templates
├── Dedicated support channel
├── API access for integration
├── White-label option
├── Target: 100 businesses
└── Revenue: $5,000/month

═══════════════════════════════════════════════
TOTAL POTENTIAL: $10,000/month (PKR 2.8M/month)
INFRASTRUCTURE COST: ~$100-200/month + Claude API
MARGIN: 95%+
═══════════════════════════════════════════════