Bybit MCP Server

Instructions

Implementation Reference

• src/bybit-service.ts:751-963 (handler)

  The primary handler function implementing the calculate_position_size tool logic. Computes recommended position quantity based on risk management parameters, fetches market data, validates against instrument lot size filters, and provides detailed calculations and warnings.
  async calculatePositionSize( category: string, symbol: string, accountBalance: number, riskPercentage: number, stopLossPrice: number, currentPrice?: number, leverage?: number ): Promise<{ recommendedQty: string; maxQty: string; riskAmount: number; positionValue: number; stopLossDistance: number; riskRewardRatio?: number; takeProfitSuggestion?: number; warnings: string[]; calculations: { riskPerTrade: number; priceDistance: number; basePositionSize: number; leveragedPositionSize: number; marginRequired: number; }; error?: string; }> { try { // Get current price if not provided let price = currentPrice; if (!price) { const ticker = await this.getTickers(category, symbol); if ('error' in ticker) { return { recommendedQty: '0', maxQty: '0', riskAmount: 0, positionValue: 0, stopLossDistance: 0, warnings: [], calculations: { riskPerTrade: 0, priceDistance: 0, basePositionSize: 0, leveragedPositionSize: 0, marginRequired: 0 }, error: `Failed to get price: ${ticker.error}` }; } price = parseFloat(ticker.result.list[0].lastPrice); } // Get instrument info for validation const instrumentInfo = await this.getInstrumentsInfo(category, symbol); if ('error' in instrumentInfo) { return { recommendedQty: '0', maxQty: '0', riskAmount: 0, positionValue: 0, stopLossDistance: 0, warnings: [], calculations: { riskPerTrade: 0, priceDistance: 0, basePositionSize: 0, leveragedPositionSize: 0, marginRequired: 0 }, error: `Failed to get instrument info: ${instrumentInfo.error}` }; } const instrument = instrumentInfo.result.list[0]; const lotSizeFilter = instrument.lotSizeFilter; const minOrderQty = parseFloat(lotSizeFilter.minOrderQty); const maxOrderQty = parseFloat(lotSizeFilter.maxOrderQty); const qtyStep = parseFloat(lotSizeFilter.qtyStep); const warnings: string[] = []; const usedLeverage = leverage || 1; // Validate inputs if (riskPercentage <= 0 || riskPercentage > 100) { warnings.push('Risk percentage should be between 0.1% and 100%'); riskPercentage = Math.max(0.1, Math.min(100, riskPercentage)); } if (riskPercentage > 5) { warnings.push('Risk percentage > 5% is considered high risk'); } // Calculate risk amount const riskAmount = (accountBalance * riskPercentage) / 100; // Calculate stop loss distance const stopLossDistance = Math.abs(price - stopLossPrice); const stopLossPercentage = (stopLossDistance / price) * 100; if (stopLossDistance === 0) { return { recommendedQty: '0', maxQty: '0', riskAmount, positionValue: 0, stopLossDistance: 0, warnings: ['Stop loss price cannot equal current price'], calculations: { riskPerTrade: riskAmount, priceDistance: 0, basePositionSize: 0, leveragedPositionSize: 0, marginRequired: 0 }, error: 'Invalid stop loss price' }; } // Calculate position size based on risk // Risk Amount = Position Size * Stop Loss Distance // Position Size = Risk Amount / Stop Loss Distance const basePositionSize = riskAmount / stopLossDistance; // With leverage, we can control a larger position with less margin const leveragedPositionSize = basePositionSize * usedLeverage; // But we need to ensure we don't exceed our margin capacity const marginRequired = (leveragedPositionSize * price) / usedLeverage; // Adjust if margin required exceeds available balance let finalPositionSize = leveragedPositionSize; if (marginRequired > accountBalance * 0.8) { // Keep 20% buffer finalPositionSize = (accountBalance * 0.8 * usedLeverage) / price; warnings.push('Position size reduced due to margin constraints'); } // Round to valid quantity step let recommendedQty = Math.floor(finalPositionSize / qtyStep) * qtyStep; // Ensure minimum quantity if (recommendedQty < minOrderQty) { recommendedQty = minOrderQty; warnings.push(`Adjusted to minimum quantity: ${minOrderQty}`); } // Ensure maximum quantity if (recommendedQty > maxOrderQty) { recommendedQty = maxOrderQty; warnings.push(`Adjusted to maximum quantity: ${maxOrderQty}`); } // Format to correct decimal places const decimalPlaces = qtyStep.toString().split('.')[1]?.length || 0; const formattedQty = recommendedQty.toFixed(decimalPlaces); const maxQty = maxOrderQty.toFixed(decimalPlaces); // Calculate position value and risk-reward suggestions const positionValue = recommendedQty * price; const actualRiskAmount = recommendedQty * stopLossDistance; // Suggest take profit at 2:1 risk-reward ratio const suggestedTakeProfit = stopLossPrice > price ? price - (2 * stopLossDistance) // Short position : price + (2 * stopLossDistance); // Long position const riskRewardRatio = 2.0; // Default 2:1 ratio // Add risk management warnings if (stopLossPercentage > 10) { warnings.push(`Stop loss distance is ${stopLossPercentage.toFixed(1)}% - consider tighter stop loss`); } if (actualRiskAmount > riskAmount * 1.1) { warnings.push('Actual risk exceeds target risk due to position size constraints'); } return { recommendedQty: formattedQty, maxQty, riskAmount: actualRiskAmount, positionValue, stopLossDistance, riskRewardRatio, takeProfitSuggestion: suggestedTakeProfit, warnings, calculations: { riskPerTrade: riskAmount, priceDistance: stopLossDistance, basePositionSize, leveragedPositionSize: finalPositionSize, marginRequired: (finalPositionSize * price) / usedLeverage } }; } catch (error: any) { return { recommendedQty: '0', maxQty: '0', riskAmount: 0, positionValue: 0, stopLossDistance: 0, warnings: [], calculations: { riskPerTrade: 0, priceDistance: 0, basePositionSize: 0, leveragedPositionSize: 0, marginRequired: 0 }, error: error.message }; } }
• src/index.ts:553-590 (schema)

  The input schema and tool metadata definition for calculate_position_size, registered in the listTools response. Defines parameters, types, descriptions, and required fields.
  { name: 'calculate_position_size', description: 'Calculate optimal position size based on risk management principles', inputSchema: { type: 'object', properties: { category: { type: 'string', description: 'Category (linear, inverse)', }, symbol: { type: 'string', description: 'Symbol (e.g., ETHUSDT)', }, accountBalance: { type: 'number', description: 'Total account balance in USDT', }, riskPercentage: { type: 'number', description: 'Risk percentage per trade (e.g., 2 for 2%)', }, stopLossPrice: { type: 'number', description: 'Stop loss price', }, currentPrice: { type: 'number', description: 'Current price (optional, will fetch if not provided)', }, leverage: { type: 'number', description: 'Leverage to use (optional, defaults to 1x)', }, }, required: ['category', 'symbol', 'accountBalance', 'riskPercentage', 'stopLossPrice'], }, },
• src/index.ts:1004-1022 (registration)

  The dispatch/registration handler in the CallToolRequestSchema that routes calls to the BybitService.calculatePositionSize method and formats the response.
  case 'calculate_position_size': { const result = await this.bybitService.calculatePositionSize( typedArgs.category, typedArgs.symbol, typedArgs.accountBalance, typedArgs.riskPercentage, typedArgs.stopLossPrice, typedArgs.currentPrice, typedArgs.leverage ); return { content: [ { type: 'text', text: JSON.stringify(result, null, 2), }, ], }; }