Adding the application.

.dummyenv

@@ -0,0 +1,12 @@
+# OpenAI API Key
+OPENAI_API_KEY=""
+
+# Weather API Key
+WEATHER_API_KEY = ""
+
+# PostgreSQL Database Configuration
+POSTGRES_HOST = ""
+POSTGRES_DB = ""
+POSTGRES_USER = ""
+POSTGRES_PASSWORD = ""
+POSTGRES_PORT = "5432"

.gitignore

@@ -0,0 +1,199 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Abstra
+# Abstra is an AI-powered process automation framework.
+# Ignore directories containing user credentials, local state, and settings.
+# Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#  Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#  that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#  and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#  you could uncomment the following to ignore the enitre vscode folder
+# .vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Cursor
+#  Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to
+#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
+#  refer to https://docs.cursor.com/context/ignore-files
+.cursorignore
+.cursorindexingignore
+.env
+.vscode
+
+data
+notebooks

README.md

@@ -12,3 +12,29 @@ short_description: Helps you keep track of your shipments.
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+
+agent-demo-track
+
+
+## Introduction
+
+TrackMate AI is an intelligent shipment tracking system that leverages artificial intelligence to provide real-time updates and insights about your packages. With TrackMate AI, you can:
+
+- Monitor all your shipments in one place
+- Receive smart predictions about delivery times
+- Analyze delivery patterns and performance
+- Access historical tracking data for reference
+
+## Usage
+
+1. Update the .env with required keys. Look at .dummyenv
+
+2. Create a dummy postgres db. Look at dummydb.md
+
+3. Run the app.py and type away.
+
+## How everything works
+
+The gradio app works on the SkeletonGraphAgent as the backend.
+The SkeletonGraphAgent dynamically creates a graph based on the user inputs.

app.py

@@ -1,658 +1,162 @@
 import gradio as gr
-import psycopg2
-from psycopg2.extras import RealDictCursor
-import os
-from dotenv import load_dotenv
-from typing import Dict, Any, List, Optional
-
-load_dotenv()
-
-def get_db_connection():
-    """Get database connection using environment variables."""
+import asyncio
+import json
+import time
+import io
+from typing import List
+from langchain_core.messages import AIMessage, HumanMessage, ToolMessage
+from core.agents.SkeletonGraphAgent import SkeletonGraphAgent
+from core.config.prompt import get_default_system_prompt
+from core.config.metadata import create_metadata
+
+# ----- State -----
+conversation_history = []
+
+# ----- Agent Initialization -----
+async def initialize_agent_async(metadata):
     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
+        new_agent = await SkeletonGraphAgent.create(metadata)
+        return new_agent, None
     except Exception as e:
-        raise Exception(f"Database connection failed: {str(e)}")
+        return None, str(e)
 
-def execute_query(query: str, params: str = None):
-    """
-    Execute a custom SQL query on the ERP database.
+def initialize_agent_handler(model_name, temperature, max_tokens, system_prompt, api_key):
+    metadata = create_metadata(model_name, temperature, max_tokens, system_prompt, api_key)
     
-    Args:
-        query: SQL query to execute
-        params: Parameters for parameterized queries (as a comma-separated string)
-    
-    Returns:
-        Query results or error message
-    """
+    # Use the existing event loop if available, otherwise create a new one
     try:
-        conn = get_db_connection()
-        cursor = conn.cursor(cursor_factory=RealDictCursor)
-        
-        # Convert string params to list if provided
-        param_list = None
-        if params and params.strip():
-            param_list = [p.strip() for p in params.split(',')]
+        loop = asyncio.get_event_loop()
+    except RuntimeError:
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
         
-        if param_list:
-            cursor.execute(query, param_list)
-        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 = [dict(row) for row in results]
-            if not results:
-                return str({
-                    "success": True,
-                    "message": "No results found",
-                    "results": []
-                })
-            return str({
-                "success": True,
-                "message": f"Query returned {len(results)} results",
-                "count": len(results),
-                "results": results
-            })
-        else:
-            # For INSERT, UPDATE, DELETE queries
-            conn.commit()
-            return str({
-                "success": True,
-                "message": f"Query executed successfully",
-                "rows_affected": cursor.rowcount
-            })
-            
-    except Exception as e:
-        return str({
-            "success": False,
-            "error": str(e)
-        })
-    finally:
-        if 'conn' in locals():
-            conn.close()
+    agent, error = loop.run_until_complete(initialize_agent_async(metadata))
+    if agent:
+        return agent, "✅ Agent initialized successfully!", "🟢 Agent Ready"
+    else:
+        return None, f"❌ Failed to initialize agent: {error}", "🔴 Agent Failed"
 
