Update Hyperliquid MCP server

README.md

@@ -1,98 +1,185 @@
 ---
-title: Hyperliquid MCP Server
-emoji: 📈
+title: Hyperliquid MCP Server & Trading Dashboard
+emoji: 📊
 colorFrom: blue
 colorTo: green
 sdk: docker
 pinned: false
 ---
 
-# Hyperliquid MCP Server
+# 🚀 Hyperliquid MCP Server & Trading Dashboard
 
-A Model Context Protocol (MCP) server that provides real-time trading data from Hyperliquid, a decentralized perpetual exchange.
+A production-ready **Model Context Protocol (MCP)** server with an interactive **Gradio dashboard** providing real-time trading data from **Hyperliquid** - the leading decentralized perpetual exchange.
 
-## Features
+## 🌐 Live Demo
+**URL**: https://huggingface.co/spaces/rzvn/hyperliquid-mcp-server
 
-- **Real-time Market Data**: Get live prices for all trading pairs
-- **Account Information**: Query user account states and positions
-- **Trade History**: Access recent trades for any trading pair
-- **Order Book Data**: Get L2 order book snapshots
-- **Historical Data**: Retrieve candlestick data with customizable intervals
-- **Market Metadata**: Get comprehensive market information
-- **Funding Rates**: Access perpetual contract funding rates
-- **Open Interest**: Monitor open interest across markets
+## 🎯 Features
 
-## API Endpoints
+### ✅ MCP Server
+- **8 Trading Tools** with RESTful API
+- **Model Context Protocol** compliance
+- **Real-time data** from Hyperliquid
 
-### Health Check
-```
-GET /health
-```
+### ✅ Interactive Dashboard
+- **5 Interactive Tabs** with live data
+- **Real-time charts** and visualizations
+- **User-friendly interface** for all tools
 
-### List Available Tools
-```
-POST /mcp/tools
-```
+## 📊 Available Trading Tools
 
-### Execute Tool
-```
-POST /mcp/call
-Content-Type: application/json
+### 1. **Market Prices** 📈
+Get real-time prices for 200+ trading pairs
+- Live price feed
+- Top 20 by value
+- Interactive data table
 
-{
-  "name": "get_all_mids",
-  "arguments": {}
-}
-```
+### 2. **Recent Trades** 💱
+View recent trading activity
+- Customizable trade count (1-1000)
+- Real-time trade history
+- Symbol-based filtering
 
-## Available Tools
+### 3. **Candlestick Charts** 📊
+Interactive price charts
+- Multiple timeframes (1m, 5m, 1h, 4h, 1d)
+- Customizable candle count
+- Professional charting with Plotly
 
-1. **get_all_mids** - Get all market prices
-2. **get_user_state** - Get user account state (requires address)
-3. **get_recent_trades** - Get recent trades for a coin
-4. **get_l2_snapshot** - Get L2 order book snapshot
-5. **get_candles** - Get historical candlestick data
-6. **get_meta** - Get market metadata
-7. **get_funding_rates** - Get funding rates
-8. **get_open_interest** - Get open interest data
+### 4. **Order Book** 📋
+Live order book visualization
+- Bid/ask depth charts
+- Real-time updates
+- Symbol-based lookup
 
-## Usage Examples
+### 5. **Funding Rates** 💰
+Perpetual contract funding rates
+- All markets overview
+- Individual symbol focus
+- Historical rate tracking
 
-### Get All Market Prices
-```bash
-curl -X POST https://your-space.hf.space/mcp/call \
-  -H "Content-Type: application/json" \
-  -d '{"name":"get_all_mids","arguments":{}}'
-```
+## 🔧 API Usage
 
-### Get Recent BTC Trades
+### MCP Endpoints
+- **Health Check**: `GET /health`
+- **List Tools**: `POST /mcp/tools`
+- **Execute Tool**: `POST /mcp/call`
+
+### Example API Calls
+
+#### Get All Market Prices
 ```bash
-curl -X POST https://your-space.hf.space/mcp/call \
+curl -X POST https://rzvn-hyperliquid-mcp-server.hf.space/mcp/call \
   -H "Content-Type: application/json" \
-  -d '{"name":"get_recent_trades","arguments":{"coin":"BTC","n":10}}'
+  -d '{"name": "get_all_mids", "arguments": {}}'
 ```
 
