Upload folder using huggingface_hub

app.py

@@ -1,32 +1,26 @@
 """
 Fintech Multi-Agent Orchestrator - HuggingFace Spaces Demo
-Uses Gemma 3 27B via HuggingFace Inference API
+Uses Gemma 3 via HuggingFace Inference API
 """
 
 import gradio as gr
-import json
-import re
 import matplotlib
 matplotlib.use('Agg')
 import matplotlib.pyplot as plt
 import numpy as np
 from io import BytesIO
 import base64
+from PIL import Image
 
-from hf_model import generate_response, calculate_expression
+from graph import run_orchestrator
 
 
-# Mock Banking Data
-MOCK_BANKING_DATA = {
-    "net_worth": {"total": 87500.00, "assets": 142000.00, "liabilities": 54500.00},
-    "assets": {"checking": 12500.00, "savings": 35000.00, "investments": 89500.00},
-    "liabilities": {"credit_cards": 4500.00, "student_loans": 25000.00, "auto_loan": 15000.00},
-    "portfolio": {"AAPL": 15200, "GOOGL": 12800, "MSFT": 18500, "AMZN": 9000, "bonds": 14000},
-}
-
-
-def create_chart(chart_type: str, data: dict, title: str) -> str:
-    """Generate chart and return base64 image."""
+def create_chart(chart_data: dict) -> Image.Image:
+    """Generate chart from chart_data dict."""
+    chart_type = chart_data.get("type", "bar")
+    title = chart_data.get("title", "Chart")
+    data = chart_data.get("data", {})
+    
     fig, ax = plt.subplots(figsize=(10, 6))
     
     if chart_type == "pie":
@@ -43,8 +37,9 @@ def create_chart(chart_type: str, data: dict, title: str) -> str:
         bars = ax.bar(labels, values, color=colors)
         ax.set_title(title, fontsize=14, fontweight='bold')
         ax.set_ylabel('Amount ($)')
+        plt.xticks(rotation=45, ha='right')
         for bar, val in zip(bars, values):
-            ax.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 500, 
+            ax.text(bar.get_x() + bar.get_width()/2, bar.get_height() + max(values)*0.02, 
                    f'${val:,.0f}', ha='center', va='bottom', fontsize=9)
     
     elif chart_type == "line":
@@ -56,148 +51,49 @@ def create_chart(chart_type: str, data: dict, title: str) -> str:
         ax.set_xticklabels(list(data.keys()))
         ax.set_title(title, fontsize=14, fontweight='bold')
         ax.set_ylabel('Amount ($)')
+        ax.yaxis.set_major_formatter(plt.FuncFormatter(lambda x, p: f'${x:,.0f}'))
     
     plt.tight_layout()
     
-    # Convert to base64
+    # Convert to PIL Image
     buf = BytesIO()
     plt.savefig(buf, format='png', dpi=150, bbox_inches='tight')
     buf.seek(0)
     plt.close()
     
-    return base64.b64encode(buf.read()).decode('utf-8')
-
-
-def route_query(query: str) -> dict:
-    """Simple router to determine what actions are needed."""
-    query_lower = query.lower()
-    
-    needs_banking = any(word in query_lower for word in 
-        ['balance', 'net worth', 'portfolio', 'assets', 'liabilities', 'account', 'hesap', 'bakiye'])
-    needs_calculation = any(word in query_lower for word in 
-        ['calculate', 'compute', 'roi', 'interest', 'compound', 'hesapla', 'faiz'])
-    needs_graph = any(word in query_lower for word in 
-        ['chart', 'graph', 'visualize', 'plot', 'pie', 'bar', 'grafik', 'görselleştir'])
-    
-    return {
-        "needs_banking": needs_banking,
-        "needs_calculation": needs_calculation,
-        "needs_graph": needs_graph,
-    }
+    return Image.open(buf)
 
 
-def process_query(query: str, history: list) -> tuple:
-    """Main orchestrator function."""
+def respond(query: str, history: list):
+    """Main chat handler."""
+    if not query.strip():
+        return history, None
     