-def list_erp_tables():
-    """
-    List all ERP tables in the database.
-    
-    Returns:
-        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()
-        
-        table_names = [row['table_name'] for row in results]
-        if not table_names:
-            return str({
-                "success": False,
-                "message": "No ERP tables found",
-                "tables": []
-            })
-        return str({
-            "success": True,
-            "message": f"Found {len(table_names)} tables",
-            "count": len(table_names),
-            "tables": table_names
-        })
-        
-    except Exception as e:
-        return str({
-            "success": False,
-            "error": str(e)
-        })
-    finally:
-        if 'conn' in locals():
-            conn.close()
+# ----- Chat Handler -----
+async def get_agent_response_async(agent, user_input):
+    global conversation_history
+    human_msg = HumanMessage(content=user_input)
+    conversation_history.append(human_msg)
 
-def get_order_status(order_id: int):
-    """
-    Get the status of an order by order ID.
-    
-    Args:
-        order_id: The ID of the order to check
-    
-    Returns:
-        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)
-        cursor.execute(query, [order_id])
-        order = cursor.fetchone()
-        
-        if not order:
-            return str({
-                "success": False,
-                "message": f"Order with ID {order_id} not found"
-            })
-        
-        # Get order items
-        items_query = """
-        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;
-        """
-        cursor.execute(items_query, [order_id])
-        items = cursor.fetchall()
-        
-        # Get order history
-        history_query = """
-        SELECT * FROM erp_order_history
-        WHERE order_id = %s
-        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]
-        
-        # Return JSON formatted response
-        return str({
-            "success": True,
-            "order": {
-                "order_id": order_id,
-                "customer": {
-                    "customer_id": order_dict['customer_id'],
-                    "name": order_dict['customer_name'],
-                    "email": order_dict['customer_email']
-                },
-                "status": order_dict['status'],
-                "shipping_address": order_dict.get('shipping_address', 'N/A'),
-                "shipping_country": order_dict.get('shipping_country', 'N/A'),
-                "destination_country": order_dict.get('destination_country', 'N/A'),
-                "items": items_list,
-                "history": history_list
-            }
-        })
-        
-    except Exception as e:
-        return str({
-            "success": False,
-            "error": str(e)
-        })
-    finally:
-        if 'conn' in locals():
-            conn.close()
+    input_message = {"messages": conversation_history.copy()}
 
-def place_new_order(
-    customer_id: int,
-    product_ids: str,
-    quantities: str,
-    shipping_address: str,
-    shipping_country: str,
-    destination_country: str,
-    previous_order_id: int = None
-):
-    """
-    Place a new order in the ERP system.
-    
-    Args:
-        customer_id: ID of the customer placing the order
-        product_ids: Comma-separated list of product IDs
-        quantities: Comma-separated list of quantities corresponding to product IDs
-        shipping_address: Shipping address for the order
-        shipping_country: Country where the order will be shipped from
-        destination_country: Country where the order will be delivered to
-        previous_order_id: ID of a previous order this is replacing (optional)
-    
-    Returns:
-        New order information
-    """
     try:
-        # Parse product IDs and quantities
-        product_id_list = [int(pid.strip()) for pid in product_ids.split(',')]
-        quantity_list = [int(qty.strip()) for qty in quantities.split(',')]
-        
-        if len(product_id_list) != len(quantity_list):
-            return str({
-                "success": False,
-                "error": "Number of product IDs must match number of quantities"
-            })
-        
-        # Create items list
-        items = [
-            {"product_id": pid, "quantity": qty} 
-            for pid, qty in zip(product_id_list, quantity_list)
-        ]
-        
-        conn = get_db_connection()
-        cursor = conn.cursor(cursor_factory=RealDictCursor)
-        
-        # 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;"
-            cursor.execute(product_query, [item['product_id']])
-            product = cursor.fetchone()
-            if not product:
-                return str({
-                    "success": False,
-                    "error": f"Product with ID {item['product_id']} not found"
-                })
-            total_amount += product['price'] * item['quantity']
-        
-        # Insert new order into the erp_orders table for the customer
-        order_query = """
-        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;
-        """
-        cursor.execute(order_query, [
-            customer_id, total_amount, shipping_address, shipping_country, destination_country, previous_order_id
-        ])
-        new_order_id = cursor.fetchone()['order_id']
-        
-        # Insert order items into erp_order_items table for the new order
-        for item in items:
-            # Get product price
-            cursor.execute(product_query, [item['product_id']])
-            product = cursor.fetchone()
-            unit_price = product['price']
-            subtotal = unit_price * item['quantity']
-            
-            item_query = """
-            INSERT INTO erp_order_items (
-                order_id, product_id, quantity, unit_price, subtotal
-            ) VALUES (
-                %s, %s, %s, %s, %s
-            );
-            """
-            cursor.execute(item_query, [
-                new_order_id, item['product_id'], item['quantity'], 
-                unit_price, subtotal
-            ])
-            
-            # Update product stock
-            update_stock_query = """
-            UPDATE erp_products 
-            SET stock_quantity = stock_quantity - %s 
-            WHERE product_id = %s;
-            """
-            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 = """
-        INSERT INTO erp_order_history (
-            order_id, timestamp, status_change, notes, updated_by
-        ) VALUES (
-            %s, 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 = """
-            INSERT INTO erp_order_history (
-                order_id, timestamp, status_change, notes, updated_by
-            ) VALUES (
-                %s, CURRENT_TIMESTAMP, 'Replaced', 'Order replaced by order #%s', 'System'
-            );
-            """
-            cursor.execute(prev_order_note_query, [previous_order_id, new_order_id])
-        
-        # Generate invoice for the new order
-        invoice_query = """
-        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;
-        """
-        cursor.execute(invoice_query, [new_order_id, total_amount, new_order_id])
-        invoice_id = cursor.fetchone()['invoice_id']
-        
-        conn.commit()
-        
-        # Get the complete new order details
-        cursor.execute("SELECT * FROM erp_orders WHERE order_id = %s;", [new_order_id])
-        order = cursor.fetchone()
-        
-        order_dict = dict(order)
-        
-        # Return JSON formatted response
-        return str({
-            "success": True,
-            "order": {
-                "order_id": new_order_id,
-                "invoice_id": invoice_id,
-                "total_amount": float(total_amount),
-                "status": order_dict['status'],
-                "estimated_delivery": str(order_dict['estimated_delivery']) if order_dict['estimated_delivery'] else None,
-                "customer_id": customer_id,
-                "shipping_address": shipping_address,
-                "shipping_country": shipping_country,
-                "destination_country": destination_country,
-                "previous_order_id": previous_order_id,
-                "items": [{"product_id": pid, "quantity": qty} for pid, qty in zip(product_id_list, quantity_list)]
-            }
-        })
-        
+        result = await agent.workflow.ainvoke(input=input_message)
+        if result and 'messages' in result:
+            for msg in reversed(result['messages']):
+                if isinstance(msg, AIMessage):
+                    conversation_history.append(msg)
+                    return msg.content, None
+        fallback = AIMessage(content="No response generated")
+        conversation_history.append(fallback)
+        return fallback.content, None
     except Exception as e:
-        if 'conn' in locals():
-            conn.rollback()
-        return str({
-            "success": False,
-            "error": str(e)
-        })
-    finally:
-        if 'conn' in locals():
-            conn.close()
+        conversation_history.pop()
+        return None, str(e)
 
-def cancel_order(order_id: int, reason: str):
-    """
-    Cancel an existing order in the ERP system.
-    
-    Args:
-        order_id: ID of the order to cancel
-        reason: Reason for cancellation
-    
-    Returns:
-        Result of the cancellation operation
-    """
-    try:
-        conn = get_db_connection()
-        cursor = conn.cursor(cursor_factory=RealDictCursor)
-        
-        # Check if order exists and can be cancelled
-        check_query = """
-        SELECT status, customer_id FROM erp_orders WHERE order_id = %s;
-        """
-        cursor.execute(check_query, [order_id])
-        order = cursor.fetchone()
-        
-        if not order:
-            return str({
-                "success": False,
-                "error": f"Order with ID {order_id} not found"
-            })
-        
-        if order['status'] in ['Delivered', 'Cancelled']:
-            return str({
-                "success": False,
-                "error": f"Cannot cancel order with status '{order['status']}'"
-            })
-        
-        # Get order items to restore stock
-        items_query = """
-        SELECT product_id, quantity FROM erp_order_items WHERE order_id = %s;
-        """
-        cursor.execute(items_query, [order_id])
-        items = cursor.fetchall()
-        
-        # Update order status to Cancelled
-        update_query = """
-        UPDATE erp_orders SET status = 'Cancelled', payment_status = 'Cancelled'
-        WHERE order_id = %s;
-        """
-        cursor.execute(update_query, [order_id])
-        
-        # Add entry to order history
-        history_query = """
-        INSERT INTO erp_order_history (
-            order_id, timestamp, status_change, notes, updated_by
-        ) VALUES (
-            %s, CURRENT_TIMESTAMP, 'Cancelled', %s, 'System'
-        );
-        """
-        cursor.execute(history_query, [order_id, f"Order cancelled: {reason}"])
-        
-        # Restore product stock quantities
-        for item in items:
-            restore_stock_query = """
-            UPDATE erp_products 
-            SET stock_quantity = stock_quantity + %s 
-            WHERE product_id = %s;
-            """
-            cursor.execute(restore_stock_query, [item['quantity'], item['product_id']])
-        
-        # Update invoice if exists
-        invoice_query = """
-        UPDATE erp_invoices 
-        SET is_paid = FALSE
-        WHERE order_id = %s;
-        """
-        cursor.execute(invoice_query, [order_id])
-        
-        conn.commit()
-        
-        return str({
-            "success": True,
-            "message": f"Order #{order_id} has been successfully cancelled",
-            "order_id": order_id,
-            "reason": reason,
-            "items_restored": len(items)
-        })
-        
-    except Exception as e:
-        if 'conn' in locals():
-            conn.rollback()
-        return str({
-            "success": False,
-            "error": str(e)
-        })
-    finally:
-        if 'conn' in locals():
-            conn.close()
+def chat_with_agent(agent, user_input, chat_history):
+    if not agent:
+        chat_history.append([user_input, "❌ Please initialize your agent first."])
+        return chat_history, ""
 
-def get_invoice_details(invoice_id: int = None, order_id: int = None):
-    """
-    Get invoice details by invoice ID or order ID.
-    
-    Args:
-        invoice_id: ID of the invoice (optional)
-        order_id: ID of the order (optional)
-    
-    Returns:
-        Invoice details including customer and order information
-    """
-    if not invoice_id and not order_id:
-        return str({
-            "success": False,
-            "error": "Either invoice_id or order_id must be provided"
-        })
-    
-    try:
-        conn = get_db_connection()
-        cursor = conn.cursor(cursor_factory=RealDictCursor)
-        
-        if invoice_id:
-            query = """
-            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;
-            """
-            cursor.execute(query, [invoice_id])
-        else:
-            query = """
-            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;
-            """
-            cursor.execute(query, [order_id])
-        
-        invoice = cursor.fetchone()
-        
-        if not invoice:
-            return str({
-                "success": False,
-                "error": f"Invoice not found for the provided {'invoice_id' if invoice_id else 'order_id'}"
-            })
-        
-        # Get order items
-        items_query = """
-        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;
-        """
-        cursor.execute(items_query, [invoice['order_id']])
-        items = cursor.fetchall()
-        
-        invoice_dict = dict(invoice)
-        items_list = [dict(item) for item in items]
-        
-        # Return JSON formatted response
-        return str({
-            "success": True,
-            "invoice": {
-                "invoice_id": invoice_dict['invoice_id'],
-                "invoice_number": invoice_dict.get('invoice_number', ''),
-                "order_id": invoice_dict['order_id'],
-                "order_date": str(invoice_dict['order_date']) if invoice_dict['order_date'] else None,
-                "order_status": invoice_dict['order_status'],
-                "amount": float(invoice_dict['amount']),
-                "due_date": str(invoice_dict['due_date']) if invoice_dict['due_date'] else None,
-                "payment_status": "Paid" if invoice_dict['is_paid'] else "Unpaid",
-                "customer": {
-                    "name": invoice_dict['customer_name'],
-                    "email": invoice_dict['customer_email'],
-                    "address": invoice_dict['customer_address']
-                },
-                "items": items_list
-            }
-        })
-        
-    except Exception as e:
-        return str({
-            "success": False,
-            "error": str(e)
-        })
-    finally:
-        if 'conn' in locals():
-            conn.close()
-
-# Create Gradio interfaces for each function
-execute_query_interface = gr.Interface(
-    fn=execute_query,
-    inputs=[
-        gr.Textbox(lines=5, label="SQL Query"),
-        gr.Textbox(label="Parameters (comma-separated)", placeholder="Optional")
-    ],
-    outputs=gr.Textbox(lines=10),
-    title="Execute SQL Query",
-    description="Execute a custom SQL query on the ERP database"
-)
-
-list_tables_interface = gr.Interface(
-    fn=list_erp_tables,
-    inputs=[],
-    outputs=gr.Textbox(lines=10),
-    title="List ERP Tables",
-    description="List all ERP tables in the database"
-)
+    if not user_input.strip():
+        return chat_history, ""
 
-order_status_interface = gr.Interface(
-    fn=get_order_status,
-    inputs=gr.Number(label="Order ID", precision=0),
-    outputs=gr.Textbox(lines=15),
-    title="Get Order Status",
-    description="Get the status of an order by order ID"
-)
+    # Use the existing event loop if available, otherwise create a new one
+    try:
+        loop = asyncio.get_event_loop()
+    except RuntimeError:
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+    
+    response, error = loop.run_until_complete(get_agent_response_async(agent, user_input))
+
+    if response:
+        chat_history.append([user_input, response])
+    else:
+        chat_history.append([user_input, f"❌ Error: {error}"])
+
+    return chat_history, ""
+
+def reset_conversation():
+    global conversation_history
+    conversation_history = []
+    return [], "🔄 Conversation reset!", "🟢 Agent Ready"
+
+# ----- Gradio Interface -----
+def create_interface():
+    with gr.Blocks(title="TrackMate AI") as app:
+        agent_state = gr.State(value=None)
+        # Header
+        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>
+        """)
+        with gr.Row():
+            with gr.Column(scale=1):
+                model_name = gr.Dropdown(
+                    choices=["gpt-4o", "gpt-4", "gpt-3.5-turbo", "claude-3-sonnet", "claude-3-haiku"],
+                    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 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
+                    )
+
+                init_btn = gr.Button("🚀 Initialize Agent")
+                status_display = gr.Textbox(label="Status", interactive=False)
+                agent_status = gr.Textbox(label="Agent Status", interactive=False)
+
+            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")
+
+        init_btn.click(
+            fn=initialize_agent_handler,
+            inputs=[model_name, temperature, max_tokens, system_prompt, api_key],
+            outputs=[agent_state, status_display, agent_status]
+        )
 
-place_order_interface = gr.Interface(
-    fn=place_new_order,
-    inputs=[
-        gr.Number(label="Customer ID", precision=0),
-        gr.Textbox(label="Product IDs (comma-separated)", placeholder="1, 2, 3"),
-        gr.Textbox(label="Quantities (comma-separated)", placeholder="2, 1, 3"),
-        gr.Textbox(label="Shipping Address"),
-        gr.Textbox(label="Shipping Country"),
-        gr.Textbox(label="Destination Country"),
-        gr.Number(label="Previous Order ID (optional)", precision=0)
-    ],
-    outputs=gr.Textbox(lines=10),
-    title="Place New Order",
-    description="Place a new order in the ERP system"
-)
+        reset_btn.click(
+            fn=reset_conversation,
+            outputs=[chatbot, status_display, agent_status]
+        )
 
-cancel_order_interface = gr.Interface(
-    fn=cancel_order,
-    inputs=[
-        gr.Number(label="Order ID", precision=0),
-        gr.Textbox(label="Reason for Cancellation")
-    ],
-    outputs=gr.Textbox(lines=5),
-    title="Cancel Order",
-    description="Cancel an existing order in the ERP system"
-)
+        send_btn.click(
+            fn=chat_with_agent,
+            inputs=[agent_state, msg_input, chatbot],
+            outputs=[chatbot, msg_input]
+        )
 
-invoice_details_interface = gr.Interface(
-    fn=get_invoice_details,
-    inputs=[
-        gr.Number(label="Invoice ID (optional)", precision=0),
-        gr.Number(label="Order ID (optional)", precision=0)
-    ],
-    outputs=gr.Textbox(lines=15),
-    title="Get Invoice Details",
-    description="Get invoice details by invoice ID or order ID"
-)
+        msg_input.submit(
+            fn=chat_with_agent,
+            inputs=[agent_state, msg_input, chatbot],
+            outputs=[chatbot, msg_input]
+        )
 
-# Create a Gradio TabItem for each interface
-demo = gr.TabbedInterface(
-    [
-        execute_query_interface,
-        list_tables_interface,
-        order_status_interface,
-        place_order_interface,
-        cancel_order_interface,
-        invoice_details_interface
-    ],
-    [
-        "Execute Query",
-        "List Tables",
-        "Order Status",
-        "Place Order",
-        "Cancel Order",
-        "Invoice Details"
-    ],
-    title="ERP System Tools"
-)
+    return app
 
-# Launch the demo with MCP server enabled
-demo.launch(mcp_server=True, server_port=7090)
+if __name__ == "__main__":
+    app = create_interface()
+    app.launch(server_name="0.0.0.0", server_port=7860)

core/agents/SkeletonGraphAgent.py

@@ -0,0 +1,814 @@
+"""
+Module Name: SkeletonGraphAgent
+Description: This module contains the Langgraph's Agent class that provides a flexible agent framework
+             using langgraph where all configuration is dynamically loaded from user input. This includes 
+             system prompts, rules, input variables, LLM configuration, output structure, and tools.
+Author: Abhishek Singh
+Last Modified: 2025-05-29
+"""
+
+import logging, re, ast, json, os, aiohttp
+from tqdm import tqdm
+from typing import Any, Dict, List, Optional, Union, TypedDict, Annotated, Sequence
+from langchain_core.messages import AIMessage, HumanMessage, SystemMessage, ToolMessage, BaseMessage
+from pydantic import BaseModel, Field, create_model
+from langgraph.graph.message import add_messages
+from langgraph.graph import StateGraph, START, END, MessagesState
+from langgraph.prebuilt import ToolNode, tools_condition
+from langchain_community.callbacks import get_openai_callback
+from core.llms.base_llm import get_llm
+from langchain_mcp_adapters.client import MultiServerMCPClient
+from urllib.parse import urlparse
+import asyncio
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+class AgentState(TypedDict):
+    """
+    Represents the state of the agent.
+    """
+    messages: Annotated[Sequence[BaseMessage], add_messages] # List of messages exchanged with the agent
+    input_variables: Dict[str, Any]  # Input variables provided to the agent
+    final_response: Optional[Dict[str, Any]]  # Final structured response from the agent
+
+class SkeletonGraphAgent:
+    """
+    A flexible agent built with langgraph that takes all configuration from user input including:
+    - System prompt
+    - Rules to be applied in the system prompt
+    - Input variables
+    - LLM configuration
+    - Output structure
+    - Tools to be used
+
+    This agent serves as a foundation for creating custom agents without modifying code.
+    It dynamically loads tools, creates structured output formats, and handles various input types.
+
+    Args:
+        metadata (Dict[str, Any]): Configuration dictionary containing:
+            - model (Dict): LLM model configuration with name and parameters
+            - temperature (float): Temperature for LLM (0-1)
+            - tokens (int): Max tokens for LLM response
+            - system_prompt (str): Base system prompt for the agent
+            - input_variables (List[Dict]): List of input variables with names and default values
+            - outputType (List[Dict]): Structure of the expected output
+            - rules (List[Dict]): Rules to be applied in the system prompt
+            - tools (List[str]): List of tool names to be loaded and used by the agent
+    """
+
+    def __init__(self, metadata: Dict[str, Any]):
+        """
+        Initializes the SkeletonGraphAgent with the provided metadata.
+
+        Args:
+            metadata (Dict[str, Any]): Configuration dictionary for the agent.
+        """
+        # Initialize MCP-related attributes
+        self.client = None
+        self.mcp_tools = []
+
+        # Extract and set the LLM configuration parameters such as model name, temperature, max tokens, system prompt, etc.
+        self._configure_llm_parameters(metadata)
+
+        # Parse the output structure for structured responses
+        self._parse_structured_output(metadata)
+
+        # Create a pydantic model of the output structure
+        self._create_pydantic_model()
+
+        # Configure the Agents tools
+        self._configure_agents_tools(metadata)
+
+        # Configuring the llm(s), one llm for generation and one for responding in output format
+        self._configure_llm()
+
+    def _configure_llm_parameters(self, metadata: Dict[str, Any]):
+        """
+        Configures the LLM parameters from the provided metadata.
+
+        Args:
+            metadata (Dict[str, Any]): Configuration dictionary containing LLM parameters.
+
+        Returns:
+            str: The name of the configured LLM.
+        """
+        # LLM Configuration
+        self.model_name = metadata.get("model", {}).get("input", "gpt-4o")
+        self.temperature = metadata.get("temperature", 0)
+        self.max_tokens = metadata.get("tokens", 1000)
+        self.system_prompt = metadata.get("system_prompt", "You are a helpful AI assistant.")
+        self.rules = self._parse_literal(metadata.get("rules", "[]"), [])
+        self.input_variables = metadata.get("input_variables", [{"name": "input", "input": ""}])
+        self.api_key = metadata.get("api_key", None)
+        
+        # If rules are provided, append them to the system prompt
+        if self.rules:
+            for rule in self.rules:
+                self.system_prompt += f"\n{rule['rulename']}: {rule['ruleDescription']}"
+
+    def _parse_structured_output(self, metadata: Dict[str, Any]):
+        """
+        Parse the outputType metadata into a dictionary of field definitions.
+        This defines the structure of the agent's output.
+
+        Args:
+            metadata (Dict[str, Any]): The metadata containing output structure
+            default (Any): The default value to return if parsing fails
+
+        Returns:
+            Dict[str, Any]: Dictionary of output fields with their types and descriptions
+        """
+        try:
+            # Parse the outputType from metadata
+            self.output_type = self._parse_literal(metadata.get("outputType", "[]"), [])
+
+            # Initialize output_fields as an empty dictionary
+            self.output_fields = {}
+
+            # Populate output_fields with the parsed outputType
+            for field in self.output_type:
+                self.output_fields[field["outputKey"]] = {
+                    "type": field["outputKeyType"],
+                    "description": field["outputDescription"]
+                }
+
+        except (ValueError, TypeError) as e:
+            logger.warning(f"Failed to parse output structure: {str(e)}")
+    
+    def _create_pydantic_model(self):
+        """
+        Dynamically create a Pydantic class based on user-provided fields.
+        This model defines the structure of the agent's output.
+        """
+        # Check if output_fields is empty
+        if not self.output_fields:
+            logger.warning("No output fields defined. Using default model with a single 'output' field.")
+        
+        try:
+            self.pydantic_model = None
+
+            if self.output_fields:
+                field_definitions = {
+                    field_name: (field_info['type'], Field(
+                        description=field_info['description']))
+                    for field_name, field_info in self.output_fields.items()
+                }
+
+                self.pydantic_model = create_model(
+                    'OutputFormat',
+                    __doc__="Dynamically generated Pydantic model for agent output.",
+                    **field_definitions
+                )
+                
+                logger.debug(f"Created Pydantic model with fields: {list(self.output_fields.keys())}")
+
+        except Exception as e:
+            logger.error(f"Failed to create Pydantic model: {str(e)}")
+
+    def _configure_agents_tools(self, metadata: Dict[str, Any]):
+        """
+        Configures the agent's tools and output structure based on the provided metadata.
+
+        Args:
+            metadata (Dict[str, Any]): Configuration dictionary containing tools and output structure.
+        """
+        # Get tools from metadata
+        tools_config = self._parse_literal(metadata.get("tools", "[]"), [])
+        
+        # Initialize tools list
+        self.tools = []
+        
+        # Handle both tool names and tool instances
+        for tool in tools_config:
+            if not tool:
+                continue
+                
+            try:
+                if callable(tool):
+                    # If tool is a function/callable (e.g. @tool decorated function), use it directly
+                    self.tools.append(tool)
+                    logger.info(f"Successfully loaded tool function: {tool.__name__}")
+                elif isinstance(tool, str):
+                    # If tool is a string, try to import from core.tools
+                    module_path = f"core.tools.{tool}"
+                    module = __import__(module_path, fromlist=[tool])
+                    tool_class = getattr(module, tool)
+                    # Check if it's already a tool instance
+                    if callable(tool_class):
+                        tool_instance = tool_class
+                    else:
+                        tool_instance = tool_class()
+                    self.tools.append(tool_instance)
+                    logger.info(f"Successfully loaded tool: {tool}")
+                else:
+                    # If it's already a tool instance
+                    self.tools.append(tool)
+                    logger.info(f"Successfully loaded tool instance: {tool.__class__.__name__}")
+            except Exception as e:
+                logger.error(f"Failed to load tool {tool}: {str(e)}")
+    
+    def _load_mcp_config(self, config_path: str = "core/config/mcp_config.json") -> Dict[str, Any]:
+        """
+        Load MCP configuration from a JSON file.
+        
+        Args:
+            config_path (str): Path to the MCP configuration file
+            
+        Returns:
+            Dict[str, Any]: MCP configuration dictionary
+        """
+        try:
+            if os.path.exists(config_path):
+                with open(config_path, 'r') as f:
+                    config = json.load(f)
+                logger.info(f"Loaded MCP configuration from {config_path}")
+                return config
+            else:
+                logger.warning(f"MCP config file not found at {config_path}. Using empty config.")
+                return {}
+        except Exception as e:
+            logger.error(f"Failed to load MCP config from {config_path}: {str(e)}")
+            return {}
+    
+    async def _check_mcp_server_health(self, url: str, timeout: int = 5) -> bool:
+        """
+        Check if an MCP server is up and running.
+        
+        Args:
+            url (str): The URL of the MCP server
+            timeout (int): Timeout in seconds for the health check
+            
+        Returns:
+            bool: True if server is up, False otherwise
+        """
+        try:
+            parsed_url = urlparse(url)
+            host = parsed_url.hostname
+            port = parsed_url.port
+            
+            if not host or not port:
+                logger.warning(f"Invalid URL format: {url}")
+                return False
+            
+            # Try to connect to the server
+            async with aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=timeout)) as session:
+                try:
+                    async with session.get(f"http://{host}:{port}") as response:
+                        # If we get any response, consider the server up
+                        logger.debug(f"MCP server at {url} is responding (status: {response.status})")
+                        return True
+                except aiohttp.ClientError:
+                    # Try a simple TCP connection if HTTP fails
+                    try:
+                        reader, writer = await asyncio.wait_for(
+                            asyncio.open_connection(host, port),
+                            timeout=timeout
+                        )
+                        writer.close()
+                        await writer.wait_closed()
+                        logger.debug(f"MCP server at {url} is reachable via TCP")
+                        return True
+                    except Exception:
+                        logger.debug(f"MCP server at {url} is not reachable")
+                        return False
+        except Exception as e:
+            logger.debug(f"Health check failed for {url}: {str(e)}")
+            return False
+    
+    async def _configure_mcp_client(self, metadata: Dict[str, Any]):
+        """
+        Configures the MCP client for the agent based on the provided metadata.
+        Handles both stdio and HTTP-based transports (sse, streamable_http).
+        """
+        try:
+            # Load MCP configuration from file
+            mcp_config = self._load_mcp_config()
+            
+            if not mcp_config:
+                logger.info("No MCP configuration found. Skipping MCP client setup.")
+                return
+            
+            # Create the MCP client with available servers
+            self.client = MultiServerMCPClient(mcp_config)
+            
+            # Start the client connection
+            await self.client.__aenter__()
+            
+            # Get the tools from the client
+            self.mcp_tools = self.client.get_tools()
+            self.tools.extend(self.mcp_tools)
+
+            logger.info(f"MCP client configured successfully with {len(mcp_config)} servers and {len(self.mcp_tools)} tools.")
+        except Exception as e:
+            logger.error(f"Failed to configure MCP client: {str(e)}")
+            self.client = None
+            self.mcp_tools = []
+
+    @classmethod
+    async def create(cls, metadata: Dict[str, Any]):
+        """
+        Async factory method to create and configure a SkeletonGraphAgent instance.
+
+        Args:
+            metadata (Dict[str, Any]): Configuration dictionary.
+
+        Returns:
+            SkeletonGraphAgent: Configured instance.
+        """
+        self = cls(metadata)  # Call __init__ with metadata
+        
+        await self._configure_mcp_client(metadata)  # Configure async parts
+        if self.mcp_tools:
+            self.main_llm = self.main_llm.bind_tools(self.tools)  # Bind MCP tools to the main LLM
+        
+        # Building the state graph for the agent, we build the state graph after the MCP client is configured
+        self._build_state_graph()
+        
+        return self
+
+    def _configure_llm(self):
+        """
+        Configures the LLM for the agent based on the provided metadata.
+
+        Args:
+            metadata (Dict[str, Any]): Configuration dictionary containing LLM parameters.
+        """
+        try:
+            # Initialize the LLM with the specified model and parameters
+            self.main_llm = get_llm(
+                model_name=self.model_name,
+                provider="openai",  # Default provider, can be changed if needed
+                api_key=self.api_key,
+                temperature=self.temperature,
+                max_tokens=self.max_tokens
+            )
+
+            # If tools are configured, bind them to the main LLM
+            if self.tools:
+                self.main_llm = self.main_llm.bind_tools(self.tools)
+
+            logger.info(f"LLM configured with model: {self.model_name}, temperature: {self.temperature}, max tokens: {self.max_tokens}")
+
+            # If a structured output is required, configure the LLM for structured output
+            if self.pydantic_model:
+                # If a second LLM is needed for structured output, configure it similarly
+                self.llm_for_response = get_llm(
+                    model_name=self.model_name,
+                    temperature=self.temperature,
+                    max_tokens=self.max_tokens
+                )
+
+                self.llm_with_structured_output = self.llm_for_response.with_structured_output(self.pydantic_model)
+
+        except Exception as e:
+            logger.error(f"Failed to configure LLM: {str(e)}")
+
+    def _parse_literal(self, value: str, default: Any) -> Any:
+        """
+        Parse a string value into a Python object.
+        Handles various string formats including lists, dictionaries, and type references.
+
+        Args:
+            value (str): The string value to parse
+            default (Any): The default value to return if parsing fails
+
+        Returns:
+            Any: The parsed Python object or the default value
+        """
+        try:
+            # Handle type references in the string
+            cleaned_value = re.sub(r"<class '(\w+)'>", r"\1", str(value))
+            # Handle type references without quotes
+            cleaned_value = re.sub(r'"type":\s*(\w+)', lambda m: f'"type": "{m.group(1)}"', cleaned_value)
+            return ast.literal_eval(cleaned_value)
+        except (ValueError, SyntaxError) as e:
+            logger.debug(f"Failed to parse literal value: {value}. Error: {str(e)}")
+            # Handle comma-separated values
+            if isinstance(value, str):
+                if ',' in value:
+                    return [item.strip() for item in value.split(',')]
+                elif ' ' in value:
+                    return value.split()
+            return default
+
+    def _build_state_graph(self):
+        """
+        Builds the state graph for the agent using langgraph.
+        This defines the flow of messages and tool usage in the agent's operation.
+        """
+        try:
+            # Initialize the state graph
+            self.graph = StateGraph(AgentState)
+
+            # Define the main agent node that processes input and generates a response
+            self.graph.add_node("agent_node", self._agent_node)
+
+            # Set entry point of the graph
+            self.graph.set_entry_point("agent_node")
+
+            # If output is required in a structured format, add a respond node
+            if self.pydantic_model:
+                # Add a node for responding in structured format
+                self.graph.add_node("respond", self._respond)
+                
+                # Connect the respond node to the END
+                self.graph.add_edge("respond", END)
+            
+            # Add a node if tools are configured
+            if self.tools:
+                # Add a node for tools
+                self.graph.add_node("tools", ToolNode(self.tools))
+                
+                # Connect the agent node to the tools node
+                self.graph.add_edge("tools", "agent_node")
+
+            # Adding the should_continue node to determine if the agent should continue processing
+            if self.pydantic_model and (self.tools or self.mcp_tools):
+                self.graph.add_conditional_edges(
+                    "agent_node",
+                    self._should_continue,
+                    {
+                        "continue": "tools",  # Continue processing
+                        "respond": "respond",       # Respond in structured format
+                        # "end": END                  # End the conversation
+                    }
+                )
+            elif self.pydantic_model and not self.tools:
+                # If structured output is required, go to respond node
+                self.graph.add_edge(
+                    "agent_node",
+                    "respond"  
+                )
+            elif not self.pydantic_model and (self.tools or self.mcp_tools):
+                self.graph.add_conditional_edges(
+                    "agent_node",
+                    self._should_continue,
+                    {
+                        "continue": "tools",  # Continue processing
+                        "end": END            # End the conversation
+                    }
+                )
+            else:
+                # If no structured output or tools, end the conversation
+                self.graph.add_edge("agent_node", END)  
+
+            self.workflow = self.graph.compile()
+            
+            logger.info("State graph built successfully with tools and initial system message.")
+
+        except Exception as e:
+            logger.error(f"Failed to build state graph: {str(e)}")
+
+    def _agent_node(self, state: AgentState) -> AgentState:
+        """
+        The main agent node that processes the input and generates a response.
+        """
+        # Get the current messages from the state
+        messages = state.get('messages', [])
+        
+        # Add system message only if it's the first message
+        if not messages or not any(isinstance(msg, SystemMessage) for msg in messages):
+            messages = [SystemMessage(content=self.system_prompt)] + messages
+
+        # Add input variables to the messages
+        input_variables = state.get("input_variables", {})
+        if input_variables:
+            input_message = HumanMessage(content=json.dumps(input_variables))
+            messages.append(input_message)
+        else:
+            input_message = HumanMessage(content="No input variables provided.")
+            messages.append(input_message)
+
+        response = self.main_llm.invoke(messages)
+
+        # Return complete state
+        return {
+            "messages": messages + [response],
+            "input_variables": state.get("input_variables", {}),  # Preserve input variables
+            "final_response": state.get("final_response")  # Preserve any existing final response
+        }
+
+    def _respond(self, state: AgentState) -> AgentState:
+        """
+        The Respond node, will be called if response is required in a Structured Format.
+
+        Args:
+            state (AgentState): The current state of the agent.
+
+        Returns:
+            AgentState: The updated state after processing the input.
+        """
+        # Get the current messages from the state
+        messages = state.get("messages", [])
+        
+        response = self.llm_with_structured_output.invoke(messages)
+
+        # Create an AIMessage with the structured response
+        ai_message = AIMessage(content=str(response))
+        
+        # Preserve existing messages and append new message
+        return {
+            "final_response": response,
+            "messages": state.get("messages", []) + [ai_message],
+            "input_variables": state.get("input_variables", {})  # Preserve input variables
+        }
+    
+    def _should_continue(self, state: AgentState) -> str:
+        """
+        Determines whether the agent should continue processing based on the state.
+        """
+        if not state.get("messages"):
+            return "end"
+            
+        last_message = state["messages"][-1]
+
+        # Check if the last message is a ToolMessage or AIMessage
+        if not last_message.tool_calls:
+            if self.pydantic_model:
+                return "respond"
+            return "end"
+        return "continue"
+
+        
+    def _show_graph(self):
+        """
+        Displays the state graph of the agent.
+        This is useful for debugging and understanding the flow of the agent.
+        """
+        from IPython.display import Image, display
+        display(Image(self.workflow.get_graph().draw_mermaid_png()))
+
+    async def _execute(self, input: str, metadata: Dict[str, Any] = {None}) -> Dict[str, Any]:
+        """
+        Execute the agent with the provided inputs.
+
+        Args:
+            input (str): The primary input text
+            metadata (Dict[str, Any]): Additional metadata including:
+                - chat_history: Optional chat history for context
+                - input_variables: Values for the input variables defined during initialization
+
+        Returns:
+            Dict[str, Any]: Dictionary containing the results and execution metadata
+        """
+
+        # Get the chat history from metadata, if provided
+        chat_history = metadata.get("chat_history", [])
+
+        # Convert history to BaseMessage objects if they're not already
+        processed_history = self._parse_history(chat_history)
+        
+        # Add the main input to the messages
+        messages = processed_history + [HumanMessage(content=input)]
+
+        # Parse input variables from metadata
+        input_variables = self._parse_input_variables(metadata.get("input_variables", []))
+        
+        try:
+            # Check if we're processing batch data
+            if "data" in input_variables:
+                result = await self._process_batch_data(input_variables, messages)
+            else:
+                result = await self._process_single_input(input_variables, messages)
+        
+        except Exception as e:
+            logger.error(f"Error processing input: {str(e)}")
+            result = {
+                "success": False,
+                "message": f"Error processing input: {str(e)}",
+                "raw_response": None,
+            }
+            
+        return result
+    
+    def _parse_history(self, chat_history: List):
+        """
+        Parses the chat history to convert it into a list of BaseMessage objects.
+
+        Args:
+            chat_history (List): The chat history to parse
+
+        Returns:
+            List[BaseMessage]: List of BaseMessage objects representing the chat history
+        """
+        parsed_history = []
+        for msg in chat_history:
+            if isinstance(msg, BaseMessage):
+                parsed_history.append(msg)
+            elif isinstance(msg, tuple) and len(msg) == 2:
+                role, content = msg
+                if role.lower() == "user" or role.lower() == "human":
+                    parsed_history.append(HumanMessage(content=content))
+                elif role.lower() == "assistant" or role.lower() == "ai":
+                    parsed_history.append(AIMessage(content=content))
+                elif role.lower() == "system":
+                    parsed_history.append(SystemMessage(content=content))
+                else:
+                    parsed_history.append(HumanMessage(content=f"{role}: {content}"))
+            else:
+                # Default to human message
+                parsed_history.append(HumanMessage(content=str(msg)))
+
+        return parsed_history
+    
+    def _parse_input_variables(self, input_variables: List[Dict[str, Any]]) -> Dict[str, Any]:
+        """
+        Parses the input variables from the provided list into a dictionary.
+
+        Args:
+            input_variables (List[Dict[str, Any]]): List of input variable definitions
+
+        Returns:
+            Dict[str, Any]: Dictionary of input variables with their names and values
+        """
+        parsed_variables = {}
+        for var in input_variables:
+            if isinstance(var, dict) and "name" in var:
+                name = var["name"]
+                value = var.get("input", "")
+                parsed_variables[name] = value
+            else:
+                logger.warning(f"Invalid input variable format: {var}")
+        return parsed_variables
+
+    def _process_structured_output(self, output: Dict[str, Any]) -> Union[Dict[str, Any], str]:
+        """
+        Process the structured output from the agent.
+
+        Args:
+            output (Dict[str, Any]): The structured output from the agent
+
+        Returns:
+            Union[Dict[str, Any], str]: Processed structured output
+        """
+        try:
+            # If a Pydantic model is defined, validate and return the structured output
+            if self.pydantic_model:
+                return {key: getattr(output['final_response'], key) for key in self.output_fields.keys()}
+            else:
+                # If no structured output is defined, return the raw output
+                return output
+        except Exception as e:
+            logger.error(f"Error processing structured output: {str(e)}")
+            return str(output)
+        
+
+    async def _process_batch_data(self, execution_inputs: Dict[str, Any], messages) -> Dict[str, Any]:
+        """
+        Process a batch of data items.
+        
+        Args:
+            execution_inputs (Dict[str, Any]): The execution inputs including data array
+            
+        Returns:
+            Dict[str, Any]: Results of batch processing
+        """
+        with get_openai_callback() as cb:
+            response = []
+            
+            try:
+                # Create a copy of inputs without the data field
+                data_inputs = execution_inputs.copy()
+                data = data_inputs.pop("data")
+                
+                # Parse data if it's a string
+                if isinstance(data, str):
+                    data = self._parse_literal(data, [])
+                
+                total_docs = len(data)
+                logger.info(f"Processing batch of {total_docs} documents")
+
+                # Process each data item with a progress bar
+                with tqdm(total=total_docs, desc="Processing documents") as pbar:
+                    for doc in data:
+                        # Add the current data item to the inputs
+                        data_inputs["data"] = doc
+
+                        # Initialize the initial state with messages and input variables
+                        initial_state = {
+                            "messages": messages,
+                            "input_variables": data_inputs,
+                            "final_response": None
+                        }
+                                                
+                        # Invoke the agent
+                        result = await self.workflow.ainvoke(initial_state)
+            
+                        # Process the structured output if a Pydantic model is defined
+                        if self.pydantic_model:
+                            output_response = self._process_structured_output(result)
+                        else:
+                            # If no structured output is defined, use the raw result
+                            output_response = result
+                        
+                        response.append(output_response)
+                        pbar.update(1)
+                
+                # Create the final result with metadata
+                result = {
+                    "success": True,
+                    "message": json.dumps(response),
+                    "metainfo": self._get_callback_metadata(cb)
+                }
+                
+            except Exception as e:
+                logger.error(f"Error processing batch data: {str(e)}")
+                result = {
+                    "success": False,
+                    "message": f"Error processing batch data: {str(e)}",
+                    "metainfo": self._get_callback_metadata(cb)
+                }
+                
+            return result
+
+    async def _process_single_input(self, execution_inputs: Dict[str, Any], messages) -> Dict[str, Any]:
+        """
+        Process a single input.
+        
+        Args:
+            execution_inputs (Dict[str, Any]): The execution inputs
+            
+        Returns:
+            Dict[str, Any]: Result of processing
+        """
+        with get_openai_callback() as cb:
+            try:
+                # Initialize the initial state with messages and input variables
+                initial_state = {
+                    "messages": messages,
+                    "input_variables": execution_inputs,
+                    "final_response": None
+                }
+                
+                # Invoke the agent
+                response = await self.workflow.ainvoke(initial_state)
+
+                # Process the result based on whether fields were provided
+                dict_data = self._process_structured_output(response)
+                
+                # Create the final result with metadata
+                result = {
+                    "success": True,
+                    "message": str(dict_data),
+                    "response": response,
+                    "metainfo": self._get_callback_metadata(cb)
+                }
+                
+            except Exception as e:
+                logger.error(f"Error processing input: {str(e)}")
+                result = {
+                    "success": False,
+                    "message": f"Error processing input: {str(e)}",
+                    "metainfo": self._get_callback_metadata(cb)
+                }
+                
+            return result
+        
+    def _get_callback_metadata(self, cb) -> Dict[str, Any]:
+        """
+        Get metadata from the OpenAI callback.
+        
+        Args:
+            cb: The OpenAI callback object
+            
+        Returns:
+            Dict[str, Any]: Metadata about the API call
+        """
+        return {
+            "prompt_tokens": cb.prompt_tokens,
+            "completion_tokens": cb.completion_tokens,
+            "total_tokens": cb.total_tokens,
+            "total_cost": cb.total_cost
+        }
+    
+    async def close(self):
+        """
+        Clean up resources, particularly the MCP client connection.
+        """
+        if self.client:
+            try:
+                await self.client.__aexit__(None, None, None)
+                logger.info("MCP client connection closed successfully.")
+            except Exception as e:
+                logger.error(f"Error closing MCP client: {str(e)}")
+            finally:
+                self.client = None
+                self.mcp_tools = []
+    
+    def __del__(self):
+        """
+        Destructor to ensure cleanup when the object is garbage collected.
+        """
+        if self.client:
+            import asyncio
+            try:
+                # Try to close the client if there's an active event loop
+                loop = asyncio.get_event_loop()
+                if loop.is_running():
+                    loop.create_task(self.close())
+                else:
+                    asyncio.run(self.close())
+            except Exception:
+                # If we can't close properly, at least log it
+                logger.warning("Could not properly close MCP client in destructor")

core/config/mcp_config.json

@@ -0,0 +1,22 @@
+{
+    "math": {
+        "command": "python",
+        "args": ["core/mcp_tools/math_server.py"],
+        "transport": "stdio"
+    },
+    "weather": {
+        "command": "python",
+        "args": ["core/mcp_tools/weather_server.py"],
+        "transport": "stdio"
+    },
+    "global_disruptions": {
+        "command": "python",
+        "args": ["core/mcp_tools/global_disruptions_server.py"],
+        "transport": "stdio"
+    },
+    "erp": {
+        "command": "python",
+        "args": ["core/mcp_tools/erp_server.py"],
+        "transport": "stdio"
+    }
+}

core/config/mcp_config.py

@@ -0,0 +1,30 @@
+"""
+Module for loading MCP configuration from JSON file.
+"""
+
+import json
+import os
+from typing import Dict, Any
+
+def load_mcp_config() -> Dict[str, Any]:
+    """
+    Load MCP configuration from JSON file.
+    
+    Returns:
+        Dict[str, Any]: MCP configuration dictionary
+    """
+    config_path = os.path.join(os.path.dirname(__file__), "mcp_config.json")
+    try:
+        if os.path.exists(config_path):
+            with open(config_path, 'r') as f:
+                config = json.load(f)
+            return config
+        else:
+            print(f"MCP config file not found at {config_path}. Using empty config.")
+            return {}
+    except Exception as e:
+        print(f"Failed to load MCP config from {config_path}: {str(e)}")
+        return {}
+
+# Load the configuration when the module is imported
+mcp_config = load_mcp_config()

core/config/metadata.py

@@ -0,0 +1,19 @@
+def create_metadata(model_name, temperature, max_tokens, system_prompt, api_key: None, provider="openai"):
+    return {
+        "model": {"input": model_name},
+        "temperature": temperature,
+        "tokens": max_tokens,
+        "system_prompt": system_prompt,
+        "api_key": api_key,
+        "provider": provider,
+        "input_variables": [
+            {"name": "input", "input": ""},
+            {"name": "language", "input": "English"},        
+        ],
+        "tools": [],
+        "outputType": [],
+        "rules": [
+            {"rulename": "Be helpful", "ruleDescription": "Always try to be helpful and provide accurate information."},
+            {"rulename": "Be conversational", "ruleDescription": "Maintain a friendly and engaging conversational tone."}
+        ],
+    }

core/config/prompt.py

@@ -0,0 +1,31 @@
+def get_default_system_prompt():
+    """Get default system prompt"""
+    return """You are a helpful AI assistant specializing in order management and shipping operations. Engage in natural conversation with the user while proactively managing their orders and shipping concerns.
+
+    ## Core Workflow for Order Status Requests
+
+    When the user asks about order status, follow this comprehensive workflow:
+
+    1. **Identify Order ID**: Extract the order ID from the user's query
+    2. **Get Order Status**: Use the appropriate tool to retrieve detailed order status information
+    3. **Extract Shipping Details**: From the order details, identify the origin and destination countries
+    4. **Check for Disruptions**: Use the disruption checking tool with the origin and destination countries to identify any active shipping disruptions
+    5. **Assess Impact**: Determine if any found disruptions affect the current order's shipping route
+    6. If disruptions are found that could impact the order, ask the user if they want to replace the order with a new shipping route:
+    - Cancel the current order using the order cancellation tool
+    - Place a new order using the order placement tool, the new order should be placed with the same items but a different shipping route.
+    - Verify the new route has no active disruptions before confirming the replacement order
+
+    When the user asks about data from the database, follow this workflow:
+
+    1. **Identify the tables**: Extract the relevant table names using the `list_erp_tables` tool.
+    2. **Query the Database**: Use the `execute_query` tool to retrieve data from the identified tables.
+
+    ## Communication Guidelines
+
+    - Maintain a helpful, conversational tone
+    - Prioritize accuracy in all responses
+    - Be proactive in preventing shipping issues
+    - Explain the reasoning behind any order changes
+    - Confirm all actions taken with the customer
+    - Provide realistic timelines and expectations"""

core/llms/base_llm.py

@@ -0,0 +1,50 @@
+import os
+import logging
+from dotenv import load_dotenv
+from langchain_openai import AzureChatOpenAI, ChatOpenAI
+from langchain_google_genai import ChatGoogleGenerativeAI
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+load_dotenv()
+
+os.environ["OPENAI_API_VERSION"] = "2024-12-01-preview"
+
+def get_llm(model_name, provider="openai", api_key=None, **kwargs):
+    """
+    Get a language model instance based on the specified provider and model name.
+    
+    Args:
+        model_name (str): The name of the model to use.
+        provider (str): The provider of the model (openai, gemini, azure).
+        api_key (str, optional): API key for the provider. If None, will use environment variable.
+        
+    Returns:
+        llm: An instance of the language model.
+    """
+    
+    if provider == "openai":
+        logging.info("Using OpenAI provider with model: %s", model_name)
+
+        # Use provided API key or fall back to environment variable
+        openai_api_key = api_key or os.getenv("OPENAI_API_KEY")
+        
+        llm = ChatOpenAI(
+            model_name = "gpt-4o-mini",
+            api_key = openai_api_key, 
+        )
+    elif provider == "gemini":
+        logging.info("Using Gemini provider with model: %s", model_name)
+
+        # Use provided API key or fall back to environment variable
+        google_api_key = api_key or os.getenv("GOOGLE_API_KEY")
+        llm = ChatGoogleGenerativeAI(
+            model='gemini-2.0-flash',
+            api_key=google_api_key,
+            **kwargs
+        )
+    else:
+        return None
+
+    return llm

core/mcp_tools/erp_server.py

@@ -0,0 +1,544 @@
+# 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
+from dotenv import load_dotenv
+import json
+from datetime import datetime
+
+load_dotenv()
+
+mcp = FastMCP("ERP Database")
+
+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)}")
+
+@mcp.tool()
+async def execute_query(query: str, params: Optional[List] = None) -> Dict[str, Any]:
+    """
+    Execute a custom SQL query on the ERP database.
+    
+    Args:
+        query (str): SQL query to execute
+        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)
+        
+        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 = [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:
+        return {
+            "success": False,
+            "error": str(e)
+        }
+    finally:
+        if 'conn' in locals():
+            conn.close()
+
+@mcp.tool()
+async def list_erp_tables() -> Dict[str, Any]:
+    """
+    List all ERP tables in the database.
+    
+    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()
+        
+        table_names = [row['table_name'] for row in results]
+        if not table_names:
+            return {
+                "success": False,
+                "message": "No ERP tables found",
+                "tables": []
+            }
+        return {
+            "success": True,
+            "message": f"Found {len(table_names)} tables",
+            "count": len(table_names),
+            "tables": table_names
+        }
+        
+    except Exception as e:
+        return {
+            "success": False,
+            "error": str(e)
+        }
+    finally:
+        if 'conn' in locals():
+            conn.close()
+
+@mcp.tool()
+async def get_order_status(order_id: int) -> Dict[str, Any]:
+    """
+    Get the status of an order by order ID.
+    
+    Args:
+        order_id (int): The ID of the order to check
+    
+    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)
+        cursor.execute(query, [order_id])
+        order = cursor.fetchone()
+        
+        if not order:
+            return {
+                "success": False,
+                "message": f"Order with ID {order_id} not found"
+            }
+        
+        # Get order items
+        items_query = """
+        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;
+        """
+        cursor.execute(items_query, [order_id])
+        items = cursor.fetchall()
+        
+        # Get order history
+        history_query = """
+        SELECT * FROM erp_order_history
+        WHERE order_id = %s
+        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]
+        
+        # Return JSON formatted response
+        return {
+            "success": True,
+            "order": {
+                "order_id": order_id,
+                "customer": {
+                    "customer_id": order_dict['customer_id'],
+                    "name": order_dict['customer_name'],
+                    "email": order_dict['customer_email']
+                },
+                "status": order_dict['status'],
+                "shipping_address": order_dict.get('shipping_address', 'N/A'),
+                "shipping_country": order_dict.get('shipping_country', 'N/A'),
+                "destination_country": order_dict.get('destination_country', 'N/A'),
+                "items": items_list,
+                "history": history_list
+            }
+        }
+        
+    except Exception as e:
+        return {
+            "success": False,
+            "error": str(e)
+        }
+    finally:
+        if 'conn' in locals():
+            conn.close()
+
+@mcp.tool()
+async def place_new_order(
+    customer_id: int,
+    items: List[Dict[str, Any]],
+    shipping_address: str,
+    shipping_country: str,
+    destination_country: str,
+    previous_order_id: Optional[int] = None
+) -> Dict[str, Any]:
+    """
+    Place a new order in the ERP system, after ensuring there are no global disruptions affecting the shipment.
+    
+    Args:
+        customer_id (int): ID of the customer placing the order
+        items (List[Dict]): List of items to order, each with product_id and quantity
+        shipping_address (str): Shipping address for the order
+        shipping_country (str): Country where the order will be shipped from
+        destination_country (str): Country where the order will be delivered to
+        previous_order_id (int, optional): ID of a previous order this is replacing
+    
+    Returns:
+        dict: New order information
+    """
+    try:
+        conn = get_db_connection()
+        cursor = conn.cursor(cursor_factory=RealDictCursor)
+        
+        # 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;"
+            cursor.execute(product_query, [item['product_id']])
+            product = cursor.fetchone()
+            if not product:
+                return {
+                    "success": False,
+                    "error": f"Product with ID {item['product_id']} not found"
+                }
+            total_amount += product['price'] * item['quantity']
+        
+        # Insert new order into the erp_orders table for the customer
+        order_query = """
+        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;
+        """
+        cursor.execute(order_query, [
+            customer_id, total_amount, shipping_address, shipping_country, destination_country, previous_order_id
+        ])
+        new_order_id = cursor.fetchone()['order_id']
+        
+        # Insert order items into erp_order_items table for the new order
+        for item in items:
+            # Get product price
+            cursor.execute(product_query, [item['product_id']])
+            product = cursor.fetchone()
+            unit_price = product['price']
+            subtotal = unit_price * item['quantity']
+            
+            item_query = """
+            INSERT INTO erp_order_items (
+                order_id, product_id, quantity, unit_price, subtotal
+            ) VALUES (
+                %s, %s, %s, %s, %s
+            );
+            """
+            cursor.execute(item_query, [
+                new_order_id, item['product_id'], item['quantity'], 
+                unit_price, subtotal
+            ])
+            
+            # Update product stock
+            update_stock_query = """
+            UPDATE erp_products 
+            SET stock_quantity = stock_quantity - %s 
+            WHERE product_id = %s;
+            """
+            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 = """
+        INSERT INTO erp_order_history (
+            order_id, timestamp, status_change, notes, updated_by
+        ) VALUES (
+            %s, 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 = """
+            INSERT INTO erp_order_history (
+                order_id, timestamp, status_change, notes, updated_by
+            ) VALUES (
+                %s, CURRENT_TIMESTAMP, 'Replaced', 'Order replaced by order #%s', 'System'
+            );
+            """
+            cursor.execute(prev_order_note_query, [previous_order_id, new_order_id])
+        
+        # Generate invoice for the new order
+        invoice_query = """
+        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;
+        """
+        cursor.execute(invoice_query, [new_order_id, total_amount, new_order_id])
+        invoice_id = cursor.fetchone()['invoice_id']
+        
+        conn.commit()
+        
+        # Get the complete new order details
+        cursor.execute("SELECT * FROM erp_orders WHERE order_id = %s;", [new_order_id])
+        order = cursor.fetchone()
+        
+        order_dict = dict(order)
+        
+        # Return JSON formatted response
+        return {
+            "success": True,
+            "order": {
+                "order_id": new_order_id,
+                "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,
+                "customer_id": customer_id,
+                "shipping_address": shipping_address,
+                "shipping_country": shipping_country,
+                "destination_country": destination_country,
+                "previous_order_id": previous_order_id
+            }
+        }
+        
+    except Exception as e:
+        if 'conn' in locals():
+            conn.rollback()
+        return {
+            "success": False,
+            "error": str(e)
+        }
+    finally:
+        if 'conn' in locals():
+            conn.close()
+
+@mcp.tool()
+async def cancel_order(order_id: int, reason: str) -> Dict[str, Any]:
+    """
+    Cancel an existing order in the ERP system.
+    
+    Args:
+        order_id (int): ID of the order to cancel
+        reason (str): Reason for cancellation
+    
+    Returns:
+        dict: Result of the cancellation operation
+    """
+    try:
+        conn = get_db_connection()
+        cursor = conn.cursor(cursor_factory=RealDictCursor)
+        
+        # Check if order exists and can be cancelled
+        check_query = """
+        SELECT status, customer_id FROM erp_orders WHERE order_id = %s;
+        """
+        cursor.execute(check_query, [order_id])
+        order = cursor.fetchone()
+        
+        if not order:
+            return {
+                "success": False,
+                "error": f"Order with ID {order_id} not found"
+            }
+        
+        if order['status'] in ['Delivered', 'Cancelled']:
+            return {
+                "success": False,
+                "error": f"Cannot cancel order with status '{order['status']}'"
+            }
+        
+        # Get order items to restore stock
+        items_query = """
+        SELECT product_id, quantity FROM erp_order_items WHERE order_id = %s;
+        """
+        cursor.execute(items_query, [order_id])
+        items = cursor.fetchall()
+        
+        # Update order status to Cancelled
+        update_query = """
+        UPDATE erp_orders SET status = 'Cancelled', payment_status = 'Cancelled'
+        WHERE order_id = %s;
+        """
+        cursor.execute(update_query, [order_id])
+        
+        # Add entry to order history
+        history_query = """
+        INSERT INTO erp_order_history (
+            order_id, timestamp, status_change, notes, updated_by
+        ) VALUES (
+            %s, CURRENT_TIMESTAMP, 'Cancelled', %s, 'System'
+        );
+        """
+        cursor.execute(history_query, [order_id, f"Order cancelled: {reason}"])
+        
+        # Restore product stock quantities
+        for item in items:
+            restore_stock_query = """
+            UPDATE erp_products 
+            SET stock_quantity = stock_quantity + %s 
+            WHERE product_id = %s;
+            """
+            cursor.execute(restore_stock_query, [item['quantity'], item['product_id']])
+        
+        # Update invoice if exists
+        invoice_query = """
+        UPDATE erp_invoices 
+        SET is_paid = FALSE
+        WHERE order_id = %s;
+        """
+        cursor.execute(invoice_query, [order_id])
+        
+        conn.commit()
+        
+        return {
+            "success": True,
+            "message": f"Order #{order_id} has been successfully cancelled",
+            "reason": reason,
+            "items_restored": len(items)
+        }
+        
+    except Exception as e:
+        if 'conn' in locals():
+            conn.rollback()
+        return {
+            "success": False,
+            "error": str(e)
+        }
+    finally:
+        if 'conn' in locals():
+            conn.close()
+
+@mcp.tool()
+async def get_invoice_details(invoice_id: Optional[int] = None, order_id: Optional[int] = None) -> Dict[str, Any]:
+    """
+    Get invoice details by invoice ID or order ID.
+    
+    Args:
+        invoice_id (int, optional): ID of the invoice
+        order_id (int, optional): ID of the order
+    
+    Returns:
+        dict: Invoice details including customer and order information
+    """
+    if not invoice_id and not order_id:
+        return {
+            "success": False,
+            "error": "Either invoice_id or order_id must be provided"
+        }
+    
+    try:
+        conn = get_db_connection()
+        cursor = conn.cursor(cursor_factory=RealDictCursor)
+        
+        if invoice_id:
+            query = """
+            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;
+            """
+            cursor.execute(query, [invoice_id])
+        else:
+            query = """
+            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;
+            """
+            cursor.execute(query, [order_id])
+        
+        invoice = cursor.fetchone()
+        
+        if not invoice:
+            return {
+                "success": False,
+                "error": f"Invoice not found for the provided {'invoice_id' if invoice_id else 'order_id'}"
+            }
+        
+        # Get order items
+        items_query = """
+        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;
+        """
+        cursor.execute(items_query, [invoice['order_id']])
+        items = cursor.fetchall()
+        
+        invoice_dict = dict(invoice)
+        items_list = [dict(item) for item in items]
+        
+        # Return JSON formatted response
+        return {
+            "success": True,
+            "invoice": {
+                "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_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,
+                "payment_status": "Paid" if invoice_dict['is_paid'] else "Unpaid",
+                "customer": {
+                    "name": invoice_dict['customer_name'],
+                    "email": invoice_dict['customer_email'],
+                    "address": invoice_dict['customer_address']
+                },
+                "items": items_list
+            }
+        }
+        
+    except Exception as e:
+        return {
+            "success": False,
+            "error": str(e)
+        }
+    finally:
+        if 'conn' in locals():
+            conn.close()
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

core/mcp_tools/global_disruptions_server.py

@@ -0,0 +1,191 @@
+# global_disruptions_server.py
+from typing import Dict, Any, List, Optional
+import psycopg2
+from psycopg2.extras import RealDictCursor
+from mcp.server.fastmcp import FastMCP
+import os
+from dotenv import load_dotenv
+from datetime import datetime, date
+
+load_dotenv()
+
+mcp = FastMCP("Global Disruptions Database")
+
+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)}")
+
+@mcp.tool()
+async def get_active_disruptions(source_country: Optional[str] = None, destination_country: Optional[str] = None) -> Dict[str, Any]:
+    """
+    Get active global disruptions that might affect orders between countries.
+    
+    Args:
+        source_country (str, optional): The country of origin for the shipment
+        destination_country (str, optional): The destination country for the shipment
+    
+    Returns:
+        dict: Information about current disruptions that might affect shipping
+    """
+    try:
+        conn = get_db_connection()
+        cursor = conn.cursor(cursor_factory=RealDictCursor)
+        
+        # Base query to get disruptions
+        query = """
+        SELECT 
+            disruption_id,
+            source_country,
+            destination_country,
+            disruption_type,
+            severity,
+            start_date,
+            expected_end_date,
+            actual_end_date,
+            is_active,
+            description,
+            impact_hours,
+            created_at,
+            updated_at
+        FROM 
+            live_global_disruptions
+        WHERE 
+            is_active = TRUE
+        """
+        
+        params = []
+        
+        # Add filters for specific countries if provided
+        if source_country and destination_country:
+            query += """
+            AND (
+                (source_country = %s AND destination_country = %s) OR
+                (source_country = %s) OR
+                (destination_country = %s)
+            )
+            """
+            params.extend([source_country, destination_country, source_country, destination_country])
+        elif source_country:
+            query += """
+            AND (source_country = %s)
+            """
+            params.append(source_country)
+        elif destination_country:
+            query += """
+            AND (destination_country = %s)
+            """
+            params.append(destination_country)
+        
+        # Order by severity and recency
+        query += """
+        ORDER BY 
+            severity DESC,
+            updated_at DESC;
+        """
+
+        print(query, params)  # Debugging line to see the query and parameters
+        
+        cursor.execute(query, params)
+        disruptions = cursor.fetchall()
+        
+        now = datetime.now()
+        
+        # Create message based on filter criteria
+        if source_country and destination_country:
+            message = f"Disruptions affecting shipments between {source_country} and {destination_country}"
+        elif source_country:
+            message = f"Disruptions affecting shipments from {source_country}"
+        elif destination_country:
+            message = f"Disruptions affecting shipments to {destination_country}"
+        else:
+            message = "All active global disruptions"
+        
+        if not disruptions:
+            return {
+                "success": True,
+                "message": f"No active disruptions found for {message.lower()}.",
+                "source_country": source_country,
+                "destination_country": destination_country,
+                "disruptions": [],
+                "count": 0,
+                "has_critical": False,
+                "max_severity": 0,
+                "recommendation": "No disruptions found. Shipping should proceed normally."
+            }
+        
+        # Format the response
+        formatted_disruptions = []
+        for disruption in disruptions:
+            d = dict(disruption)
+            
+            # Format severity level as text
+            severity = d['severity']
+            severity_text = "Critical" if severity == 5 else "High" if severity == 4 else "Medium" if severity == 3 else "Low" if severity == 2 else "Minimal"
+            
+            # Calculate days active
+            days_active = (now.date() - d['start_date']).days if d['start_date'] else None
+            
+            # Format dates for JSON
+            formatted_disruption = {
+                "disruption_id": d['disruption_id'],
+                "source_country": d['source_country'],
+                "destination_country": d['destination_country'],
+                "disruption_type": d['disruption_type'],
+                "severity": d['severity'],
+                "severity_text": severity_text,
+                "start_date": d['start_date'].strftime("%Y-%m-%d") if d['start_date'] else None,
+                "expected_end_date": d['expected_end_date'].strftime("%Y-%m-%d") if d['expected_end_date'] else None,
+                "actual_end_date": d['actual_end_date'].strftime("%Y-%m-%d") if d['actual_end_date'] else None,
+                "days_active": days_active,
+                "is_active": d['is_active'],
+                "description": d['description'],
+                "impact_hours": d['impact_hours'],
+                "created_at": d['created_at'].strftime("%Y-%m-%d %H:%M:%S") if d['created_at'] else None,
+                "updated_at": d['updated_at'].strftime("%Y-%m-%d %H:%M:%S") if d['updated_at'] else None
+            }
+            formatted_disruptions.append(formatted_disruption)
+        
+        # Add recommendations based on disruptions
+        max_severity = max(d['severity'] for d in disruptions)
+        has_critical = any(d['severity'] >= 4 for d in disruptions)
+        
+        if max_severity >= 4:
+            recommendation = "Consider alternative shipping routes or delaying shipments until disruptions are resolved."
+        elif max_severity == 3:
+            recommendation = "Expect delays and consider adding buffer time to delivery estimates."
+        else:
+            recommendation = "Monitor situation for changes. Minor delays possible."
+        
+        return {
+            "success": True,
+            "message": message,
+            "source_country": source_country,
+            "destination_country": destination_country,
+            "disruptions": formatted_disruptions,
+            "count": len(formatted_disruptions),
+            "has_critical": has_critical,
+            "max_severity": max_severity,
+            "recommendation": recommendation
+        }
+        
+    except Exception as e:
+        return {
+            "success": False,
+            "error": str(e)
+        }
+    finally:
+        if 'conn' in locals():
+            conn.close()
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

