custom-indicator

name	custom-indicator
description	Creates a custom indicator class in QuantConnect/LEAN. Invoke for "create a custom indicator", "implement [name] indicator", "I need an indicator LEAN doesn't have", py`PythonIndicator`cs`ComputeNextValue`, "custom indicator class". Skip for LEAN built-ins (SMA, EMA, RSI).

/custom-indicator -- QuantConnect Custom Indicator

Creates a custom indicator class and wires it into an algorithm.

Step 1 -- Gather Indicator Information

Ask the user: (1) indicator name; (2) formula/logic; (3) input type -- IndicatorDataPoint (single price), TradeBar (OHLCV, default), QuoteBar (bid/ask); (4) period; (5) internal LEAN indicators (SMA, EMA, RSI) -- construct and update inside pyupdatecsComputeNextValue; (6) scope -- single symbol or universe; (7) warm-up -- manual (recommended) or automatic.

Step 2 -- Generate the Code

Python: from AlgorithmImports import * only. Inherit PythonIndicator. File: snake_case.py in its own file.

C#: inherit Indicator (or BarIndicator for OHLCV). Declare a WarmUpPeriod property (implement IIndicatorWarmUpPeriodProvider). File: PascalCase.cs.

Manual warm-up (default): loop pyself.history[TradeBar](symbol, period + 1)csHistory<TradeBar>(symbol, period + 1, Resolution.Daily), call pyindicator.update(bar)csindicator.Update(bar) before pyself.register_indicatorcsRegisterIndicator. Automatic warm-up: pyself.settings.automatic_indicator_warm_up = TruecsSettings.AutomaticIndicatorWarmUp = true in pyinitializecsInitialize.

Indicator class

class CustomVolatility(PythonIndicator):
    def __init__(self, period):
        super().__init__()
        self.value = 0
        self._window = RollingWindow[float](period)
    def update(self, input_: BaseData):
        self._window.add(input_.value)
        if self._window.is_ready:
            prices = np.array(list(self._window)[::-1])
            self.value = np.std(np.diff(np.log(prices))) * math.sqrt(252) * 100
        return self.is_ready
    @property
    def is_ready(self) -> bool:
        return self._window.is_ready

public class CustomVolatility : Indicator, IIndicatorWarmUpPeriodProvider
{
    private readonly RollingWindow<decimal> _window;
    public int WarmUpPeriod => _window.Size;
    public CustomVolatility(int period) : base("CustomVolatility")
    {
        _window = new RollingWindow<decimal>(period);
    }
    public override bool IsReady => _window.IsReady;
    protected override decimal ComputeNextValue(IndicatorDataPoint input)
    {
        _window.Add(input.Value);
        if (!IsReady) return 0m;
        // Compute from _window here.
        return 0m;
    }
}

For OHLCV in C#, inherit BarIndicator and use IBaseDataBar in ComputeNextValue.

Single-symbol integration

def initialize(self):
    symbol = self.add_equity("SPY", Resolution.DAILY).symbol
    self._indicator = CustomVolatility(period)
    for bar in self.history[TradeBar](symbol, period + 1):
        self._indicator.update(bar)
    self.register_indicator(symbol, self._indicator)

var symbol = AddEquity("SPY", Resolution.Daily).Symbol;
_indicator = new CustomVolatility(period);
foreach (var bar in History<TradeBar>(symbol, period + 1, Resolution.Daily))
    _indicator.Update(bar);
RegisterIndicator(symbol, _indicator);

Universe integration

def on_securities_changed(self, changes):
    for security in changes.added_securities:
        security.indicator = CustomVolatility(period)
        for bar in self.history[TradeBar](security, period + 1):
            security.indicator.update(bar)
        self.register_indicator(security, security.indicator)
    for security in changes.removed_securities:
        self.deregister_indicator(security.indicator)
        self.liquidate(security)

In OnSecuritiesChanged, create and warm the indicator for each added security, then RegisterIndicator; on removal, DeregisterIndicator and Liquidate. Track them in a Dictionary<Symbol, CustomVolatility> and gate reads on _indicators[symbol].IsReady.

Step 3 -- Write Files via MCP

1. quantconnect:create_file with the indicator class.
2. quantconnect:update_file_contents for pymain.pycsMain.cs.

3. Python only: add from custom_volatility import CustomVolatility after from AlgorithmImports import *.

Step 4 -- Compile

1. quantconnect:create_compile. Poll quantconnect:read_compile until BuildSuccess or BuildError. Fix errors and loop.

Step 5 -- Backtest and Verify

1. quantconnect:create_backtest. Poll quantconnect:read_backtest until complete.
2. Confirm pyis_readycsIsReady becomes true and at least one order placed (if the algorithm has entry conditions).