Added dummy sqlite DB

.dummyenv

@@ -4,9 +4,19 @@ OPENAI_API_KEY=""
 # Weather API Key
 WEATHER_API_KEY = ""
 
+# Database Configuration
+ERP_DB_TYPE = "sqlite"  # Options: "sqlite" or "postgres"
+SQLITE_DB_PATH = "./data/erp_db.sqlite"
+
 # PostgreSQL Database Configuration
 POSTGRES_HOST = ""
 POSTGRES_DB = ""
 POSTGRES_USER = ""
 POSTGRES_PASSWORD = ""
-POSTGRES_PORT = "5432"
+POSTGRES_PORT = "5432"
+
+# ERP Postgres DB
+ERP_DB_TYPE = "postgres" # Options: "postgres" or "sqlite"
+
+# Disruption DB
+DISRUPTIONS_DB_TYPE = "postgres"  # Options: "postgres" or "sqlite"

.gitignore

@@ -195,5 +195,4 @@ cython_debug/
 .env
 .vscode
 
-data
 notebooks

.gradio/certificate.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

README.md

@@ -21,6 +21,11 @@ tags:
 
 **TrackMate AI** is a Gradio-powered autonomous agent designed to interface with an ERP system via MCP tools. It connects to a custom MCP Server and lets users chat with an LLM to place, modify, or track orders — all through natural language.
 
+Designed for seamless interaction with ERP infrastructure, TrackMate AI empowers users to manage operational workflows via a conversational interface — no dashboards, no dropdowns, just intelligent dialogue.
+
+Whether you're tracking an order, generating invoices, or accessing global risk intelligence, TrackMate AI brings an intuitive, natural language layer to your business operations.
+
+
 ---
 
 ## 📺 Demo Video

app.py

@@ -89,49 +89,319 @@ def reset_conversation():
 
 # ----- Gradio Interface -----
 def create_interface():
-    with gr.Blocks(title="TrackMate AI") as app:
+    with gr.Blocks(
+        title="TrackMate AI",
+        theme=gr.themes.Soft(),
+        css="""
+        /* Dark theme colors */
+        :root {
+            --bg-primary: #121212;
+            --bg-secondary: #1e1e1e;
+            --bg-tertiary: #252525;
+            --text-primary: #e0e0e0;
+            --text-secondary: #a0a0a0;
+            --accent-primary: #3a506b;
+            --accent-secondary: #1c2541;
+            --accent-tertiary: #0b132b;
+            --highlight: #5bc0be;
+            --error: #ff6b6b;
+            --success: #6bd425;
+        }
+        
+        .documentation-container {
+            background-color: var(--bg-secondary);
+            color: var(--text-primary);
+            padding: 2rem;
+            border-radius: 15px;
+            margin-bottom: 2rem;
+            box-shadow: 0 8px 32px rgba(0, 0, 0, 0.3);
+        }
+        
+        .documentation-header {
+            text-align: center;
+            margin-bottom: 1.5rem;
+        }
+        
+        .documentation-section {
+            background-color: var(--bg-tertiary);
+            padding: 1.5rem;
+            border-radius: 10px;
+            margin-bottom: 1.5rem;
+            border-left: 4px solid var(--highlight);
+        }
+        
+        .config-panel {
+            background-color: var(--bg-secondary);
+            padding: 1.5rem;
+            border-radius: 15px;
+            box-shadow: 0 4px 20px rgba(0, 0, 0, 0.3);
+            height: 100%;
+            display: flex;
+            flex-direction: column;
+        }
+        
+        .chat-panel {
+            background-color: var(--bg-secondary);
+            padding: 1.5rem;
+            border-radius: 15px;
+            box-shadow: 0 4px 20px rgba(0, 0, 0, 0.3);
+            height: 100%;
+            display: flex;
+            flex-direction: column;
+        }
+        
+        .panel-header {
+            text-align: center;
+            padding: 1rem;
+            background-color: var(--accent-primary);
+            color: var(--text-primary);
+            border-radius: 10px;
+            margin-bottom: 1rem;
+        }
+        
+        .tools-table {
+            width: 100%;
+            border-collapse: collapse;
+            margin-top: 1rem;
+        }
+        
+        .tools-table th, .tools-table td {
+            padding: 0.75rem;
+            text-align: left;
+            border-bottom: 1px solid var(--accent-secondary);
+        }
+        
+        .tools-table th {
+            font-weight: bold;
+            background-color: var(--accent-tertiary);
+        }
+        
+        .feature-list {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
+            gap: 0.5rem;
+            margin-top: 1rem;
+        }
+        
+        .feature-item {
+            background-color: var(--accent-secondary);
+            padding: 0.75rem;
+            border-radius: 10px;
+        }
+        
+        a {
+            color: var(--highlight);
+            text-decoration: none;
+            font-weight: bold;
+        }
+        
+        a:hover {
+            text-decoration: underline;
+        }
+        
+        /* Chat avatar styling */
+        .chatbot .avatar {
+            display: flex !important;
+            align-items: center;
+            justify-content: center;
+            width: 40px !important;
+            height: 40px !important;
+            border-radius: 50%;
+            background-color: var(--accent-secondary);
+            color: var(--text-primary);
+            font-size: 20px;
+            margin-right: 10px;
+        }
+        
+        /* Ensure chat messages have proper contrast */
+        .chatbot .user-message {
+            background-color: var(--accent-primary) !important;
+            color: var(--text-primary) !important;
+            border-radius: 10px !important;
+        }
+        
+        .chatbot .bot-message {
+            background-color: var(--accent-secondary) !important;
+            color: var(--text-primary) !important;
+            border-radius: 10px !important;
+        }
+        
+        /* Override any theme styles that might hide avatars */
+        .chatbot .message-container {
+            display: flex !important;
+            align-items: flex-start !important;
+        }
+        """
+    ) as app:
         agent_state = gr.State(value=None)
-        # Header
+        
+        # Consolidated Documentation Section
         gr.HTML("""
-        <div style="text-align: center; padding: 1rem 0; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; border-radius: 10px; margin-bottom: 2rem;">
-            <h1 style="margin: 0; font-size: 2.5rem;">🧠 TrackMate AI</h1>
-            <p style="margin: 0; opacity: 0.9;">Your smart companion for tracking and managing orders.</p>
+        <div class="documentation-container">
+            <div class="documentation-header">
+                <h1 style="margin: 0; font-size: 3rem; font-weight: 700;">🤖 TrackMate AI</h1>
+                <p style="margin: 0.5rem 0 0 0; font-size: 1.2rem; opacity: 0.9;">Your smart companion for tracking and managing orders.</p>
+            </div>
+            
+            <div class="documentation-section">
+                <h2 style="margin: 0 0 1rem 0; font-size: 1.8rem;">📋 About TrackMate AI</h2>
+                <p style="margin: 0; font-size: 1.1rem; line-height: 1.6;">
+                    <strong>TrackMate AI</strong> is a Gradio-powered autonomous agent designed to interface with an ERP system via MCP tools. 
+                    It connects to a custom MCP Server and lets users chat with an LLM to place, modify, or track orders — all through natural language. Designed for seamless interaction with ERP infrastructure, TrackMate AI empowers users to manage operational workflows via a conversational interface — no dashboards, no dropdowns, just intelligent dialogue. Whether you're tracking an order, generating invoices, or accessing global risk intelligence, TrackMate AI brings an intuitive, natural language layer to your business operations.
+                </p>
+                
+                <h3 style="margin: 1.5rem 0 0.5rem 0; font-size: 1.4rem;">📺 Demo Video</h3>
+                <p style="margin: 0; font-size: 1.1rem;">
+                    <a href="https://youtu.be/hzaNbPRrrz8" target="_blank">
+                        📹 Watch Demo Video - TrackMate AI Agent
+                    </a>
+                </p>
+                
+                <h3 style="margin: 1.5rem 0 0.5rem 0; font-size: 1.4rem;">✨ What It Can Do</h3>
+                <div class="feature-list">
+                    <div class="feature-item">🔍 Query live ERP data (orders, invoices, customers)</div>
+                    <div class="feature-item">�� Place or cancel orders</div>
+                    <div class="feature-item">🌐 Check for geopolitical disruptions</div>
+                    <div class="feature-item">🧠 Leverage multiple tools via MCP + Gradio agent framework</div>
+                    <div class="feature-item">🧮 Use a calculator for quick computations</div>
+                    <div class="feature-item">☀️🌧️ Get live weather updates for any location</div>
+                </div>
+                
+                <h3 style="margin: 1.5rem 0 0.5rem 0; font-size: 1.4rem;">🔌 Connected Tools</h3>
+                <p style="margin: 0 0 1rem 0; font-size: 1.1rem;">
+                    TrackMate AI uses a bunch of tools provided by the 
+                    <a href="https://huggingface.co/spaces/Agents-MCP-Hackathon/TrackMate-AI-MCP-Server" target="_blank">
+                        TrackMate AI MCP Server
+                    </a>:
+                </p>
+                <table style="width: 100%; border-collapse: collapse; border: 1px solid white;">
+                    <thead>
+                        <tr>
+                            <th style="border: 1px solid white; padding: 8px; background-color: #333; color: white;">Tool Name</th>
+                            <th style="border: 1px solid white; padding: 8px; background-color: #333; color: white;">Description</th>
+                        </tr>
+                    </thead>
+                    <tbody>
+                        <tr>
+                            <td style="border: 1px solid white; padding: 8px; color: white;"><code>list_tables</code></td>
+                            <td style="border: 1px solid white; padding: 8px; color: white;">Lists all ERP database tables</td>
+                        </tr>
+                        <tr>
+                            <td style="border: 1px solid white; padding: 8px; color: white;"><code>execute_query</code></td>
+                            <td style="border: 1px solid white; padding: 8px; color: white;">Executes a custom SQL query</td>
+                        </tr>
+                        <tr>
+                            <td style="border: 1px solid white; padding: 8px; color: white;"><code>get_order_status</code></td>
+                            <td style="border: 1px solid white; padding: 8px; color: white;">Gets status of an order</td>
+                        </tr>
+                        <tr>
+                            <td style="border: 1px solid white; padding: 8px; color: white;"><code>place_order</code></td>
+                            <td style="border: 1px solid white; padding: 8px; color: white;">Places a new order</td>
+                        </tr>
+                        <tr>
+                            <td style="border: 1px solid white; padding: 8px; color: white;"><code>cancel_order</code></td>
+                            <td style="border: 1px solid white; padding: 8px; color: white;">Cancels an existing order</td>
+                        </tr>
+                        <tr>
+                            <td style="border: 1px solid white; padding: 8px; color: white;"><code>get_active_disruptions</code></td>
+                            <td style="border: 1px solid white; padding: 8px; color: white;">Returns geopolitical disruptions between nations</td>
+                        </tr>
+                        <tr>
+                            <td style="border: 1px solid white; padding: 8px; color: white;"><code>add, subtract, multiple</code></td>
+                            <td style="border: 1px solid white; padding: 8px; color: white;">Use a simple calculator</td>
+                        </tr>
+                    </tbody>
+                </table>
+
+            </div>
         </div>
         """)
