add chroma_db to Docker, skip rebuild on startup

Dockerfile

@@ -7,8 +7,9 @@ RUN pip install --no-cache-dir -r requirements.txt
 
 COPY app.py fiscal.py auth.py plaid_client.py rebuild_index.py ./
 COPY docs/ ./docs/
+COPY chroma_db/ ./chroma_db/
 
 EXPOSE 7860
 
-# Rebuild ChromaDB then start the server
+# Skip rebuild if chroma_db exists, then start
 CMD ["sh", "-c", "python rebuild_index.py && uvicorn app:app --host 0.0.0.0 --port 7860"]

plaid_client.py

@@ -1,973 +1,36 @@
 import os
-from datetime import date, timedelta
-from plaid.api import plaid_api
-from plaid.configuration import Configuration
-from plaid.api_client import ApiClient
-from plaid.model.products import Products
-from plaid.model.country_code import CountryCode
-from plaid.exceptions import ApiException
-from plaid.model.accounts_balance_get_request import AccountsBalanceGetRequest
-from plaid.model.transactions_get_request import TransactionsGetRequest
-from plaid.model.transactions_get_request_options import TransactionsGetRequestOptions
-from plaid.model.link_token_create_request import LinkTokenCreateRequest
-from plaid.model.link_token_create_request_user import LinkTokenCreateRequestUser
-from plaid.model.item_public_token_exchange_request import ItemPublicTokenExchangeRequest
-from collections import defaultdict
-from datetime import date, timedelta
-import re
 