-### Get User State
+#### Get Recent BTC Trades
 ```bash
-curl -X POST https://your-space.hf.space/mcp/call \
+curl -X POST https://rzvn-hyperliquid-mcp-server.hf.space/mcp/call \
   -H "Content-Type: application/json" \
-  -d '{"name":"get_user_state","arguments":{"address":"0x123...abc"}}'
+  -d '{"name": "get_recent_trades", "arguments": {"coin": "BTC", "n": 50}}'
 ```
 
-## Local Development
+## 🖥️ Interactive Dashboard Usage
+
+### Dashboard Tabs
+
+#### 📈 **Market Prices Tab**
+- Click "Get All Market Prices" to load live data
+- View top 20 cryptocurrencies by price
+- Interactive sorting and filtering
+
+#### 💱 **Recent Trades Tab**
+- Enter coin symbol (e.g., "BTC", "ETH")
+- Adjust number of trades with slider
+- View detailed trade history table
+
+#### 📊 **Candlestick Charts Tab**
+- Enter coin symbol
+- Select timeframe (1m to 1d)
+- Adjust number of candles
+- Interactive zoom and pan
+
+#### 📋 **Order Book Tab**
+- Enter coin symbol
+- View live bid/ask depth
+- Visual order book representation
+
+#### 💰 **Funding Rates Tab**
+- Optional coin symbol input
+- View all funding rates or specific symbol
+- Real-time rate updates
 
+## 🛠️ Development
+
+### Local Setup
 ```bash
+# Clone the repository
+git clone https://huggingface.co/spaces/rzvn/hyperliquid-mcp-server
+cd hyperliquid-mcp-server
+
+# Install dependencies
 pip install -r requirements.txt
+
+# Run locally
 python app.py
 ```
 
-## Docker Deployment
+### Access Points
+- **Gradio Dashboard**: http://localhost:7860
+- **MCP API**: http://localhost:3001
 
+### Docker Build
 ```bash
 docker build -t hyperliquid-mcp .
-docker run -p 7860:7860 hyperliquid-mcp
+docker run -p 7860:7860 -p 3001:3001 hyperliquid-mcp
 ```
 
-## Integration with MCP Clients
+## 🔗 MCP Integration
+
+This server follows the **Model Context Protocol (MCP)** standard, making it compatible with:
+- Claude Desktop
+- Cursor AI
+- Any MCP-compatible client
+- Custom applications
+
+## 📈 Data Coverage
+
+- **200+ Trading Pairs**: All major cryptocurrencies and altcoins
+- **Real-time Data**: Live prices, trades, and order books
+- **Historical Data**: Candlestick charts with multiple timeframes
+- **Perpetual Contracts**: Funding rates and open interest
+- **Account Analytics**: Portfolio tracking and position management
+
+## 🎯 Use Cases
+
+### For Traders
+- **Real-time market monitoring**
+- **Technical analysis with charts**
+- **Order book analysis**
+- **Funding rate tracking**
+
+### For Developers
+- **MCP server integration**
+- **RESTful API access**
+- **Real-time data feeds**
+- **Trading bot development**
+
+### For Analysts
+- **Market research**
+- **Historical data analysis**
+- **Trading strategy backtesting**
+- **Market sentiment analysis**
+
+## 🤝 Contributing
+
+Feel free to open issues or submit pull requests to enhance the server with additional Hyperliquid endpoints or features.
+
+## 📄 License
+
+MIT License - Feel free to use this server for your own projects and applications.
+
+---
 
-This server follows the Model Context Protocol (MCP) specification and can be integrated with any MCP-compatible client. Configure your client to use the space URL as the MCP server endpoint.
+**Built with ❤️ for the Hyperliquid trading community**

app.py

@@ -1,269 +1,433 @@
-import os
 import json
 import requests
+import gradio as gr
 from flask import Flask, request, jsonify
 from flask_cors import CORS
+import pandas as pd
+import plotly.graph_objects as go
+import plotly.express as px
+from datetime import datetime
+import threading
 
 app = Flask(__name__)
 CORS(app)
 
 # Hyperliquid API base URL
-BASE_URL = "https://api.hyperliquid.xyz"
+HYPERLIQUID_API = "https://api.hyperliquid.xyz/info"
 
