tradingview-mcp 1.0.0__py3-none-any.whl

tradingview_mcp/server.py

@@ -0,0 +1,1361 @@
+"""
+TradingView MCP Server - Main server implementation.
+
+Provides comprehensive MCP tools and resources for TradingView market screening.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+from typing import Any, Optional
+
+from mcp.server.fastmcp import FastMCP
+
+from tradingview_mcp.column import Column
+from tradingview_mcp.constants import (
+    COLUMNS,
+    CRYPTO_COLUMNS,
+    DEFAULT_COLUMNS,
+    EXCHANGE_SCREENER,
+    MARKETS,
+    POSTMARKET_COLUMNS,
+    PREMARKET_COLUMNS,
+    TECHNICAL_COLUMNS,
+)
+from tradingview_mcp.query import And, Or, Query, get_all_symbols
+from tradingview_mcp.scanner import CryptoScanner, Scanner
+from tradingview_mcp.utils import (
+    analyze_indicators,
+    compute_bollinger_band_width,
+    compute_bollinger_rating,
+    compute_percent_change,
+    format_symbol,
+    format_technical_rating,
+    sanitize_exchange,
+    sanitize_market,
+    sanitize_timeframe,
+    timeframe_to_resolution,
+)
+
+# Initialize MCP Server
+mcp = FastMCP(
+    name="TradingView Screener MCP",
+    instructions=(
+        "A comprehensive MCP server for TradingView market screening. "
+        "Provides tools for stock and cryptocurrency screening, technical analysis, "
+        "and market data retrieval. Supports 76+ markets and 250+ technical indicators."
+    ),
+)
+
+
+# =============================================================================
+# MCP Resources
+# =============================================================================
+
+
+@mcp.resource("markets://list")
+def list_markets() -> str:
+    """List all available markets for screening."""
+    categories = {
+        "crypto": ["crypto", "coin"],
+        "instruments": ["forex", "futures", "bonds", "cfd", "options", "economics2"],
+        "americas": ["america", "argentina", "brazil", "canada", "chile", "colombia", "mexico", "peru", "venezuela"],
+        "europe": [
+            "austria",
+            "belgium",
+            "cyprus",
+            "czech",
+            "denmark",
+            "estonia",
+            "finland",
+            "france",
+            "germany",
+            "greece",
+            "hungary",
+            "iceland",
+            "italy",
+            "latvia",
+            "lithuania",
+            "luxembourg",
+            "netherlands",
+            "norway",
+            "poland",
+            "portugal",
+            "romania",
+            "russia",
+            "serbia",
+            "slovakia",
+            "spain",
+            "sweden",
+            "switzerland",
+            "turkey",
+            "uk",
+        ],
+        "asia_pacific": [
+            "australia",
+            "bangladesh",
+            "china",
+            "hongkong",
+            "india",
+            "indonesia",
+            "japan",
+            "korea",
+            "malaysia",
+            "newzealand",
+            "pakistan",
+            "philippines",
+            "singapore",
+            "srilanka",
+            "taiwan",
+            "thailand",
+            "vietnam",
+        ],
+        "middle_east_africa": [
+            "bahrain",
+            "egypt",
+            "israel",
+            "kenya",
+            "ksa",
+            "kuwait",
+            "morocco",
+            "nigeria",
+            "qatar",
+            "rsa",
+            "tunisia",
+            "uae",
+        ],
+    }
+
+    result = "# Available Markets\n\n"
+    for category, markets in categories.items():
+        result += f"## {category.replace('_', ' ').title()}\n"
+        result += ", ".join(sorted(markets)) + "\n\n"
+    return result
+
+
+@mcp.resource("columns://list")
+def list_columns() -> str:
+    """List all available columns/indicators for screening."""
+    result = "# Available Columns\n\n"
+
+    # Group columns by category
+    categories = {
+        "Price & Change": [
+            "close",
+            "open",
+            "high",
+            "low",
+            "volume",
+            "change",
+            "change_abs",
+            "gap",
+        ],
+        "Moving Averages": [
+            "SMA5",
+            "SMA10",
+            "SMA20",
+            "SMA50",
+            "SMA100",
+            "SMA200",
+            "EMA5",
+            "EMA10",
+            "EMA20",
+            "EMA50",
+            "EMA100",
+            "EMA200",
+        ],
+        "Oscillators": [
+            "RSI",
+            "RSI7",
+            "MACD.macd",
+            "MACD.signal",
+            "Stoch.K",
+            "Stoch.D",
+            "CCI20",
+            "Mom",
+            "AO",
+            "UO",
+        ],
+        "Volatility": ["BB.upper", "BB.lower", "ATR", "Volatility.D", "Volatility.W", "Volatility.M"],
+        "Trend": ["ADX", "ADX+DI", "ADX-DI", "Aroon.Up", "Aroon.Down", "P.SAR"],
+        "Volume": [
+            "volume",
+            "VWAP",
+            "VWMA",
+            "relative_volume_10d_calc",
+            "average_volume_10d_calc",
+            "average_volume_30d_calc",
+        ],
+        "Pre/Post Market": [
+            "premarket_change",
+            "premarket_volume",
+            "premarket_gap",
+            "postmarket_change",
+            "postmarket_volume",
+        ],
+        "Performance": ["Perf.W", "Perf.1M", "Perf.3M", "Perf.6M", "Perf.Y", "Perf.YTD", "Perf.All"],
+        "Fundamentals": [
+            "market_cap_basic",
+            "price_earnings_ttm",
+            "earnings_per_share_basic_ttm",
+            "dividend_yield_recent",
+            "price_book_fq",
+        ],
+        "Ratings": ["Recommend.All", "Recommend.MA", "Recommend.Other"],
+    }
+
+    for category, cols in categories.items():
+        result += f"## {category}\n"
+        result += ", ".join(cols) + "\n\n"
+
+    result += "\n## Full Column Mapping\n"
+    result += "Use human-readable names or API names:\n\n"
+    for human_name, api_name in sorted(COLUMNS.items())[:50]:  # First 50
+        result += f"- `{human_name}` → `{api_name}`\n"
+    result += f"\n... and {len(COLUMNS) - 50} more columns available."
+
+    return result
+
+
+@mcp.resource("exchanges://crypto")
+def list_crypto_exchanges() -> str:
+    """List supported cryptocurrency exchanges."""
+    crypto_exchanges = [ex for ex, screener in EXCHANGE_SCREENER.items() if screener == "crypto"]
+    return f"# Supported Crypto Exchanges\n\n" + ", ".join(sorted(crypto_exchanges))
+
+
+@mcp.resource("scanners://presets")
+def list_scanner_presets() -> str:
+    """List available pre-built scanner presets."""
+    result = "# Scanner Presets\n\n"
+
+    result += "## Stock Scanners\n"
+    for name in Scanner.names():
+        result += f"- `{name}`\n"
+
+    result += "\n## Crypto Scanners\n"
+    for name in CryptoScanner.names():
+        result += f"- `{name}`\n"
+
+    return result
+
+
+# =============================================================================
+# MCP Tools - Basic Screening
+# =============================================================================
+
+
+@mcp.tool()
+def screen_market(
+    market: str = "america",
+    columns: Optional[list[str]] = None,
+    sort_by: str = "volume",
+    ascending: bool = False,
+    limit: int = 50,
+    filters: Optional[list[dict[str, Any]]] = None,
+) -> list[dict[str, Any]]:
+    """
+    Execute a custom market screening query.
+
+    Args:
+        market: Market to screen (america, crypto, uk, etc.)
+        columns: Columns to return (default: name, close, volume, market_cap_basic)
+        sort_by: Column to sort by
+        ascending: Sort order (True=ascending, False=descending)
+        limit: Maximum results (1-500)
+        filters: List of filter conditions as dicts with keys: column, operation, value
+                 Operations: gt, gte, lt, lte, eq, neq, between, isin
+
+    Returns:
+        List of matching symbols with requested data
+    """
+    market = sanitize_market(market)
+    limit = max(1, min(limit, 500))
+    cols = columns or DEFAULT_COLUMNS
+
+    query = Query().set_markets(market).select(*cols).order_by(sort_by, ascending=ascending).limit(limit)
+
+    # Apply filters if provided
+    if filters:
+        filter_expressions = []
+        for f in filters:
+            col = Column(f.get("column", "close"))
+            op = f.get("operation", "gt")
+            val = f.get("value")
+
+            if op == "gt":
+                filter_expressions.append(col > val)
+            elif op == "gte":
+                filter_expressions.append(col >= val)
+            elif op == "lt":
+                filter_expressions.append(col < val)
+            elif op == "lte":
+                filter_expressions.append(col <= val)
+            elif op == "eq":
+                filter_expressions.append(col == val)
+            elif op == "neq":
+                filter_expressions.append(col != val)
+            elif op == "between" and isinstance(val, (list, tuple)) and len(val) == 2:
+                filter_expressions.append(col.between(val[0], val[1]))
+            elif op == "isin" and isinstance(val, (list, tuple)):
+                filter_expressions.append(col.isin(val))
+
+        if filter_expressions:
+            query = query.where(*filter_expressions)
+
+    try:
+        total_count, df = query.get_scanner_data()
+        results = df.to_dict("records")
+
+        return [{"total_count": total_count, "returned": len(results), "data": results}]
+    except Exception as e:
+        return [{"error": str(e)}]
+
+
+@mcp.tool()
+def get_top_gainers(market: str = "america", limit: int = 25) -> list[dict[str, Any]]:
+    """
+    Get top gaining assets in a market.
+
+    Args:
+        market: Market to scan (america, crypto, uk, etc.)
+        limit: Number of results (1-100)
+
+    Returns:
+        List of top gainers with price and change data
+    """
+    market = sanitize_market(market)
+    limit = max(1, min(limit, 100))
+
+    cols = ["name", "close", "volume", "change", "change_abs", "market_cap_basic"]
+
+    query = (
+        Query()
+        .set_markets(market)
+        .select(*cols)
+        .where(Column("change") > 0)
+        .order_by("change", ascending=False)
+        .limit(limit)
+    )
+
+    try:
+        total, df = query.get_scanner_data()
+        return df.to_dict("records")
+    except Exception as e:
+        return [{"error": str(e)}]
+
+
+@mcp.tool()
+def get_top_losers(market: str = "america", limit: int = 25) -> list[dict[str, Any]]:
+    """
+    Get top losing assets in a market.
+
+    Args:
+        market: Market to scan (america, crypto, uk, etc.)
+        limit: Number of results (1-100)
+
+    Returns:
+        List of top losers with price and change data
+    """
+    market = sanitize_market(market)
+    limit = max(1, min(limit, 100))
+
+    cols = ["name", "close", "volume", "change", "change_abs", "market_cap_basic"]
+
+    query = (
+        Query()
+        .set_markets(market)
+        .select(*cols)
+        .where(Column("change") < 0)
+        .order_by("change", ascending=True)
+        .limit(limit)
+    )
+
+    try:
+        total, df = query.get_scanner_data()
+        return df.to_dict("records")
+    except Exception as e:
+        return [{"error": str(e)}]
+
+
+@mcp.tool()
+def get_most_active(market: str = "america", limit: int = 25) -> list[dict[str, Any]]:
+    """
+    Get most actively traded assets by volume.
+
+    Args:
+        market: Market to scan
+        limit: Number of results (1-100)
+
+    Returns:
+        List of most active assets by volume
+    """
+    market = sanitize_market(market)
+    limit = max(1, min(limit, 100))
+
+    cols = ["name", "close", "volume", "change", "relative_volume_10d_calc", "market_cap_basic"]
+
+    query = Query().set_markets(market).select(*cols).order_by("volume", ascending=False).limit(limit)
+
+    try:
+        total, df = query.get_scanner_data()
+        return df.to_dict("records")
+    except Exception as e:
+        return [{"error": str(e)}]
+
+
+@mcp.tool()
+def get_premarket_movers(
+    scan_type: str = "gainers", limit: int = 25
+) -> list[dict[str, Any]]:
+    """
+    Get pre-market movers (US market only).
+
+    Args:
+        scan_type: Type of scan - 'gainers', 'losers', 'most_active', 'gappers'
+        limit: Number of results (1-100)
+
+    Returns:
+        List of pre-market movers
+    """
+    limit = max(1, min(limit, 100))
+
+    scanner_map = {
+        "gainers": Scanner.premarket_gainers,
+        "losers": Scanner.premarket_losers,
+        "most_active": Scanner.premarket_most_active,
+        "gappers": Scanner.premarket_gappers,
+    }
+
+    scanner = scanner_map.get(scan_type, Scanner.premarket_gainers).copy()
+    scanner = scanner.limit(limit)
+
+    try:
+        total, df = scanner.get_scanner_data()
+        return df.to_dict("records")
+    except Exception as e:
+        return [{"error": str(e)}]
+
+
+@mcp.tool()
+def get_postmarket_movers(
+    scan_type: str = "gainers", limit: int = 25
+) -> list[dict[str, Any]]:
+    """
+    Get post-market movers (US market only).
+
+    Args:
+        scan_type: Type of scan - 'gainers', 'losers', 'most_active'
+        limit: Number of results (1-100)
+
+    Returns:
+        List of post-market movers
+    """
+    limit = max(1, min(limit, 100))
+
+    scanner_map = {
+        "gainers": Scanner.postmarket_gainers,
+        "losers": Scanner.postmarket_losers,
+        "most_active": Scanner.postmarket_most_active,
+    }
+
+    scanner = scanner_map.get(scan_type, Scanner.postmarket_gainers).copy()
+    scanner = scanner.limit(limit)
+
+    try:
+        total, df = scanner.get_scanner_data()
+        return df.to_dict("records")
+    except Exception as e:
+        return [{"error": str(e)}]
+
+
+# =============================================================================
+# MCP Tools - Technical Analysis Scanners
+# =============================================================================
+
+
+@mcp.tool()
+def scan_rsi_extremes(
+    market: str = "america",
+    condition: str = "oversold",
+    threshold: float = 30,
+    limit: int = 25,
+) -> list[dict[str, Any]]:
+    """
+    Scan for RSI overbought/oversold conditions.
+
+    Args:
+        market: Market to scan
+        condition: 'oversold' or 'overbought'
+        threshold: RSI threshold (default 30 for oversold, 70 for overbought)
+        limit: Number of results (1-100)
+
+    Returns:
+        List of symbols matching RSI criteria
+    """
+    market = sanitize_market(market)
+    limit = max(1, min(limit, 100))
+
+    cols = ["name", "close", "volume", "change", "RSI", "RSI7", "market_cap_basic"]
+
+    query = Query().set_markets(market).select(*cols).limit(limit)
+
+    if condition == "oversold":
+        threshold = min(threshold, 50)
+        query = query.where(Column("RSI") < threshold).order_by("RSI", ascending=True)
+    else:  # overbought
+        threshold = max(threshold, 50)
+        query = query.where(Column("RSI") > threshold).order_by("RSI", ascending=False)
+
+    try:
+        total, df = query.get_scanner_data()
+        results = df.to_dict("records")
+
+        # Add signal interpretation
+        for r in results:
+            rsi = r.get("RSI", 50)
+            if rsi < 20:
+                r["signal"] = "EXTREMELY_OVERSOLD"
+            elif rsi < 30:
+                r["signal"] = "OVERSOLD"
+            elif rsi > 80:
+                r["signal"] = "EXTREMELY_OVERBOUGHT"
+            elif rsi > 70:
+                r["signal"] = "OVERBOUGHT"
+            else:
+                r["signal"] = "NEUTRAL"
+
+        return results
+    except Exception as e:
+        return [{"error": str(e)}]
+
+
+@mcp.tool()
+def scan_macd_crossover(
+    market: str = "america",
+    crossover_type: str = "bullish",
+    limit: int = 25,
+) -> list[dict[str, Any]]:
+    """
+    Scan for MACD crossover signals.
+
+    Args:
+        market: Market to scan
+        crossover_type: 'bullish' (MACD crosses above signal) or 'bearish'
+        limit: Number of results (1-100)
+
+    Returns:
+        List of symbols with MACD crossover
+    """
+    market = sanitize_market(market)
+    limit = max(1, min(limit, 100))
+
+    cols = ["name", "close", "volume", "change", "MACD.macd", "MACD.signal", "market_cap_basic"]
+
+    query = Query().set_markets(market).select(*cols).limit(limit)
+
+    if crossover_type == "bullish":
+        query = query.where(Column("MACD.macd").crosses_above(Column("MACD.signal"))).order_by(
+            "change", ascending=False
+        )
+    else:
+        query = query.where(Column("MACD.macd").crosses_below(Column("MACD.signal"))).order_by(
+            "change", ascending=True
+        )
+
+    try:
+        total, df = query.get_scanner_data()
+        results = df.to_dict("records")
+
+        for r in results:
+            macd = r.get("MACD.macd", 0)
+            signal = r.get("MACD.signal", 0)
+            r["macd_histogram"] = round(macd - signal, 4) if macd and signal else None
+            r["crossover"] = crossover_type
+
+        return results
+    except Exception as e:
+        return [{"error": str(e)}]
+
+
+@mcp.tool()
+def scan_bollinger_bands(
+    market: str = "america",
+    condition: str = "squeeze",
+    limit: int = 25,
+) -> list[dict[str, Any]]:
+    """
+    Scan for Bollinger Band conditions.
+
+    Args:
+        market: Market to scan
+        condition: 'squeeze' (low volatility), 'above_upper', 'below_lower'
+        limit: Number of results (1-100)
+
+    Returns:
+        List of symbols matching BB criteria
+    """
+    market = sanitize_market(market)
+    limit = max(1, min(limit, 100))
+
+    cols = ["name", "close", "volume", "change", "BB.upper", "BB.lower", "SMA20", "ATR", "Volatility.D"]
+
+    query = Query().set_markets(market).select(*cols).limit(limit)
+
+    if condition == "squeeze":
+        query = query.order_by("Volatility.D", ascending=True)
+    elif condition == "above_upper":
+        query = query.where(Column("close") > Column("BB.upper")).order_by("change", ascending=False)
+    elif condition == "below_lower":
+        query = query.where(Column("close") < Column("BB.lower")).order_by("change", ascending=True)
+
+    try:
+        total, df = query.get_scanner_data()
+        results = df.to_dict("records")
+
+        # Calculate BBW and add signals
+        for r in results:
+            bb_upper = r.get("BB.upper", 0)
+            bb_lower = r.get("BB.lower", 0)
+            sma20 = r.get("SMA20", 0)
+            close = r.get("close", 0)
+
+            if sma20 and bb_upper and bb_lower:
+                bbw = compute_bollinger_band_width(sma20, bb_upper, bb_lower)
+                r["bbw"] = round(bbw, 4) if bbw else None
+
+                rating, signal = compute_bollinger_rating(close, bb_upper, sma20, bb_lower)
+                r["bb_rating"] = rating
+                r["bb_signal"] = signal
+
+        return results
+    except Exception as e:
+        return [{"error": str(e)}]
+
+
+@mcp.tool()
+def scan_volume_breakout(
+    market: str = "america",
+    volume_multiplier: float = 2.0,
+    min_price_change: float = 3.0,
+    limit: int = 25,
+) -> list[dict[str, Any]]:
+    """
+    Scan for volume breakout candidates.
+
+    Args:
+        market: Market to scan
+        volume_multiplier: Minimum relative volume vs 10-day average (default 2.0)
+        min_price_change: Minimum absolute price change % (default 3.0)
+        limit: Number of results (1-100)
+
+    Returns:
+        List of symbols with volume breakouts
+    """
+    market = sanitize_market(market)
+    limit = max(1, min(limit, 100))
+    volume_multiplier = max(1.2, min(10.0, volume_multiplier))
+    min_price_change = max(0.5, min(20.0, min_price_change))
+
+    cols = [
+        "name",
+        "close",
+        "volume",
+        "change",
+        "change_abs",
+        "relative_volume_10d_calc",
+        "average_volume_10d_calc",
+    ]
+
+    query = (
+        Query()
+        .set_markets(market)
+        .select(*cols)
+        .where(
+            Column("relative_volume_10d_calc") >= volume_multiplier,
+        )
+        .order_by("relative_volume_10d_calc", ascending=False)
+        .limit(limit * 2)  # Get more to filter
+    )
+
+    try:
+        total, df = query.get_scanner_data()
+        results = df.to_dict("records")
+
+        # Filter by price change
+        filtered = []
+        for r in results:
+            change = abs(r.get("change", 0) or 0)
+            if change >= min_price_change:
+                rel_vol = r.get("relative_volume_10d_calc", 1)
+                r["breakout_type"] = "bullish" if r.get("change", 0) > 0 else "bearish"
+                r["volume_strength"] = "VERY_STRONG" if rel_vol >= 3 else "STRONG" if rel_vol >= 2 else "MODERATE"
+                filtered.append(r)
+
+        return filtered[:limit]
+    except Exception as e:
+        return [{"error": str(e)}]
+
+
+@mcp.tool()
+def scan_moving_average_crossover(
+    market: str = "america",
+    crossover_type: str = "golden_cross",
+    limit: int = 25,
+) -> list[dict[str, Any]]:
+    """
+    Scan for moving average crossovers.
+
+    Args:
+        market: Market to scan
+        crossover_type: 'golden_cross' (SMA50 crosses above SMA200),
+                       'death_cross' (SMA50 crosses below SMA200),
+                       'above_all_mas', 'below_all_mas'
+        limit: Number of results (1-100)
+
+    Returns:
+        List of symbols with MA crossovers
+    """
+    market = sanitize_market(market)
+    limit = max(1, min(limit, 100))
+
+    scanner_map = {
+        "golden_cross": Scanner.golden_cross,
+        "death_cross": Scanner.death_cross,
+        "above_all_mas": Scanner.above_all_mas,
+    }
+
+    scanner = scanner_map.get(crossover_type)
+    if scanner:
+        scanner = scanner.copy().set_markets(market).limit(limit)
+    else:
+        # below_all_mas
+        scanner = (
+            Query()
+            .set_markets(market)
+            .select("name", "close", "volume", "change", "SMA20", "SMA50", "SMA200")
+            .where(
+                Column("close") < Column("SMA20"),
+                Column("close") < Column("SMA50"),
+                Column("close") < Column("SMA200"),
+            )
+            .order_by("change", ascending=True)
+            .limit(limit)
+        )
+
+    try:
+        total, df = scanner.get_scanner_data()
+        results = df.to_dict("records")
+
+        for r in results:
+            r["crossover_type"] = crossover_type
+
+        return results
+    except Exception as e:
+        return [{"error": str(e)}]
+
+
+@mcp.tool()
+def scan_52_week_levels(
+    market: str = "america",
+    level_type: str = "near_high",
+    threshold_pct: float = 5.0,
+    limit: int = 25,
+) -> list[dict[str, Any]]:
+    """
+    Scan for stocks near 52-week highs or lows.
+
+    Args:
+        market: Market to scan
+        level_type: 'near_high', 'near_low', 'new_high', 'new_low'
+        threshold_pct: How close to the level (default 5%)
+        limit: Number of results (1-100)
+
+    Returns:
+        List of symbols near 52-week extremes
+    """
+    market = sanitize_market(market)
+    limit = max(1, min(limit, 100))
+    threshold_pct = max(1.0, min(20.0, threshold_pct))
+
+    cols = ["name", "close", "volume", "change", "price_52_week_high", "price_52_week_low", "Perf.Y"]
+
+    query = Query().set_markets(market).select(*cols).limit(limit)
+
+    if level_type == "near_high":
+        # Price within threshold_pct of 52-week high
+        multiplier = 1 - (threshold_pct / 100)
+        query = query.where(Column("close").above_pct("price_52_week_high", multiplier)).order_by(
+            "change", ascending=False
+        )
+    elif level_type == "near_low":
+        # Price within threshold_pct of 52-week low
+        multiplier = 1 + (threshold_pct / 100)
+        query = query.where(Column("close").below_pct("price_52_week_low", multiplier)).order_by(
+            "change", ascending=True
+        )
+    elif level_type == "new_high":
+        query = query.where(Column("close") >= Column("price_52_week_high")).order_by(
+            "change", ascending=False
+        )
+    else:  # new_low
+        query = query.where(Column("close") <= Column("price_52_week_low")).order_by(
+            "change", ascending=True
+        )
+
+    try:
+        total, df = query.get_scanner_data()
+        results = df.to_dict("records")
+
+        for r in results:
+            close = r.get("close", 0)
+            high52 = r.get("price_52_week_high", 0)
+            low52 = r.get("price_52_week_low", 0)
+
+            if high52:
+                r["pct_from_52w_high"] = round(((close - high52) / high52) * 100, 2)
+            if low52:
+                r["pct_from_52w_low"] = round(((close - low52) / low52) * 100, 2)
+
+        return results
+    except Exception as e:
+        return [{"error": str(e)}]
+
+
+# =============================================================================
+# MCP Tools - Symbol Analysis
+# =============================================================================
+
+
+@mcp.tool()
+def get_symbol_analysis(
+    symbol: str,
+    include_fundamentals: bool = True,
+) -> dict[str, Any]:
+    """
+    Get comprehensive technical analysis for a specific symbol.
+
+    Args:
+        symbol: Symbol in format 'EXCHANGE:SYMBOL' (e.g., 'NASDAQ:AAPL', 'BINANCE:BTCUSDT')
+        include_fundamentals: Include fundamental data if available
+
+    Returns:
+        Comprehensive analysis with indicators, signals, and recommendations
+    """
+    # Select columns based on what we want
+    cols = [
+        "name",
+        "description",
+        "type",
+        "exchange",
+        "close",
+        "open",
+        "high",
+        "low",
+        "volume",
+        "change",
+        "change_abs",
+        # Technical indicators
+        "RSI",
+        "RSI7",
+        "MACD.macd",
+        "MACD.signal",
+        "BB.upper",
+        "BB.lower",
+        "SMA20",
+        "SMA50",
+        "SMA200",
+        "EMA20",
+        "EMA50",
+        "EMA200",
+        "ADX",
+        "ATR",
+        "Stoch.K",
+        "Stoch.D",
+        "VWAP",
+        "Volatility.D",
+        # Performance
+        "Perf.W",
+        "Perf.1M",
+        "Perf.3M",
+        "Perf.Y",
+        # Recommendations
+        "Recommend.All",
+        "Recommend.MA",
+        "Recommend.Other",
+    ]
+
+    if include_fundamentals:
+        cols.extend(
+            [
+                "market_cap_basic",
+                "price_earnings_ttm",
+                "earnings_per_share_basic_ttm",
+                "dividend_yield_recent",
+                "price_52_week_high",
+                "price_52_week_low",
+            ]
+        )
+
+    try:
+        query = Query().set_tickers(symbol).select(*cols)
+        total, df = query.get_scanner_data()
+
+        if df.empty:
+            return {"error": f"No data found for {symbol}"}
+
+        row = df.iloc[0].to_dict()
+
+        # Perform technical analysis
+        analysis = analyze_indicators(row)
+
+        # Build result
+        result = {
+            "symbol": symbol,
+            "name": row.get("name"),
+            "exchange": row.get("exchange"),
+            "type": row.get("type"),
+            "price_data": {
+                "close": row.get("close"),
+                "open": row.get("open"),
+                "high": row.get("high"),
+                "low": row.get("low"),
+                "volume": row.get("volume"),
+                "change": row.get("change"),
+                "change_abs": row.get("change_abs"),
+            },
+            "technical_indicators": {
+                "rsi": row.get("RSI"),
+                "rsi7": row.get("RSI7"),
+                "macd": row.get("MACD.macd"),
+                "macd_signal": row.get("MACD.signal"),
+                "bb_upper": row.get("BB.upper"),
+                "bb_lower": row.get("BB.lower"),
+                "sma20": row.get("SMA20"),
+                "sma50": row.get("SMA50"),
+                "sma200": row.get("SMA200"),
+                "ema20": row.get("EMA20"),
+                "ema50": row.get("EMA50"),
+                "ema200": row.get("EMA200"),
+                "adx": row.get("ADX"),
+                "atr": row.get("ATR"),
+                "stoch_k": row.get("Stoch.K"),
+                "stoch_d": row.get("Stoch.D"),
+                "vwap": row.get("VWAP"),
+                "volatility": row.get("Volatility.D"),
+            },
+            "performance": {
+                "weekly": row.get("Perf.W"),
+                "monthly": row.get("Perf.1M"),
+                "quarterly": row.get("Perf.3M"),
+                "yearly": row.get("Perf.Y"),
+            },
+            "ratings": {
+                "overall": row.get("Recommend.All"),
+                "overall_label": format_technical_rating(row.get("Recommend.All", 0)),
+                "moving_averages": row.get("Recommend.MA"),
+                "oscillators": row.get("Recommend.Other"),
+            },
+            "analysis": analysis,
+        }
+
+        if include_fundamentals:
+            result["fundamentals"] = {
+                "market_cap": row.get("market_cap_basic"),
+                "pe_ratio": row.get("price_earnings_ttm"),
+                "eps": row.get("earnings_per_share_basic_ttm"),
+                "dividend_yield": row.get("dividend_yield_recent"),
+                "52_week_high": row.get("price_52_week_high"),
+                "52_week_low": row.get("price_52_week_low"),
+            }
+
+        return result
+
+    except Exception as e:
+        return {"error": str(e), "symbol": symbol}
+
+
+@mcp.tool()
+def compare_symbols(
+    symbols: list[str],
+    columns: Optional[list[str]] = None,
+) -> list[dict[str, Any]]:
+    """
+    Compare multiple symbols side by side.
+
+    Args:
+        symbols: List of symbols (e.g., ['NASDAQ:AAPL', 'NASDAQ:MSFT', 'NASDAQ:GOOGL'])
+        columns: Columns to compare (default: standard comparison set)
+
+    Returns:
+        Comparison data for all symbols
+    """
+    if not symbols:
+        return [{"error": "No symbols provided"}]
+
+    cols = columns or [
+        "name",
+        "close",
+        "change",
+        "volume",
+        "RSI",
+        "MACD.macd",
+        "market_cap_basic",
+        "Perf.1M",
+        "Perf.Y",
+        "Recommend.All",
+    ]
+
+    try:
+        query = Query().set_tickers(*symbols).select(*cols)
+        total, df = query.get_scanner_data()
+
+        results = df.to_dict("records")
+
+        # Add technical rating labels
+        for r in results:
+            rec = r.get("Recommend.All")
+            if rec is not None:
+                r["rating_label"] = format_technical_rating(rec)
+
+        return results
+
+    except Exception as e:
+        return [{"error": str(e)}]
+
+
+# =============================================================================
+# MCP Tools - Utility Functions
+# =============================================================================
+
+
+@mcp.tool()
+def get_all_market_symbols(market: str = "america") -> dict[str, Any]:
+    """
+    Get all available symbols for a market.
+
+    Args:
+        market: Market identifier (america, crypto, uk, etc.)
+
+    Returns:
+        Dictionary with symbol count and list of symbols
+    """
+    market = sanitize_market(market)
+
+    try:
+        symbols = get_all_symbols(market)
+        return {
+            "market": market,
+            "total_symbols": len(symbols),
+            "symbols": symbols[:500],  # Return first 500 to avoid huge responses
+            "note": f"Showing first 500 of {len(symbols)} symbols" if len(symbols) > 500 else None,
+        }
+    except Exception as e:
+        return {"error": str(e), "market": market}
+
+
+@mcp.tool()
+def run_scanner_preset(
+    preset_name: str,
+    market: Optional[str] = None,
+    limit: int = 50,
+) -> list[dict[str, Any]]:
+    """
+    Run a pre-built scanner preset.
+
+    Args:
+        preset_name: Name of the preset (see scanners://presets resource)
+        market: Override market (optional)
+        limit: Number of results (1-100)
+
+    Returns:
+        Scanner results
+    """
+    limit = max(1, min(limit, 100))
+
+    # Try stock scanners first
+    scanner = getattr(Scanner, preset_name, None)
+
+    # Try crypto scanners
+    if scanner is None:
+        scanner = getattr(CryptoScanner, preset_name, None)
+
+    if scanner is None:
+        available = Scanner.names() + CryptoScanner.names()
+        return [{"error": f"Unknown preset: {preset_name}", "available_presets": available}]
+
+    scanner = scanner.copy().limit(limit)
+
+    if market:
+        market = sanitize_market(market)
+        scanner = scanner.set_markets(market)
+
+    try:
+        total, df = scanner.get_scanner_data()
+        return df.to_dict("records")
+    except Exception as e:
+        return [{"error": str(e)}]
+
+
+@mcp.tool()
+def advanced_query(
+    market: str = "america",
+    select_columns: list[str] = None,
+    conditions: list[dict[str, Any]] = None,
+    logic: str = "and",
+    sort_by: str = "volume",
+    ascending: bool = False,
+    limit: int = 50,
+) -> list[dict[str, Any]]:
+    """
+    Execute an advanced query with complex AND/OR logic.
+
+    Args:
+        market: Market to scan
+        select_columns: Columns to return
+        conditions: List of conditions, each with:
+                   - column: Column name
+                   - op: Operation (gt, gte, lt, lte, eq, neq, between, isin, crosses_above, crosses_below)
+                   - value: Value or [min, max] for between
+        logic: 'and' or 'or' to combine conditions
+        sort_by: Column to sort by
+        ascending: Sort order
+        limit: Maximum results (1-500)
+
+    Returns:
+        Query results
+
+    Example:
+        conditions=[
+            {"column": "RSI", "op": "lt", "value": 30},
+            {"column": "volume", "op": "gt", "value": 1000000},
+            {"column": "change", "op": "between", "value": [-5, 5]}
+        ]
+    """
+    market = sanitize_market(market)
+    limit = max(1, min(limit, 500))
+    cols = select_columns or TECHNICAL_COLUMNS
+
+    query = Query().set_markets(market).select(*cols).order_by(sort_by, ascending=ascending).limit(limit)
+
+    if conditions:
+        expressions = []
+        for cond in conditions:
+            col = Column(cond.get("column", "close"))
+            op = cond.get("op", "gt")
+            val = cond.get("value")
+
+            if op == "gt":
+                expressions.append(col > val)
+            elif op == "gte":
+                expressions.append(col >= val)
+            elif op == "lt":
+                expressions.append(col < val)
+            elif op == "lte":
+                expressions.append(col <= val)
+            elif op == "eq":
+                expressions.append(col == val)
+            elif op == "neq":
+                expressions.append(col != val)
+            elif op == "between" and isinstance(val, (list, tuple)) and len(val) == 2:
+                expressions.append(col.between(val[0], val[1]))
+            elif op == "isin" and isinstance(val, (list, tuple)):
+                expressions.append(col.isin(val))
+            elif op == "crosses_above":
+                expressions.append(col.crosses_above(Column(val) if isinstance(val, str) else val))
+            elif op == "crosses_below":
+                expressions.append(col.crosses_below(Column(val) if isinstance(val, str) else val))
+            elif op == "above_pct" and isinstance(val, (list, tuple)) and len(val) == 2:
+                expressions.append(col.above_pct(val[0], val[1]))
+            elif op == "below_pct" and isinstance(val, (list, tuple)) and len(val) == 2:
+                expressions.append(col.below_pct(val[0], val[1]))
+
+        if expressions:
+            if logic == "or":
+                query = query.where2(Or(*expressions))
+            else:
+                query = query.where(*expressions)
+
+    try:
+        total, df = query.get_scanner_data()
+        results = df.to_dict("records")
+        return [{"total_count": total, "returned": len(results), "data": results}]
+    except Exception as e:
+        return [{"error": str(e)}]
+
+
+# =============================================================================
+# MCP Tools - Crypto Specific
+# =============================================================================
+
+
+@mcp.tool()
+def get_crypto_gainers(exchange: Optional[str] = None, limit: int = 25) -> list[dict[str, Any]]:
+    """
+    Get top gaining cryptocurrencies.
+
+    Args:
+        exchange: Specific exchange (binance, coinbase, etc.) or None for all
+        limit: Number of results (1-100)
+
+    Returns:
+        List of top crypto gainers
+    """
+    limit = max(1, min(limit, 100))
+
+    cols = ["name", "close", "volume", "change", "change_abs", "market_cap_basic", "24h_vol|5"]
+
+    query = (
+        Query()
+        .set_markets("crypto")
+        .select(*cols)
+        .where(Column("change") > 0)
+        .order_by("change", ascending=False)
+        .limit(limit)
+    )
+
+    if exchange:
+        query = query.where(Column("exchange") == exchange.upper())
+
+    try:
+        total, df = query.get_scanner_data()
+        return df.to_dict("records")
+    except Exception as e:
+        return [{"error": str(e)}]
+
+
+@mcp.tool()
+def get_crypto_losers(exchange: Optional[str] = None, limit: int = 25) -> list[dict[str, Any]]:
+    """
+    Get top losing cryptocurrencies.
+
+    Args:
+        exchange: Specific exchange (binance, coinbase, etc.) or None for all
+        limit: Number of results (1-100)
+
+    Returns:
+        List of top crypto losers
+    """
+    limit = max(1, min(limit, 100))
+
+    cols = ["name", "close", "volume", "change", "change_abs", "market_cap_basic", "24h_vol|5"]
+
+    query = (
+        Query()
+        .set_markets("crypto")
+        .select(*cols)
+        .where(Column("change") < 0)
+        .order_by("change", ascending=True)
+        .limit(limit)
+    )
+
+    if exchange:
+        query = query.where(Column("exchange") == exchange.upper())
+
+    try:
+        total, df = query.get_scanner_data()
+        return df.to_dict("records")
+    except Exception as e:
+        return [{"error": str(e)}]
+
+
+@mcp.tool()
+def scan_crypto_technicals(
+    scan_type: str = "oversold",
+    exchange: Optional[str] = None,
+    limit: int = 25,
+) -> list[dict[str, Any]]:
+    """
+    Scan cryptocurrencies based on technical indicators.
+
+    Args:
+        scan_type: Type of scan - 'oversold', 'overbought', 'macd_bullish', 'macd_bearish', 'high_volume'
+        exchange: Specific exchange or None for all
+        limit: Number of results (1-100)
+
+    Returns:
+        Crypto technical scan results
+    """
+    limit = max(1, min(limit, 100))
+
+    scanner_map = {
+        "oversold": CryptoScanner.oversold,
+        "overbought": CryptoScanner.overbought,
+        "high_volume": CryptoScanner.high_volume,
+        "most_volatile": CryptoScanner.most_volatile,
+    }
+
+    if scan_type in scanner_map:
+        scanner = scanner_map[scan_type].copy().limit(limit)
+    elif scan_type == "macd_bullish":
+        scanner = (
+            Query()
+            .set_markets("crypto")
+            .select("name", "close", "volume", "change", "MACD.macd", "MACD.signal", "RSI")
+            .where(Column("MACD.macd").crosses_above(Column("MACD.signal")))
+            .order_by("change", ascending=False)
+            .limit(limit)
+        )
+    elif scan_type == "macd_bearish":
+        scanner = (
+            Query()
+            .set_markets("crypto")
+            .select("name", "close", "volume", "change", "MACD.macd", "MACD.signal", "RSI")
+            .where(Column("MACD.macd").crosses_below(Column("MACD.signal")))
+            .order_by("change", ascending=True)
+            .limit(limit)
+        )
+    else:
+        return [{"error": f"Unknown scan_type: {scan_type}"}]
+
+    if exchange:
+        scanner = scanner.where(Column("exchange") == exchange.upper())
+
+    try:
+        total, df = scanner.get_scanner_data()
+        return df.to_dict("records")
+    except Exception as e:
+        return [{"error": str(e)}]
+
+
+# =============================================================================
+# Server Entry Point
+# =============================================================================
+
+
+def main() -> None:
+    """Main entry point for the MCP server."""
+    parser = argparse.ArgumentParser(description="TradingView Screener MCP Server")
+    parser.add_argument(
+        "transport",
+        choices=["stdio", "streamable-http"],
+        default="stdio",
+        nargs="?",
+        help="Transport protocol (default: stdio)",
+    )
+    parser.add_argument("--host", default=os.environ.get("HOST", "127.0.0.1"), help="HTTP host")
+    parser.add_argument(
+        "--port", type=int, default=int(os.environ.get("PORT", "8000")), help="HTTP port"
+    )
+    args = parser.parse_args()
+
+    if os.environ.get("DEBUG_MCP"):
+        import sys
+
+        print(f"[DEBUG] TradingView MCP starting: transport={args.transport}", file=sys.stderr, flush=True)
+
+    if args.transport == "stdio":
+        mcp.run()
+    else:
+        try:
+            mcp.settings.host = args.host
+            mcp.settings.port = args.port
+        except AttributeError:
+            pass
+        mcp.run(transport="streamable-http")
+
+
+if __name__ == "__main__":
+    main()