-        with gr.Row():
+        
+        # Main Interface
+        with gr.Row(equal_height=True):
+            # Configuration Panel
             with gr.Column(scale=1):
-                model_name = gr.Dropdown(
-                    choices=["gpt-4o-mini", "gpt-4o", "gpt-4"],
-                    value="gpt-4o",
-                    label="Model"
-                )
-                temperature = gr.Slider(0.0, 1.0, value=0.7, step=0.1, label="Temperature")
-                max_tokens = gr.Number(value=1000, minimum=100, maximum=4000, step=100, label="Max Tokens")
-                api_key = gr.Textbox(
-                    value="",
-                    label="API Key",
-                    placeholder="Enter your OpenAI API key",
-                    type="password",
-                    interactive=True
-                )
-                with gr.Accordion("System Prompt", open=False):
-                    system_prompt = gr.Textbox(
-                        value=get_default_system_prompt(),
-                        lines=10,
-                        label="System Prompt",
-                        interactive=True
+                with gr.Group(elem_classes="config-panel"):
+                    gr.HTML('<div class="panel-header"><h3 style="margin: 0;">⚙️ Agent Configuration</h3></div>')
+                    
+                    model_name = gr.Dropdown(
+                        choices=["gpt-4o-mini", "gpt-4o", "gpt-4"],
+                        value="gpt-4o",
+                        label="🤖 Model",
+                        info="Select the OpenAI model to use"
                     )
+                    temperature = gr.Slider(
+                        0.0, 1.0, 
+                        value=0.7, 
+                        step=0.1, 
+                        label="🌡️ Temperature",
+                        info="Controls randomness (0=deterministic, 1=creative)"
+                    )
+                    max_tokens = gr.Number(
+                        value=1000, 
+                        minimum=100, 
+                        maximum=4000, 
+                        step=100, 
+                        label="📏 Max Tokens",
+                        info="Maximum response length"
+                    )
+                    api_key = gr.Textbox(
+                        value="",
+                        label="🔑 API Key",
+                        placeholder="Enter your OpenAI API key",
+                        type="password",
+                        interactive=True,
+                        info="Your OpenAI API key (kept secure)"
+                    )
+                    
+                    with gr.Accordion("📝 System Prompt", open=False):
+                        system_prompt = gr.Textbox(
+                            value=get_default_system_prompt(),
+                            lines=10,
+                            label="System Prompt",
+                            interactive=True,
+                            info="Customize the agent's behavior and instructions"
+                        )
 
-                init_btn = gr.Button("🚀 Initialize Agent")
-                status_display = gr.Textbox(label="Status", interactive=False)
-                agent_status = gr.Textbox(label="Agent Status", interactive=False)
+                    init_btn = gr.Button("🚀 Initialize Agent", variant="primary", size="lg")
+                    
+                    with gr.Group():
+                        status_display = gr.Textbox(
+                            label="📊 Status", 
+                            interactive=False,
+                            info="Current operation status"
+                        )
+                        agent_status = gr.Textbox(
+                            label="🤖 Agent Status", 
+                            interactive=False,
+                            info="Agent readiness indicator"
+                        )
 
+            # Chat Panel
             with gr.Column(scale=3, min_width=700):
-                    chatbot = gr.Chatbot(label="TrackMate AI Chat", height=500)
-                    msg_input = gr.Textbox(label="Message")
-                    send_btn = gr.Button("Send")
-                    reset_btn = gr.Button("🔄 Reset Chat")
+                with gr.Group(elem_classes="chat-panel"):
+                    gr.HTML('<div class="panel-header"><h3 style="margin: 0;">💬 Chat Interface</h3></div>')
+                    
+                    chatbot = gr.Chatbot(
+                        label="TrackMate AI Chat", 
+                        height=650,
+                        show_label=False,
+                        show_copy_button=True,
+                        elem_classes="chatbot"
+                    )
+                    
+                    # Make the message input take full width
+                    msg_input = gr.Textbox(
+                        label="💭 Message",
+                        placeholder="Ask me about orders, inventory, weather, or anything else...",
+                        show_label=False
+                    )
+
+                    send_btn = gr.Button("📤 Send", variant="primary", scale=1)
+                    
+                    reset_btn = gr.Button("🔄 Reset Chat", variant="secondary", scale=1)
 
+        # Event handlers
         init_btn.click(
             fn=initialize_agent_handler,
             inputs=[model_name, temperature, max_tokens, system_prompt, api_key],

core/mcp_tools/erp_db_init.py

@@ -0,0 +1,145 @@
+# erp_db_init.py
+import sqlite3
+import os
+import pathlib
+
+def init_sqlite_db(db_path='./data/erp_db.sqlite'):
+    """Initialize SQLite database with ERP tables."""
+    try:
+        # Create the database directory if it doesn't exist
+        db_dir = pathlib.Path(os.path.dirname(db_path))
+        db_dir.mkdir(exist_ok=True)
+        
+        # Connect to SQLite database (will be created if it doesn't exist)
+        conn = sqlite3.connect(db_path)
+        cursor = conn.cursor()
+        
+        # Enable foreign keys
+        conn.execute("PRAGMA foreign_keys = ON")
+        
+        # Create customers table
+        cursor.execute('''
+        CREATE TABLE IF NOT EXISTS erp_customers (
+            customer_id INTEGER PRIMARY KEY AUTOINCREMENT,
+            name TEXT NOT NULL,
+            email TEXT NOT NULL UNIQUE,
+            phone TEXT,
+            address TEXT,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+        ''')
+        
+        # Create products table
+        cursor.execute('''
+        CREATE TABLE IF NOT EXISTS erp_products (
+            product_id INTEGER PRIMARY KEY AUTOINCREMENT,
+            product_name TEXT NOT NULL,
+            description TEXT,
+            category TEXT,
+            price REAL NOT NULL,
+            stock_quantity INTEGER NOT NULL DEFAULT 0,
+            sku TEXT UNIQUE
+        )
+        ''')
+        
+        # Create orders table
+        cursor.execute('''
+        CREATE TABLE IF NOT EXISTS erp_orders (
+            order_id INTEGER PRIMARY KEY AUTOINCREMENT,
+            customer_id INTEGER,
+            order_date DATE DEFAULT CURRENT_DATE,
+            total_amount REAL NOT NULL,
+            status TEXT NOT NULL DEFAULT 'Processing',
+            previous_order_id INTEGER,
+            estimated_delivery DATE,
+            actual_delivery DATE,
+            payment_status TEXT DEFAULT 'Pending',
+            shipping_address TEXT NOT NULL,
+            shipping_country TEXT,
+            destination_country TEXT,
+            FOREIGN KEY (customer_id) REFERENCES erp_customers (customer_id),
+            FOREIGN KEY (previous_order_id) REFERENCES erp_orders (order_id)
+        )
+        ''')
+        
+        # Create order items table
+        cursor.execute('''
+        CREATE TABLE IF NOT EXISTS erp_order_items (
+            order_item_id INTEGER PRIMARY KEY AUTOINCREMENT,
+            order_id INTEGER,
+            product_id INTEGER,
+            quantity INTEGER NOT NULL,
+            unit_price REAL NOT NULL,
+            subtotal REAL NOT NULL,
+            FOREIGN KEY (order_id) REFERENCES erp_orders (order_id),
+            FOREIGN KEY (product_id) REFERENCES erp_products (product_id)
+        )
+        ''')
+        
+        # Create order history table
+        cursor.execute('''
+        CREATE TABLE IF NOT EXISTS erp_order_history (
+            history_id INTEGER PRIMARY KEY AUTOINCREMENT,
+            order_id INTEGER,
+            timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            status_change TEXT,
+            notes TEXT,
+            updated_by TEXT,
+            FOREIGN KEY (order_id) REFERENCES erp_orders (order_id)
+        )
+        ''')
+        
+        # Create invoices table
+        cursor.execute('''
+        CREATE TABLE IF NOT EXISTS erp_invoices (
+            invoice_id INTEGER PRIMARY KEY AUTOINCREMENT,
+            order_id INTEGER,
+            invoice_date DATE DEFAULT CURRENT_DATE,
+            amount REAL NOT NULL,
+            payment_terms TEXT,
+            due_date DATE,
+            is_paid BOOLEAN DEFAULT 0,
+            invoice_number TEXT UNIQUE,
+            FOREIGN KEY (order_id) REFERENCES erp_orders (order_id)
+        )
+        ''')
+        
+        # Create global disruptions table
+        cursor.execute('''
+        CREATE TABLE IF NOT EXISTS live_global_disruptions (
+            disruption_id INTEGER PRIMARY KEY AUTOINCREMENT,
+            source_country TEXT NOT NULL,
+            destination_country TEXT NOT NULL,
+            disruption_type TEXT NOT NULL,
+            severity INTEGER NOT NULL CHECK (severity >= 1 AND severity <= 5),
+            start_date DATE NOT NULL,
+            expected_end_date DATE,
+            actual_end_date DATE,
+            is_active BOOLEAN DEFAULT 1,
+            description TEXT,
+            impact_hours INTEGER,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            UNIQUE (source_country, destination_country, disruption_type, start_date)
+        )
+        ''')
+        
+        # Create indexes
+        cursor.execute('CREATE INDEX IF NOT EXISTS idx_orders_customer ON erp_orders (customer_id)')
+        cursor.execute('CREATE INDEX IF NOT EXISTS idx_order_items_order ON erp_order_items (order_id)')
+        cursor.execute('CREATE INDEX IF NOT EXISTS idx_order_items_product ON erp_order_items (product_id)')
+        cursor.execute('CREATE INDEX IF NOT EXISTS idx_order_history_order ON erp_order_history (order_id)')
+        cursor.execute('CREATE INDEX IF NOT EXISTS idx_invoices_order ON erp_invoices (order_id)')
+        cursor.execute('CREATE INDEX IF NOT EXISTS idx_global_disruptions_active ON live_global_disruptions (is_active)')
+        cursor.execute('CREATE INDEX IF NOT EXISTS idx_global_disruptions_countries ON live_global_disruptions (source_country, destination_country)')
+        
+        conn.commit()
+        conn.close()
+        
+        return True
+    except Exception as e:
+        print(f"Error initializing SQLite database: {str(e)}")
+        return False
+
+if __name__ == "__main__":
+    init_sqlite_db()

core/mcp_tools/erp_server.py

@@ -1,64 +1,129 @@
 # erp_server.py
-from typing import Dict, Any, List, Optional
-import psycopg2
-from psycopg2.extras import RealDictCursor
-from mcp.server.fastmcp import FastMCP
 import os
+import sys
+from typing import TypedDict, List, Union
+
+# Add the project root directory to the Python path
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '../..')))
+
+from typing import Dict, Any, List, Optional
 from dotenv import load_dotenv