-    # Route the query
-    route = route_query(query)
+    # Run orchestrator
+    response, chart_data = run_orchestrator(query)
     
-    response_parts = []
+    # Create chart if needed
     chart_image = None
+    if chart_data:
+        chart_image = create_chart(chart_data)
     
-    # Get banking data if needed
-    banking_context = ""
-    if route["needs_banking"]:
-        banking_context = f"""
-**📊 Account Data:**
-- Net Worth: ${MOCK_BANKING_DATA['net_worth']['total']:,.2f}
-- Total Assets: ${MOCK_BANKING_DATA['net_worth']['assets']:,.2f}
-- Total Liabilities: ${MOCK_BANKING_DATA['net_worth']['liabilities']:,.2f}
-
-**Portfolio:**
-""" + "\n".join([f"- {k}: ${v:,.2f}" for k, v in MOCK_BANKING_DATA['portfolio'].items()])
-        response_parts.append(banking_context)
-    
-    # Perform calculation if needed
-    if route["needs_calculation"]:
-        # Extract numbers from query for calculation
-        calc_prompt = f"""You are a financial calculator. Extract the calculation from this request and provide the result.
-
-Request: {query}
-
-If there's a compound interest calculation, use the formula: A = P(1 + r)^t
-Where P = principal, r = annual rate (as decimal), t = years
-
-Respond with ONLY the calculation result in this format:
-CALCULATION: [expression]
-RESULT: [number]
-EXPLANATION: [brief explanation]"""
-        
-        messages = [{"role": "user", "content": calc_prompt}]
-        calc_response = generate_response(messages, max_tokens=500)
-        response_parts.append(f"\n**🧮 Calculation:**\n{calc_response}")
-    
-    # Generate chart if needed
-    if route["needs_graph"]:
-        query_lower = query.lower()
-        
-        if 'portfolio' in query_lower or 'pie' in query_lower:
-            chart_data = MOCK_BANKING_DATA['portfolio']
-            chart_type = 'pie'
-            title = 'Portfolio Distribution'
-        elif 'assets' in query_lower:
-            chart_data = MOCK_BANKING_DATA['assets']
-            chart_type = 'bar'
-            title = 'Assets Breakdown'
-        elif 'liabilities' in query_lower:
-            chart_data = MOCK_BANKING_DATA['liabilities']
-            chart_type = 'bar'
-            title = 'Liabilities Breakdown'
-        else:
-            # Default: net worth projection
-            initial = MOCK_BANKING_DATA['net_worth']['total']
-            rate = 0.08
-            chart_data = {f"Year {i}": initial * (1 + rate) ** i for i in range(6)}
-            chart_type = 'line'
-            title = 'Net Worth Projection (8% Growth)'
-        
-        chart_base64 = create_chart(chart_type, chart_data, title)
-        response_parts.append(f"\n**📈 Chart Generated:** {title}")
-        
-        # Return as PIL Image for Gradio
-        import io
-        from PIL import Image
-        img_bytes = base64.b64decode(chart_base64)
-        chart_image = Image.open(io.BytesIO(img_bytes))
-    
-    # If no specific action, use LLM for general response
-    if not any(route.values()):
-        context = f"""You are a fintech assistant. Answer the user's question about finance, banking, or investments.
-Keep your response concise and helpful.
-
-Available account data (if needed):
-- Net Worth: ${MOCK_BANKING_DATA['net_worth']['total']:,.2f}
-- Assets: ${MOCK_BANKING_DATA['net_worth']['assets']:,.2f}
-- Liabilities: ${MOCK_BANKING_DATA['net_worth']['liabilities']:,.2f}
-
-User question: {query}"""
-        
-        messages = [{"role": "user", "content": context}]
-        llm_response = generate_response(messages, max_tokens=800)
-        response_parts.append(llm_response)
+    # Update history (Gradio 6.x messages format)
+    history = history or []
+    history.append({"role": "user", "content": query})
+    history.append({"role": "assistant", "content": response})
     