-# ---------- Client setup ----------
-
-def _make_client():
-    env = os.environ.get("PLAID_ENV", "sandbox")
-    host = {
-        "sandbox":     "https://sandbox.plaid.com",
-        "development": "https://development.plaid.com",
-        "production":  "https://production.plaid.com",
-    }[env]
-
-    config = Configuration(
-        host=host,
-        api_key={
-        "clientId": os.environ["PLAID_CLIENT_ID"],   # reads from .env
-        "secret":   os.environ["PLAID_SECRET"]
-        }
+if os.path.exists("./chroma_db"):
+    print("chroma_db/ exists, skipping rebuild.")
+else:
+    from langchain_community.document_loaders import TextLoader
+    from langchain_text_splitters import MarkdownHeaderTextSplitter
+    from langchain_huggingface import HuggingFaceEmbeddings
+    from langchain_community.vectorstores import Chroma
+
+    print("Building new index...")
+    loader = TextLoader("./docs/fiscal_knowledge.md", encoding="utf-8")
+    docs = loader.load()
+    text = docs[0].page_content
+    print(f"Loaded {len(text):,} characters")
+
+    splitter = MarkdownHeaderTextSplitter(
+        headers_to_split_on=[("##", "question")],
+        strip_headers=False,
     )
-    return plaid_api.PlaidApi(ApiClient(config))
-
-plaid_client = _make_client()
-
-
-# ---------- Balances ----------
-
-def get_balances(access_token: str) -> str:
-    request = AccountsBalanceGetRequest(access_token=access_token)
-    response = plaid_client.accounts_balance_get(request)
-
-    lines = ["USER'S CURRENT ACCOUNT BALANCES:"]
-    for account in response['accounts']:
-        name    = account['name']
-        subtype = str(account['subtype'])
-        current = account['balances']['current']
-
-        if current is None:
-            continue
-
-        # Skip mortgage and line of credit — not relevant for daily budgeting
-        if subtype in ['mortgage', 'line of credit']:
-            continue
-
-        if subtype == 'credit card':
-            limit     = account['balances']['limit'] or 0
-            owing     = current
-            available = limit - current if limit > 0 else 0
-            lines.append(
-                f"- {name} (Credit Card): "
-                f"${owing:.2f} owing, ${available:.2f} available out of ${limit:.2f} limit"
-            )
-        elif subtype == 'checking':
-            available = account['balances']['available'] or current
-            lines.append(f"- {name} (Chequing): ${current:.2f} balance, ${available:.2f} available")
-        elif subtype == 'savings':
-            lines.append(f"- {name} (Savings): ${current:.2f}")
-        elif subtype == 'rrsp':
-            lines.append(f"- {name} (RRSP): ${current:.2f}")
-        else:
-            lines.append(f"- {name} ({subtype}): ${current:.2f}")
+    chunks = splitter.split_text(text)
+    print(f"Split into {len(chunks)} chunks")
 
-    return "\n".join(lines)
-    request = AccountsBalanceGetRequest(access_token=access_token)
-    response = plaid_client.accounts_balance_get(request)
-
-    lines = ["USER'S CURRENT ACCOUNT BALANCES:"]
-    for account in response['accounts']:
-        name    = account['name']
-        subtype = account['subtype']
-        current = account['balances']['current']
-
-        if current is None:
-            continue
-
-        if subtype == 'credit card':
-            limit     = account['balances']['limit'] or 0
-            available = account['balances']['available'] or (limit - current)
-            lines.append(
-                f"- {name} (Credit Card): "
-                f"${current:.2f} owing, ${available:.2f} available"
-            )
-        elif subtype in ['mortgage', 'line of credit']:
-            lines.append(f"- {name} ({subtype}): ${current:.2f} outstanding")
-        else:
-            lines.append(f"- {name} ({subtype}): ${current:.2f}")
-
-    return "\n".join(lines)
-
-# ---------- Transactions ----------
-
-def get_transactions(access_token: str, days: int = 30) -> str:
-    end_date = date.today()
-    start_date = end_date - timedelta(days=days)
-    week_start = end_date - timedelta(days=end_date.weekday())
-
-    request = TransactionsGetRequest(
-        access_token=access_token,
-        start_date=start_date,
-        end_date=end_date,
-        options=TransactionsGetRequestOptions(
-            count=200,
-            include_personal_finance_category=True
-        )
+    embeddings = HuggingFaceEmbeddings(
+        model_name="nomic-ai/nomic-embed-text-v1",
+        model_kwargs={"trust_remote_code": True},
     )
-    response = plaid_client.transactions_get(request)
-    transactions = response['transactions']
-
-    if not transactions:
-        return "No transactions found in the last 30 days."
-
-    today_total = 0.0
-    week_total = 0.0
-    month_total = 0.0
-    income_total = 0.0
-    category_totals: dict[str, float] = {}
-
-    for txn in transactions:
-        amount = txn['amount']
-        name = txn['name']
-        txn_date = txn['date']
-        category = txn.get('personal_finance_category', {}).get('primary', 'OTHER')
-
-        # Skip internal transfers between own accounts
-        if category in ['TRANSFER_IN', 'TRANSFER_OUT']:
-            continue
-
-        # Detect payroll mislabeled as loan payments
-        name_lower = name.lower()
-        if category == 'LOAN_PAYMENTS' and any(w in name_lower for w in ['payroll', 'salary', 'direct dep', 'employer', 'wages']):
-            income_total += amount
-            continue
-
-        # Skip other loan payments (mortgage, LOC) — not daily spending
-        if category == 'LOAN_PAYMENTS':
-            continue
-
-        # Income (negative = money in)
-        if amount < 0:
-            income_total += abs(amount)
-            continue
-
-        # Spending
-        month_total += amount
-        readable = category.replace("_", " ").title()
-        category_totals[readable] = category_totals.get(readable, 0) + amount
-
-        if txn_date >= week_start:
-            week_total += amount
-
-        if txn_date == end_date:
-            today_total += amount
-
-    lines = ["FINANCIAL SUMMARY (pre-calculated, do NOT recalculate):"]
-    lines.append(f"Today's spending: ${today_total:.2f}")
-    lines.append(f"This week's spending (since {week_start}): ${week_total:.2f}")
-    lines.append(f"This month's spending (last {days} days): ${month_total:.2f}")
-
-    if income_total > 0:
-        lines.append(f"Income received (last {days} days): +${income_total:.2f}")
-
-    lines.append(f"Average daily spending: ${month_total / max(days, 1):.2f}")
-
-    lines.append("\nSPENDING BY CATEGORY:")
-    for category, total in sorted(category_totals.items(), key=lambda x: -x[1]):
-        pct = (total / month_total * 100) if month_total > 0 else 0
-        lines.append(f"- {category}: ${total:.2f} ({pct:.0f}%)")
-
-    lines.append("\nRECENT TRANSACTIONS (last 5):")
-    count = 0
-    for txn in transactions:
-        if count >= 5:
-            break
-        amount = txn['amount']
-        category = txn.get('personal_finance_category', {}).get('primary', 'OTHER')
-        if amount <= 0 or category in ['TRANSFER_IN', 'TRANSFER_OUT', 'LOAN_PAYMENTS']:
-            continue
-        lines.append(f"  - {txn['date']} {txn['name']}: ${amount:.2f}")
-        count += 1
-
-    return "\n".join(lines)
-    end_date = date.today()
-    start_date = end_date - timedelta(days=days)
-    week_start = end_date - timedelta(days=end_date.weekday())
-
-    request = TransactionsGetRequest(
-        access_token=access_token,
-        start_date=start_date,
-        end_date=end_date,
-        options=TransactionsGetRequestOptions(
-            count=100,
-            include_personal_finance_category=True
-        )
-    )
-    response = plaid_client.transactions_get(request)
-    transactions = response['transactions']
-
-    if not transactions:
-        return "No transactions found in the last 30 days."
-
-    # Pre-calculate everything — never let LLM do math
-    today_total = 0.0
-    week_total = 0.0
-    month_total = 0.0
-    income_total = 0.0
-    category_totals: dict[str, float] = {}
-    today_transactions: list[str] = []
-    week_transactions: list[str] = []
-
-    for txn in transactions:
-        amount = txn['amount']
-        name = txn['name']
-        txn_date = txn['date']
-        category = txn.get('personal_finance_category', {}).get('primary', 'OTHER')
-
-        # Income (negative = money in)
-        if amount < 0:
-            income_total += abs(amount)
-            continue
-
-        # Skip internal transfers
-        if category in ['TRANSFER_IN', 'TRANSFER_OUT']:
-            continue
-
-        name_lower = name.lower()
-        if category == 'LOAN_PAYMENTS' and any(w in name_lower for w in ['payroll', 'salary', 'direct dep', 'employer', 'wages']):
-            income_total += amount
-            continue
-
-        # Spending totals by time period
-        month_total += amount
-        category_totals[category] = category_totals.get(category, 0) + amount
-
-        if txn_date >= week_start:
-            week_total += amount
-            week_transactions.append(f"  - {txn_date} {name}: ${amount:.2f}")
-
-        if txn_date == end_date:
-            today_total += amount
-            today_transactions.append(f"  - {name}: ${amount:.2f}")
-
-    # Build compact summary — no raw transaction dumps
-    lines = ["FINANCIAL SUMMARY (pre-calculated, do NOT recalculate):"]
-    lines.append(f"Today's spending: ${today_total:.2f}")
-    lines.append(f"This week's spending (since {week_start}): ${week_total:.2f}")
-    lines.append(f"This month's spending (last {days} days): ${month_total:.2f}")
-    
-    if income_total > 0:
-        lines.append(f"Income received (last {days} days): +${income_total:.2f}")
-
-    lines.append(f"Average daily spending: ${month_total / max(days, 1):.2f}")
-
-    lines.append("\nSPENDING BY CATEGORY:")
-    for category, total in sorted(category_totals.items(), key=lambda x: -x[1]):
-        readable = category.replace("_", " ").title()
-        pct = (total / month_total * 100) if month_total > 0 else 0
-        lines.append(f"- {readable}: ${total:.2f} ({pct:.0f}%)")
-
-    # Only include recent transactions, limited to 5
-    lines.append("\nRECENT TRANSACTIONS (last 5):")
-    for txn in transactions[:5]:
-        amount = txn['amount']
-        if amount <= 0:
-            continue
-        prefix = "-"
-        lines.append(f"  {prefix} {txn['date']} {txn['name']}: ${abs(amount):.2f}")
-
-    return "\n".join(lines)
-
-# ---------- Combined snapshot ----------
-
-def get_financial_snapshot(access_token: str) -> str:
-    try:
-        balances = get_balances(access_token)
-        transactions = get_transactions(access_token)
-        return f"{balances}\n\n{transactions}"
-    except Exception as e:
-        error_str = str(e)
-        print(f"Plaid API Exception caught: {error_str}", flush=True)
-        if "ITEM_LOGIN_REQUIRED" in error_str:
-            return "BANK_REAUTH_REQUIRED"
-        return "NO_BANK_DATA"
-
-# ---------- Update Mode Link Token ----------
-
-def create_update_link_token(user_id: str, access_token: str) -> str:
-    """
-    Creates a Plaid Link token in Update Mode for a broken access token.
-    Launches direct bank sync to clear the ITEM_LOGIN_REQUIRED status.
-    """
-    request = LinkTokenCreateRequest(
-        user=LinkTokenCreateRequestUser(client_user_id=user_id),
-        client_name="FISCAL",
-        country_codes=[CountryCode("CA")],
-        language="en",
-        access_token=access_token # Passing this parameter triggers Update Mode
-    )
-    response = plaid_client.link_token_create(request)
-    return response["link_token"]
-
-
-def create_link_token(user_id: str) -> str:
-    """Creates a Plaid Link token for the given user."""
-    request = LinkTokenCreateRequest(
-        user=LinkTokenCreateRequestUser(client_user_id=user_id),
-        client_name="FISCAL",
-        products=[Products("transactions")],
-        country_codes=[CountryCode("CA")],
-        language="en",
-    )
-    response = plaid_client.link_token_create(request)
-    return response["link_token"]
-
-def exchange_public_token(public_token: str) -> str:
-    """Exchanges a public token for a permanent access token."""
-    request = ItemPublicTokenExchangeRequest(public_token=public_token)
-    response = plaid_client.item_public_token_exchange(request)
-    return response["access_token"]
-
-
-def get_chart_data(access_token: str) -> dict:
-    """Returns burn-down velocity chart data based on chequing account."""
-    end_date = date.today()
-    start_date = end_date.replace(day=1)
-
-    # Get balances
-    accounts = []
-    chequing_balance = 0.0
-    chequing_account_id = None
-
-    try:
-        balance_req = AccountsBalanceGetRequest(access_token=access_token)
-        balance_resp = plaid_client.accounts_balance_get(balance_req)
-        for account in balance_resp['accounts']:
-            current = account['balances']['current']
-            if current is None:
-                continue
-            subtype = str(account['subtype'])
-            
-            # Find the main chequing account
-            if subtype == 'checking':
-                chequing_balance = current
-                chequing_account_id = account['account_id']
-
-            # Skip mortgage and line of credit from display
-            if subtype in ['mortgage', 'line of credit']:
-                continue
-
-            accounts.append({
-                "name": account['name'],
-                "type": subtype,
-                "balance": round(current, 2),
-            })
-    except Exception as e:
-        print(f"Balance error in chart_data: {e}", flush=True)
-
-    # Get transactions
-    burndown = []
-    income_total = 0.0
-    expense_total = 0.0
-
-    try:
-        request = TransactionsGetRequest(
-            access_token=access_token,
-            start_date=start_date,
-            end_date=end_date,
-            options=TransactionsGetRequestOptions(
-                count=300,
-                include_personal_finance_category=True
-            )
-        )
-        response = plaid_client.transactions_get(request)
-        transactions = response['transactions']
-
-        # Separate spending by day across chequing + credit cards
-        daily_net: dict[str, float] = {}
-
-        for txn in transactions:
-            amount = txn['amount']
-            txn_date = str(txn['date'])
-            category = txn.get('personal_finance_category', {}).get('primary', 'OTHER')
-
-            # Skip internal transfers between own accounts
-            if category in ['TRANSFER_IN', 'TRANSFER_OUT']:
-                continue
-
-            # Skip loan payments that are actually payroll
-            name_lower = txn['name'].lower()
-            if category == 'LOAN_PAYMENTS' and any(w in name_lower for w in ['payroll', 'salary', 'direct dep', 'employer', 'wages']):
-                income_total += amount
-                daily_net[txn_date] = daily_net.get(txn_date, 0) - amount  # income adds to balance
-                continue
-
-            if amount < 0:
-                # Money coming in (income)
-                income_total += abs(amount)
-                daily_net[txn_date] = daily_net.get(txn_date, 0) + abs(amount)  # adds to balance
-            else:
-                # Money going out (spending)
-                expense_total += amount
-                daily_net[txn_date] = daily_net.get(txn_date, 0) - amount  # subtracts from balance
-
-        # Reconstruct daily balance working BACKWARD from today's chequing balance
-        # today_balance = chequing_balance
-        # yesterday_balance = today_balance - net_change_today
-        # (because net_change is already applied to get to today's balance)
-        
-        daily_balances: dict[str, float] = {}
-        running = chequing_balance
-        
-        # Work backward from today
-        current = end_date
-        while current >= start_date:
-            day_str = str(current)
-            daily_balances[day_str] = running
-            # Undo this day's net change to get previous day's balance
-            net_today = daily_net.get(day_str, 0)
-            running = running - net_today  # undo: if we spent $50 (net=-50), previous day was +50 higher
-            current -= timedelta(days=1)
-
-        # Now build burndown in forward order
-        current = start_date
-        while current <= end_date:
-            day_str = str(current)
-            balance = daily_balances.get(day_str, 0)
-            day_spend = 0
-            
-            # Calculate just spending for this day (not net)
-            for txn in transactions:
-                if str(txn['date']) == day_str and txn['amount'] > 0:
-                    cat = txn.get('personal_finance_category', {}).get('primary', 'OTHER')
-                    if cat not in ['TRANSFER_IN', 'TRANSFER_OUT']:
-                        day_spend += txn['amount']
 
-            burndown.append({
-                "date": current.strftime("%b %d"),
-                "balance": round(balance, 2),
-                "spent": round(day_spend, 2),
-            })
-            current += timedelta(days=1)
-
-    except Exception as e:
-        print(f"Transaction error in chart_data: {e}", flush=True)
-
-    return {
-        "burndown": burndown,
-        "income_total": round(income_total, 2),
-        "expense_total": round(expense_total, 2),
-        "accounts": accounts,
-    }
-    """Returns burn-down velocity chart data."""
-    end_date = date.today()
-    start_date = end_date.replace(day=1)  # Start of current month
-
-    # Get balances
-    accounts = []
-    try:
-        balance_req = AccountsBalanceGetRequest(access_token=access_token)
-        balance_resp = plaid_client.accounts_balance_get(balance_req)
-        for account in balance_resp['accounts']:
-            current = account['balances']['current']
-            if current is None:
-                continue
-            accounts.append({
-                "name": account['name'],
-                "type": str(account['subtype']),
-                "balance": round(current, 2),
-            })
-    except Exception as e:
-        print(f"Balance error in chart_data: {e}", flush=True)
-
-    # Get transactions for current month
-    burndown = []
-    income_total = 0.0
-    expense_total = 0.0
-
-    try:
-        request = TransactionsGetRequest(
-            access_token=access_token,
-            start_date=start_date,
-            end_date=end_date,
-            options=TransactionsGetRequestOptions(
-                count=200,
-                include_personal_finance_category=True
-            )
-        )
-        response = plaid_client.transactions_get(request)
-        transactions = response['transactions']
-
-        # Build daily income and spending
-        daily_income: dict[str, float] = {}
-        daily_spending: dict[str, float] = {}
-
-        for txn in transactions:
-            amount = txn['amount']
-            txn_date = str(txn['date'])
-            category = txn.get('personal_finance_category', {}).get('primary', 'OTHER')
-
-            if amount < 0:
-                income_total += abs(amount)
-                daily_income[txn_date] = daily_income.get(txn_date, 0) + abs(amount)
-                continue
-
-            if category in ['TRANSFER_IN', 'TRANSFER_OUT']:
-                continue
-
-            name_lower = txn['name'].lower()
-            if category == 'LOAN_PAYMENTS' and any(w in name_lower for w in ['payroll', 'salary', 'direct dep', 'employer', 'wages']):
-                income_total += amount
-                daily_income[txn_date] = daily_income.get(txn_date, 0) + amount
-                continue
-
-            expense_total += amount
-            daily_spending[txn_date] = daily_spending.get(txn_date, 0) + amount
-
-        # Build burn-down: start with total income, subtract spending each day
-        running_balance = income_total
-        current = start_date
-        while current <= end_date:
-            day_str = str(current)
-            day_spend = daily_spending.get(day_str, 0)
-            day_income = daily_income.get(day_str, 0)
-            running_balance = running_balance - day_spend + (day_income if current != start_date else 0)
-
-            burndown.append({
-                "date": current.strftime("%b %d"),
-                "balance": round(running_balance, 2),
-                "spent": round(day_spend, 2),
-            })
-            current += timedelta(days=1)
-
-    except Exception as e:
-        print(f"Transaction error in chart_data: {e}", flush=True)
-
-    return {
-        "burndown": burndown,
-        "income_total": round(income_total, 2),
-        "expense_total": round(expense_total, 2),
-        "accounts": accounts,
-    }
-    """Returns structured JSON for frontend charts."""
-    end_date = date.today()
-    start_date = end_date - timedelta(days=30)
-
-    # Get balances (usually ready immediately)
-    try:
-        balance_req = AccountsBalanceGetRequest(access_token=access_token)
-        balance_resp = plaid_client.accounts_balance_get(balance_req)
-        accounts = []
-        for account in balance_resp['accounts']:
-            current = account['balances']['current']
-            if current is None:
-                continue
-            accounts.append({
-                "name": account['name'],
-                "type": str(account['subtype']),
-                "balance": round(current, 2),
-            })
-    except Exception as e:
-        print(f"Balance error in chart_data: {e}", flush=True)
-        accounts = []
-
-    # Get transactions (may not be ready yet)
-    category_chart = []
-    weekly_data = []
-    income_total = 0.0
-    expense_total = 0.0
-
-    try:
-        request = TransactionsGetRequest(
-            access_token=access_token,
-            start_date=start_date,
-            end_date=end_date,
-            options=TransactionsGetRequestOptions(
-                count=200,
-                include_personal_finance_category=True
-            )
-        )
-        response = plaid_client.transactions_get(request)
-        transactions = response['transactions']
-
-        category_totals: dict[str, float] = {}
-        daily_spending: dict[str, float] = {}
-        daily_income: dict[str, float] = {}
-
-        for txn in transactions:
-            amount = txn['amount']
-            txn_date = str(txn['date'])
-            category = txn.get('personal_finance_category', {}).get('primary', 'OTHER')
-
-            if amount < 0:
-                income_total += abs(amount)
-                daily_income[txn_date] = daily_income.get(txn_date, 0) + abs(amount)
-                continue
-
-            if category in ['TRANSFER_IN', 'TRANSFER_OUT']:
-                continue
-
-            name_lower = txn['name'].lower()
-            if category == 'LOAN_PAYMENTS' and any(w in name_lower for w in ['payroll', 'salary', 'direct dep', 'employer', 'wages']):
-                income_total += amount
-                daily_income[txn_date] = daily_income.get(txn_date, 0) + amount
-                continue
-
-            expense_total += amount
-            readable = category.replace("_", " ").title()
-            category_totals[readable] = category_totals.get(readable, 0) + amount
-            daily_spending[txn_date] = daily_spending.get(txn_date, 0) + amount
-
-        category_chart = [
-            {"name": cat, "value": round(total, 2)}
-            for cat, total in sorted(category_totals.items(), key=lambda x: -x[1])
-        ]
-
-        for i in range(4):
-            week_end = end_date - timedelta(weeks=i)
-            week_start_d = week_end - timedelta(days=6)
-            week_label = f"{week_start_d.strftime('%b %d')} - {week_end.strftime('%b %d')}"
-            week_spending = sum(v for k, v in daily_spending.items() if str(week_start_d) <= k <= str(week_end))
-            week_income = sum(v for k, v in daily_income.items() if str(week_start_d) <= k <= str(week_end))
-            weekly_data.append({"week": week_label, "spending": round(week_spending, 2), "income": round(week_income, 2)})
-        weekly_data.reverse()
-
-    except Exception as e:
-        print(f"Transaction error in chart_data: {e}", flush=True)
-
-    return {
-        "category_chart": category_chart,
-        "weekly_chart": weekly_data,
-        "income_vs_expenses": {
-            "income": round(income_total, 2),
-            "expenses": round(expense_total, 2),
-        },
-        "accounts": accounts,
-    }
-    """Returns structured JSON for frontend charts."""
-    end_date = date.today()
-    start_date = end_date - timedelta(days=30)
-
-    # Get transactions
-    request = TransactionsGetRequest(
-        access_token=access_token,
-        start_date=start_date,
-        end_date=end_date,
-        options=TransactionsGetRequestOptions(
-            count=200,
-            include_personal_finance_category=True
-        )
+    vectorstore = Chroma.from_documents(
+        chunks,
+        embedding=embeddings,
+        persist_directory="./chroma_db",
     )
-    response = plaid_client.transactions_get(request)
-    transactions = response['transactions']
-
-    # Get balances
-    balance_req = AccountsBalanceGetRequest(access_token=access_token)
-    balance_resp = plaid_client.accounts_balance_get(balance_req)
-
-    # 1. Spending by category
-    category_totals: dict[str, float] = {}
-    income_total = 0.0
-    expense_total = 0.0
-    
-    # 2. Daily spending for weekly breakdown
-    daily_spending: dict[str, float] = {}
-    daily_income: dict[str, float] = {}
-
-    for txn in transactions:
-        amount = txn['amount']
-        txn_date = str(txn['date'])
-        category = txn.get('personal_finance_category', {}).get('primary', 'OTHER')
-
-        if amount < 0:
-            income_total += abs(amount)
-            daily_income[txn_date] = daily_income.get(txn_date, 0) + abs(amount)
-            continue
-
-        if category in ['TRANSFER_IN', 'TRANSFER_OUT']:
-            continue
-
-        name_lower = txn['name'].lower()
-        if category == 'LOAN_PAYMENTS' and any(w in name_lower for w in ['payroll', 'salary', 'direct dep', 'employer', 'wages']):
-            income_total += amount
-            daily_income[txn_date] = daily_income.get(txn_date, 0) + amount
-            continue
-
-        expense_total += amount
-        readable = category.replace("_", " ").title()
-        category_totals[readable] = category_totals.get(readable, 0) + amount
-        daily_spending[txn_date] = daily_spending.get(txn_date, 0) + amount
-
-    # Build category chart data (sorted by amount)
-    category_chart = [
-        {"name": cat, "value": round(total, 2)}
-        for cat, total in sorted(category_totals.items(), key=lambda x: -x[1])
-    ]
-
-    # Build weekly chart data (last 4 weeks)
-    weekly_data = []
-    for i in range(4):
-        week_end = end_date - timedelta(weeks=i)
-        week_start = week_end - timedelta(days=6)
-        week_label = f"{week_start.strftime('%b %d')} - {week_end.strftime('%b %d')}"
-
-        week_spending = sum(
-            v for k, v in daily_spending.items()
-            if str(week_start) <= k <= str(week_end)
-        )
-        week_income = sum(
-            v for k, v in daily_income.items()
-            if str(week_start) <= k <= str(week_end)
-        )
-
-        weekly_data.append({
-            "week": week_label,
-            "spending": round(week_spending, 2),
-            "income": round(week_income, 2),
-        })
-
-    weekly_data.reverse()
-
-    # Build account balances
-    accounts = []
-    for account in balance_resp['accounts']:
-        current = account['balances']['current']
-        if current is None:
-            continue
-        accounts.append({
-            "name": account['name'],
-            "type": str(account['subtype']),
-            "balance": round(current, 2),
-        })
-
-    return {
-        "category_chart": category_chart,
-        "weekly_chart": weekly_data,
-        "income_vs_expenses": {
-            "income": round(income_total, 2),
-            "expenses": round(expense_total, 2),
-        },
-        "accounts": accounts,
-    }
-
-
-def get_recurring_transactions(access_token: str) -> dict:
-    """Analyze 6 months of transactions to find recurring patterns."""
-    end_date = date.today()
-    start_date = end_date - timedelta(days=180)
-
-    try:
-        # Fetch all transactions for 6 months
-        all_transactions = []
-        offset = 0
-        while True:
-            request = TransactionsGetRequest(
-                access_token=access_token,
-                start_date=start_date,
-                end_date=end_date,
-                options=TransactionsGetRequestOptions(
-                    count=500,
-                    offset=offset,
-                    include_personal_finance_category=True
-                )
-            )
-            response = plaid_client.transactions_get(request)
-            all_transactions.extend(response['transactions'])
-            if len(all_transactions) >= response['total_transactions']:
-                break
-            offset = len(all_transactions)
-
-        # ... rest of the function stays the same ...
-
-    except Exception as e:
-        error_str = str(e)
-        print(f"Recurring transaction error: {error_str}", flush=True)
-        
-        # Check if it's PRODUCT_NOT_READY
-        not_ready = 'PRODUCT_NOT_READY' in error_str or 'not yet ready' in error_str
-        
-        return {
-            'recurring_expenses': [],
-            'recurring_income': [],
-            'projected_events': [],
-            'analysis_period': None,
-            'not_ready': not_ready,
-        }
-    """Analyze 6 months of transactions to find recurring patterns."""
-    end_date = date.today()
-    start_date = end_date - timedelta(days=180)  # 6 months back
-
-    try:
-        # Fetch all transactions for 6 months
-        all_transactions = []
-        offset = 0
-        while True:
-            request = TransactionsGetRequest(
-                access_token=access_token,
-                start_date=start_date,
-                end_date=end_date,
-                options=TransactionsGetRequestOptions(
-                    count=500,
-                    offset=offset,
-                    include_personal_finance_category=True
-                )
-            )
-            response = plaid_client.transactions_get(request)
-            all_transactions.extend(response['transactions'])
-            if len(all_transactions) >= response['total_transactions']:
-                break
-            offset = len(all_transactions)
-
-        # Group transactions by normalized merchant name
-        merchant_groups: dict[str, list] = defaultdict(list)
-
-        for txn in all_transactions:
-            name = txn['name']
-            amount = txn['amount']
-            txn_date = txn['date']
-            category = txn.get('personal_finance_category', {}).get('primary', 'OTHER')
-
-            # Skip transfers
-            if category in ['TRANSFER_IN', 'TRANSFER_OUT']:
-                continue
-
-            # Normalize merchant name (remove numbers, extra spaces)
-            normalized = re.sub(r'[0-9#]+', '', name).strip()
-            normalized = re.sub(r'\s+', ' ', normalized).upper()
-
-            merchant_groups[normalized].append({
-                'date': str(txn_date),
-                'amount': amount,
-                'name': name,
-                'category': category,
-            })
-
-        # Detect recurring patterns
-        recurring = []
-        income = []
-
-        for merchant, txns in merchant_groups.items():
-            if len(txns) < 3:  # Need at least 3 occurrences
-                continue
-
-            # Sort by date
-            txns.sort(key=lambda x: x['date'])
-
-            # Check if amounts are consistent (within 10% variance)
-            amounts = [t['amount'] for t in txns]
-            avg_amount = sum(amounts) / len(amounts)
-            if avg_amount == 0:
-                continue
-            variance = max(amounts) - min(amounts)
-            is_consistent_amount = variance / abs(avg_amount) < 0.15
-
-            if not is_consistent_amount:
-                continue
-
-            # Detect frequency by analyzing gaps between transactions
-            dates = [date.fromisoformat(t['date']) for t in txns]
-            gaps = [(dates[i+1] - dates[i]).days for i in range(len(dates)-1)]
-            avg_gap = sum(gaps) / len(gaps) if gaps else 0
-
-            # Classify frequency
-            if 5 <= avg_gap <= 10:
-                frequency = 'weekly'
-                freq_days = 7
-            elif 12 <= avg_gap <= 17:
-                frequency = 'biweekly'
-                freq_days = 14
-            elif 25 <= avg_gap <= 35:
-                frequency = 'monthly'
-                freq_days = 30
-            else:
-                continue  # Irregular — skip
-
-            # Count consecutive months present
-            months_present = set()
-            for t in txns:
-                d = date.fromisoformat(t['date'])
-                months_present.add(f"{d.year}-{d.month:02d}")
-
-            consecutive = len(months_present)
-
-            # Determine if it's income or expense
-            is_income = avg_amount < 0  # Negative = money in
-
-            entry = {
-                'merchant': txns[0]['name'],
-                'normalized_name': merchant,
-                'amount': round(abs(avg_amount), 2),
-                'frequency': frequency,
-                'frequency_days': freq_days,
-                'category': txns[0]['category'],
-                'consecutive_months': consecutive,
-                'last_date': txns[-1]['date'],
-                'is_income': is_income,
-                'history': [{'date': t['date'], 'amount': t['amount']} for t in txns],
-            }
-
-            if consecutive >= 5:
-                entry['status'] = 'confirmed'  # 5+ months = add indefinitely
-            elif consecutive >= 3:
-                entry['status'] = 'likely'
-            else:
-                entry['status'] = 'possible'
-
-            if is_income:
-                income.append(entry)
-            else:
-                recurring.append(entry)
-
-        # Sort by amount descending
-        recurring.sort(key=lambda x: -x['amount'])
-        income.sort(key=lambda x: -x['amount'])
-
-        # Project future dates for confirmed recurring items
-        projected_events = []
-        today = date.today()
-
-        for item in recurring + income:
-            last = date.fromisoformat(item['last_date'])
-            freq = item['frequency_days']
-
-            # Project next 90 days
-            next_date = last + timedelta(days=freq)
-            while next_date <= today + timedelta(days=90):
-                if next_date >= today:
-                    projected_events.append({
-                        'date': str(next_date),
-                        'merchant': item['merchant'],
-                        'amount': item['amount'],
-                        'is_income': item['is_income'],
-                        'frequency': item['frequency'],
-                        'status': item['status'],
-                        'category': item['category'],
-                    })
-                next_date += timedelta(days=freq)
-
-        projected_events.sort(key=lambda x: x['date'])
-
-        return {
-            'recurring_expenses': recurring,
-            'recurring_income': income,
-            'projected_events': projected_events,
-            'total_transactions': len(all_transactions),
-            'analysis_period': {
-                'start': str(start_date),
-                'end': str(end_date),
-                'total_transactions': len(all_transactions),
-            }
-        }
+    print(f"Indexed {len(chunks)} chunks")
 
-    except Exception as e:
-        print(f"Recurring transaction error: {e}", flush=True)
-        return {
-            'recurring_expenses': [],
-            'recurring_income': [],
-            'projected_events': [],
-            'analysis_period': None,
-        }
+print("Ready.")