-def make_hyperliquid_request(endpoint, payload=None):
-    """Make a request to the Hyperliquid API"""
+# MCP Server Info
+MCP_INFO = {
+    "name": "Hyperliquid MCP Server",
+    "version": "1.0.0",
+    "description": "MCP server for Hyperliquid trading data",
+    "endpoints": {
+        "tools": "/mcp/tools",
+        "call": "/mcp/call",
+        "health": "/health"
+    }
+}
+
+# Tool definitions
+TOOLS = [
+    {
+        "name": "get_all_mids",
+        "description": "Get all market prices from Hyperliquid",
+        "inputSchema": {"type": "object", "properties": {}}
+    },
+    {
+        "name": "get_user_state",
+        "description": "Get user account state and positions",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "address": {"type": "string", "description": "User wallet address"}
+            },
+            "required": ["address"]
+        }
+    },
+    {
+        "name": "get_recent_trades",
+        "description": "Get recent trades for a specific coin",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "coin": {"type": "string", "description": "Trading pair symbol (e.g., 'BTC')"},
+                "n": {"type": "number", "description": "Number of trades to retrieve (1-1000)", "default": 100}
+            },
+            "required": ["coin"]
+        }
+    },
+    {
+        "name": "get_l2_snapshot",
+        "description": "Get L2 order book snapshot",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "coin": {"type": "string", "description": "Trading pair symbol (e.g., 'BTC')"}
+            },
+            "required": ["coin"]
+        }
+    },
+    {
+        "name": "get_candles",
+        "description": "Get historical candlestick data",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "coin": {"type": "string", "description": "Trading pair symbol (e.g., 'BTC')"},
+                "interval": {"type": "string", "description": "Time interval (e.g., '1m', '5m', '1h', '1d')", "default": "1h"},
+                "limit": {"type": "number", "description": "Number of candles to retrieve (1-5000)", "default": 500}
+            },
+            "required": ["coin"]
+        }
+    },
+    {
+        "name": "get_meta",
+        "description": "Get market metadata",
+        "inputSchema": {"type": "object", "properties": {}}
+    },
+    {
+        "name": "get_funding_rates",
+        "description": "Get funding rates for perpetual contracts",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "coin": {"type": "string", "description": "Trading pair symbol (optional)"}
+            }
+        }
+    },
+    {
+        "name": "get_open_interest",
+        "description": "Get open interest data",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "coin": {"type": "string", "description": "Trading pair symbol"}
+            },
+            "required": ["coin"]
+        }
+    }
+]
+
+# Tool implementations
+def get_all_mids():
+    """Get all market prices from Hyperliquid"""
     try:
-        url = f"{BASE_URL}/{endpoint}"
-        if payload:
-            response = requests.post(url, json=payload, timeout=10)
-        else:
-            response = requests.get(url, timeout=10)
-        
+        response = requests.post(HYPERLIQUID_API, json={"type": "allMids"})
         response.raise_for_status()
-        return response.json()
-    except requests.exceptions.RequestException as e:
-        return {"error": str(e)}
+        return {"success": True, "data": response.json()}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
 
-@app.route('/')
-def home():
-    """Home page with API information"""
-    return jsonify({
-        "name": "Hyperliquid MCP Server",
-        "version": "1.0.0",
-        "description": "MCP server for Hyperliquid trading data",
-        "endpoints": {
-            "health": "/health",
-            "tools": "/mcp/tools",
-            "call": "/mcp/call"
-        }
-    })
+def get_user_state(address):
+    """Get user account state and positions"""
+    try:
+        response = requests.post(HYPERLIQUID_API, json={
+            "type": "userState",
+            "user": address
+        })
+        response.raise_for_status()
+        return {"success": True, "data": response.json()}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+def get_recent_trades(coin, n=100):
+    """Get recent trades for a specific coin"""
+    try:
+        response = requests.post(HYPERLIQUID_API, json={
+            "type": "trades",
+            "coin": coin,
+            "n": n
+        })
+        response.raise_for_status()
+        return {"success": True, "data": response.json()}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+def get_l2_snapshot(coin):
+    """Get L2 order book snapshot"""
+    try:
+        response = requests.post(HYPERLIQUID_API, json={
+            "type": "l2Book",
+            "coin": coin
+        })
+        response.raise_for_status()
+        return {"success": True, "data": response.json()}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+def get_candles(coin, interval="1h", limit=500):
+    """Get historical candlestick data"""
+    try:
+        response = requests.post(HYPERLIQUID_API, json={
+            "type": "candles",
+            "coin": coin,
+            "interval": interval,
+            "limit": limit
+        })
+        response.raise_for_status()
+        return {"success": True, "data": response.json()}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+def get_meta():
+    """Get market metadata"""
+    try:
+        response = requests.post(HYPERLIQUID_API, json={"type": "meta"})
+        response.raise_for_status()
+        return {"success": True, "data": response.json()}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
 
