binance-futures-mcp 1.0.0__py3-none-any.whl

binance_futures_mcp-1.0.0.dist-info/METADATA

@@ -0,0 +1,437 @@
+Metadata-Version: 2.4
+Name: binance-futures-mcp
+Version: 1.0.0
+Summary: A Model Context Protocol server for Binance Futures API
+Author: Binance MCP Server
+License: MIT
+Project-URL: Homepage, https://github.com/bin-mcp/binance-mcp-server
+Project-URL: Repository, https://github.com/bin-mcp/binance-mcp-server.git
+Project-URL: Issues, https://github.com/bin-mcp/binance-mcp-server/issues
+Keywords: mcp,binance,trading,futures,api,model-context-protocol
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Office/Business :: Financial :: Investment
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mcp>=1.0.0
+Requires-Dist: aiohttp>=3.8.0
+Requires-Dist: pydantic>=2.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Dynamic: license-file
+
+# Binance MCP Server
+
+A Model Context Protocol (MCP) server that provides comprehensive access to Binance Futures API endpoints. This server implements all major trading, account management, and market data functionality as documented in the Binance Futures API.
+
+## Features
+
+### Account Information Tools
+- Get account info, balance, and position information
+- Query position mode and commission rates
+- Access risk management data (ADL quantile, leverage brackets, force orders)
+
+### Order Management Tools
+- Place orders (MARKET, LIMIT, STOP, STOP_MARKET, TRAILING_STOP_MARKET)
+- Place multiple orders in batch
+- Cancel orders (single, multiple, or all)
+- Query order status and history
+- Auto-cancel functionality
+
+### Trading Configuration Tools
+- Change leverage and margin type
+- Switch between hedge and one-way position modes
+- Modify position margins
+
+### Market Data Tools
+- Get exchange information and trading rules
+- Access real-time price data and order books
+- Retrieve candlestick/kline data
+- Get mark prices and funding rates
+- Access aggregate trade data
+
+### Trading History Tools
+- Get account trade history
+- Access income history (funding fees, PnL, etc.)
+- Retrieve funding rate history
+
+## Installation
+
+### Prerequisites
+- Python 3.8 or higher
+- Binance Futures API credentials
+
+### Method 1: Install via uvx (Recommended)
+
+```bash
+uvx --from git+https://github.com/alexcandrabersiva/bin-mcp binance-mcp-server
+```
+
+### Method 2: Local Installation
+
+```bash
+cd binance-mcp-server
+pip install -e .
+```
+
+Or install development dependencies:
+
+```bash
+pip install -e ".[dev]"
+```
+
+## MCP Client Configuration
+
+This server can be integrated with various MCP clients. Here are configuration examples for popular clients:
+
+### VS Code
+
+Add to your VS Code `settings.json`:
+
+```json
+{
+  "mcp.servers": {
+    "binance": {
+      "command": "uvx",
+      "args": ["binance-mcp-server"],
+      "env": {
+        "BINANCE_API_KEY": "your_api_key_here",
+        "BINANCE_SECRET_KEY": "your_secret_key_here"
+      }
+    }
+  }
+}
+```
+
+### Cursor
+
+Add to your Cursor configuration file (`.cursor/mcp.json`):
+
+```json
+{
+  "servers": {
+    "binance": {
+      "command": "uvx",
+      "args": ["binance-mcp-server"],
+      "env": {
+        "BINANCE_API_KEY": "your_api_key_here",
+        "BINANCE_SECRET_KEY": "your_secret_key_here"
+      }
+    }
+  }
+}
+```
+
+### Windsurf
+
+Add to your Windsurf configuration (`.windsurf/mcp.json`):
+
+```json
+{
+  "mcpServers": {
+    "binance": {
+      "command": "uvx",
+      "args": ["binance-mcp-server"],
+      "env": {
+        "BINANCE_API_KEY": "your_api_key_here",
+        "BINANCE_SECRET_KEY": "your_secret_key_here"
+      }
+    }
+  }
+}
+```
+
+### Claude Desktop
+
+Add to your Claude Desktop configuration file:
+
+**On macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
+**On Windows**: `%APPDATA%/Claude/claude_desktop_config.json`
+
+```json
+{
+  "mcpServers": {
+    "binance": {
+      "command": "uvx",
+      "args": ["binance-mcp-server"],
+      "env": {
+        "BINANCE_API_KEY": "your_api_key_here",
+        "BINANCE_SECRET_KEY": "your_secret_key_here"
+      }
+    }
+  }
+}
+```
+
+### Configuration Notes
+
+1. **No path needed**: With PyPI installation, you don't need to specify paths or working directories.
+
+2. **Set API credentials**: Replace `your_api_key_here` and `your_secret_key_here` with your actual Binance API credentials.
+
+3. **Alternative commands**: You can also use:
+   - `pip install binance-mcp-server && python -m binance_mcp`
+   - `binance-mcp-server` (if installed globally)
+
+4. **Python environment**: Using `uvx` automatically handles the Python environment.
+
+5. **Security**: For production use, consider storing credentials in your system's environment variables instead of directly in configuration files.
+
+## Installation
+
+### Prerequisites
+- Python 3.8 or higher
+- Binance Futures API credentials
+
+### Method 1: Install via uvx (Recommended)
+
+```bash
+uvx --from git+https://github.com/alexcandrabersiva/bin-mcp binance-mcp-server
+```
+
+### Method 2: Local Installation
+
+```bash
+cd binance-mcp-server
+pip install -e .
+```
+
+Or install development dependencies:
+
+```bash
+pip install -e ".[dev]"
+```
+
+## Configuration
+
+### Environment Variables
+
+Set your Binance API credentials as environment variables:
+
+```bash
+export BINANCE_API_KEY="your_api_key_here"
+export BINANCE_SECRET_KEY="your_secret_key_here"
+```
+
+### API Permissions
+
+Your Binance API key needs the following permissions:
+- **Futures Trading**: For order placement and management
+- **Futures Reading**: For account and market data access
+
+**Note**: Market data endpoints (exchange info, prices, order books, etc.) work without authentication.
+
+## Usage
+
+### Running the Server
+
+```bash
+# Run directly
+python -m binance_mcp
+
+# Or using the installed script
+binance-mcp-server
+```
+
+### Available Tools
+
+The server provides 32 tools organized into categories:
+
+#### Account Information (5 tools)
+- `get_account_info` - Get futures account information
+- `get_balance` - Get account balance for all assets
+- `get_position_info` - Get current position information
+- `get_position_mode` - Get position mode (Hedge/One-way)
+- `get_commission_rate` - Get commission rate for a symbol
+
+#### Risk Management (4 tools)
+- `get_adl_quantile` - Get ADL quantile estimation
+- `get_leverage_brackets` - Get leverage brackets
+- `get_force_orders` - Get liquidation orders
+- `get_position_margin_history` - Get margin change history
+
+#### Order Management (10 tools)
+- `place_order` - Place a futures order
+- `place_multiple_orders` - Place multiple orders in batch
+- `cancel_order` - Cancel an active order
+- `cancel_multiple_orders` - Cancel multiple orders
+- `cancel_all_orders` - Cancel all open orders for a symbol
+- `auto_cancel_all_orders` - Set up auto-cancellation
+- `get_open_order` - Query specific open order
+- `get_open_orders` - Get all open orders
+- `get_all_orders` - Get all orders (filled, canceled, rejected)
+- `query_order` - Query order status
+
+#### Trading Configuration (4 tools)
+- `change_leverage` - Change initial leverage
+- `change_margin_type` - Change margin type (ISOLATED/CROSSED)
+- `change_position_mode` - Change position mode
+- `modify_position_margin` - Modify position margin
+
+#### Market Data (6 tools)
+- `get_exchange_info` - Get trading rules and symbol info
+- `get_book_ticker` - Get best bid/ask prices
+- `get_price_ticker` - Get latest prices
+- `get_order_book` - Get order book depth
+- `get_klines` - Get candlestick data
+- `get_mark_price` - Get mark price and funding rate
+- `get_aggregate_trades` - Get aggregate trade data
+
+#### Trading History (3 tools)
+- `get_account_trades` - Get account trade history
+- `get_income_history` - Get income history
+- `get_funding_rate_history` - Get funding rate history
+
+## Example Usage
+
+### Place a Market Order
+
+```json
+{
+  "tool": "place_order",
+  "arguments": {
+    "symbol": "BTCUSDT",
+    "side": "BUY",
+    "order_type": "MARKET",
+    "quantity": 0.001
+  }
+}
+```
+
+### Place a Limit Order
+
+```json
+{
+  "tool": "place_order",
+  "arguments": {
+    "symbol": "BTCUSDT",
+    "side": "BUY",
+    "order_type": "LIMIT",
+    "quantity": 0.001,
+    "price": 50000.0,
+    "time_in_force": "GTC"
+  }
+}
+```
+
+### Get Account Information
+
+```json
+{
+  "tool": "get_account_info",
+  "arguments": {}
+}
+```
+
+### Get Market Data
+
+```json
+{
+  "tool": "get_klines",
+  "arguments": {
+    "symbol": "BTCUSDT",
+    "interval": "1h",
+    "limit": 100
+  }
+}
+```
+
+## Security
+
+### API Key Security
+- Store API credentials securely using environment variables
+- Never commit credentials to version control
+- Use API keys with minimal required permissions
+- Consider using testnet for development
+
+### Rate Limiting
+The server respects Binance's rate limits:
+- Weight-based limits for different endpoints
+- Order placement rate limits
+- Automatic signature generation for authenticated requests
+
+### Error Handling
+- Comprehensive error handling for API failures
+- Clear error messages for common issues
+- Validation of required parameters
+
+## API Reference
+
+This server implements all endpoints documented in the Binance Futures API:
+
+- **Base URL**: `https://fapi.binance.com`
+- **API Type**: Binance USD-S Margined Futures
+- **Authentication**: API Key + HMAC SHA256 Signature
+
+For detailed parameter specifications, see the [Binance Futures API Documentation](https://binance-docs.github.io/apidocs/futures/en/).
+
+## Development
+
+### Project Structure
+
+```
+binance-mcp-server/
+├── src/
+│   └── binance_mcp/
+│       ├── __init__.py
+│       ├── __main__.py
+│       └── server.py
+├── pyproject.toml
+└── README.md
+```
+
+### Running Tests
+
+```bash
+pytest
+```
+
+### Code Formatting
+
+```bash
+black src/
+ruff check src/
+```
+
+## Error Codes
+
+Common Binance API error codes:
+- `-1121`: Invalid symbol
+- `-2019`: Margin is insufficient  
+- `-1116`: Invalid orderType
+- `-1013`: Filter failure (PRICE_FILTER, LOT_SIZE, etc.)
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes
+4. Add tests if applicable
+5. Submit a pull request
+
+## License
+
+MIT License - see LICENSE file for details.
+
+## Disclaimer
+
+This software is for educational and development purposes. Trading cryptocurrencies involves substantial risk. Use at your own risk and never trade with money you cannot afford to lose.
+
+## Support
+
+For issues and questions:
+- Check the [Binance API Documentation](https://binance-docs.github.io/apidocs/futures/en/)
+- Review the error codes in the API documentation
+- Ensure your API credentials have the correct permissions

binance_futures_mcp-1.0.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+binance_futures_mcp-1.0.0.dist-info/licenses/LICENSE,sha256=zqfwopvOi7kOx5YVOnehgmRFR-IU3x1n9JEShr3QOYg,1075
+binance_mcp/__init__.py,sha256=ExUxc1kp3GoSwmEtC7eGgFMZlvSQ4IdW1T5xhw-NT98,106
+binance_mcp/__main__.py,sha256=arjH5cad7koMZTvXR3u3eLE6I7pdT1zg5ttp7KNjQ6Y,131
+binance_mcp/server.py,sha256=LW16OetihWrkBLC1X-0Wg6k_Oug6PQ3LRVPkpEa32s0,38221
+binance_futures_mcp-1.0.0.dist-info/METADATA,sha256=_rOapSOSDn8prUvEifrTocZ4wEMNJm0TJXql2YTkXFk,11017
+binance_futures_mcp-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+binance_futures_mcp-1.0.0.dist-info/entry_points.txt,sha256=Olf_ctXC2kgUJEg-bfsy90EXuCDM0gW8xJwO_QzraqE,65
+binance_futures_mcp-1.0.0.dist-info/top_level.txt,sha256=RqGhe1caZUvBF_ezvTiLZD8kVS25eiWVkfJfmoND9m8,12
+binance_futures_mcp-1.0.0.dist-info/RECORD,,

binance_futures_mcp-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

binance_futures_mcp-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+binance-mcp-server = binance_mcp.__main__:main

binance_futures_mcp-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Binance MCP Server
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

binance_futures_mcp-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+binance_mcp

binance_mcp/__init__.py

@@ -0,0 +1,3 @@
+"""Binance MCP Server - A Model Context Protocol server for Binance Futures API"""
+
+__version__ = "1.0.0"

binance_mcp/__main__.py

@@ -0,0 +1,7 @@
+#!/usr/bin/env python3
+
+from binance_mcp.server import main
+
+if __name__ == "__main__":
+    import asyncio
+    asyncio.run(main())

binance_mcp/server.py

@@ -0,0 +1,760 @@
+#!/usr/bin/env python3
+
+import asyncio
+import hashlib
+import hmac
+import json
+import time
+from datetime import datetime
+from typing import Any, Dict, List, Optional, Union
+from urllib.parse import urlencode
+
+import aiohttp
+from mcp.server import Server
+from mcp.server.models import InitializationOptions
+from mcp.server.stdio import stdio_server
+from mcp.types import TextContent, Tool
+from pydantic import BaseModel, Field
+
+
+class BinanceConfig:
+    """Configuration for Binance API"""
+    BASE_URL = "https://fapi.binance.com"
+    
+    def __init__(self, api_key: str = "", secret_key: str = ""):
+        self.api_key = api_key
+        self.secret_key = secret_key
+
+
+class BinanceClient:
+    """Binance Futures API client"""
+    
+    def __init__(self, config: BinanceConfig):
+        self.config = config
+        self.session: Optional[aiohttp.ClientSession] = None
+    
+    async def __aenter__(self):
+        self.session = aiohttp.ClientSession()
+        return self
+    
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        if self.session:
+            await self.session.close()
+    
+    def _generate_signature(self, query_string: str) -> str:
+        """Generate HMAC SHA256 signature"""
+        return hmac.new(
+            self.config.secret_key.encode('utf-8'),
+            query_string.encode('utf-8'),
+            hashlib.sha256
+        ).hexdigest()
+    
+    async def _make_request(
+        self,
+        method: str,
+        endpoint: str,
+        params: Optional[Dict[str, Any]] = None,
+        security_type: str = "NONE"
+    ) -> Dict[str, Any]:
+        """Make API request to Binance"""
+        
+        if params is None:
+            params = {}
+        
+        url = self.config.BASE_URL + endpoint
+        headers = {}
+        
+        if security_type in ["USER_DATA", "TRADE"]:
+            # Add API key to headers
+            headers["X-MBX-APIKEY"] = self.config.api_key
+            
+            # Add timestamp
+            params["timestamp"] = int(time.time() * 1000)
+            
+            # Generate signature
+            query_string = urlencode(params)
+            signature = self._generate_signature(query_string)
+            params["signature"] = signature
+        
+        try:
+            if method == "GET":
+                async with self.session.get(url, params=params, headers=headers) as response:
+                    return await response.json()
+            elif method == "POST":
+                async with self.session.post(url, data=params, headers=headers) as response:
+                    return await response.json()
+            elif method == "DELETE":
+                async with self.session.delete(url, data=params, headers=headers) as response:
+                    return await response.json()
+            else:
+                raise ValueError(f"Unsupported HTTP method: {method}")
+                
+        except Exception as e:
+            raise Exception(f"Request failed: {str(e)}")
+
+
+class BinanceMCPServer:
+    """Binance MCP Server implementation"""
+    
+    def __init__(self, api_key: str = "", secret_key: str = ""):
+        self.server = Server("binance-futures-mcp-server")
+        self.config = BinanceConfig(api_key, secret_key)
+        self._setup_tools()
+    
+    def _setup_tools(self):
+        """Setup all MCP tools"""
+        
+        @self.server.list_tools()
+        async def handle_list_tools() -> List[Tool]:
+            """Handle tools/list requests"""
+            return [
+                # Account Information Tools
+                Tool(
+                    name="get_account_info",
+                    description="Get futures account information V2",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {},
+                        "required": []
+                    }
+                ),
+                Tool(
+                    name="get_balance", 
+                    description="Get futures account balance V2",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {},
+                        "required": []
+                    }
+                ),
+                Tool(
+                    name="get_position_info",
+                    description="Get current position information V2",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "symbol": {"type": "string", "description": "Trading pair symbol"}
+                        },
+                        "required": []
+                    }
+                ),
+                Tool(
+                    name="get_position_mode",
+                    description="Get user's position mode (Hedge Mode or One-way Mode)",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {},
+                        "required": []
+                    }
+                ),
+                Tool(
+                    name="get_commission_rate",
+                    description="Get user's commission rate for a symbol",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "symbol": {"type": "string", "description": "Trading pair symbol"}
+                        },
+                        "required": ["symbol"]
+                    }
+                ),
+                
+                # Risk Management Tools
+                Tool(
+                    name="get_adl_quantile",
+                    description="Get position ADL quantile estimation",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "symbol": {"type": "string", "description": "Trading pair symbol"}
+                        },
+                        "required": []
+                    }
+                ),
+                Tool(
+                    name="get_leverage_brackets",
+                    description="Get notional and leverage brackets",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "symbol": {"type": "string", "description": "Trading pair symbol"}
+                        },
+                        "required": []
+                    }
+                ),
+                Tool(
+                    name="get_force_orders",
+                    description="Get user's force orders",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "symbol": {"type": "string", "description": "Trading pair symbol"},
+                            "auto_close_type": {"type": "string", "description": "Optional filter by auto-close type"},
+                            "start_time": {"type": "integer", "description": "Optional start time in ms"},
+                            "end_time": {"type": "integer", "description": "Optional end time in ms"},
+                            "limit": {"type": "integer", "description": "Maximum number of orders to return (default 50)"}
+                        },
+                        "required": []
+                    }
+                ),
+                Tool(
+                    name="get_position_margin_history",
+                    description="Get position margin modification history",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "symbol": {"type": "string", "description": "Trading pair symbol"},
+                            "margin_type": {"type": "integer", "description": "1 for add position margin, 2 for reduce position margin"},
+                            "limit": {"type": "integer", "description": "Number of entries to return"}
+                        },
+                        "required": ["symbol", "margin_type", "limit"]
+                    }
+                ),
+
+                # Order Management Tools
+                Tool(
+                    name="place_order",
+                    description="Place a futures order of any type (MARKET, LIMIT, STOP, STOP_MARKET, TRAILING_STOP_MARKET, etc)",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "symbol": {"type": "string", "description": "Trading pair symbol"},
+                            "side": {"type": "string", "description": "Order side ('BUY' or 'SELL')"},
+                            "order_type": {"type": "string", "description": "Order type ('MARKET', 'LIMIT', 'STOP', 'STOP_MARKET', 'TRAILING_STOP_MARKET', etc)"},
+                            "quantity": {"type": "number", "description": "Order quantity"},
+                            "price": {"type": "number", "description": "Order price (for LIMIT orders)"},
+                            "stop_price": {"type": "number", "description": "Stop price (for STOP orders)"},
+                            "time_in_force": {"type": "string", "description": "Time in force (GTC, IOC, FOK)"},
+                            "position_side": {"type": "string", "description": "Position side ('BOTH', 'LONG', 'SHORT')"},
+                            "reduce_only": {"type": "string", "description": "Reduce only flag"},
+                            "new_client_order_id": {"type": "string", "description": "Custom order ID"},
+                            "close_position": {"type": "string", "description": "Close position flag"},
+                            "activation_price": {"type": "number", "description": "Activation price (for TRAILING_STOP_MARKET)"},
+                            "callback_rate": {"type": "number", "description": "Callback rate (for TRAILING_STOP_MARKET)"},
+                            "working_type": {"type": "string", "description": "Working type (MARK_PRICE, CONTRACT_PRICE)"},
+                            "price_protect": {"type": "string", "description": "Price protection flag"},
+                            "new_order_resp_type": {"type": "string", "description": "Response type"},
+                            "recv_window": {"type": "integer", "description": "Receive window"},
+                            "timestamp": {"type": "integer", "description": "Timestamp"},
+                            "quantity_precision": {"type": "integer", "description": "Quantity precision for validation"},
+                            "price_precision": {"type": "integer", "description": "Price precision for validation"}
+                        },
+                        "required": ["symbol", "side", "order_type"]
+                    }
+                ),
+                Tool(
+                    name="place_multiple_orders",
+                    description="Place multiple orders at once",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "orders": {"type": "array", "description": "List of order parameters"},
+                            "quantity_precision": {"type": "integer", "description": "Quantity precision for validation"},
+                            "price_precision": {"type": "integer", "description": "Price precision for validation"}
+                        },
+                        "required": ["orders"]
+                    }
+                ),
+                Tool(
+                    name="cancel_order",
+                    description="Cancel an active order",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "symbol": {"type": "string", "description": "Trading pair symbol"},
+                            "order_id": {"type": "integer", "description": "Order ID to cancel"}
+                        },
+                        "required": ["symbol", "order_id"]
+                    }
+                ),
+                Tool(
+                    name="cancel_multiple_orders",
+                    description="Cancel multiple orders",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "symbol": {"type": "string", "description": "Trading pair symbol"},
+                            "order_id_list": {"type": "array", "description": "List of order IDs to cancel (up to 10 orders per batch)"}
+                        },
+                        "required": ["symbol", "order_id_list"]
+                    }
+                ),
+                Tool(
+                    name="cancel_all_orders",
+                    description="Cancel all open orders for a symbol",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "symbol": {"type": "string", "description": "Trading pair symbol"}
+                        },
+                        "required": ["symbol"]
+                    }
+                ),
+                Tool(
+                    name="auto_cancel_all_orders",
+                    description="Set up auto-cancellation of all orders after countdown",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "symbol": {"type": "string", "description": "Trading pair symbol"},
+                            "countdown_time": {"type": "integer", "description": "Countdown time in milliseconds"}
+                        },
+                        "required": ["symbol", "countdown_time"]
+                    }
+                ),
+
+                # Order Query Tools
+                Tool(
+                    name="get_open_order",
+                    description="Query current open order by order id",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "symbol": {"type": "string", "description": "Trading pair symbol"},
+                            "order_id": {"type": "integer", "description": "Order ID to query"}
+                        },
+                        "required": ["symbol", "order_id"]
+                    }
+                ),
+                Tool(
+                    name="get_open_orders",
+                    description="Get all open futures orders for a specific symbol",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "symbol": {"type": "string", "description": "Trading pair symbol"}
+                        },
+                        "required": ["symbol"]
+                    }
+                ),
+                Tool(
+                    name="get_all_orders",
+                    description="Get all account orders",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "symbol": {"type": "string", "description": "Trading pair symbol"},
+                            "order_id": {"type": "integer", "description": "Optional order ID to start from"},
+                            "start_time": {"type": "integer", "description": "Optional start time in ms"},
+                            "end_time": {"type": "integer", "description": "Optional end time in ms"},
+                            "limit": {"type": "integer", "description": "Maximum number of orders to return (default 500)"}
+                        },
+                        "required": ["symbol"]
+                    }
+                ),
+                Tool(
+                    name="query_order",
+                    description="Query a specific order's status",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "symbol": {"type": "string", "description": "Trading pair symbol"},
+                            "order_id": {"type": "integer", "description": "Order ID to query"}
+                        },
+                        "required": ["symbol", "order_id"]
+                    }
+                ),
+
+                # Trading Configuration Tools
+                Tool(
+                    name="change_leverage",
+                    description="Change initial leverage for a symbol",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "symbol": {"type": "string", "description": "Trading pair symbol"},
+                            "leverage": {"type": "integer", "description": "Target initial leverage (1-125)"}
+                        },
+                        "required": ["symbol", "leverage"]
+                    }
+                ),
+                Tool(
+                    name="change_margin_type",
+                    description="Change margin type between isolated and cross",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "symbol": {"type": "string", "description": "Trading pair symbol"},
+                            "margin_type": {"type": "string", "description": "'ISOLATED' or 'CROSSED'"}
+                        },
+                        "required": ["symbol", "margin_type"]
+                    }
+                ),
+                Tool(
+                    name="change_position_mode",
+                    description="Change position mode between Hedge Mode and One-way Mode",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "dual_side": {"type": "boolean", "description": "\"true\" for Hedge Mode, \"false\" for One-way Mode"}
+                        },
+                        "required": ["dual_side"]
+                    }
+                ),
+                Tool(
+                    name="modify_position_margin",
+                    description="Modify isolated position margin",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "symbol": {"type": "string", "description": "Trading pair symbol"},
+                            "amount": {"type": "number", "description": "Amount to modify"},
+                            "position_side": {"type": "string", "description": "Position side ('BOTH', 'LONG', or 'SHORT')"},
+                            "margin_type": {"type": "integer", "description": "1 for add position margin, 2 for reduce position margin"}
+                        },
+                        "required": ["symbol", "amount", "position_side", "margin_type"]
+                    }
+                ),
+
+                # Market Data Tools
+                Tool(
+                    name="get_exchange_info",
+                    description="Get exchange trading rules and symbol information",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "symbol": {"type": "string", "description": "Trading pair symbol (optional)"}
+                        },
+                        "required": []
+                    }
+                ),
+                Tool(
+                    name="get_book_ticker",
+                    description="Get best price/qty on the order book for a symbol",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "symbol": {"type": "string", "description": "Trading pair symbol"}
+                        },
+                        "required": []
+                    }
+                ),
+                Tool(
+                    name="get_price_ticker",
+                    description="Get latest price for a symbol", 
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "symbol": {"type": "string", "description": "Trading pair symbol"}
+                        },
+                        "required": []
+                    }
+                ),
+                Tool(
+                    name="get_order_book",
+                    description="Get order book for a symbol",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "symbol": {"type": "string", "description": "Trading pair symbol"},
+                            "limit": {"type": "integer", "description": "Number of bids/asks (5,10,20,50,100,500,1000)"}
+                        },
+                        "required": ["symbol", "limit"]
+                    }
+                ),
+                Tool(
+                    name="get_klines",
+                    description="Get kline/candlestick data for a symbol",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "symbol": {"type": "string", "description": "Trading pair symbol"},
+                            "interval": {"type": "string", "description": "Kline interval"},
+                            "start_time": {"type": "integer", "description": "Start timestamp in ms"},
+                            "end_time": {"type": "integer", "description": "End timestamp in ms"},
+                            "limit": {"type": "integer", "description": "Number of klines (max 1500)"}
+                        },
+                        "required": ["symbol", "interval"]
+                    }
+                ),
+                Tool(
+                    name="get_mark_price",
+                    description="Get mark price and funding rate for a symbol",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "symbol": {"type": "string", "description": "Trading pair symbol"}
+                        },
+                        "required": []
+                    }
+                ),
+                Tool(
+                    name="get_aggregate_trades",
+                    description="Get compressed, aggregate market trades",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "symbol": {"type": "string", "description": "Trading pair symbol"},
+                            "from_id": {"type": "integer", "description": "ID to get trades from"},
+                            "start_time": {"type": "integer", "description": "Start timestamp in ms"},
+                            "end_time": {"type": "integer", "description": "End timestamp in ms"},
+                            "limit": {"type": "integer", "description": "Number of trades (max 1000)"}
+                        },
+                        "required": ["symbol"]
+                    }
+                ),
+                Tool(
+                    name="get_funding_rate_history",
+                    description="Get funding rate history for a symbol",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "symbol": {"type": "string", "description": "Trading pair symbol"},
+                            "start_time": {"type": "integer", "description": "Start timestamp in ms"},
+                            "end_time": {"type": "integer", "description": "End timestamp in ms"},
+                            "limit": {"type": "integer", "description": "Number of entries (max 1000)"}
+                        },
+                        "required": []
+                    }
+                ),
+
+                # Trading History Tools
+                Tool(
+                    name="get_account_trades",
+                    description="Get account trade list",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "symbol": {"type": "string", "description": "Trading pair symbol"},
+                            "start_time": {"type": "integer", "description": "Optional start time in ms"},
+                            "end_time": {"type": "integer", "description": "Optional end time in ms"},
+                            "from_id": {"type": "integer", "description": "Optional trade ID to fetch from"},
+                            "limit": {"type": "integer", "description": "Maximum number of trades to return (default 500)"}
+                        },
+                        "required": ["symbol"]
+                    }
+                ),
+                Tool(
+                    name="get_income_history",
+                    description="Get income history",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "symbol": {"type": "string", "description": "Trading pair symbol"},
+                            "income_type": {"type": "string", "description": "Optional income type filter"},
+                            "start_time": {"type": "integer", "description": "Optional start time in ms"},
+                            "end_time": {"type": "integer", "description": "Optional end time in ms"},
+                            "limit": {"type": "integer", "description": "Maximum number of records to return (default 100)"}
+                        },
+                        "required": []
+                    }
+                )
+            ]
+        
+        @self.server.call_tool()
+        async def handle_call_tool(name: str, arguments: Dict[str, Any]) -> List[TextContent]:
+            """Handle tool calls"""
+            
+            # Check if API credentials are configured for authenticated endpoints
+            unauthenticated_tools = [
+                "get_exchange_info", "get_price_ticker", "get_book_ticker", 
+                "get_order_book", "get_klines", "get_mark_price", 
+                "get_aggregate_trades", "get_funding_rate_history"
+            ]
+            
+            if not self.config.api_key or not self.config.secret_key:
+                if name not in unauthenticated_tools:
+                    return [TextContent(
+                        type="text",
+                        text="Error: API credentials not configured. Please provide valid API key and secret key."
+                    )]
+            
+            try:
+                async with BinanceClient(self.config) as client:
+                    
+                    # Account Information Tools
+                    if name == "get_account_info":
+                        result = await client._make_request("GET", "/fapi/v2/account", security_type="USER_DATA")
+                    elif name == "get_balance":
+                        result = await client._make_request("GET", "/fapi/v2/balance", security_type="USER_DATA")
+                    elif name == "get_position_info":
+                        params = {}
+                        if "symbol" in arguments:
+                            params["symbol"] = arguments["symbol"]
+                        result = await client._make_request("GET", "/fapi/v2/positionRisk", params, "USER_DATA")
+                    elif name == "get_position_mode":
+                        result = await client._make_request("GET", "/fapi/v1/positionSide/dual", security_type="USER_DATA")
+                    elif name == "get_commission_rate":
+                        params = {"symbol": arguments["symbol"]}
+                        result = await client._make_request("GET", "/fapi/v1/commissionRate", params, "USER_DATA")
+                    
+                    # Risk Management Tools
+                    elif name == "get_adl_quantile":
+                        params = {}
+                        if "symbol" in arguments:
+                            params["symbol"] = arguments["symbol"]
+                        result = await client._make_request("GET", "/fapi/v1/adlQuantile", params, "USER_DATA")
+                    elif name == "get_leverage_brackets":
+                        params = {}
+                        if "symbol" in arguments:
+                            params["symbol"] = arguments["symbol"]
+                        result = await client._make_request("GET", "/fapi/v1/leverageBracket", params, "USER_DATA")
+                    elif name == "get_force_orders":
+                        params = {k: v for k, v in arguments.items() if v is not None}
+                        result = await client._make_request("GET", "/fapi/v1/forceOrders", params, "USER_DATA")
+                    elif name == "get_position_margin_history":
+                        params = {k: v for k, v in arguments.items() if v is not None}
+                        result = await client._make_request("GET", "/fapi/v1/positionMargin/history", params, "USER_DATA")
+                    
+                    # Order Management Tools
+                    elif name == "place_order":
+                        params = {k: v for k, v in arguments.items() if v is not None and k not in ["quantity_precision", "price_precision"]}
+                        # Convert order_type to type for API
+                        if "order_type" in params:
+                            params["type"] = params.pop("order_type")
+                        result = await client._make_request("POST", "/fapi/v1/order", params, "TRADE")
+                    elif name == "place_multiple_orders":
+                        # This requires special handling for batch orders
+                        params = {k: v for k, v in arguments.items() if v is not None}
+                        result = await client._make_request("POST", "/fapi/v1/batchOrders", params, "TRADE")
+                    elif name == "cancel_order":
+                        params = {"symbol": arguments["symbol"], "orderId": arguments["order_id"]}
+                        result = await client._make_request("DELETE", "/fapi/v1/order", params, "TRADE")
+                    elif name == "cancel_multiple_orders":
+                        params = {
+                            "symbol": arguments["symbol"],
+                            "orderIdList": arguments["order_id_list"]
+                        }
+                        result = await client._make_request("DELETE", "/fapi/v1/batchOrders", params, "TRADE")
+                    elif name == "cancel_all_orders":
+                        params = {"symbol": arguments["symbol"]}
+                        result = await client._make_request("DELETE", "/fapi/v1/allOpenOrders", params, "TRADE")
+                    elif name == "auto_cancel_all_orders":
+                        params = {
+                            "symbol": arguments["symbol"],
+                            "countdownTime": arguments["countdown_time"]
+                        }
+                        result = await client._make_request("POST", "/fapi/v1/countdownCancelAll", params, "TRADE")
+                    
+                    # Order Query Tools
+                    elif name == "get_open_order":
+                        params = {"symbol": arguments["symbol"], "orderId": arguments["order_id"]}
+                        result = await client._make_request("GET", "/fapi/v1/openOrder", params, "USER_DATA")
+                    elif name == "get_open_orders":
+                        params = {"symbol": arguments["symbol"]}
+                        result = await client._make_request("GET", "/fapi/v1/openOrders", params, "USER_DATA")
+                    elif name == "get_all_orders":
+                        params = {k: v for k, v in arguments.items() if v is not None}
+                        result = await client._make_request("GET", "/fapi/v1/allOrders", params, "USER_DATA")
+                    elif name == "query_order":
+                        params = {"symbol": arguments["symbol"], "orderId": arguments["order_id"]}
+                        result = await client._make_request("GET", "/fapi/v1/order", params, "USER_DATA")
+                    
+                    # Trading Configuration Tools
+                    elif name == "change_leverage":
+                        params = {
+                            "symbol": arguments["symbol"],
+                            "leverage": arguments["leverage"]
+                        }
+                        result = await client._make_request("POST", "/fapi/v1/leverage", params, "TRADE")
+                    elif name == "change_margin_type":
+                        params = {
+                            "symbol": arguments["symbol"],
+                            "marginType": arguments["margin_type"]
+                        }
+                        result = await client._make_request("POST", "/fapi/v1/marginType", params, "TRADE")
+                    elif name == "change_position_mode":
+                        params = {"dualSidePosition": arguments["dual_side"]}
+                        result = await client._make_request("POST", "/fapi/v1/positionSide/dual", params, "TRADE")
+                    elif name == "modify_position_margin":
+                        params = {
+                            "symbol": arguments["symbol"],
+                            "positionSide": arguments["position_side"],
+                            "amount": arguments["amount"],
+                            "type": arguments["margin_type"]
+                        }
+                        result = await client._make_request("POST", "/fapi/v1/positionMargin", params, "TRADE")
+                    
+                    # Market Data Tools
+                    elif name == "get_exchange_info":
+                        params = {}
+                        if "symbol" in arguments:
+                            params["symbol"] = arguments["symbol"]
+                        result = await client._make_request("GET", "/fapi/v1/exchangeInfo", params)
+                    elif name == "get_book_ticker":
+                        params = {}
+                        if "symbol" in arguments:
+                            params["symbol"] = arguments["symbol"]
+                        result = await client._make_request("GET", "/fapi/v1/ticker/bookTicker", params)
+                    elif name == "get_price_ticker":
+                        params = {}
+                        if "symbol" in arguments:
+                            params["symbol"] = arguments["symbol"]
+                        result = await client._make_request("GET", "/fapi/v1/ticker/price", params)
+                    elif name == "get_order_book":
+                        params = {
+                            "symbol": arguments["symbol"],
+                            "limit": arguments["limit"]
+                        }
+                        result = await client._make_request("GET", "/fapi/v1/depth", params)
+                    elif name == "get_klines":
+                        params = {k: v for k, v in arguments.items() if v is not None}
+                        result = await client._make_request("GET", "/fapi/v1/klines", params)
+                    elif name == "get_mark_price":
+                        params = {}
+                        if "symbol" in arguments:
+                            params["symbol"] = arguments["symbol"]
+                        result = await client._make_request("GET", "/fapi/v1/premiumIndex", params)
+                    elif name == "get_aggregate_trades":
+                        params = {k: v for k, v in arguments.items() if v is not None}
+                        result = await client._make_request("GET", "/fapi/v1/aggTrades", params)
+                    elif name == "get_funding_rate_history":
+                        params = {k: v for k, v in arguments.items() if v is not None}
+                        result = await client._make_request("GET", "/fapi/v1/fundingRate", params)
+                    
+                    # Trading History Tools
+                    elif name == "get_account_trades":
+                        params = {k: v for k, v in arguments.items() if v is not None}
+                        result = await client._make_request("GET", "/fapi/v1/userTrades", params, "USER_DATA")
+                    elif name == "get_income_history":
+                        params = {k: v for k, v in arguments.items() if v is not None}
+                        result = await client._make_request("GET", "/fapi/v1/income", params, "USER_DATA")
+                    
+                    else:
+                        raise ValueError(f"Unknown tool: {name}")
+                    
+                    return [TextContent(
+                        type="text",
+                        text=json.dumps(result, indent=2)
+                    )]
+                    
+            except Exception as e:
+                return [TextContent(
+                    type="text",
+                    text=f"Error: {str(e)}"
+                )]
+
+
+async def main():
+    import argparse
+    import os
+    
+    # Parse command-line arguments
+    parser = argparse.ArgumentParser(description="Binance Futures MCP Server")
+    parser.add_argument("--binance-api-key", 
+                       help="Binance API key", 
+                       default=os.getenv("BINANCE_API_KEY", ""))
+    parser.add_argument("--binance-secret-key", 
+                       help="Binance secret key", 
+                       default=os.getenv("BINANCE_SECRET_KEY", ""))
+    
+    args = parser.parse_args()
+    
+    # Initialize server with credentials
+    server_instance = BinanceMCPServer(args.binance_api_key, args.binance_secret_key)
+    
+    # Run server using stdio
+    async with stdio_server() as (read_stream, write_stream):
+        await server_instance.server.run(
+            read_stream, 
+            write_stream, 
+            InitializationOptions(
+                server_name="binance-futures-mcp-server",
+                server_version="1.0.0",
+                capabilities={}
+            )
+        )
+
+
+if __name__ == "__main__":
+    asyncio.run(main())