-import json
-from datetime import datetime
+from datetime import datetime, date
+import pathlib, logging
+
+# Initialize logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+# Import both database libraries
+import sqlite3
+try:
+    import psycopg2
+    from psycopg2.extras import RealDictCursor
+    POSTGRES_AVAILABLE = True
+except ImportError:
+    POSTGRES_AVAILABLE = False
+
+# Import SQLite initialization function
+from core.mcp_tools.erp_db_init import init_sqlite_db
+
+from mcp.server.fastmcp import FastMCP
 
 load_dotenv()
 
 mcp = FastMCP("ERP Database")
 
+# Helper function to convert SQLite row to dict
+def dict_factory(cursor, row):
+    d = {}
+    for idx, col in enumerate(cursor.description):
+        d[col[0]] = row[idx]
+    return d
+
+# Helper function to handle date serialization for JSON
+def serialize_dates(obj):
+    if isinstance(obj, (date, datetime)):
+        return obj.isoformat()
+    return obj
+
 def get_db_connection():
-    """Get database connection using environment variables."""
-    try:
-        conn = psycopg2.connect(
-            host=os.getenv("POSTGRES_HOST", "localhost"),
-            database=os.getenv("POSTGRES_DB", "erp_db"),
-            user=os.getenv("POSTGRES_USER", "postgres"),
-            password=os.getenv("POSTGRES_PASSWORD", ""),
-            port=os.getenv("POSTGRES_PORT", "5432")
-        )
-        return conn
-    except Exception as e:
-        raise Exception(f"Database connection failed: {str(e)}")
+    """Get database connection based on configuration."""
+    # Default to SQLite unless explicitly set to use PostgreSQL
+    db_type = os.getenv("ERP_DB_TYPE", "sqlite").lower()
+
+    logging.info(f"Connecting to {db_type} database...")
+
+    if db_type == "postgres" and POSTGRES_AVAILABLE:
+        try:
+            conn = psycopg2.connect(
+                host=os.getenv("POSTGRES_HOST", "localhost"),
+                database=os.getenv("POSTGRES_DB", "erp_db"),
+                user=os.getenv("POSTGRES_USER", "postgres"),
+                password=os.getenv("POSTGRES_PASSWORD", ""),
+                port=os.getenv("POSTGRES_PORT", "5432")
+            )
+            return conn, "postgres"
+        except Exception as e:
+            raise Exception(f"PostgreSQL connection failed: {str(e)}")
+    else:
+        try:
+            # Get SQLite database path from environment or use default
+            db_path = os.getenv("SQLITE_DB_PATH", "./data/erp_db.sqlite")
+            
+            # Ensure database is initialized
+            db_dir = pathlib.Path(os.path.dirname(db_path))
+            if not db_dir.exists() or not pathlib.Path(db_path).exists():
+                init_sqlite_db(db_path)
+            
+            conn = sqlite3.connect(db_path)
+            conn.row_factory = dict_factory
+            
+            # Enable foreign keys
+            conn.execute("PRAGMA foreign_keys = ON")
+            
+            return conn, "sqlite"
+        except Exception as e:
+            raise Exception(f"SQLite connection failed: {str(e)}")
 
 @mcp.tool()
 async def execute_query(query: str, params: Optional[List] = None) -> Dict[str, Any]:
     """
     Execute a custom SQL query on the ERP database.
+    Only SELECT statements are allowed for security reasons.
     
     Args:
-        query (str): SQL query to execute
+        query (str): SQL query to execute (must be a SELECT statement)
         params (List, optional): Parameters for parameterized queries
     
     Returns:
         dict: Query results or error message
     """
     try:
-        conn = get_db_connection()
-        cursor = conn.cursor(cursor_factory=RealDictCursor)
+        # Check if it's a SELECT query
+        if not query.strip().upper().startswith('SELECT'):
+            return {
+                "success": False,
+                "error": "Only SELECT statements are allowed for security reasons."
+            }
+            
+        conn, db_type = get_db_connection()
+        
+        if db_type == "postgres":
+            cursor = conn.cursor(cursor_factory=RealDictCursor)
+        else:  # sqlite
+            cursor = conn.cursor()
         
         if params:
             cursor.execute(query, params)
         else:
             cursor.execute(query)
         
-        # Check if it's a SELECT query
-        if query.strip().upper().startswith('SELECT'):
-            results = cursor.fetchall()
-            # Convert RealDictRow to regular dict for JSON serialization
+        results = cursor.fetchall()
+        # Convert results to regular dict for JSON serialization
+        if db_type == "postgres":
             results = [dict(row) for row in results]