+def get_funding_rates(coin=None):
+    """Get funding rates for perpetual contracts"""
+    try:
+        payload = {"type": "fundingRate"}
+        if coin:
+            payload["coin"] = coin
+        response = requests.post(HYPERLIQUID_API, json=payload)
+        response.raise_for_status()
+        return {"success": True, "data": response.json()}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+def get_open_interest(coin):
+    """Get open interest data"""
+    try:
+        response = requests.post(HYPERLIQUID_API, json={
+            "type": "openInterest",
+            "coin": coin
+        })
+        response.raise_for_status()
+        return {"success": True, "data": response.json()}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+# Flask routes for MCP
 @app.route('/health')
 def health():
-    """Health check endpoint"""
-    return jsonify({
-        "status": "healthy",
-        "timestamp": requests.utils.default_user_agent()
-    })
+    return jsonify({"status": "healthy", "timestamp": datetime.now().isoformat()})
 
 @app.route('/mcp/tools', methods=['POST'])
-def list_tools():
-    """List all available MCP tools"""
-    tools = [
-        {
-            "name": "get_all_mids",
-            "description": "Get all market prices from Hyperliquid",
-            "inputSchema": {
-                "type": "object",
-                "properties": {},
-            },
-        },
-        {
-            "name": "get_user_state",
-            "description": "Get user account state and positions",
-            "inputSchema": {
-                "type": "object",
-                "properties": {
-                    "address": {
-                        "type": "string",
-                        "description": "User wallet address",
-                    },
-                },
-                "required": ["address"],
-            },
-        },
-        {
-            "name": "get_recent_trades",
-            "description": "Get recent trades for a specific coin",
-            "inputSchema": {
-                "type": "object",
-                "properties": {
-                    "coin": {
-                        "type": "string",
-                        "description": "Trading pair symbol (e.g., 'BTC')",
-                    },
-                    "n": {
-                        "type": "number",
-                        "description": "Number of trades to retrieve (1-1000)",
-                        "default": 100,
-                    },
-                },
-                "required": ["coin"],
-            },
-        },
-        {
-            "name": "get_l2_snapshot",
-            "description": "Get L2 order book snapshot",
-            "inputSchema": {
-                "type": "object",
-                "properties": {
-                    "coin": {
-                        "type": "string",
-                        "description": "Trading pair symbol (e.g., 'BTC')",
-                    },
-                },
-                "required": ["coin"],
-            },
-        },
-        {
-            "name": "get_candles",
-            "description": "Get historical candlestick data",
-            "inputSchema": {
-                "type": "object",
-                "properties": {
-                    "coin": {
-                        "type": "string",
-                        "description": "Trading pair symbol (e.g., 'BTC')",
-                    },
-                    "interval": {
-                        "type": "string",
-                        "description": "Time interval (e.g., '1m', '5m', '1h', '1d')",
-                        "default": "1h",
-                    },
-                    "startTime": {
-                        "type": "number",
-                        "description": "Start timestamp in milliseconds",
-                    },
-                    "endTime": {
-                        "type": "number",
-                        "description": "End timestamp in milliseconds",
-                    },
-                    "limit": {
-                        "type": "number",
-                        "description": "Number of candles to retrieve (1-5000)",
-                        "default": 500,
-                    },
-                },
-                "required": ["coin"],
-            },
-        },
-        {
-            "name": "get_meta",
-            "description": "Get market metadata",
-            "inputSchema": {
-                "type": "object",
-                "properties": {},
-            },
-        },
-        {
-            "name": "get_funding_rates",
-            "description": "Get funding rates for perpetual contracts",
-            "inputSchema": {
-                "type": "object",
-                "properties": {
-                    "coin": {
-                        "type": "string",
-                        "description": "Trading pair symbol (optional)",
-                    },
-                },
-            },
-        },
-        {
-            "name": "get_open_interest",
-            "description": "Get open interest data",
-            "inputSchema": {
-                "type": "object",
-                "properties": {
-                    "coin": {
-                        "type": "string",
-                        "description": "Trading pair symbol",
-                    },
-                },
-                "required": ["coin"],
-            },
-        },
-    ]
-    return jsonify({"tools": tools})
+def mcp_tools():
+    return jsonify({"tools": TOOLS})
 
 @app.route('/mcp/call', methods=['POST'])
