Spaces:
Sleeping
Sleeping
| import gradio as gr | |
| import pandas as pd | |
| from utils.ledger_analysis import handle_csv_upload, analyze_ledger_data | |
| from typing import Dict | |
| import io | |
| import uuid | |
| from datetime import datetime | |
| # Setup Modal client | |
| try: | |
| import os | |
| import modal | |
| # Modal automatically reads MODAL_TOKEN_ID and MODAL_TOKEN_SECRET from environment | |
| modal_app = modal.App.lookup("smartledger", create_if_missing=False) | |
| modal_create_index = modal.Function.from_name("smartledger", "create_index") | |
| modal_query_data = modal.Function.from_name("smartledger", "query_data") | |
| modal_check_health = modal.Function.from_name("smartledger", "check_health") | |
| modal_list_sessions = modal.Function.from_name("smartledger", "list_sessions") | |
| modal_process_image = modal.Function.from_name("smartledger", "process_image_transactions") | |
| modal_reconcile = modal.Function.from_name("smartledger", "reconcile_transactions") | |
| modal_available = True | |
| print("✅ Using Modal functions with AI models and image processing") | |
| except Exception as e: | |
| print(f"⚠️ Modal not available: {e}") | |
| modal_available = False | |
| modal_create_index = None | |
| modal_query_data = None | |
| modal_check_health = None | |
| modal_list_sessions = None | |
| modal_process_image = None | |
| modal_reconcile = None | |
| # Global session management | |
| current_session_id = None | |
| def analyze_ledger_from_csv(csv_content: str) -> Dict: | |
| """ | |
| Analyze a ledger CSV using Modal serverless functions for LLM-powered insights. | |
| This function processes CSV data and creates an intelligent financial index using | |
| Modal's serverless compute with embedding models and LLMs. | |
| Args: | |
| csv_content: CSV content as string with required columns: date,vendor,amount | |
| Optional columns: category,description | |
| Returns: | |
| Dictionary containing analysis results, statistics, and LLM indexing status | |
| """ | |
| global current_session_id | |
| try: | |
| # Parse CSV content for basic analysis | |
| df = pd.read_csv(io.StringIO(csv_content)) | |
| # Process the data | |
| df['amount'] = pd.to_numeric(df['amount'], errors='coerce') | |
| df['date'] = pd.to_datetime(df['date'], errors='coerce') | |
| # Handle different column names for vendor/description | |
| if 'vendor' not in df.columns and 'description' in df.columns: | |
| df['vendor'] = df['description'] | |
| elif 'vendor' not in df.columns and 'description' not in df.columns: | |
| df['vendor'] = 'Unknown' | |
| df = df.dropna(subset=['date', 'amount']) | |
| if df.empty: | |
| return {"error": "No valid transactions found"} | |
| # Generate basic analysis | |
| analysis_text = analyze_ledger_data(df) | |
| # Create structured response | |
| total_amount = float(df['amount'].sum()) | |
| transaction_count = len(df) | |
| avg_amount = float(df['amount'].mean()) | |
| # Top vendors | |
| top_vendors = df['vendor'].value_counts().head(5).to_dict() | |
| # Categories if available | |
| categories = {} | |
| if 'category' in df.columns: | |
| categories = df.groupby('category')['amount'].sum().to_dict() | |
| categories = {k: float(v) for k, v in categories.items()} | |
| # Create Modal index for LLM analysis | |
| modal_indexing_status = "Modal not available" | |
| llm_ready = False | |
| if modal_available and modal_create_index: | |
| try: | |
| # Generate unique session ID | |
| current_session_id = f"session_{uuid.uuid4().hex[:8]}_{datetime.now().strftime('%Y%m%d_%H%M%S')}" | |
| # Standardize column names for Modal | |
| modal_df = df.copy() | |
| if 'vendor' in modal_df.columns: | |
| modal_df['description'] = modal_df['vendor'] | |
| if 'category' not in modal_df.columns: | |
| modal_df['category'] = 'Uncategorized' | |
| # Convert to CSV for Modal | |
| modal_csv = modal_df.to_csv(index=False) | |
| # Call Modal function to create index | |
| print(f"🚀 Creating Modal index for session: {current_session_id}") | |
| modal_result = modal_create_index.remote(modal_csv, current_session_id) | |
| if modal_result.get("status") == "success": | |
| modal_indexing_status = f"✅ Modal LLM index created (Session: {current_session_id[:12]}...)" | |
| llm_ready = True | |
| else: | |
| modal_indexing_status = f"❌ Modal indexing failed: {modal_result.get('error', 'Unknown error')}" | |
| except Exception as e: | |
| modal_indexing_status = f"❌ Modal indexing error: {str(e)}" | |
| return { | |
| "status": "success", | |
| "summary": { | |
| "total_transactions": transaction_count, | |
| "total_amount": total_amount, | |
| "average_transaction": avg_amount, | |
| "date_range": { | |
| "start": df['date'].min().strftime('%Y-%m-%d'), | |
| "end": df['date'].max().strftime('%Y-%m-%d') | |
| } | |
| }, | |
| "top_vendors": top_vendors, | |
| "categories": categories, | |
| "analysis_text": analysis_text, | |
| "indexing_status": modal_indexing_status, | |
| "llm_ready": llm_ready, | |
| "session_id": current_session_id, | |
| "modal_available": modal_available | |
| } | |
| except Exception as e: | |
| return {"error": f"Analysis failed: {str(e)}"} | |
| def get_spending_by_category(csv_content: str, category: str = "") -> Dict: | |
| """ | |
| Get spending breakdown by category or filter by specific category. | |
| Analyzes financial data to provide category-based spending insights. | |
| If no category is specified, returns all categories with totals. | |
| Args: | |
| csv_content: CSV content as string with transaction data | |
| category: Optional specific category name to filter results | |
| Returns: | |
| Spending information organized by category with totals and transaction counts | |
| """ | |
| try: | |
| df = pd.read_csv(io.StringIO(csv_content)) | |
| df['amount'] = pd.to_numeric(df['amount'], errors='coerce') | |
| df = df.dropna(subset=['amount']) | |
| if 'category' not in df.columns: | |
| return {"error": "No category column found in the data"} | |
| if category: | |
| # Filter by specific category | |
| category_data = df[df['category'].str.contains(category, case=False, na=False)] | |
| total = float(category_data['amount'].sum()) | |
| count = len(category_data) | |
| return { | |
| "category": category, | |
| "total_amount": total, | |
| "transaction_count": count, | |
| "transactions": category_data[['date', 'vendor', 'amount', 'description']].to_dict('records') | |
| } | |
| else: | |
| # All categories | |
| category_totals = df.groupby('category')['amount'].agg(['sum', 'count']).round(2) | |
| result = {} | |
| for cat, row in category_totals.iterrows(): | |
| result[cat] = { | |
| "total_amount": float(row['sum']), | |
| "transaction_count": int(row['count']) | |
| } | |
| return {"categories": result} | |
| except Exception as e: | |
| return {"error": f"Category analysis failed: {str(e)}"} | |
| def get_vendor_analysis(csv_content: str, vendor: str = "") -> Dict: | |
| """ | |
| Analyze spending patterns by vendor with detailed transaction breakdowns. | |
| Provides comprehensive vendor spending analysis including total amounts, | |
| transaction frequencies, and average spending per vendor. | |
| Args: | |
| csv_content: CSV content as string containing transaction data | |
| vendor: Optional specific vendor name to analyze in detail | |
| Returns: | |
| Vendor spending analysis with totals, averages, and transaction details | |
| """ | |
| try: | |
| df = pd.read_csv(io.StringIO(csv_content)) | |
| df['amount'] = pd.to_numeric(df['amount'], errors='coerce') | |
| df = df.dropna(subset=['vendor', 'amount']) | |
| if vendor: | |
| # Specific vendor analysis | |
| vendor_data = df[df['vendor'].str.contains(vendor, case=False, na=False)] | |
| if vendor_data.empty: | |
| return {"error": f"No transactions found for vendor: {vendor}"} | |
| total = float(vendor_data['amount'].sum()) | |
| count = len(vendor_data) | |
| avg = float(vendor_data['amount'].mean()) | |
| return { | |
| "vendor": vendor, | |
| "total_amount": total, | |
| "transaction_count": count, | |
| "average_amount": avg, | |
| "transactions": vendor_data[['date', 'amount', 'category', 'description']].to_dict('records') | |
| } | |
| else: | |
| # All vendors summary | |
| vendor_stats = df.groupby('vendor')['amount'].agg(['sum', 'count', 'mean']).round(2) | |
| vendor_stats = vendor_stats.sort_values('sum', ascending=False) | |
| result = {} | |
| for vendor_name, row in vendor_stats.iterrows(): | |
| result[vendor_name] = { | |
| "total_amount": float(row['sum']), | |
| "transaction_count": int(row['count']), | |
| "average_amount": float(row['mean']) | |
| } | |
| return {"vendors": result} | |
| except Exception as e: | |
| return {"error": f"Vendor analysis failed: {str(e)}"} | |
| def process_image_and_reconcile(image_file, csv_file) -> Dict: | |
| """ | |
| Process both image and CSV files, then reconcile transactions | |
| Args: | |
| image_file: Uploaded image file (bank statement, receipt) | |
| csv_file: Uploaded CSV ledger file | |
| Returns: | |
| Dictionary containing reconciliation results and analysis | |
| """ | |
| global current_session_id | |
| try: | |
| if not modal_available: | |
| return {"error": "Modal functions not available"} | |
| if not image_file or not csv_file: | |
| return {"error": "Please upload both an image and CSV file"} | |
| # Generate session ID | |
| current_session_id = f"session_{uuid.uuid4().hex[:8]}_{datetime.now().strftime('%Y%m%d_%H%M%S')}" | |
| # Process CSV first | |
| print("📊 Processing CSV file...") | |
| try: | |
| df = pd.read_csv(csv_file.name) | |
| csv_content = df.to_csv(index=False) | |
| csv_result = modal_create_index.remote(csv_content, current_session_id) | |
| if csv_result.get("status") != "success": | |
| return {"error": f"CSV processing failed: {csv_result.get('error', 'Unknown error')}"} | |
| print(f"✅ CSV processed: {csv_result.get('total_transactions', 0)} transactions indexed") | |
| except Exception as e: | |
| return {"error": f"CSV processing error: {str(e)}"} | |
| # Process image | |
| print("📷 Processing image file...") | |
| try: | |
| import base64 | |
| # Read image file and encode to base64 | |
| print(f"type(image_file) in process_image_and_reconcile: {type(image_file)}") | |
| with open(image_file.name, "rb") as f: | |
| image_bytes = f.read() | |
| print(f"type(image_bytes) in process_image_and_reconcile: {type(image_bytes)}") | |
| image_base64 = base64.b64encode(image_bytes).decode('utf-8') | |
| print(f"type(image_base64) in process_image_and_reconcile: {type(image_base64)}") | |
| image_result = modal_process_image.remote( | |
| image_base64, | |
| current_session_id, | |
| image_file.name | |
| ) | |
| if image_result.get("status") != "success": | |
| return {"error": f"Image processing failed: {image_result.get('error', 'Unknown error')}"} | |
| print(f"✅ Image processed: {image_result.get('total_transactions', 0)} transactions extracted") | |
| except Exception as e: | |
| return {"error": f"Image processing error: {str(e)}"} | |
| # Reconcile transactions | |
| print("🔄 Reconciling transactions...") | |
| try: | |
| reconcile_result = modal_reconcile.remote(current_session_id) | |
| if reconcile_result.get("status") != "success": | |
| return {"error": f"Reconciliation failed: {reconcile_result.get('error', 'Unknown error')}"} | |
| print(f"✅ Reconciliation complete: {reconcile_result['summary']['total_matches']} matches found") | |
| return { | |
| "status": "success", | |
| "session_id": current_session_id, | |
| "csv_transactions": csv_result.get("total_transactions", 0), | |
| "image_transactions": image_result.get("total_transactions", 0), | |
| "reconciliation": reconcile_result, | |
| "processed_at": datetime.now().isoformat() | |
| } | |
| except Exception as e: | |
| return {"error": f"Reconciliation error: {str(e)}"} | |
| except Exception as e: | |
| return {"error": f"Processing failed: {str(e)}"} | |
| def query_financial_data(question: str) -> Dict: | |
| """ | |
| Query financial data using Modal's LLM-powered analysis. | |
| Ask natural language questions about spending patterns, vendor analysis, budget trends, | |
| or any other financial insights. Modal's serverless LLM will analyze the data to provide answers. | |
| Args: | |
| question: Natural language question about the financial data | |
| Returns: | |
| Dictionary containing the answer and supporting analysis | |
| """ | |
| global current_session_id | |
| try: | |
| if not question.strip(): | |
| return {"error": "Please provide a question about your financial data"} | |
| if not current_session_id: | |
| return {"error": "No financial data indexed. Please upload and analyze files first."} | |
| if not modal_available or not modal_query_data: | |
| return {"error": "Modal LLM functions not available. Please ensure Modal is deployed."} | |
| # Call Modal function for intelligent query processing | |
| print(f"💬 Processing query for session: {current_session_id}") | |
| print(f"Question: {question}") | |
| modal_result = modal_query_data.remote(question, current_session_id) | |
| if modal_result.get("status") == "success": | |
| return { | |
| "status": "success", | |
| "question": question, | |
| "insights": modal_result.get("llm_analysis", "No insights available"), | |
| "matching_transactions": modal_result.get("matching_transactions", 0), | |
| "total_amount": modal_result.get("total_amount", 0), | |
| "results": modal_result.get("results", []), | |
| "session_id": current_session_id, | |
| "processed_at": modal_result.get("processed_at") | |
| } | |
| else: | |
| return {"error": f"Modal query failed: {modal_result.get('error', 'Unknown error')}"} | |
| except Exception as e: | |
| return {"error": f"Query failed: {str(e)}"} | |
| with gr.Blocks(title="SmartLedger - Transaction Reconciliation", theme=gr.themes.Soft()) as demo: | |
| gr.Markdown("# 📊 SmartLedger - Smart Business Accounting Reconciliation") | |
| gr.Markdown("Upload both your CSV ledger and bank statement/receipt image to automatically reconcile transactions with AI-powered confidence scoring.") | |
| # Dual Upload Section | |
| gr.Markdown("## 📁 Upload Files for Reconciliation") | |
| with gr.Row(): | |
| with gr.Column(): | |
| csv_file = gr.File( | |
| label="📊 Upload CSV Ledger", | |
| file_types=[".csv"], | |
| value=None | |
| ) | |
| gr.Markdown("*Required columns: date, vendor, amount*\n*Optional: category, description*") | |
| with gr.Column(): | |
| image_file = gr.File( | |
| label="📷 Upload Bank Statement/Receipt Image", | |
| file_types=[".jpg", ".jpeg", ".png", ".pdf"], | |
| value=None | |
| ) | |
| print(f"type(image_file): {type(image_file)}") | |
| gr.Markdown("*Supports: Bank statements, receipts, invoices*\n*Formats: JPG, PNG, PDF*") | |
| reconcile_btn = gr.Button("🔄 Process & Reconcile Transactions", variant="primary", size="lg") | |
| with gr.Accordion("📋 File Format Guide", open=False): | |
| with gr.Row(): | |
| with gr.Column(): | |
| gr.Markdown("**CSV Format:**") | |
| gr.Textbox( | |
| value="""date,vendor,amount,category,description | |
| 2024-01-15,Coffee Shop,4.50,Meals,Morning coffee | |
| 2024-01-16,Gas Station,45.00,Vehicle,Fuel | |
| 2024-01-17,Office Depot,23.99,Supplies,Paper""", | |
| label="Expected CSV Format", | |
| interactive=False, | |
| lines=4, | |
| max_lines=4 | |
| ) | |
| with gr.Column(): | |
| gr.Markdown("**Image Requirements:**") | |
| gr.Markdown(""" | |
| • Clear, readable text | |
| • Bank statements or receipts | |
| • Transaction details visible | |
| • Date, amount, vendor information | |
| • JPG, PNG, or PDF format | |
| """) | |
| # Reconciliation Results Section | |
| gr.Markdown("## 📊 Reconciliation Results") | |
| reconciliation_status = gr.Textbox( | |
| label="Processing Status", | |
| interactive=False, | |
| lines=8, | |
| value="Upload both CSV and image files to begin reconciliation" | |
| ) | |
| # Results Tabs | |
| with gr.Tabs(): | |
| with gr.TabItem("🎯 Match Summary"): | |
| summary_dataframe = gr.Dataframe( | |
| label="Reconciliation Summary", | |
| interactive=False, | |
| wrap=True, | |
| value=None | |
| ) | |
| with gr.TabItem("✅ High Confidence Matches"): | |
| high_confidence_dataframe = gr.Dataframe( | |
| label="High Confidence Matches (≥85%)", | |
| interactive=False, | |
| wrap=True, | |
| value=None | |
| ) | |
| with gr.TabItem("⚠️ Medium Confidence Matches"): | |
| medium_confidence_dataframe = gr.Dataframe( | |
| label="Medium Confidence Matches (65-84%)", | |
| interactive=False, | |
| wrap=True, | |
| value=None | |
| ) | |
| with gr.TabItem("🔍 Low Confidence Matches"): | |
| low_confidence_dataframe = gr.Dataframe( | |
| label="Low Confidence Matches (<65%) - Review Required", | |
| interactive=False, | |
| wrap=True, | |
| value=None | |
| ) | |
| with gr.TabItem("❌ Unmatched Transactions"): | |
| unmatched_dataframe = gr.Dataframe( | |
| label="Unmatched Transactions", | |
| interactive=False, | |
| wrap=True, | |
| value=None | |
| ) | |
| # # AI Analysis Section | |
| # gr.Markdown("## 🤖 AI-Powered Analysis") | |
| # # Questions Section | |
| # gr.Markdown("### 💬 Ask Questions About Your Data") | |
| # question_input = gr.Textbox( | |
| # label="Natural Language Query", | |
| # placeholder="e.g., What are my highest spending categories? Show me restaurant transactions.", | |
| # lines=2 | |
| # ) | |
| # query_btn = gr.Button("Get AI Insights", variant="primary", size="lg") | |
| # # AI Results | |
| # llm_results = gr.Textbox( | |
| # label="AI Analysis Results", | |
| # interactive=False, | |
| # lines=12, | |
| # value="Upload and analyze a CSV file to enable AI-powered insights" | |
| # ) | |
| # # Quick Test Section | |
| # gr.Markdown("## 🎯 Quick Test") | |
| # sample_btn = gr.Button("Load Sample Data", variant="primary", size="lg") | |
| # # System Status Section | |
| # gr.Markdown("## 🔗 System Status & Integration") | |
| # # Modal Status | |
| # if modal_available: | |
| # gr.Markdown("✅ **Modal AI Status:** Connected and Ready\n🚀 **Features:** Smart transaction analysis, natural language queries\n📡 **Functions:** Session management, keyword search, basic insights") | |
| # else: | |
| # gr.Markdown("❌ **Modal AI Status:** Not available\n⚠️ **Mode:** Basic analysis only (no AI features)") | |
| # # MCP Tools Info | |
| # with gr.Accordion("🛠️ Available MCP Tools", open=False): | |
| # gr.Markdown(""" | |
| # **Core Analysis Tools:** | |
| # - `analyze_ledger_from_csv` - Process and index financial data | |
| # - `get_spending_by_category` - Category-based spending breakdown | |
| # - `get_vendor_analysis` - Vendor spending patterns | |
| # - `query_financial_data` - Natural language financial queries | |
| # **Integration:** These tools are available for external AI agents via MCP protocol. | |
| # """) | |
| # Enhanced dual file processing handler | |
| def process_dual_upload(image_file, csv_file): | |
| """Process both image and CSV files and reconcile transactions""" | |
| try: | |
| result = process_image_and_reconcile(image_file, csv_file) | |
| if result.get("status") == "success": | |
| reconciliation = result["reconciliation"] | |
| summary = reconciliation["summary"] | |
| # Create status message | |
| status = f"""✅ Processing Complete! | |
| 📊 **Processing Summary:** | |
| • CSV Transactions: {result['csv_transactions']} | |
| • Image Transactions: {result['image_transactions']} | |
| • Total Matches: {summary['total_matches']} ({summary['match_rate']}% match rate) | |
| 🎯 **Confidence Breakdown:** | |
| • High Confidence (≥85%): {summary['high_confidence_matches']} transactions | |
| • Medium Confidence (65-84%): {summary['medium_confidence_matches']} transactions | |
| • Low Confidence (<65%): {summary['low_confidence_matches']} transactions | |
| 💰 **Financial Summary:** | |
| • Total Image Amount: ${summary['total_image_amount']} | |
| • Total Matched Amount: ${summary['total_matched_amount']} ({summary['reconciliation_percentage']}%) | |
| • Unmatched Image Transactions: {summary['unmatched_image_transactions']} | |
| Session ID: {result['session_id'][:20]}...""" | |
| # Create summary dataframe | |
| summary_data = pd.DataFrame([{ | |
| "Metric": "CSV Transactions", | |
| "Value": summary["total_csv_transactions"] | |
| }, { | |
| "Metric": "Image Transactions", | |
| "Value": summary["total_image_transactions"] | |
| }, { | |
| "Metric": "Total Matches", | |
| "Value": f"{summary['total_matches']} ({summary['match_rate']}%)" | |
| }, { | |
| "Metric": "High Confidence Matches", | |
| "Value": summary["high_confidence_matches"] | |
| }, { | |
| "Metric": "Medium Confidence Matches", | |
| "Value": summary["medium_confidence_matches"] | |
| }, { | |
| "Metric": "Low Confidence Matches", | |
| "Value": summary["low_confidence_matches"] | |
| }, { | |
| "Metric": "Match Rate", | |
| "Value": f"{summary['match_rate']}%" | |
| }, { | |
| "Metric": "Reconciliation %", | |
| "Value": f"{summary['reconciliation_percentage']}%" | |
| }]) | |
| # Create match dataframes | |
| def format_matches(matches): | |
| if not matches: | |
| return pd.DataFrame({"Message": ["No matches in this category"]}) | |
| formatted = [] | |
| for match in matches: | |
| csv_txn = match["csv_transaction"] | |
| img_txn = match["image_transaction"] | |
| formatted.append({ | |
| "Confidence": f"{match['confidence_score']*100:.1f}%", | |
| "CSV Date": csv_txn.get("date", ""), | |
| "CSV Vendor": csv_txn.get("vendor", ""), | |
| "CSV Amount": f"${csv_txn.get('amount', 0):.2f}", | |
| "Image Date": img_txn.get("date", ""), | |
| "Image Vendor": img_txn.get("vendor", ""), | |
| "Image Amount": f"${img_txn.get('amount', 0):.2f}", | |
| "Match Reasons": ", ".join(match.get("match_reasons", [])), | |
| "Discrepancies": ", ".join(match.get("discrepancies", [])) | |
| }) | |
| return pd.DataFrame(formatted) | |
| high_conf_df = format_matches(reconciliation["matches"]["high_confidence"]) | |
| med_conf_df = format_matches(reconciliation["matches"]["medium_confidence"]) | |
| low_conf_df = format_matches(reconciliation["matches"]["low_confidence"]) | |
| # Create unmatched dataframes | |
| unmatched_data = [] | |
| for txn in reconciliation["unmatched"]["image_transactions"]: | |
| unmatched_data.append({ | |
| "Source": "Image (Unmatched)", | |
| "Date": txn.get("date", ""), | |
| "Vendor": txn.get("vendor", ""), | |
| "Amount": f"${txn.get('amount', 0):.2f}", | |
| "Description": txn.get("description", "") | |
| }) | |
| for txn in reconciliation["unmatched"]["csv_transactions"]: | |
| unmatched_data.append({ | |
| "Source": "CSV (Unmatched)", | |
| "Date": txn.get("date", ""), | |
| "Vendor": txn.get("vendor", ""), | |
| "Amount": f"${txn.get('amount', 0):.2f}", | |
| "Description": txn.get("description", "") | |
| }) | |
| unmatched_df = pd.DataFrame(unmatched_data) if unmatched_data else pd.DataFrame({"Message": ["No unmatched transactions"]}) | |
| return status, summary_data, high_conf_df, med_conf_df, low_conf_df, unmatched_df | |
| else: | |
| error_msg = f"❌ Processing Failed: {result.get('error', 'Unknown error')}" | |
| empty_df = pd.DataFrame({"Error": [result.get('error', 'Unknown error')]}) | |
| return error_msg, empty_df, empty_df, empty_df, empty_df, empty_df | |
| except Exception as e: | |
| error_msg = f"❌ Error during processing: {str(e)}" | |
| empty_df = pd.DataFrame({"Error": [str(e)]}) | |
| return error_msg, empty_df, empty_df, empty_df, empty_df, empty_df | |
| # Event handlers | |
| reconcile_btn.click( | |
| fn=process_dual_upload, | |
| inputs=[image_file, csv_file], | |
| outputs=[reconciliation_status, summary_dataframe, high_confidence_dataframe, | |
| medium_confidence_dataframe, low_confidence_dataframe, unmatched_dataframe] | |
| ) | |
| # # Quick Test Section with sample data | |
| # gr.Markdown("## 🎯 Quick Test") | |
| # sample_btn = gr.Button("📄 Load Sample Data (CSV + Mock Image)", variant="secondary", size="lg") | |
| # def load_sample_for_reconciliation(): | |
| # """Load sample data and create a mock reconciliation scenario""" | |
| # try: | |
| # # Mock reconciliation result for demonstration | |
| # status = """✅ Sample Data Loaded! | |
| # 📊 **Processing Summary:** | |
| # • CSV Transactions: 5 | |
| # • Image Transactions: 3 (simulated) | |
| # • Total Matches: 2 (66.7% match rate) | |
| # 🎯 **Confidence Breakdown:** | |
| # • High Confidence (≥85%): 1 transactions | |
| # • Medium Confidence (65-84%): 1 transactions | |
| # • Low Confidence (<65%): 0 transactions | |
| # 💰 **Financial Summary:** | |
| # • Total Image Amount: $68.49 | |
| # • Total Matched Amount: $49.50 (72.3%) | |
| # • Unmatched Image Transactions: 1 | |
| # 🧪 This is sample data for demonstration purposes.""" | |
| # # Create sample summary | |
| # summary_data = pd.DataFrame([ | |
| # {"Metric": "CSV Transactions", "Value": 5}, | |
| # {"Metric": "Image Transactions", "Value": 3}, | |
| # {"Metric": "Total Matches", "Value": "2 (66.7%)"}, | |
| # {"Metric": "High Confidence Matches", "Value": 1}, | |
| # {"Metric": "Medium Confidence Matches", "Value": 1}, | |
| # {"Metric": "Low Confidence Matches", "Value": 0}, | |
| # {"Metric": "Match Rate", "Value": "66.7%"}, | |
| # {"Metric": "Reconciliation %", "Value": "72.3%"} | |
| # ]) | |
| # # Sample high confidence match | |
| # high_conf = pd.DataFrame([{ | |
| # "Confidence": "92.5%", | |
| # "CSV Date": "2024-01-15", | |
| # "CSV Vendor": "Coffee Shop Downtown", | |
| # "CSV Amount": "$4.50", | |
| # "Image Date": "2024-01-15", | |
| # "Image Vendor": "Coffee Shop", | |
| # "Image Amount": "$4.50", | |
| # "Match Reasons": "Exact amount match, Exact date match, Partial vendor match", | |
| # "Discrepancies": "" | |
| # }]) | |
| # # Sample medium confidence match | |
| # med_conf = pd.DataFrame([{ | |
| # "Confidence": "78.0%", | |
| # "CSV Date": "2024-01-16", | |
| # "CSV Vendor": "Shell Gas Station", | |
| # "CSV Amount": "$45.00", | |
| # "Image Date": "2024-01-16", | |
| # "Image Vendor": "Shell", | |
| # "Image Amount": "$45.00", | |
| # "Match Reasons": "Exact amount match, Exact date match, Vendor keyword match", | |
| # "Discrepancies": "Vendor difference: SHELL GAS STATION vs SHELL" | |
| # }]) | |
| # # Empty low confidence | |
| # low_conf = pd.DataFrame({"Message": ["No matches in this category"]}) | |
| # # Sample unmatched | |
| # unmatched = pd.DataFrame([ | |
| # {"Source": "Image (Unmatched)", "Date": "2024-01-17", "Vendor": "Amazon", "Amount": "$18.99", "Description": "Online purchase"}, | |
| # {"Source": "CSV (Unmatched)", "Date": "2024-01-17", "Vendor": "Office Depot", "Amount": "$23.99", "Description": "Printer paper"}, | |
| # {"Source": "CSV (Unmatched)", "Date": "2024-01-18", "Vendor": "Uber Technologies", "Amount": "$18.75", "Description": "Ride to meeting"}, | |
| # {"Source": "CSV (Unmatched)", "Date": "2024-01-19", "Vendor": "Microsoft Corporation", "Amount": "$99.99", "Description": "Office 365"} | |
| # ]) | |
| # return status, summary_data, high_conf, med_conf, low_conf, unmatched | |
| # except Exception as e: | |
| # error_msg = f"❌ Error loading sample data: {str(e)}" | |
| # empty_df = pd.DataFrame({"Error": [str(e)]}) | |
| # return error_msg, empty_df, empty_df, empty_df, empty_df, empty_df | |
| # sample_btn.click( | |
| # fn=load_sample_for_reconciliation, | |
| # outputs=[reconciliation_status, summary_dataframe, high_confidence_dataframe, | |
| # medium_confidence_dataframe, low_confidence_dataframe, unmatched_dataframe] | |
| # ) | |
| # # AI Analysis handler | |
| # def run_query(question): | |
| # """Run financial query and return formatted results""" | |
| # if not question.strip(): | |
| # return "Please enter a question about your financial data." | |
| # result = query_financial_data(question) | |
| # if result.get("status") == "success": | |
| # return f"💡 QUESTION: {result['question']}\n\n📊 INSIGHTS:\n{result['insights']}" | |
| # else: | |
| # return f"❌ {result.get('error', 'Unknown error')}" | |
| # query_btn.click( | |
| # fn=run_query, | |
| # inputs=[question_input], | |
| # outputs=[llm_results] | |
| # ) | |
| # # Auto-query on Enter | |
| # question_input.submit( | |
| # fn=run_query, | |
| # inputs=[question_input], | |
| # outputs=[llm_results] | |
| # ) | |
| if __name__ == "__main__": | |
| demo.launch( | |
| server_name="0.0.0.0", | |
| server_port=7860, | |
| share=False, | |
| mcp_server=True | |
| ) |