-            if not results:
-                return "No results found"
-            return results
-        else:
-            # For INSERT, UPDATE, DELETE queries
-            conn.commit()
-            return f"Query executed successfully. {cursor.rowcount} rows affected."
+        if not results:
+            return "No results found"
+        return results
             
     except Exception as e:
         return {
@@ -77,21 +142,33 @@ async def list_erp_tables() -> Dict[str, Any]:
     Returns:
         dict: List of ERP table names
     """
-    query = """
-    SELECT table_name 
-    FROM information_schema.tables 
-    WHERE table_schema = 'public'
-    AND table_name LIKE 'erp_%'
-    ORDER BY table_name;
-    """
-    
     try:
-        conn = get_db_connection()
-        cursor = conn.cursor(cursor_factory=RealDictCursor)
-        cursor.execute(query)
-        results = cursor.fetchall()
+        conn, db_type = get_db_connection()
+        
+        if db_type == "postgres":
+            query = """
+            SELECT table_name 
+            FROM information_schema.tables 
+            WHERE table_schema = 'public'
+            AND table_name LIKE 'erp_%'
+            ORDER BY table_name;
+            """
+            cursor = conn.cursor(cursor_factory=RealDictCursor)
+            cursor.execute(query)
+            results = cursor.fetchall()
+            table_names = [row['table_name'] for row in results]
+        else:  # sqlite
+            query = """
+            SELECT name as table_name
+            FROM sqlite_master
+            WHERE type='table' AND name LIKE 'erp_%'
+            ORDER BY name;
+            """
+            cursor = conn.cursor()
+            cursor.execute(query)
+            results = cursor.fetchall()
+            table_names = [row['table_name'] for row in results]
         
-        table_names = [row['table_name'] for row in results]
         if not table_names:
             return {
                 "success": False,
@@ -125,17 +202,24 @@ async def get_order_status(order_id: int) -> Dict[str, Any]:
     Returns:
         dict: Order status information including shipping and destination countries
     """
-    query = """
-    SELECT o.*, c.name as customer_name, c.email as customer_email,
-           o.shipping_country, o.destination_country
-    FROM erp_orders o
-    JOIN erp_customers c ON o.customer_id = c.customer_id
-    WHERE o.order_id = %s;
-    """
-    
     try:
-        conn = get_db_connection()
-        cursor = conn.cursor(cursor_factory=RealDictCursor)
+        conn, db_type = get_db_connection()
+        
+        if db_type == "postgres":
+            cursor = conn.cursor(cursor_factory=RealDictCursor)
+            param_placeholder = "%s"
+        else:  # sqlite
+            cursor = conn.cursor()
+            param_placeholder = "?"
+        
+        query = f"""
+        SELECT o.*, c.name as customer_name, c.email as customer_email,
+               o.shipping_country, o.destination_country
+        FROM erp_orders o
+        JOIN erp_customers c ON o.customer_id = c.customer_id
+        WHERE o.order_id = {param_placeholder};
+        """
+        
         cursor.execute(query, [order_id])
         order = cursor.fetchone()
         
@@ -146,28 +230,28 @@ async def get_order_status(order_id: int) -> Dict[str, Any]:
             }
         
         # Get order items
-        items_query = """
+        items_query = f"""
         SELECT oi.order_item_id, oi.order_id, oi.product_id, oi.quantity, oi.unit_price, oi.subtotal,
                p.product_name, p.sku
         FROM erp_order_items oi
         JOIN erp_products p ON oi.product_id = p.product_id
-        WHERE oi.order_id = %s;
+        WHERE oi.order_id = {param_placeholder};
         """
         cursor.execute(items_query, [order_id])
         items = cursor.fetchall()
         
         # Get order history
-        history_query = """
+        history_query = f"""
         SELECT * FROM erp_order_history
-        WHERE order_id = %s
+        WHERE order_id = {param_placeholder}
         ORDER BY timestamp DESC;
         """
         cursor.execute(history_query, [order_id])
         history = cursor.fetchall()
         