-def call_tool():
-    """Execute an MCP tool"""
-    try:
-        data = request.get_json()
-        tool_name = data.get('name')
-        arguments = data.get('arguments', {})
-        
-        if not tool_name:
-            return jsonify({"error": "Tool name is required"}), 400
-        
-        # Handle different tool calls
-        if tool_name == "get_all_mids":
-            result = make_hyperliquid_request("info", {"type": "allMids"})
-            
-        elif tool_name == "get_user_state":
-            address = arguments.get("address")
-            if not address:
-                return jsonify({"error": "address is required"}), 400
-            result = make_hyperliquid_request("info", {"type": "userState", "user": address})
-            
-        elif tool_name == "get_recent_trades":
-            coin = arguments.get("coin")
-            n = arguments.get("n", 100)
-            if not coin:
-                return jsonify({"error": "coin is required"}), 400
-            result = make_hyperliquid_request("info", {"type": "recentTrades", "coin": coin, "n": n})
-            
-        elif tool_name == "get_l2_snapshot":
-            coin = arguments.get("coin")
-            if not coin:
-                return jsonify({"error": "coin is required"}), 400
-            result = make_hyperliquid_request("info", {"type": "l2Snapshot", "coin": coin})
-            
-        elif tool_name == "get_candles":
-            coin = arguments.get("coin")
-            if not coin:
-                return jsonify({"error": "coin is required"}), 400
-            payload = {
-                "type": "candles",
-                "coin": coin,
-                "interval": arguments.get("interval", "1h"),
-                "limit": arguments.get("limit", 500)
-            }
-            if "startTime" in arguments:
-                payload["startTime"] = arguments["startTime"]
-            if "endTime" in arguments:
-                payload["endTime"] = arguments["endTime"]
-            result = make_hyperliquid_request("info", payload)
-            
-        elif tool_name == "get_meta":
-            result = make_hyperliquid_request("info", {"type": "meta"})
-            
-        elif tool_name == "get_funding_rates":
-            coin = arguments.get("coin")
-            payload = {"type": "fundingRates"}
-            if coin:
-                payload["coin"] = coin
-            result = make_hyperliquid_request("info", payload)
+def mcp_call():
+    data = request.get_json()
+    tool_name = data.get('name')
+    arguments = data.get('arguments', {})
+    
+    if not tool_name:
+        return jsonify({"error": "Tool name is required"}), 400
+    
+    # Map tool names to functions
+    tool_functions = {
+        "get_all_mids": get_all_mids,
+        "get_user_state": lambda: get_user_state(arguments.get("address")),
+        "get_recent_trades": lambda: get_recent_trades(arguments.get("coin"), arguments.get("n", 100)),
+        "get_l2_snapshot": lambda: get_l2_snapshot(arguments.get("coin")),
+        "get_candles": lambda: get_candles(arguments.get("coin"), arguments.get("interval", "1h"), arguments.get("limit", 500)),
+        "get_meta": get_meta,
+        "get_funding_rates": lambda: get_funding_rates(arguments.get("coin")),
+        "get_open_interest": lambda: get_open_interest(arguments.get("coin"))
+    }
+    
+    if tool_name not in tool_functions:
+        return jsonify({"error": f"Unknown tool: {tool_name}"}), 400
+    
+    result = tool_functions[tool_name]()
+    
+    if result["success"]:
+        return jsonify({"content": [{"type": "text", "text": json.dumps(result["data"], indent=2)}]})
+    else:
+        return jsonify({"error": result["error"]}), 500
+
+# Gradio UI functions
+def get_all_prices_ui():
+    """UI function for getting all market prices"""
+    result = get_all_mids()
+    if result["success"]:
+        prices = result["data"]
+        # Create a DataFrame for better display
+        df = pd.DataFrame(list(prices.items()), columns=['Symbol', 'Price'])
+        df['Price'] = pd.to_numeric(df['Price'])
+        df = df.sort_values('Price', ascending=False).head(20)
+        return df
+    return pd.DataFrame()
+
+def get_recent_trades_ui(coin, num_trades):
+    """UI function for getting recent trades"""
+    if not coin:
+        return pd.DataFrame(), "Please enter a coin symbol"
+    
+    result = get_recent_trades(coin.upper(), int(num_trades))
+    if result["success"]:
+        trades = result["data"]
+        if trades:
+            df = pd.DataFrame(trades)
+            return df, f"Found {len(trades)} trades for {coin.upper()}"
+    return pd.DataFrame(), f"No trades found for {coin.upper()}"
+
+def get_candles_ui(coin, interval, limit):
+    """UI function for getting candlestick data"""
+    if not coin:
+        return None, "Please enter a coin symbol"
+    
+    result = get_candles(coin.upper(), interval, int(limit))
+    if result["success"]:
+        candles = result["data"]
+        if candles:
+            df = pd.DataFrame(candles, columns=['time', 'open', 'high', 'low', 'close', 'volume'])
+            df['time'] = pd.to_datetime(df['time'], unit='ms')
             