core/mcp_tools/math_server.py

@@ -0,0 +1,24 @@
+# math_server.py
+from mcp.server.fastmcp import FastMCP
+
+mcp = FastMCP("Math")
+
+mcp.settings.port = 8000
+
+@mcp.tool()
+async def add(a: int, b: int) -> int:
+    """Add two numbers"""
+    return a + b
+
+@mcp.tool()
+async def multiply(a: int, b: int) -> int:
+    """Multiply two numbers"""
+    return a * b
+
+@mcp.tool()
+async def subtract(a: int, b: int) -> int:
+    """Subtract two numbers"""
+    return a - b
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

core/mcp_tools/weather_server.py

@@ -0,0 +1,49 @@
+# weather_server.py
+from typing import Dict, Any, Optional
+import requests
+from mcp.server.fastmcp import FastMCP
+import os
+from dotenv import load_dotenv
+load_dotenv()
+
+mcp = FastMCP("Weather")
+
+mcp.settings.port = 8001
+
+@mcp.tool()
+async def get_weather(location: str, lang: str = 'en') -> Dict[str, Any]:
+    """
+    Get current weather for a given location using WeatherAPI.
+
+    Args:
+        location (str): Location query, e.g., city name or "latitude,longitude".
+        lang (str): Language code for the response (default is 'en').
+
+    Returns:
+        dict: JSON response from WeatherAPI.
+    """
+    api_key = os.getenv("WEATHER_API_KEY")
+    if not api_key:
+        return {"error": "WEATHER_API_KEY not found in environment variables"}
+    
+    base_url = "http://api.weatherapi.com/v1"
+    endpoint = "/current.json"
+    
+    params = {
+        'key': api_key,
+        'q': location,
+        'lang': lang
+    }
+
+    try:
+        response = requests.get(base_url + endpoint, params=params)
+        response.raise_for_status()  # Raise exception for HTTP errors
+        data = response.json()
+        return data
+    except requests.RequestException as e:
+        return {"error": f"Request failed: {str(e)}"}
+    except Exception as e:
+        return {"error": f"Unexpected error: {str(e)}"}
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

