Upload folder using huggingface_hub

README.md

@@ -1,12 +1,53 @@
 ---
-title: Fintech Orchestrator
-emoji: 🐠
-colorFrom: indigo
-colorTo: blue
+title: Fintech Multi-Agent Orchestrator
+emoji: 🏦
+colorFrom: blue
+colorTo: indigo
 sdk: gradio
-sdk_version: 6.5.1
+sdk_version: 4.44.0
 app_file: app.py
 pinned: false
+license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🏦 Fintech Multi-Agent Orchestrator
+
+**Powered by Gemma 3 270m via HuggingFace Inference API**
+
+A multi-agent financial assistant that can:
+- 📊 Query account data (mock data for demo)
+- 🧮 Perform financial calculations
+- 📈 Generate charts and visualizations
+
+## Example Queries
+
+```
+"What is my net worth?"
+"Show my portfolio as a pie chart"
+"Calculate compound interest on $10000 at 8% for 5 years"
+"Show my assets breakdown as a bar chart"
+```
+
+## Architecture
+
+```
+User Query → Router → Banking/Calculator/Graph Agents → Response
+```
+
+## Tech Stack
+
+- **LLM**: Gemma 3 270m (HuggingFace Inference API)
+- **UI**: Gradio
+- **Charts**: Matplotlib
+
+## Setup (Local)
+
+```bash
+pip install -r requirements.txt
+export HF_TOKEN="your-huggingface-token"
+python app.py
+```
+
+## License
+
+MIT

app.py

@@ -0,0 +1,270 @@
+"""
+Fintech Multi-Agent Orchestrator - HuggingFace Spaces Demo
+Uses Gemma 3 27B 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 hf_model import generate_response, calculate_expression
+
+
+# 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."""
+    fig, ax = plt.subplots(figsize=(10, 6))
+    
+    if chart_type == "pie":
+        labels = list(data.keys())
+        values = list(data.values())
+        colors = plt.cm.Set3(np.linspace(0, 1, len(labels)))
+        ax.pie(values, labels=labels, autopct='%1.1f%%', colors=colors, startangle=90)
+        ax.set_title(title, fontsize=14, fontweight='bold')
+    
+    elif chart_type == "bar":
+        labels = list(data.keys())
+        values = list(data.values())
+        colors = plt.cm.viridis(np.linspace(0.3, 0.9, len(labels)))
+        bars = ax.bar(labels, values, color=colors)
+        ax.set_title(title, fontsize=14, fontweight='bold')
+        ax.set_ylabel('Amount ($)')
+        for bar, val in zip(bars, values):
+            ax.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 500, 
+                   f'${val:,.0f}', ha='center', va='bottom', fontsize=9)
+    
+    elif chart_type == "line":
+        x = list(range(len(data)))
+        y = list(data.values())
+        ax.plot(x, y, marker='o', linewidth=2, markersize=8, color='#2E86AB')
+        ax.fill_between(x, y, alpha=0.3, color='#2E86AB')
+        ax.set_xticks(x)
+        ax.set_xticklabels(list(data.keys()))
+        ax.set_title(title, fontsize=14, fontweight='bold')
+        ax.set_ylabel('Amount ($)')
+    
+    plt.tight_layout()
+    
+    # Convert to base64
+    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,
+    }
+
+
+def process_query(query: str, history: list) -> tuple:
+    """Main orchestrator function."""
+    
+    # Route the query
+    route = route_query(query)
+    
+    response_parts = []
+    chart_image = None
+    
+    # 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)
+    
+    final_response = "\n".join(response_parts)
+    
+    return final_response, 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**
+    
+    Ask questions about your finances, request calculations, or generate charts!
+    
+    ### Example queries:
+    - "What is my net worth?"
+    - "Show my portfolio as a pie chart"
+    - "Calculate compound interest on $10000 at 8% for 5 years"
+    - "Show my assets breakdown"
+    """)
+    
+    with gr.Row():
+        with gr.Column(scale=2):
+            chatbot = gr.Chatbot(
+                label="Chat",
+                height=400,
+                type="messages",
+            )
+            
+            with gr.Row():
+                query_input = gr.Textbox(
+                    label="Your Question",
+                    placeholder="Ask about your finances...",
+                    scale=4,
+                )
+                submit_btn = gr.Button("Send", variant="primary", scale=1)
+        
+        with gr.Column(scale=1):
+            chart_output = gr.Image(
+                label="Generated Chart",
+                height=400,
+            )
+    
+    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],
+        outputs=[chatbot, chart_output],
+    ).then(
+        lambda: "",
+        outputs=[query_input],
+    )
+    
+    query_input.submit(
+        respond,
+        inputs=[query_input, chatbot],
+        outputs=[chatbot, chart_output],
+    ).then(
+        lambda: "",
+        outputs=[query_input],
+    )
+    
+    clear_btn.click(
+        lambda: ([], None),
+        outputs=[chatbot, chart_output],
+    )
+
+
+if __name__ == "__main__":
+    demo.launch()

hf_model.py

@@ -0,0 +1,67 @@
+"""
+HuggingFace Inference API Model Wrapper
+Uses Gemma 3 27B for fintech orchestrator
+"""
+
+import os
+from huggingface_hub import InferenceClient
+
+# Initialize client
+HF_TOKEN = os.getenv("HF_TOKEN")
+MODEL_ID = "google/gemma-3-270m-it"  # Gemma 3 27B Instruct
+
+client = InferenceClient(token=HF_TOKEN)
+
+
+def generate_response(
+    messages: list[dict],
+    max_tokens: int = 1024,
+    temperature: float = 0.7,
+) -> str:
+    """
+    Generate response using HuggingFace Inference API.
+    
+    Args:
+        messages: List of message dicts with 'role' and 'content'
+        max_tokens: Maximum tokens to generate
+        temperature: Sampling temperature
+    
+    Returns:
+        Generated text response
+    """
+    try:
+        response = client.chat.completions.create(
+            model=MODEL_ID,
+            messages=messages,
+            max_tokens=max_tokens,
+            temperature=temperature,
+        )
+        return response.choices[0].message.content
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+
+def calculate_expression(expression: str) -> str:
+    """Simple calculator for financial expressions."""
+    import re
+    import math
+    
+    # Safe eval with limited functions
+    allowed_names = {
+        'abs': abs, 'round': round, 'min': min, 'max': max,
+        'pow': pow, 'sqrt': math.sqrt, 'log': math.log,
+        'exp': math.exp, 'pi': math.pi, 'e': math.e,
+    }
+    
+    try:
+        # Clean the expression
+        expr = expression.strip()
+        # Basic validation
+        if not re.match(r'^[\d\s\+\-\*\/\.\(\)\^]+$', expr.replace('**', '^')):
+            # Try to extract numbers and operators more flexibly
+            pass
+        
+        result = eval(expr, {"__builtins__": {}}, allowed_names)
+        return f"{result:,.2f}"
+    except Exception as e:
+        return f"Calculation error: {str(e)}"

requirements.txt

@@ -0,0 +1,5 @@
+gradio>=4.0.0
+huggingface-hub>=0.20.0
+matplotlib>=3.8.0
+numpy>=1.24.0
+Pillow>=10.0.0