-        elif tool_name == "get_open_interest":
-            coin = arguments.get("coin")
-            if not coin:
-                return jsonify({"error": "coin is required"}), 400
-            result = make_hyperliquid_request("info", {"type": "openInterest", "coin": coin})
+            # Create candlestick chart
+            fig = go.Figure(data=[go.Candlestick(
+                x=df['time'],
+                open=df['open'],
+                high=df['high'],
+                low=df['low'],
+                close=df['close'],
+                name=coin.upper()
+            )])
+            fig.update_layout(
+                title=f'{coin.upper()} Candlestick Chart ({interval})',
+                xaxis_title='Time',
+                yaxis_title='Price',
+                template='plotly_dark'
+            )
+            return fig, f"Loaded {len(df)} candles for {coin.upper()}"
+    return None, f"No data found for {coin.upper()}"
+
+def get_orderbook_ui(coin):
+    """UI function for getting order book"""
+    if not coin:
+        return None, "Please enter a coin symbol"
+    
+    result = get_l2_snapshot(coin.upper())
+    if result["success"]:
+        data = result["data"]
+        if data and 'levels' in data:
+            bids = pd.DataFrame(data['levels'][0], columns=['price', 'size'])
+            asks = pd.DataFrame(data['levels'][1], columns=['price', 'size'])
             
-        else:
-            return jsonify({"error": f"Unknown tool: {tool_name}"}), 400
+            # Create order book chart
+            fig = go.Figure()
+            fig.add_trace(go.Bar(
+                x=bids['price'], y=bids['size'],
+                name='Bids', marker_color='green', opacity=0.7
+            ))
+            fig.add_trace(go.Bar(
+                x=asks['price'], y=asks['size'],
+                name='Asks', marker_color='red', opacity=0.7
+            ))
+            fig.update_layout(
+                title=f'{coin.upper()} Order Book',
+                xaxis_title='Price',
+                yaxis_title='Size',
+                template='plotly_dark',
+                barmode='overlay'
+            )
+            return fig, f"Order book loaded for {coin.upper()}"
+    return None, f"No order book data for {coin.upper()}"
+
+def get_funding_rates_ui(coin):
+    """UI function for getting funding rates"""
+    result = get_funding_rates(coin.upper() if coin else None)
+    if result["success"]:
+        rates = result["data"]
+        if rates:
+            df = pd.DataFrame(rates)
+            return df
+    return pd.DataFrame()
+
+# Create Gradio interface
+def create_gradio_interface():
+    with gr.Blocks(title="Hyperliquid Trading Dashboard", theme=gr.themes.Soft()) as demo:
+        gr.Markdown("# 📊 Hyperliquid Trading Dashboard")
+        gr.Markdown("Real-time trading data from Hyperliquid decentralized exchange")
         