dummydb.md

@@ -0,0 +1,273 @@
+Database Schema:
+
+CREATE TABLE IF NOT EXISTS public.erp_customers
+
+(
+
+    customer_id integer NOT NULL DEFAULT nextval('erp_customers_customer_id_seq'::regclass),
+
+    name character varying(100) COLLATE pg_catalog."default" NOT NULL,
+
+    email character varying(100) COLLATE pg_catalog."default" NOT NULL,
+
+    phone character varying(20) COLLATE pg_catalog."default",
+
+    address text COLLATE pg_catalog."default",
+
+    created_at timestamp without time zone DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT erp_customers_pkey PRIMARY KEY (customer_id),
+
+    CONSTRAINT erp_customers_email_key UNIQUE (email)
+
+)
+
+TABLESPACE pg_default;
+
+ALTER TABLE IF EXISTS public.erp_customers
+
+    OWNER to postgres;
+
+
+CREATE TABLE IF NOT EXISTS public.erp_invoices
+
+(
+
+    invoice_id integer NOT NULL DEFAULT nextval('erp_invoices_invoice_id_seq'::regclass),
+
+    order_id integer,
+
+    invoice_date date DEFAULT CURRENT_DATE,
+
+    amount numeric(12,2) NOT NULL,
+
+    payment_terms character varying(50) COLLATE pg_catalog."default",
+
+    due_date date,
+
+    is_paid boolean DEFAULT false,
+
+    invoice_number character varying(50) COLLATE pg_catalog."default",
+
+    CONSTRAINT erp_invoices_pkey PRIMARY KEY (invoice_id),
+
+    CONSTRAINT erp_invoices_invoice_number_key UNIQUE (invoice_number),
+
+    CONSTRAINT erp_invoices_order_id_fkey FOREIGN KEY (order_id)
+
+        REFERENCES public.erp_orders (order_id) MATCH SIMPLE
+
+        ON UPDATE NO ACTION
+
+        ON DELETE NO ACTION
+
+)
+
+TABLESPACE pg_default;
+
+ALTER TABLE IF EXISTS public.erp_invoices
+
+    OWNER to postgres;
+
+CREATE INDEX IF NOT EXISTS idx_invoices_order
+
+    ON public.erp_invoices USING btree
+
+    (order_id ASC NULLS LAST)
+
+    TABLESPACE pg_default;
+
+CREATE TABLE IF NOT EXISTS public.erp_order_history
+
+(
+
+    history_id integer NOT NULL DEFAULT nextval('erp_order_history_history_id_seq'::regclass),
+
+    order_id integer,
+
+    "timestamp" timestamp without time zone DEFAULT CURRENT_TIMESTAMP,
+
+    status_change character varying(50) COLLATE pg_catalog."default",
+
+    notes text COLLATE pg_catalog."default",
+
+    updated_by character varying(100) COLLATE pg_catalog."default",
+
+    CONSTRAINT erp_order_history_pkey PRIMARY KEY (history_id),
+
+    CONSTRAINT erp_order_history_order_id_fkey FOREIGN KEY (order_id)
+
+        REFERENCES public.erp_orders (order_id) MATCH SIMPLE
+
+        ON UPDATE NO ACTION
+
+        ON DELETE NO ACTION
+
+)
+
+TABLESPACE pg_default;
+
+ALTER TABLE IF EXISTS public.erp_order_history
+
+    OWNER to postgres;
+
+CREATE INDEX IF NOT EXISTS idx_order_history_order
+
+    ON public.erp_order_history USING btree
+
+    (order_id ASC NULLS LAST)
+
+    TABLESPACE pg_default;
+
+CREATE TABLE IF NOT EXISTS public.erp_order_items
+
+(
+
+    order_item_id integer NOT NULL DEFAULT nextval('erp_order_items_order_item_id_seq'::regclass),
+
+    order_id integer,
+
+    product_id integer,
+
+    quantity integer NOT NULL,
+
+    unit_price numeric(10,2) NOT NULL,
+
+    subtotal numeric(12,2) NOT NULL,
+
+    CONSTRAINT erp_order_items_pkey PRIMARY KEY (order_item_id),
+
+    CONSTRAINT erp_order_items_order_id_fkey FOREIGN KEY (order_id)
+
+        REFERENCES public.erp_orders (order_id) MATCH SIMPLE
+
+        ON UPDATE NO ACTION
+
+        ON DELETE NO ACTION,
+
+    CONSTRAINT erp_order_items_product_id_fkey FOREIGN KEY (product_id)
+
+        REFERENCES public.erp_products (product_id) MATCH SIMPLE
+
+        ON UPDATE NO ACTION
+
+        ON DELETE NO ACTION
+
+)
+
+TABLESPACE pg_default;
+
+ALTER TABLE IF EXISTS public.erp_order_items
+
+    OWNER to postgres;
+
+
+CREATE INDEX IF NOT EXISTS idx_order_items_order
+
+    ON public.erp_order_items USING btree
+
+    (order_id ASC NULLS LAST)
+
+    TABLESPACE pg_default;
+
+
+CREATE INDEX IF NOT EXISTS idx_order_items_product
+
+    ON public.erp_order_items USING btree
+
+    (product_id ASC NULLS LAST)
+
+    TABLESPACE pg_default;
+
+CREATE TABLE IF NOT EXISTS public.erp_orders
+
+(
+
+    order_id integer NOT NULL DEFAULT nextval('erp_orders_order_id_seq'::regclass),
+
+    customer_id integer,
+
+    order_date date DEFAULT CURRENT_DATE,
+
+    total_amount numeric(12,2) NOT NULL,
+
+    status character varying(20) COLLATE pg_catalog."default" NOT NULL DEFAULT 'Processing'::character varying,
+
+    previous_order_id integer,
+
+    estimated_delivery date,
+
+    actual_delivery date,
+
+    payment_status character varying(20) COLLATE pg_catalog."default" DEFAULT 'Pending'::character varying,
+
+    shipping_address text COLLATE pg_catalog."default" NOT NULL,
+
+    shipping_country character varying(100) COLLATE pg_catalog."default",
+
+    destination_country character varying(100) COLLATE pg_catalog."default",
+
+    CONSTRAINT erp_orders_pkey PRIMARY KEY (order_id),
+
+    CONSTRAINT erp_orders_customer_id_fkey FOREIGN KEY (customer_id)
+
+        REFERENCES public.erp_customers (customer_id) MATCH SIMPLE
+
+        ON UPDATE NO ACTION
+
+        ON DELETE NO ACTION,
+
+    CONSTRAINT erp_orders_previous_order_id_fkey FOREIGN KEY (previous_order_id)
+
+        REFERENCES public.erp_orders (order_id) MATCH SIMPLE
+
+        ON UPDATE NO ACTION
+
+        ON DELETE NO ACTION
+
+)
+
+TABLESPACE pg_default;
+
+ALTER TABLE IF EXISTS public.erp_orders
+
+    OWNER to postgres;
+
+CREATE INDEX IF NOT EXISTS idx_orders_customer
+
+    ON public.erp_orders USING btree
+
+    (customer_id ASC NULLS LAST)
+
+    TABLESPACE pg_default;
+
+
+CREATE TABLE IF NOT EXISTS public.erp_products
+
+(
+
+    product_id integer NOT NULL DEFAULT nextval('erp_products_product_id_seq'::regclass),
+
+    product_name character varying(100) COLLATE pg_catalog."default" NOT NULL,
+
+    description text COLLATE pg_catalog."default",
+
+    category character varying(50) COLLATE pg_catalog."default",
+
+    price numeric(10,2) NOT NULL,
+
+    stock_quantity integer NOT NULL DEFAULT 0,
+
+    sku character varying(50) COLLATE pg_catalog."default",
+
+    CONSTRAINT erp_products_pkey PRIMARY KEY (product_id),
+
+    CONSTRAINT erp_products_sku_key UNIQUE (sku)
+
+)
+
+TABLESPACE pg_default;
+
+ALTER TABLE IF EXISTS public.erp_products
+
+    OWNER to postgres;

requirements.txt

@@ -1 +1,11 @@
-psycopg2-binary==2.9.10
+psycopg2-binary==2.9.10
+gradio>=4.0.0
+langchain>=0.1.0
+langchain-core>=0.1.0
+langchain-openai>=0.0.5
+langchain-google-genai>=0.0.5
+langchain-community>=0.0.10
+langgraph=0.4.7
+langchain-mcp-adapters=0.0.5
+python-dotenv>=1.0.0
+mcp==1.9.0