-    final_response = "\n".join(response_parts)
-    
-    return final_response, chart_image
+    return history, chart_image
 
 
 # Gradio Interface
 with gr.Blocks(
     title="Fintech Multi-Agent Orchestrator",
-    theme=gr.themes.Soft(
-        primary_hue="blue",
-        secondary_hue="slate",
-    ),
-    css="""
-    .gradio-container { max-width: 1200px !important; }
-    .main-title { text-align: center; margin-bottom: 1rem; }
-    """
 ) as demo:
     
     gr.Markdown("""
     # 🏦 Fintech Multi-Agent Orchestrator
     
-    **Powered by Gemma 3 27B via HuggingFace Inference API**
+    **Powered by Gemma 3 via HuggingFace Inference API**
     
     Ask questions about your finances, request calculations, or generate charts!
     
@@ -206,6 +102,7 @@ with gr.Blocks(
     - "Show my portfolio as a pie chart"
     - "Calculate compound interest on $10000 at 8% for 5 years"
     - "Show my assets breakdown"
+    - "Show net worth projection"
     """)
     
     with gr.Row():
@@ -213,7 +110,6 @@ with gr.Blocks(
             chatbot = gr.Chatbot(
                 label="Chat",
                 height=400,
-                type="messages",
             )
             
             with gr.Row():
@@ -233,15 +129,6 @@ with gr.Blocks(
     with gr.Row():
         clear_btn = gr.Button("Clear Chat")
     
-    def respond(query, history):
-        if not query.strip():
-            return history, None
-        
-        response, chart = process_query(query, history)
-        history.append({"role": "user", "content": query})
-        history.append({"role": "assistant", "content": response})
-        return history, chart
-    
     submit_btn.click(
         respond,
         inputs=[query_input, chatbot],

graph.py

@@ -0,0 +1,274 @@
+# -*- coding: utf-8 -*-
+"""
+Fintech Orchestrator Graph — HuggingFace Version
+
+Adapted from orchestrator_v3.py for HuggingFace Spaces deployment.
+Uses HF Inference API (Gemma 3) instead of local Qwen.
+Uses mocked banking data instead of A2A remote agent.
+"""
+
+from __future__ import annotations
+
+from typing import Optional
+from pydantic import BaseModel, Field
+
+from hf_model import generate_response
+
+
+# ---------------------------------------------------------------------------
+# Mock Banking Data (replaces A2A agent)
+# ---------------------------------------------------------------------------
+
+MOCK_BANKING_DATA = {
+    "net_worth": {
+        "total": 87500.00,
+        "assets": 142000.00,
+        "liabilities": 54500.00,
+        "currency": "USD",
+    },
+    "assets": {
+        "checking": 12500.00,
+        "savings": 35000.00,
+        "investments": 89500.00,
+        "other": 5000.00,
+    },
+    "liabilities": {
+        "credit_cards": 4500.00,
+        "student_loans": 25000.00,
+        "auto_loan": 15000.00,
+        "other": 10000.00,
+    },
+    "portfolio": {
+        "AAPL": 15200,
+        "GOOGL": 12800,
+        "MSFT": 18500,
+        "AMZN": 9000,
+        "bonds": 14000,
+        "ETFs": 18000,
+    },
+    "transactions": [
+        {"date": "2026-02-08", "description": "Salary Deposit", "amount": 5200.00},
+        {"date": "2026-02-07", "description": "Grocery Store", "amount": -127.43},
+        {"date": "2026-02-06", "description": "Electric Bill", "amount": -145.00},
+        {"date": "2026-02-05", "description": "Restaurant", "amount": -68.50},
+        {"date": "2026-02-04", "description": "Gas Station", "amount": -52.30},
+    ],
+}
+
+
+def get_banking_data(query: str) -> str:
+    """Mock banking query - returns relevant data based on query."""
+    query_lower = query.lower()
+    
+    if "net worth" in query_lower or "toplam" in query_lower:
+        data = MOCK_BANKING_DATA["net_worth"]
+        return f"""Net Worth Summary:
+- Total Net Worth: ${data['total']:,.2f}
+- Total Assets: ${data['assets']:,.2f}
+- Total Liabilities: ${data['liabilities']:,.2f}"""
+    
+    elif "portfolio" in query_lower or "stocks" in query_lower:
+        portfolio = MOCK_BANKING_DATA["portfolio"]
+        lines = [f"- {k}: ${v:,.2f}" for k, v in portfolio.items()]
+        total = sum(portfolio.values())
+        return f"Portfolio (Total: ${total:,.2f}):\n" + "\n".join(lines)
+    
+    elif "assets" in query_lower or "varlık" in query_lower:
+        assets = MOCK_BANKING_DATA["assets"]
+        lines = [f"- {k.title()}: ${v:,.2f}" for k, v in assets.items()]
+        total = sum(assets.values())
+        return f"Assets (Total: ${total:,.2f}):\n" + "\n".join(lines)
+    
+    elif "liabilities" in query_lower or "borç" in query_lower:
+        liabilities = MOCK_BANKING_DATA["liabilities"]
+        lines = [f"- {k.replace('_', ' ').title()}: ${v:,.2f}" for k, v in liabilities.items()]
+        total = sum(liabilities.values())
+        return f"Liabilities (Total: ${total:,.2f}):\n" + "\n".join(lines)
+    
+    elif "transaction" in query_lower or "işlem" in query_lower:
+        transactions = MOCK_BANKING_DATA["transactions"]
+        lines = [f"- {t['date']}: {t['description']} (${t['amount']:+,.2f})" for t in transactions]
+        return "Recent Transactions:\n" + "\n".join(lines)
+    
+    else:
+        return f"""Account Summary:
+- Net Worth: ${MOCK_BANKING_DATA['net_worth']['total']:,.2f}
+- Checking: ${MOCK_BANKING_DATA['assets']['checking']:,.2f}
+- Savings: ${MOCK_BANKING_DATA['assets']['savings']:,.2f}
+- Investments: ${MOCK_BANKING_DATA['assets']['investments']:,.2f}"""
+
+
+# ---------------------------------------------------------------------------
+# Router Decision Schema
+# ---------------------------------------------------------------------------
+
+class RouterDecision(BaseModel):
+    """Router decision with multi-step planning"""
+    needs_banking: bool = Field(
+        default=False,
+        description="True if real account data is needed"
+    )
+    needs_calculation: bool = Field(
+        default=False,
+        description="True if financial calculation is needed"
+    )
+    needs_graph: bool = Field(
+        default=False,
+        description="True if visualization/chart is needed"
+    )
+    task_description: str = Field(
+        default="",
+        description="Description of what needs to be done"
+    )
+
+
+def route_query(query: str) -> RouterDecision:
+    """Simple keyword-based router (fast, no LLM call)."""
+    query_lower = query.lower()
+    
+    needs_banking = any(word in query_lower for word in [
+        'balance', 'net worth', 'portfolio', 'assets', 'liabilities',
+        'account', 'transaction', 'hesap', 'bakiye', 'varlık', 'borç'
+    ])
+    
+    needs_calculation = any(word in query_lower for word in [
+        'calculate', 'compute', 'roi', 'interest', 'compound', 'projection',
+        'hesapla', 'faiz', 'getiri'
+    ])
+    
+    needs_graph = any(word in query_lower for word in [
+        'chart', 'graph', 'visualize', 'plot', 'pie', 'bar', 'line',
+        'grafik', 'görselleştir', 'çiz'
+    ])
+    
+    return RouterDecision(
+        needs_banking=needs_banking,
+        needs_calculation=needs_calculation,
+        needs_graph=needs_graph,
+        task_description=query
+    )
+
+
+# ---------------------------------------------------------------------------
+# Calculator
+# ---------------------------------------------------------------------------
+
+def calculate(expression: str, banking_data: str = "") -> str:
+    """Perform financial calculation using LLM."""
+    prompt = f"""You are a financial calculator. Perform the calculation requested.
+
+Request: {expression}
+
+{"Available account data:\n" + banking_data if banking_data else ""}
+
+Provide:
+1. The calculation formula used
+2. Step-by-step calculation
+3. Final result
+
+For compound interest: A = P(1 + r)^t
+For ROI: ((Final - Initial) / Initial) * 100
+"""
+    
+    messages = [{"role": "user", "content": prompt}]
+    return generate_response(messages, max_tokens=600)
+
+
+# ---------------------------------------------------------------------------
+# Orchestrator State
+# ---------------------------------------------------------------------------
+
+class OrchestratorState:
+    """State container for orchestrator."""
+    def __init__(self):
+        self.banking_data: Optional[str] = None
+        self.calculation_result: Optional[str] = None
+        self.graph_data: Optional[dict] = None
+        self.output: str = ""
+
+
+# ---------------------------------------------------------------------------
+# Main Orchestrator Function
+# ---------------------------------------------------------------------------
+
+def run_orchestrator(query: str) -> tuple[str, Optional[dict]]:
+    """
+    Main entry point for the orchestrator.
+    
+    Args:
+        query: User's query string
+        
+    Returns:
+        Tuple of (response_text, chart_data_dict_or_none)
+    """
+    # Route the query
+    decision = route_query(query)
+    state = OrchestratorState()
+    response_parts = []
+    chart_data = None
+    
+    # Step 1: Get banking data if needed
+    if decision.needs_banking:
+        state.banking_data = get_banking_data(query)
+        response_parts.append(f"📊 **Account Data:**\n{state.banking_data}")
+    
+    # Step 2: Perform calculation if needed
+    if decision.needs_calculation:
+        state.calculation_result = calculate(query, state.banking_data or "")
+        response_parts.append(f"\n🧮 **Calculation:**\n{state.calculation_result}")
+    
+    # Step 3: Prepare chart data if needed
+    if decision.needs_graph:
+        query_lower = query.lower()
+        
+        if 'portfolio' in query_lower or 'pie' in query_lower:
+            chart_data = {
+                "type": "pie",
+                "title": "Portfolio Distribution",
+                "data": MOCK_BANKING_DATA["portfolio"]
+            }
+        elif 'assets' in query_lower:
+            chart_data = {
+                "type": "bar",
+                "title": "Assets Breakdown",
+                "data": MOCK_BANKING_DATA["assets"]
+            }
+        elif 'liabilities' in query_lower:
+            chart_data = {
+                "type": "bar",
+                "title": "Liabilities Breakdown",
+                "data": MOCK_BANKING_DATA["liabilities"]
+            }
+        else:
+            # Default: net worth projection
+            initial = MOCK_BANKING_DATA["net_worth"]["total"]
+            rate = 0.08
+            chart_data = {
+                "type": "line",
+                "title": "Net Worth Projection (8% Annual Growth)",
+                "data": {f"Year {i}": initial * (1 + rate) ** i for i in range(6)}
+            }
+        
+        response_parts.append(f"\n📈 **Chart:** {chart_data['title']}")
+    
+    # Step 4: If no specific action, use LLM for general response
+    if not any([decision.needs_banking, decision.needs_calculation, decision.needs_graph]):
+        context = f"""You are a fintech assistant. Answer the user's question about finance.
+
+Available account data:
+- Net Worth: ${MOCK_BANKING_DATA['net_worth']['total']:,.2f}
+- Assets: ${MOCK_BANKING_DATA['net_worth']['assets']:,.2f}  
+- Liabilities: ${MOCK_BANKING_DATA['net_worth']['liabilities']:,.2f}
+
+User question: {query}
+
+Provide a helpful, concise response."""
+        
+        messages = [{"role": "user", "content": context}]
+        llm_response = generate_response(messages, max_tokens=800)
+        response_parts.append(llm_response)
+    
+    # Combine response
+    state.output = "\n\n".join(response_parts)
+    
+    return state.output, chart_data

hf_model.py

@@ -8,7 +8,7 @@ from huggingface_hub import InferenceClient
 
 # Initialize client
 HF_TOKEN = os.getenv("HF_TOKEN")
-MODEL_ID = "google/gemma-3-270m-it"  # Gemma 3 27B Instruct
+MODEL_ID = "google/gemma-3-4b-it"  # Gemma 3 27B Instruct
 
 client = InferenceClient(token=HF_TOKEN)