-        return jsonify({
-            "content": [
-                {
-                    "type": "text",
-                    "text": json.dumps(result, indent=2)
-                }
-            ]
-        })
+        with gr.Tab("📈 Market Prices"):
+            with gr.Row():
+                get_prices_btn = gr.Button("Get All Market Prices", variant="primary")
+            prices_output = gr.Dataframe(headers=["Symbol", "Price"], interactive=False)
+            get_prices_btn.click(get_all_prices_ui, outputs=prices_output)
         
-    except Exception as e:
-        return jsonify({
-            "content": [
-                {
-                    "type": "text",
-                    "text": f"Error: {str(e)}"
-                }
-            ],
-            "isError": True
-        }), 500
+        with gr.Tab("💱 Recent Trades"):
+            with gr.Row():
+                coin_input = gr.Textbox(label="Coin Symbol", placeholder="BTC")
+                num_trades = gr.Slider(1, 1000, 50, label="Number of Trades")
+                get_trades_btn = gr.Button("Get Trades", variant="primary")
+            trades_output = gr.Dataframe(interactive=False)
+            trades_status = gr.Textbox(label="Status", interactive=False)
+            get_trades_btn.click(
+                get_recent_trades_ui,
+                inputs=[coin_input, num_trades],
+                outputs=[trades_output, trades_status]
+            )
+        
+        with gr.Tab("📊 Candlestick Charts"):
+            with gr.Row():
+                candle_coin = gr.Textbox(label="Coin Symbol", placeholder="BTC")
+                candle_interval = gr.Dropdown(
+                    choices=["1m", "5m", "15m", "1h", "4h", "1d"],
+                    value="1h",
+                    label="Interval"
+                )
+                candle_limit = gr.Slider(10, 1000, 100, label="Number of Candles")
+                get_candles_btn = gr.Button("Get Chart", variant="primary")
+            candle_chart = gr.Plot()
+            candle_status = gr.Textbox(label="Status", interactive=False)
+            get_candles_btn.click(
+                get_candles_ui,
+                inputs=[candle_coin, candle_interval, candle_limit],
+                outputs=[candle_chart, candle_status]
+            )
+        
+        with gr.Tab("📋 Order Book"):
+            with gr.Row():
+                orderbook_coin = gr.Textbox(label="Coin Symbol", placeholder="BTC")
+                get_orderbook_btn = gr.Button("Get Order Book", variant="primary")
+            orderbook_chart = gr.Plot()
+            orderbook_status = gr.Textbox(label="Status", interactive=False)
+            get_orderbook_btn.click(
+                get_orderbook_ui,
+                inputs=[orderbook_coin],
+                outputs=[orderbook_chart, orderbook_status]
+            )
+        
+        with gr.Tab("💰 Funding Rates"):
+            with gr.Row():
+                funding_coin = gr.Textbox(label="Coin Symbol (optional)", placeholder="BTC")
+                get_funding_btn = gr.Button("Get Funding Rates", variant="primary")
+            funding_output = gr.Dataframe(interactive=False)
+            get_funding_btn.click(
+                get_funding_rates_ui,
+                inputs=[funding_coin],
+                outputs=[funding_output]
+            )
+    
+    return demo
+
+# Create and launch Gradio interface
+gradio_demo = create_gradio_interface()
+
+# Flask routes
+@app.route('/')
+def home():
+    return jsonify(MCP_INFO)
 
-if __name__ == "__main__":
-    port = int(os.environ.get("PORT", 7860))
-    app.run(host="0.0.0.0", port=port)
+# Start both Flask and Gradio
+if __name__ == '__main__':
+    # Start Gradio in a separate thread
+    def run_gradio():
+        gradio_demo.launch(
+            server_name="0.0.0.0",
+            server_port=7860,
+            share=False,
+            quiet=True
+        )
+    
+    # Start Flask in main thread
+    threading.Thread(target=run_gradio, daemon=True).start()
+    app.run(host='0.0.0.0', port=3001, debug=False)

requirements.txt

@@ -1,4 +1,7 @@
 flask==2.3.3
 flask-cors==4.0.0
 requests==2.31.0
-gunicorn==21.2.0
+gunicorn==21.2.0
+gradio==4.44.0
+pandas==2.1.4
+plotly==5.17.0