-        order_dict = dict(order)
-        items_list = [dict(item) for item in items]
-        history_list = [dict(entry) for entry in history]
+        order_dict = order if db_type == "sqlite" else dict(order)
+        items_list = items if db_type == "sqlite" else [dict(item) for item in items]
+        history_list = history if db_type == "sqlite" else [dict(entry) for entry in history]
         
         # Return JSON formatted response
         return {
@@ -221,13 +305,27 @@ async def place_new_order(
         dict: New order information
     """
     try:
-        conn = get_db_connection()
-        cursor = conn.cursor(cursor_factory=RealDictCursor)
+        conn, db_type = get_db_connection()
+        
+        if db_type == "postgres":
+            cursor = conn.cursor(cursor_factory=RealDictCursor)
+            param_placeholder = "%s"
+            returning_clause = "RETURNING order_id"
+            date_interval = "CURRENT_DATE + INTERVAL '7 days'"
+            due_date_interval = "CURRENT_DATE + INTERVAL '30 days'"
+            concat_op = "||"
+        else:  # sqlite
+            cursor = conn.cursor()
+            param_placeholder = "?"
+            returning_clause = ""
+            date_interval = "date('now', '+7 days')"
+            due_date_interval = "date('now', '+30 days')"
+            concat_op = "||"
         
         # Calculate total amount based on the total items and their prices
         total_amount = 0
         for item in items:
-            product_query = "SELECT price FROM erp_products WHERE product_id = %s;"
+            product_query = f"SELECT price FROM erp_products WHERE product_id = {param_placeholder};"
             cursor.execute(product_query, [item['product_id']])
             product = cursor.fetchone()
             if not product:
@@ -238,21 +336,26 @@ async def place_new_order(
             total_amount += product['price'] * item['quantity']
         
         # Insert new order into the erp_orders table for the customer
-        order_query = """
+        order_query = f"""
         INSERT INTO erp_orders (
             customer_id, order_date, total_amount, status, 
             shipping_address, shipping_country, destination_country, previous_order_id,
             estimated_delivery, payment_status
         ) VALUES (
-            %s, CURRENT_DATE, %s, 'Processing', 
-            %s, %s, %s, %s,
-            CURRENT_DATE + INTERVAL '7 days', 'Pending'
-        ) RETURNING order_id;
+            {param_placeholder}, CURRENT_DATE, {param_placeholder}, 'Processing', 
+            {param_placeholder}, {param_placeholder}, {param_placeholder}, {param_placeholder},
+            {date_interval}, 'Pending'
+        ) {returning_clause};
         """
+        
         cursor.execute(order_query, [
             customer_id, total_amount, shipping_address, shipping_country, destination_country, previous_order_id
         ])
-        new_order_id = cursor.fetchone()['order_id']
+        
+        if db_type == "postgres":
+            new_order_id = cursor.fetchone()['order_id']
+        else:  # sqlite
+            new_order_id = cursor.lastrowid
         
         # Insert order items into erp_order_items table for the new order
         for item in items:
@@ -262,11 +365,11 @@ async def place_new_order(
             unit_price = product['price']
             subtotal = unit_price * item['quantity']
             
-            item_query = """
+            item_query = f"""
             INSERT INTO erp_order_items (
                 order_id, product_id, quantity, unit_price, subtotal
             ) VALUES (
-                %s, %s, %s, %s, %s
+                {param_placeholder}, {param_placeholder}, {param_placeholder}, {param_placeholder}, {param_placeholder}
             );
             """
             cursor.execute(item_query, [
@@ -275,52 +378,66 @@ async def place_new_order(
             ])
             
             # Update product stock
-            update_stock_query = """
+            update_stock_query = f"""
             UPDATE erp_products 
-            SET stock_quantity = stock_quantity - %s 
-            WHERE product_id = %s;
+            SET stock_quantity = stock_quantity - {param_placeholder} 
+            WHERE product_id = {param_placeholder};
             """
             cursor.execute(update_stock_query, [item['quantity'], item['product_id']])
         
         # Create order history entry into the erp_order_history for the new order
-        history_query = """
+        history_query = f"""
         INSERT INTO erp_order_history (
             order_id, timestamp, status_change, notes, updated_by
         ) VALUES (
-            %s, CURRENT_TIMESTAMP, 'Order Created', 'New order placed', 'System'
+            {param_placeholder}, CURRENT_TIMESTAMP, 'Order Created', 'New order placed', 'System'
         );
         """
         cursor.execute(history_query, [new_order_id])
         
         # If this is a replacement order, add a note to the previous order
         if previous_order_id:
-            prev_order_note_query = """
+            prev_order_note_query = f"""
             INSERT INTO erp_order_history (
                 order_id, timestamp, status_change, notes, updated_by
             ) VALUES (
-                %s, CURRENT_TIMESTAMP, 'Replaced', 'Order replaced by order #%s', 'System'
+                {param_placeholder}, CURRENT_TIMESTAMP, 'Replaced', 'Order replaced by order #' {concat_op} {param_placeholder}, 'System'
             );
             """
             cursor.execute(prev_order_note_query, [previous_order_id, new_order_id])
         
         # Generate invoice for the new order
-        invoice_query = """
+        invoice_query = f"""
         INSERT INTO erp_invoices (
             order_id, invoice_date, amount, payment_terms, due_date, is_paid, invoice_number
         ) VALUES (
-            %s, CURRENT_DATE, %s, 'Net 30', CURRENT_DATE + INTERVAL '30 days', FALSE, 'INV-' || %s
-        ) RETURNING invoice_id;
+            {param_placeholder}, CURRENT_DATE, {param_placeholder}, 'Net 30', {due_date_interval}, 0, 'INV-' {concat_op} {param_placeholder}
+        ) {returning_clause};
         """
-        cursor.execute(invoice_query, [new_order_id, total_amount, new_order_id])
-        invoice_id = cursor.fetchone()['invoice_id']
+        cursor.execute(invoice_query, [new_order_id, total_amount, str(new_order_id)])
+        
+        if db_type == "postgres":
+            invoice_id = cursor.fetchone()['invoice_id']
+        else:  # sqlite
+            invoice_id = cursor.lastrowid
         
         conn.commit()
         
         # Get the complete new order details
-        cursor.execute("SELECT * FROM erp_orders WHERE order_id = %s;", [new_order_id])
+        cursor.execute(f"SELECT * FROM erp_orders WHERE order_id = {param_placeholder};", [new_order_id])
         order = cursor.fetchone()
         
-        order_dict = dict(order)
+        order_dict = order
+        
+        # Format date for response
+        estimated_delivery = order_dict.get('estimated_delivery')
+        if estimated_delivery:
+            if isinstance(estimated_delivery, str):
+                estimated_delivery_str = estimated_delivery
+            else:
+                estimated_delivery_str = estimated_delivery.strftime("%Y-%m-%d") if hasattr(estimated_delivery, 'strftime') else str(estimated_delivery)
+        else:
+            estimated_delivery_str = None
         
         # Return JSON formatted response
         return {
@@ -330,7 +447,7 @@ async def place_new_order(
                 "invoice_id": invoice_id,
                 "total_amount": float(total_amount),
                 "status": order_dict['status'],
-                "estimated_delivery": order_dict['estimated_delivery'].strftime("%Y-%m-%d") if order_dict['estimated_delivery'] else None,
+                "estimated_delivery": estimated_delivery_str,
                 "customer_id": customer_id,
                 "shipping_address": shipping_address,
                 "shipping_country": shipping_country,
@@ -363,12 +480,18 @@ async def cancel_order(order_id: int, reason: str) -> Dict[str, Any]:
         dict: Result of the cancellation operation
     """
     try:
-        conn = get_db_connection()
-        cursor = conn.cursor(cursor_factory=RealDictCursor)
+        conn, db_type = get_db_connection()
+        
+        if db_type == "postgres":
+            cursor = conn.cursor(cursor_factory=RealDictCursor)
+            param_placeholder = "%s"
+        else:  # sqlite
+            cursor = conn.cursor()
+            param_placeholder = "?"
         
         # Check if order exists and can be cancelled
-        check_query = """
-        SELECT status, customer_id FROM erp_orders WHERE order_id = %s;
+        check_query = f"""
+        SELECT status, customer_id FROM erp_orders WHERE order_id = {param_placeholder};
         """
         cursor.execute(check_query, [order_id])
         order = cursor.fetchone()
@@ -386,43 +509,43 @@ async def cancel_order(order_id: int, reason: str) -> Dict[str, Any]:
             }
         
         # Get order items to restore stock
-        items_query = """
-        SELECT product_id, quantity FROM erp_order_items WHERE order_id = %s;
+        items_query = f"""
+        SELECT product_id, quantity FROM erp_order_items WHERE order_id = {param_placeholder};
         """
         cursor.execute(items_query, [order_id])
         items = cursor.fetchall()
         
         # Update order status to Cancelled
-        update_query = """
+        update_query = f"""
         UPDATE erp_orders SET status = 'Cancelled', payment_status = 'Cancelled'
-        WHERE order_id = %s;
+        WHERE order_id = {param_placeholder};
         """
         cursor.execute(update_query, [order_id])
         
         # Add entry to order history
-        history_query = """
+        history_query = f"""
         INSERT INTO erp_order_history (
             order_id, timestamp, status_change, notes, updated_by
         ) VALUES (
-            %s, CURRENT_TIMESTAMP, 'Cancelled', %s, 'System'
+            {param_placeholder}, CURRENT_TIMESTAMP, 'Cancelled', {param_placeholder}, 'System'
         );
         """
         cursor.execute(history_query, [order_id, f"Order cancelled: {reason}"])
         
         # Restore product stock quantities
         for item in items:
-            restore_stock_query = """
+            restore_stock_query = f"""
             UPDATE erp_products 
-            SET stock_quantity = stock_quantity + %s 
-            WHERE product_id = %s;
+            SET stock_quantity = stock_quantity + {param_placeholder} 
+            WHERE product_id = {param_placeholder};
             """
             cursor.execute(restore_stock_query, [item['quantity'], item['product_id']])
         
         # Update invoice if exists
-        invoice_query = """
+        invoice_query = f"""
         UPDATE erp_invoices 
-        SET is_paid = FALSE
-        WHERE order_id = %s;
+        SET is_paid = 0
+        WHERE order_id = {param_placeholder};
         """
         cursor.execute(invoice_query, [order_id])
         
@@ -465,27 +588,33 @@ async def get_invoice_details(invoice_id: Optional[int] = None, order_id: Option
         }
     
     try:
-        conn = get_db_connection()
-        cursor = conn.cursor(cursor_factory=RealDictCursor)
+        conn, db_type = get_db_connection()
+        
+        if db_type == "postgres":
+            cursor = conn.cursor(cursor_factory=RealDictCursor)
+            param_placeholder = "%s"
+        else:  # sqlite
+            cursor = conn.cursor()
+            param_placeholder = "?"
         
         if invoice_id:
-            query = """
+            query = f"""
             SELECT i.*, o.order_date, o.status as order_status, 
                    c.name as customer_name, c.email as customer_email, c.address as customer_address
             FROM erp_invoices i
             JOIN erp_orders o ON i.order_id = o.order_id
             JOIN erp_customers c ON o.customer_id = c.customer_id
-            WHERE i.invoice_id = %s;
+            WHERE i.invoice_id = {param_placeholder};
             """
             cursor.execute(query, [invoice_id])
         else:
-            query = """
+            query = f"""
             SELECT i.*, o.order_date, o.status as order_status, 
                    c.name as customer_name, c.email as customer_email, c.address as customer_address
             FROM erp_invoices i
             JOIN erp_orders o ON i.order_id = o.order_id
             JOIN erp_customers c ON o.customer_id = c.customer_id
-            WHERE i.order_id = %s;
+            WHERE i.order_id = {param_placeholder};
             """
             cursor.execute(query, [order_id])
         
@@ -498,17 +627,36 @@ async def get_invoice_details(invoice_id: Optional[int] = None, order_id: Option
             }
         
         # Get order items
-        items_query = """
+        items_query = f"""
         SELECT oi.*, p.product_name, p.sku
         FROM erp_order_items oi
         JOIN erp_products p ON oi.product_id = p.product_id
-        WHERE oi.order_id = %s;
+        WHERE oi.order_id = {param_placeholder};
         """
         cursor.execute(items_query, [invoice['order_id']])
         items = cursor.fetchall()
         
-        invoice_dict = dict(invoice)
-        items_list = [dict(item) for item in items]
+        invoice_dict = invoice
+        items_list = items
+        
+        # Format dates for response
+        order_date = invoice_dict.get('order_date')
+        if order_date:
+            if isinstance(order_date, str):
+                order_date_str = order_date
+            else:
+                order_date_str = order_date.strftime("%Y-%m-%d") if hasattr(order_date, 'strftime') else str(order_date)
+        else:
+            order_date_str = None
+            
+        due_date = invoice_dict.get('due_date')
+        if due_date:
+            if isinstance(due_date, str):
+                due_date_str = due_date
+            else:
+                due_date_str = due_date.strftime("%Y-%m-%d") if hasattr(due_date, 'strftime') else str(due_date)
+        else:
+            due_date_str = None
         
         # Return JSON formatted response
         return {
@@ -517,10 +665,10 @@ async def get_invoice_details(invoice_id: Optional[int] = None, order_id: Option
                 "invoice_id": invoice_dict['invoice_id'],
                 "invoice_number": invoice_dict.get('invoice_number', ''),
                 "order_id": invoice_dict['order_id'],
-                "order_date": invoice_dict['order_date'].strftime("%Y-%m-%d") if invoice_dict['order_date'] else None,
+                "order_date": order_date_str,
                 "order_status": invoice_dict['order_status'],
                 "amount": float(invoice_dict['amount']),
-                "due_date": invoice_dict['due_date'].strftime("%Y-%m-%d") if invoice_dict['due_date'] else None,
+                "due_date": due_date_str,
                 "payment_status": "Paid" if invoice_dict['is_paid'] else "Unpaid",
                 "customer": {
                     "name": invoice_dict['customer_name'],

core/mcp_tools/global_disruptions_server.py

@@ -1,29 +1,133 @@
 # global_disruptions_server.py
+
+import os
+import sys
+from typing import TypedDict, List, Union
+
+# Add the project root directory to the Python path
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '../..')))
+
 from typing import Dict, Any, List, Optional
-import psycopg2
-from psycopg2.extras import RealDictCursor
-from mcp.server.fastmcp import FastMCP
 import os
+import sys
+import pathlib
 from dotenv import load_dotenv
 from datetime import datetime, date
 
+# Import both database libraries
+import sqlite3
+try:
+    import psycopg2
+    from psycopg2.extras import RealDictCursor
+    POSTGRES_AVAILABLE = True
+except ImportError:
+    POSTGRES_AVAILABLE = False
+
+# Import SQLite initialization function
+from core.mcp_tools.erp_db_init import init_sqlite_db
+from mcp.server.fastmcp import FastMCP
+
 load_dotenv()
 
 mcp = FastMCP("Global Disruptions Database")
 
+# Helper function to convert SQLite row to dict
+def dict_factory(cursor, row):
+    d = {}
+    for idx, col in enumerate(cursor.description):
+        d[col[0]] = row[idx]
+    return d
+
+# Helper function to handle date serialization for JSON
+def serialize_dates(obj):
+    if isinstance(obj, (date, datetime)):
+        return obj.isoformat()
+    return obj
+
 def get_db_connection():
-    """Get database connection using environment variables."""
+    """Get database connection based on configuration."""
+    # Default to SQLite unless explicitly set to use PostgreSQL
+    db_type = os.getenv("DISRUPTIONS_DB_TYPE", "sqlite").lower()
+    
+    if db_type == "postgres" and POSTGRES_AVAILABLE:
+        try:
+            conn = psycopg2.connect(
+                host=os.getenv("POSTGRES_HOST", "localhost"),
+                database=os.getenv("POSTGRES_DB", "erp_db"),
+                user=os.getenv("POSTGRES_USER", "postgres"),
+                password=os.getenv("POSTGRES_PASSWORD", ""),
+                port=os.getenv("POSTGRES_PORT", "5432")
+            )
+            return conn, "postgres"
+        except Exception as e:
+            raise Exception(f"PostgreSQL connection failed: {str(e)}")
+    else:
+        try:
+            # Get SQLite database path from environment or use default
+            db_path = os.getenv("SQLITE_DB_PATH", "./data/erp_db.sqlite")
+            
+            # Ensure database is initialized
+            db_dir = pathlib.Path(os.path.dirname(db_path))
+            if not db_dir.exists() or not pathlib.Path(db_path).exists():
+                init_sqlite_db(db_path)
+            
+            conn = sqlite3.connect(db_path)
+            conn.row_factory = dict_factory
+            
+            # Enable foreign keys
+            conn.execute("PRAGMA foreign_keys = ON")
+            
+            return conn, "sqlite"
+        except Exception as e:
+            raise Exception(f"SQLite connection failed: {str(e)}")
+        
+@mcp.tool()
+async def execute_query(query: str, params: Optional[List] = None) -> Dict[str, Any]:
+    """
+    Execute a custom SQL query on the Global Disruptions database.
+    
+    Args:
+        query (str): SQL query to execute
+        params (List, optional): Parameters for parameterized queries
+    
+    Returns:
+        dict: Query results or error message
+    """
     try:
-        conn = psycopg2.connect(
-            host=os.getenv("POSTGRES_HOST", "localhost"),
-            database=os.getenv("POSTGRES_DB", "erp_db"),
-            user=os.getenv("POSTGRES_USER", "postgres"),
-            password=os.getenv("POSTGRES_PASSWORD", ""),
-            port=os.getenv("POSTGRES_PORT", "5432")
-        )
-        return conn
+        conn, db_type = get_db_connection()
+        
+        if db_type == "postgres":
+            cursor = conn.cursor(cursor_factory=RealDictCursor)
+        else:  # sqlite
+            cursor = conn.cursor()
+        
+        if params:
+            cursor.execute(query, params)
+        else:
+            cursor.execute(query)
+        
+        # Check if it's a SELECT query
+        if query.strip().upper().startswith('SELECT'):
+            results = cursor.fetchall()
+            # Convert results to regular dict for JSON serialization
+            if db_type == "postgres":
+                results = [dict(row) for row in results]
+            if not results:
+                return "No results found"
+            return results
+        else:
+            # For INSERT, UPDATE, DELETE queries
+            conn.commit()
+            return f"Query executed successfully. {cursor.rowcount} rows affected."
+            
     except Exception as e:
-        raise Exception(f"Database connection failed: {str(e)}")
+        return {
+            "success": False,
+            "error": str(e)
+        }
+    finally:
+        if 'conn' in locals():
+            conn.close()
 
 @mcp.tool()
 async def get_active_disruptions(source_country: Optional[str] = None, destination_country: Optional[str] = None) -> Dict[str, Any]:
@@ -38,11 +142,19 @@ async def get_active_disruptions(source_country: Optional[str] = None, destinati
         dict: Information about current disruptions that might affect shipping
     """
     try:
-        conn = get_db_connection()
-        cursor = conn.cursor(cursor_factory=RealDictCursor)
+        conn, db_type = get_db_connection()
+        
+        if db_type == "postgres":
+            cursor = conn.cursor(cursor_factory=RealDictCursor)
+            param_placeholder = "%s"
+            true_value = "TRUE"
+        else:  # sqlite
+            cursor = conn.cursor()
+            param_placeholder = "?"
+            true_value = "1"
         
         # Base query to get disruptions
-        query = """
+        query = f"""
         SELECT 
             disruption_id,
             source_country,
@@ -60,29 +172,29 @@ async def get_active_disruptions(source_country: Optional[str] = None, destinati
         FROM 
             live_global_disruptions
         WHERE 
-            is_active = TRUE
+            is_active = {true_value}
         """
         
         params = []
         
         # Add filters for specific countries if provided
         if source_country and destination_country:
-            query += """
+            query += f"""
             AND (
-                (source_country = %s AND destination_country = %s) OR
-                (source_country = %s) OR
-                (destination_country = %s)
+                (source_country = {param_placeholder} AND destination_country = {param_placeholder}) OR
+                (source_country = {param_placeholder}) OR
+                (destination_country = {param_placeholder})
             )
             """
             params.extend([source_country, destination_country, source_country, destination_country])
         elif source_country:
-            query += """
-            AND (source_country = %s)
+            query += f"""
+            AND (source_country = {param_placeholder})
             """
             params.append(source_country)
         elif destination_country:
-            query += """
-            AND (destination_country = %s)
+            query += f"""
+            AND (destination_country = {param_placeholder})
             """
             params.append(destination_country)
         
@@ -92,8 +204,6 @@ async def get_active_disruptions(source_country: Optional[str] = None, destinati
             severity DESC,
             updated_at DESC;
         """
-
-        print(query, params)  # Debugging line to see the query and parameters
         
         cursor.execute(query, params)
         disruptions = cursor.fetchall()
@@ -126,7 +236,7 @@ async def get_active_disruptions(source_country: Optional[str] = None, destinati
         # Format the response
         formatted_disruptions = []
         for disruption in disruptions:
-            d = dict(disruption)
+            d = disruption if db_type == "sqlite" else dict(disruption)
             
             # Format severity level as text
             severity = d['severity']

core/mcp_tools/populate_erp_db.py

@@ -0,0 +1,415 @@
+# populate_erp_db.py
+import sqlite3
+import os
+import pathlib
+import datetime
+import random
+from erp_db_init import init_sqlite_db
+
+def populate_erp_db(db_path='./data/erp_db.sqlite'):
+    """Populate SQLite database with sample ERP data."""
+    try:
+        # Ensure database exists
+        if not os.path.exists(db_path):
+            init_sqlite_db(db_path)
+        
+        # Connect to SQLite database
+        conn = sqlite3.connect(db_path)
+        cursor = conn.cursor()
+        
+        # Sample data for customers
+        customers = [
+            ('John Doe', 'john.doe@example.com', '555-123-4567', '123 Main St, Anytown, USA'),
+            ('Jane Smith', 'jane.smith@example.com', '555-234-5678', '456 Oak Ave, Somewhere, USA'),
+            ('Robert Johnson', 'robert.j@example.com', '555-345-6789', '789 Pine Rd, Nowhere, USA'),
+            ('Emily Davis', 'emily.davis@example.com', '555-456-7890', '101 Maple Dr, Anywhere, USA'),
+            ('Michael Wilson', 'michael.w@example.com', '555-567-8901', '202 Cedar Ln, Everywhere, USA'),
+            ('Sarah Brown', 'sarah.b@example.com', '555-678-9012', '303 Birch Blvd, Somewhere, USA'),
+            ('David Miller', 'david.m@example.com', '555-789-0123', '404 Elm St, Anytown, USA'),
+            ('Jennifer Taylor', 'jennifer.t@example.com', '555-890-1234', '505 Walnut Ave, Nowhere, USA'),
+            ('Christopher Anderson', 'chris.a@example.com', '555-901-2345', '606 Spruce Rd, Anywhere, USA'),
+            ('Lisa Thomas', 'lisa.t@example.com', '555-012-3456', '707 Fir Dr, Everywhere, USA'),
+            ('Daniel Jackson', 'daniel.j@example.com', '555-123-7890', '808 Pine St, Somewhere, USA'),
+            ('Michelle White', 'michelle.w@example.com', '555-234-8901', '909 Oak Rd, Anytown, USA')
+        ]
+        
+        # Sample data for products
+        products = [
+            ('Laptop Pro', 'High-performance laptop for professionals', 'Electronics', 1299.99, 50, 'LP-001'),
+            ('Smartphone X', 'Latest smartphone with advanced features', 'Electronics', 899.99, 100, 'SP-001'),
+            ('Office Chair', 'Ergonomic office chair', 'Furniture', 199.99, 30, 'OC-001'),
+            ('Desk Lamp', 'LED desk lamp with adjustable brightness', 'Home', 49.99, 75, 'DL-001'),
+            ('Coffee Maker', 'Programmable coffee maker', 'Appliances', 89.99, 40, 'CM-001'),
+            ('Wireless Headphones', 'Noise-cancelling wireless headphones', 'Electronics', 149.99, 60, 'WH-001'),
+            ('Tablet Mini', 'Compact tablet for on-the-go use', 'Electronics', 399.99, 45, 'TM-001'),
+            ('External Hard Drive', '2TB external hard drive', 'Electronics', 129.99, 55, 'EH-001'),
+            ('Wireless Mouse', 'Ergonomic wireless mouse', 'Electronics', 29.99, 80, 'WM-001'),
+            ('Bluetooth Speaker', 'Portable Bluetooth speaker', 'Electronics', 79.99, 65, 'BS-001'),
+            ('Monitor 27"', '27-inch 4K monitor', 'Electronics', 349.99, 35, 'MN-001'),
+            ('Keyboard', 'Mechanical gaming keyboard', 'Electronics', 119.99, 70, 'KB-001'),
+            ('Desk', 'Adjustable standing desk', 'Furniture', 299.99, 25, 'DK-001'),
+            ('Bookshelf', 'Modern 5-tier bookshelf', 'Furniture', 149.99, 20, 'BS-002')
+        ]
+        
+        # Insert customers
+        cursor.executemany('''
+        INSERT INTO erp_customers (name, email, phone, address)
+        VALUES (?, ?, ?, ?)
+        ''', customers)
+        
+        # Insert products
+        cursor.executemany('''
+        INSERT INTO erp_products (product_name, description, category, price, stock_quantity, sku)
+        VALUES (?, ?, ?, ?, ?, ?)
+        ''', products)
+        
+        # Get customer IDs for reference
+        cursor.execute('SELECT customer_id FROM erp_customers')
+        customer_ids = [row[0] for row in cursor.fetchall()]
+        
+        # Get product IDs for reference
+        cursor.execute('SELECT product_id, price FROM erp_products')
+        product_data = cursor.fetchall()
+        product_ids = [row[0] for row in product_data]
+        product_prices = {row[0]: row[1] for row in product_data}
+        
+        # Sample data for orders
+        orders = []
+        order_items = []
+        invoices = []
+        order_history = []
+        
+        # Generate 15 orders
+        for i in range(1, 16):
+            # Randomly select a customer
+            customer_id = random.choice(customer_ids)
+            
+            # Get customer address for shipping
+            cursor.execute('SELECT address FROM erp_customers WHERE customer_id = ?', (customer_id,))
+            address = cursor.fetchone()[0]
+            
+            # Generate order date (within the last 60 days)
+            days_ago = random.randint(1, 60)
+            order_date = (datetime.datetime.now() - datetime.timedelta(days=days_ago)).strftime('%Y-%m-%d')
+            
+            # Generate estimated delivery (3-10 days after order)
+            est_delivery = (datetime.datetime.now() - datetime.timedelta(days=days_ago) + 
+                           datetime.timedelta(days=random.randint(3, 10))).strftime('%Y-%m-%d')
+            
+            # Determine if order has been delivered
+            delivered = random.random() > 0.3  # 70% chance of being delivered
+            actual_delivery = None
+            if delivered:
+                # Delivery occurred 0-2 days after estimated delivery
+                delivery_offset = random.randint(-1, 2)  # Can be early or late
+                actual_delivery = (datetime.datetime.now() - datetime.timedelta(days=days_ago) + 
+                                  datetime.timedelta(days=random.randint(3, 10) + delivery_offset)).strftime('%Y-%m-%d')
+            
+            # Determine order status
+            if days_ago <= 1:
+                status = 'Processing'
+            elif days_ago <= 3:
+                status = 'Shipped'
+            elif delivered:
+                status = 'Delivered'
+            else:
+                status = random.choice(['Processing', 'Shipped', 'In Transit'])
+            
+            # Determine payment status
+            payment_status = random.choice(['Paid', 'Pending', 'Paid', 'Paid'])  # 75% chance of being paid
+            
+            # Generate shipping and destination countries
+            shipping_country = random.choice([
+                'USA', 'Canada', 'UK', 'Germany', 'France', 'Australia', 
+                'China', 'Japan', 'India', 'Brazil', 'Mexico', 'South Africa',
+                'Italy', 'Spain', 'Russia', 'South Korea', 'Singapore', 'UAE',
+                'Netherlands', 'Sweden'
+            ])
+            destination_country = shipping_country  # Usually the same
+            
+            # Previous order (for some customers)
+            previous_order_id = None
+            if i > 5 and random.random() > 0.7:  # 30% chance of having a previous order
+                previous_order_id = random.randint(1, i-1)
+            
+            # Add to orders list
+            orders.append((
+                customer_id, order_date, 0,  # Total amount will be updated later
+                status, previous_order_id, est_delivery, actual_delivery,
+                payment_status, address, shipping_country, destination_country
+            ))
+        
+        # Insert orders
+        cursor.executemany('''
+        INSERT INTO erp_orders (
+            customer_id, order_date, total_amount, status, previous_order_id,
+            estimated_delivery, actual_delivery, payment_status, shipping_address,
+            shipping_country, destination_country
+        )
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ''', orders)
+        
+        # Get order IDs
+        cursor.execute('SELECT order_id FROM erp_orders')
+        order_ids = [row[0] for row in cursor.fetchall()]
+        
+        # Generate order items for each order
+        for order_id in order_ids:
+            # Each order has 1-5 items
+            num_items = random.randint(1, 5)
+            order_total = 0
+            
+            # Select random products for this order
+            selected_products = random.sample(product_ids, num_items)
+            
+            for product_id in selected_products:
+                quantity = random.randint(1, 3)
+                unit_price = product_prices[product_id]
+                subtotal = quantity * unit_price
+                order_total += subtotal
+                
+                # Add to order items list
+                order_items.append((order_id, product_id, quantity, unit_price, subtotal))
+            
+            # Update order total
+            cursor.execute('UPDATE erp_orders SET total_amount = ? WHERE order_id = ?', (order_total, order_id))
+            
+            # Generate invoice for paid orders
+            cursor.execute('SELECT payment_status FROM erp_orders WHERE order_id = ?', (order_id,))
+            payment_status = cursor.fetchone()[0]
+            
+            if payment_status == 'Paid':
+                invoice_date = (datetime.datetime.now() - datetime.timedelta(days=random.randint(1, 30))).strftime('%Y-%m-%d')
+                due_date = (datetime.datetime.now() - datetime.timedelta(days=random.randint(1, 15))).strftime('%Y-%m-%d')
+                invoice_number = f'INV-{order_id}-{random.randint(1000, 9999)}'
+                
+                invoices.append((order_id, invoice_date, order_total, 'Net 30', due_date, 1, invoice_number))
+            
+            # Generate order history entries
+            # Initial status
+            order_history.append((
+                order_id, 
+                (datetime.datetime.now() - datetime.timedelta(days=random.randint(50, 60))).strftime('%Y-%m-%d %H:%M:%S'),
+                'Order Created',
+                'New order placed',
+                'System'
+            ))
+            
+            # Processing status
+            order_history.append((
+                order_id, 
+                (datetime.datetime.now() - datetime.timedelta(days=random.randint(40, 49))).strftime('%Y-%m-%d %H:%M:%S'),
+                'Processing',
+                'Order is being processed',
+                'System'
+            ))
+            
+            # Additional statuses based on current order status
+            cursor.execute('SELECT status FROM erp_orders WHERE order_id = ?', (order_id,))
+            current_status = cursor.fetchone()[0]
+            
+            if current_status in ['Shipped', 'In Transit', 'Delivered']:
+                order_history.append((
+                    order_id, 
+                    (datetime.datetime.now() - datetime.timedelta(days=random.randint(30, 39))).strftime('%Y-%m-%d %H:%M:%S'),
+                    'Shipped',
+                    'Order has been shipped',
+                    'Shipping Dept'
+                ))
+            
+            if current_status in ['In Transit', 'Delivered']:
+                order_history.append((
+                    order_id, 
+                    (datetime.datetime.now() - datetime.timedelta(days=random.randint(20, 29))).strftime('%Y-%m-%d %H:%M:%S'),
+                    'In Transit',
+                    'Order is in transit',
+                    'Shipping Carrier'
+                ))
+            
+            if current_status == 'Delivered':
+                order_history.append((
+                    order_id, 
+                    (datetime.datetime.now() - datetime.timedelta(days=random.randint(1, 19))).strftime('%Y-%m-%d %H:%M:%S'),
+                    'Delivered',
+                    'Order has been delivered',
+                    'Shipping Carrier'
+                ))
+        
+        # Insert order items
+        cursor.executemany('''
+        INSERT INTO erp_order_items (order_id, product_id, quantity, unit_price, subtotal)
+        VALUES (?, ?, ?, ?, ?)
+        ''', order_items)
+        
+        # Insert invoices
+        cursor.executemany('''
+        INSERT INTO erp_invoices (order_id, invoice_date, amount, payment_terms, due_date, is_paid, invoice_number)
+        VALUES (?, ?, ?, ?, ?, ?, ?)
+        ''', invoices)
+        
+        # Insert order history
+        cursor.executemany('''
+        INSERT INTO erp_order_history (order_id, timestamp, status_change, notes, updated_by)
+        VALUES (?, ?, ?, ?, ?)
+        ''', order_history)
+        
+        # Sample data for global disruptions
+        disruption_types = [
+            'Natural Disaster', 'Political Unrest', 'Labor Strike', 
+            'Transportation Issue', 'Customs Delay', 'Weather Event',
+            'Port Congestion', 'Regulatory Change', 'Supply Shortage',
+            'Infrastructure Failure', 'Security Threat', 'Health Crisis'
+        ]
+        
+        countries = [
+            'USA', 'Canada', 'UK', 'Germany', 'France', 'Australia', 
+            'China', 'Japan', 'India', 'Brazil', 'Mexico', 'South Africa',
+            'Italy', 'Spain', 'Russia', 'South Korea', 'Singapore', 'UAE',
+            'Netherlands', 'Sweden'
+        ]
+        
+        global_disruptions = []
+        
+        # Generate 15 global disruptions
+        for i in range(1, 16):
+            # Select random countries for source and destination
+            source_country = random.choice(countries)
+            # Ensure destination is different from source
+            destination_options = [c for c in countries if c != source_country]
+            destination_country = random.choice(destination_options)
+            
+            # Select random disruption type
+            disruption_type = random.choice(disruption_types)
+            
+            # Generate severity (1-5)
+            severity = random.randint(1, 5)
+            
+            # Generate start date (within the last 90 days)
+            days_ago = random.randint(1, 90)
+            start_date = (datetime.datetime.now() - datetime.timedelta(days=days_ago)).strftime('%Y-%m-%d')
+            
+            # Generate expected end date (1-30 days after start)
+            expected_days_duration = random.randint(1, 30)
+            expected_end_date = (datetime.datetime.now() - datetime.timedelta(days=days_ago) + 
+                               datetime.timedelta(days=expected_days_duration)).strftime('%Y-%m-%d')
+            
+            # Determine if disruption has ended
+            is_ended = random.random() > 0.6  # 40% chance of being ended
+            actual_end_date = None
+            if is_ended:
+                # Actual end occurred 0-5 days after/before expected end
+                end_offset = random.randint(-5, 5)
+                actual_end_date = (datetime.datetime.now() - datetime.timedelta(days=days_ago) + 
+                                  datetime.timedelta(days=expected_days_duration + end_offset)).strftime('%Y-%m-%d')
+            
+            # Determine if disruption is active
+            is_active = not is_ended
+            
+            # Generate impact hours based on severity
+            impact_hours = severity * random.randint(10, 48)
+            
+            # Generate description
+            descriptions = {
+                'Natural Disaster': [
+                    f"Severe flooding in {source_country} affecting shipments to {destination_country}",
+                    f"Earthquake in {source_country} disrupting supply chain to {destination_country}",
+                    f"Hurricane impacting shipping routes between {source_country} and {destination_country}"
+                ],
+                'Political Unrest': [
+                    f"Protests in {source_country} affecting exports to {destination_country}",
+                    f"Trade dispute between {source_country} and {destination_country}",
+                    f"Political tensions causing delays in shipments from {source_country} to {destination_country}"
+                ],
+                'Labor Strike': [
+                    f"Port workers strike in {source_country} affecting shipments to {destination_country}",
+                    f"Transportation union strike impacting deliveries between {source_country} and {destination_country}",
+                    f"Warehouse workers strike in {source_country} delaying orders to {destination_country}"
+                ],
+                'Transportation Issue': [
+                    f"Major highway closure between {source_country} and {destination_country}",
+                    f"Shipping container shortage affecting routes from {source_country} to {destination_country}",
+                    f"Fuel shortage in {source_country} impacting deliveries to {destination_country}"
+                ],
+                'Customs Delay': [
+                    f"New customs regulations in {destination_country} causing delays from {source_country}",
+                    f"Increased inspection rates at {destination_country} border for goods from {source_country}",
+                    f"Documentation issues for shipments from {source_country} to {destination_country}"
+                ],
+                'Weather Event': [
+                    f"Severe snowstorm in {source_country} delaying shipments to {destination_country}",
+                    f"Fog at major ports in {source_country} affecting vessels bound for {destination_country}",
+                    f"Extreme heat causing transportation issues between {source_country} and {destination_country}"
+                ],
+                'Port Congestion': [
+                    f"Backlog at {source_country} ports affecting shipments to {destination_country}",
+                    f"Vessel scheduling issues at {source_country} ports for routes to {destination_country}",
+                    f"Limited berthing capacity at {destination_country} ports for vessels from {source_country}"
+                ],
+                'Regulatory Change': [
+                    f"New import regulations in {destination_country} affecting goods from {source_country}",
+                    f"Export restrictions in {source_country} for shipments to {destination_country}",
+                    f"Changed documentation requirements between {source_country} and {destination_country}"
+                ],
+                'Supply Shortage': [
+                    f"Raw material shortage in {source_country} affecting production for {destination_country}",
+                    f"Component shortage impacting products shipped from {source_country} to {destination_country}",
+                    f"Limited availability of goods in {source_country} for export to {destination_country}"
+                ],
+                'Infrastructure Failure': [
+                    f"Bridge collapse on major route between {source_country} and {destination_country}",
+                    f"Power outage in {source_country} affecting production for {destination_country}",
+                    f"IT system failure impacting customs processing between {source_country} and {destination_country}"
+                ],
+                'Security Threat': [
+                    f"Increased piracy risk on shipping routes from {source_country} to {destination_country}",
+                    f"Security concerns at {source_country} borders affecting shipments to {destination_country}",
+                    f"Cybersecurity incident affecting logistics between {source_country} and {destination_country}"
+                ],
+                'Health Crisis': [
+                    f"Disease outbreak in {source_country} affecting workforce for exports to {destination_country}",
+                    f"Quarantine requirements delaying shipments from {source_country} to {destination_country}",
+                    f"Health screening causing delays at {destination_country} border for goods from {source_country}"
+                ]
+            }
+            
+            description = random.choice(descriptions.get(disruption_type, [f"{disruption_type} affecting shipments from {source_country} to {destination_country}"]))
+            
+            # Add to global disruptions list
+            global_disruptions.append((
+                source_country, destination_country, disruption_type, severity,
+                start_date, expected_end_date, actual_end_date, is_active,
+                description, impact_hours
+            ))
+        
+        # Insert global disruptions
+        cursor.executemany('''
+        INSERT INTO live_global_disruptions (
+            source_country, destination_country, disruption_type, severity,
+            start_date, expected_end_date, actual_end_date, is_active,
+            description, impact_hours
+        )
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ''', global_disruptions)
+        
+        # Commit changes and close connection
+        conn.commit()
+        conn.close()
+        
+        print(f"Successfully populated ERP database with sample data.")
+        
+        # Print summary of inserted data
+        print(f"Inserted {len(customers)} customers")
+        print(f"Inserted {len(products)} products")
+        print(f"Inserted {len(orders)} orders")
+        print(f"Inserted {len(order_items)} order items")
+        print(f"Inserted {len(invoices)} invoices")
+        print(f"Inserted {len(order_history)} order history entries")
+        print(f"Inserted {len(global_disruptions)} global disruptions")
+        
+        return True
+    except Exception as e:
+        print(f"Error populating SQLite database: {str(e)}")
+        return False
+
+if __name__ == "__main__":
+    populate_erp_db()

core/mcp_tools/reset_erp_db.py

@@ -0,0 +1,47 @@
+# reset_erp_db.py
+import os
+import pathlib
+from erp_db_init import init_sqlite_db
+from populate_erp_db import populate_erp_db
+
+def reset_erp_db(db_path='./data/erp_db.sqlite'):
+    """Reset the ERP database by deleting it and recreating it with fresh data."""
+    try:
+        print(f"Resetting ERP database at {db_path}...")
+        
+        # Check if database file exists
+        if os.path.exists(db_path):
+            print(f"Removing existing database file...")
+            os.remove(db_path)
+            print(f"Database file removed.")
+        else:
+            print(f"No existing database file found.")
+        
+        # Create database directory if it doesn't exist
+        db_dir = pathlib.Path(os.path.dirname(db_path))
+        db_dir.mkdir(exist_ok=True)
+        
+        # Initialize the database
+        print(f"Initializing new database...")
+        init_result = init_sqlite_db(db_path)
+        if not init_result:
+            print(f"Failed to initialize database.")
+            return False
+        print(f"Database initialized successfully.")
+        
+        # Populate the database with sample data
+        print(f"Populating database with sample data...")
+        populate_result = populate_erp_db(db_path)
+        if not populate_result:
+            print(f"Failed to populate database.")
+            return False
+        print(f"Database populated successfully.")
+        
+        print(f"Database reset complete.")
+        return True
+    except Exception as e:
+        print(f"Error resetting database: {str(e)}")
+        return False
+
+if __name__ == "__main__":
+    reset_erp_db()