TradingView MCP Server

Instructions

Implementation Reference

• src/tradingview_mcp/server.py:296-312 (handler)

  The core handler function for the top_losers tool. It sanitizes inputs, fetches trending analysis data, sorts by ascending change percentage to get losers, and formats the output as a list of dictionaries with symbol, changePercent, and indicators.

  @mcp.tool()
  def top_losers(exchange: str = "KUCOIN", timeframe: str = "15m", limit: int = 25) -> list[dict]:
      """Return top losers for an exchange and timeframe using bollinger band analysis."""
      exchange = sanitize_exchange(exchange, "KUCOIN")
      timeframe = sanitize_timeframe(timeframe, "15m")
      limit = max(1, min(limit, 50))
      
      rows = _fetch_trending_analysis(exchange, timeframe=timeframe, limit=limit)
      # Reverse sort for losers (lowest change first)
      rows.sort(key=lambda x: x["changePercent"])
      
      # Convert to dict format
      return [{
          "symbol": row["symbol"],
          "changePercent": row["changePercent"],
          "indicators": dict(row["indicators"])
      } for row in rows[:limit]]

• src/tradingview_mcp/server.py:146-208 (helper)

  Helper function that fetches the trending analysis data used by top_losers (and top_gainers). It loads symbols, processes in batches using TradingView TA, computes metrics, applies filters, and returns sorted rows of data.

  def _fetch_trending_analysis(exchange: str, timeframe: str = "5m", filter_type: str = "", rating_filter: int = None, limit: int = 50) -> List[Row]:
      """Fetch trending coins analysis similar to the original app's trending endpoint."""
      if not TRADINGVIEW_TA_AVAILABLE:
          raise RuntimeError("tradingview_ta is missing; run `uv sync`.")
      
      symbols = load_symbols(exchange)
      if not symbols:
          raise RuntimeError(f"No symbols found for exchange: {exchange}")
      
      # Process symbols in batches due to TradingView API limits
      batch_size = 200  # Considering API limitations
      all_coins = []
      
      screener = EXCHANGE_SCREENER.get(exchange, "crypto")
      
      # Process symbols in batches
      for i in range(0, len(symbols), batch_size):
          batch_symbols = symbols[i:i + batch_size]
          
          try:
              analysis = get_multiple_analysis(screener=screener, interval=timeframe, symbols=batch_symbols)
          except Exception as e:
              continue  # If this batch fails, move to the next one
              
          # Process coins in this batch
          for key, value in analysis.items():
              try:
                  if value is None:
                      continue
                      
                  indicators = value.indicators
                  metrics = compute_metrics(indicators)
                  
                  if not metrics or metrics.get('bbw') is None:
                      continue
                  
                  # Apply rating filter if specified
                  if filter_type == "rating" and rating_filter is not None:
                      if metrics['rating'] != rating_filter:
                          continue
                  
                  all_coins.append(Row(
                      symbol=key,
                      changePercent=metrics['change'],
                      indicators=IndicatorMap(
                          open=metrics.get('open'),
                          close=metrics.get('price'),
                          SMA20=indicators.get("SMA20"),
                          BB_upper=indicators.get("BB.upper"),
                          BB_lower=indicators.get("BB.lower"),
                          EMA50=indicators.get("EMA50"),
                          RSI=indicators.get("RSI"),
                          volume=indicators.get("volume"),
                      )
                  ))
                  
              except (TypeError, ZeroDivisionError, KeyError):
                  continue
      
      # Sort all coins by change percentage
      all_coins.sort(key=lambda x: x["changePercent"], reverse=True)
      
      return all_coins[:limit]

• src/tradingview_mcp/server.py:296-296 (registration)

  The @mcp.tool() decorator registers the top_losers function as an MCP tool.

  @mcp.tool()