calculate_position_size
Calculate optimal position size for Bybit trades using risk percentage, account balance, and stop loss to manage trading risk effectively.
Instructions
Calculate optimal position size based on risk management principles
Input Schema
TableJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| category | Yes | Category (linear, inverse) | |
| symbol | Yes | Symbol (e.g., ETHUSDT) | |
| accountBalance | Yes | Total account balance in USDT | |
| riskPercentage | Yes | Risk percentage per trade (e.g., 2 for 2%) | |
| stopLossPrice | Yes | Stop loss price | |
| currentPrice | No | Current price (optional, will fetch if not provided) | |
| leverage | No | Leverage to use (optional, defaults to 1x) |
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), }, ], }; }