Update hl_indicators_server.py

hl_indicators_server.py

@@ -0,0 +1,325 @@
+# hl_indicators_server.py
+"""
+FastMCP server exposing Hyperliquid indicator tools.
+
+This server provides a unified interface to compute common trading indicators
+directly from Hyperliquid testnet market data via the `candles_snapshot` API.
+
+Available tools:
+- ema        → Exponential Moving Average
+- macd       → Moving Average Convergence Divergence
+- stoch_rsi  → Stochastic RSI
+- adl        → Accumulation / Distribution Line
+- obv        → On-Balance Volume
+- atr_adx    → Average True Range / Directional Index / ADX
+- bbands     → Bollinger Bands
+- mfi        → Money Flow Index
+- vwap       → Volume-Weighted Average Price
+- volume     → Raw trading volume
+- bundle     → Compute multiple indicators in one call
+
+Run:
+    python hl_indicators_server.py
+"""
+
+from __future__ import annotations
+from typing import List, Optional, Literal, Dict, Any
+
+from mcp.server.fastmcp import FastMCP
+import hl_indicators as hi
+
+Interval = Literal["1m", "5m", "15m", "1h", "4h", "1d"]
+
+mcp = FastMCP("hl_indicators_server")
+
+
+# ------------------ Health check ------------------ #
+
+@mcp.tool()
+async def ping() -> str:
+    """Check if the MCP server is online and responding."""
+    return "pong"
+
+
+# ------------------ Indicator tools ------------------ #
+
+@mcp.tool()
+async def ema(
+    name: str,
+    interval: Interval = "1h",
+    periods: Optional[List[int]] = None,
+    lookback: Optional[int] = None,
+    limit: int = 600,
+) -> Dict[str, Any]:
+    """
+    Compute Exponential Moving Averages (EMA).
+
+    Args:
+        name: Coin name (e.g. "BTC", "ETH", "HYPE").
+        interval: Candle interval ("1m", "5m", "15m", "1h", "4h", "1d").
+        periods: List of EMA window lengths (e.g. [20, 200]).
+        lookback: Optional shorthand for a single EMA (e.g. 36).
+        limit: Number of candles to fetch from the API.
+
+    Notes:
+        - `limit` controls how many data points are retrieved; it should be at
+          least 2–3× the largest EMA period for accurate results.
+        - The function automatically uses Hyperliquid testnet data.
+
+    Returns:
+        A dictionary containing EMA series for each period and the most recent values.
+    """
+    if periods is None and lookback is not None:
+        periods = [lookback]
+    return hi.get_ema(name=name, periods=periods, interval=interval, limit=limit, testnet=False)
+
+
+@mcp.tool()
+async def macd(
+    name: str,
+    interval: Interval = "1h",
+    fast: int = 12,
+    slow: int = 26,
+    signal: int = 9,
+    limit: int = 600,
+) -> Dict[str, Any]:
+    """
+    Compute the Moving Average Convergence Divergence (MACD).
+
+    Args:
+        name: Coin name (e.g. "BTC").
+        interval: Candle interval.
+        fast: Period for the fast EMA (default: 12).
+        slow: Period for the slow EMA (default: 26).
+        signal: Period for the MACD signal line (default: 9).
+        limit: Number of candles to fetch.
+
+    Returns:
+        A dictionary with MACD line, signal line, histogram, and last computed values.
+    """
+    return hi.get_macd(name=name, fast=fast, slow=slow, signal=signal, interval=interval, limit=limit, testnet=False)
+
+
+@mcp.tool()
+async def stoch_rsi(
+    name: str,
+    interval: Interval = "1h",
+    rsi_length: int = 14,
+    stoch_length: int = 14,
+    k_smooth: int = 3,
+    d_smooth: int = 3,
+    limit: int = 600,
+) -> Dict[str, Any]:
+    """
+    Compute the Stochastic RSI oscillator (%K and %D).
+
+    Args:
+        name: Coin name.
+        interval: Candle interval.
+        rsi_length: Period for RSI computation (default: 14).
+        stoch_length: Period for Stochastic window (default: 14).
+        k_smooth: Smoothing factor for %K (default: 3).
+        d_smooth: Smoothing factor for %D (default: 3).
+        limit: Number of candles to fetch.
+
+    Returns:
+        A dictionary containing %K, %D, and the raw StochRSI values.
+    """
+    return hi.get_stoch_rsi(
+        name=name,
+        rsi_length=rsi_length,
+        stoch_length=stoch_length,
+        k_smooth=k_smooth,
+        d_smooth=d_smooth,
+        interval=interval,
+        limit=limit,
+        testnet=False,
+    )
+
+
+@mcp.tool()
+async def adl(name: str, interval: Interval = "1h", limit: int = 600) -> Dict[str, Any]:
+    """
+    Compute the Accumulation/Distribution Line (ADL).
+
+    Args:
+        name: Coin name.
+        interval: Candle interval.
+        limit: Number of candles to fetch.
+
+    Returns:
+        A dictionary containing the ADL time series and the latest ADL value.
+    """
+    return hi.get_adl(name=name, interval=interval, limit=limit, testnet=False)
+
+
+@mcp.tool()
+async def obv(name: str, interval: Interval = "1h", limit: int = 600) -> Dict[str, Any]:
+    """
+    Compute the On-Balance Volume (OBV).
+
+    Args:
+        name: Coin name.
+        interval: Candle interval.
+        limit: Number of candles to fetch.
+
+    Returns:
+        OBV values accumulated over time and the latest OBV.
+    """
+    return hi.get_obv(name=name, interval=interval, limit=limit, testnet=False)
+
+
+@mcp.tool()
+async def atr_adx(name: str, interval: Interval = "1h", period: int = 14, limit: int = 600) -> Dict[str, Any]:
+    """
+    Compute volatility and directional indicators: ATR, +DI, -DI, and ADX.
+
+    Args:
+        name: Coin name.
+        interval: Candle interval.
+        period: Lookback for smoothing (default: 14).
+        limit: Number of candles to fetch.
+
+    Returns:
+        A dictionary with ATR, +DI, -DI, and ADX values.
+    """
+    return hi.get_atr_adx(name=name, period=period, interval=interval, limit=limit, testnet=False)
+
+
+@mcp.tool()
+async def bbands(
+    name: str,
+    interval: Interval = "1h",
+    period: int = 20,
+    std_mult: float = 2.0,
+    limit: int = 600,
+) -> Dict[str, Any]:
+    """
+    Compute Bollinger Bands (basis, upper/lower bands, %b, bandwidth).
+
+    Args:
+        name: Coin name.
+        interval: Candle interval.
+        period: Window for SMA (default: 20).
+        std_mult: Standard deviation multiplier (default: 2.0).
+        limit: Number of candles to fetch.
+
+    Returns:
+        A dictionary with band series and the most recent band values.
+    """
+    return hi.get_bbands(name=name, period=period, std_mult=std_mult, interval=interval, limit=limit, testnet=False)
+
+
+@mcp.tool()
+async def mfi(name: str, interval: Interval = "1h", period: int = 14, limit: int = 600) -> Dict[str, Any]:
+    """
+    Compute the Money Flow Index (MFI), a volume-weighted momentum oscillator.
+
+    Args:
+        name: Coin name.
+        interval: Candle interval.
+        period: Rolling window (default: 14).
+        limit: Number of candles to fetch.
+
+    Returns:
+        A dictionary containing MFI series and the most recent value.
+    """
+    return hi.get_mfi(name=name, period=period, interval=interval, limit=limit, testnet=False)
+
+
+@mcp.tool()
+async def vwap(name: str, interval: Interval = "1h", daily_reset: bool = False, limit: int = 600) -> Dict[str, Any]:
+    """
+    Compute the Volume-Weighted Average Price (VWAP).
+
+    Args:
+        name: Coin name.
+        interval: Candle interval.
+        daily_reset: If True, VWAP resets each trading day.
+        limit: Number of candles to fetch.
+
+    Returns:
+        VWAP time series and the last computed VWAP value.
+    """
+    return hi.get_vwap(name=name, daily_reset=daily_reset, interval=interval, limit=limit, testnet=False)
+
+
+@mcp.tool()
+async def volume(name: str, interval: Interval = "1h", limit: int = 600) -> Dict[str, Any]:
+    """
+    Retrieve the raw trading volume per candle.
+
+    Args:
+        name: Coin name.
+        interval: Candle interval.
+        limit: Number of candles to fetch.
+
+    Returns:
+        Volume values for each candle and the latest volume.
+    """
+    return hi.get_volume(name=name, interval=interval, limit=limit, testnet=False)
+
+
+@mcp.tool()
+async def bundle(
+    name: str,
+    interval: Interval = "1h",
+    limit: int = 600,
+    include: Optional[List[str]] = None,
+    ema_periods: Optional[List[int]] = None,
+    macd_fast: int = 12,
+    macd_slow: int = 26,
+    macd_signal: int = 9,
+    stoch_rsi_len: int = 14,
+    stoch_len: int = 14,
+    k_smooth: int = 3,
+    d_smooth: int = 3,
+    bb_period: int = 20,
+    bb_std: float = 2.0,
+    mfi_period: int = 14,
+    vwap_daily_reset: bool = False,
+) -> Dict[str, Any]:
+    """
+    Compute multiple indicators in a single request.
+
+    Args:
+        name: Coin name.
+        interval: Candle interval.
+        limit: Number of candles to fetch.
+        include: List of indicators to include. Default includes all:
+            ["ema","macd","stoch_rsi","adl","obv","atr_adx","bbands","mfi","vwap","volume"]
+        ema_periods: EMA periods (default: [20, 200]).
+        macd_fast / macd_slow / macd_signal: MACD configuration.
+        stoch_rsi_len / stoch_len / k_smooth / d_smooth: StochRSI configuration.
+        bb_period / bb_std: Bollinger Band configuration.
+        mfi_period: Money Flow Index lookback.
+        vwap_daily_reset: Whether VWAP resets daily.
+
+    Returns:
+        A combined dictionary with all requested indicators.
+    """
+    return hi.get_bundle(
+        name=name,
+        interval=interval,
+        limit=limit,
+        testnet=False,
+        include=include or ("ema","macd","stoch_rsi","adl","obv","atr_adx","bbands","mfi","vwap","volume"),
+        ema_periods=ema_periods,
+        macd_fast=macd_fast,
+        macd_slow=macd_slow,
+        macd_signal=macd_signal,
+        stoch_rsi_len=stoch_rsi_len,
+        stoch_len=stoch_len,
+        k_smooth=k_smooth,
+        d_smooth=d_smooth,
+        bb_period=bb_period,
+        bb_std=bb_std,
+        mfi_period=mfi_period,
+        vwap_daily_reset=vwap_daily_reset,
+    )
+
+
+# ------------------ Entry point ------------------ #
+
+if __name__ == "__main__":
+    mcp.run(transport='stdio')