tradingview-mcp 26.2.0__py3-none-any.whl → 26.3.1__py3-none-any.whl

tradingview_mcp/server.py

@@ -6,75 +6,57 @@ Provides comprehensive MCP tools and resources for TradingView market screening.
 
 from __future__ import annotations
 
-import argparse
 import inspect
 import json
 import os
 import traceback
 from datetime import datetime
 from functools import wraps
-from typing import Any, Optional
+from typing import Any
 
 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.docs_data import suggest_fields_for_error
+from tradingview_mcp.tools.search import search_symbols, get_symbol_info
+from tradingview_mcp.tools.screener import (
+    screen_market, 
+    get_top_gainers, 
+    get_top_losers, 
+    get_most_active
 )
-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,
+from tradingview_mcp.tools.technical import (
+    get_technical_analysis,
+    scan_rsi_extremes,
+    scan_bollinger_bands,
+    scan_macd_crossover
 )
-from tradingview_mcp.docs_data import (
-    get_ai_quick_reference,
-    get_column_display_names,
-    get_common_fields,
-    get_fields_by_market,
-    get_markets_data,
-    get_metainfo as load_metainfo,
-    get_screener_code_examples,
-    get_screener_markets,
-    get_screener_presets,
-    get_stock_screeners,
-    get_stock_screeners_failed,
-    get_stock_screener_presets,
-    get_valid_fields_for_market,
-    suggest_fields_for_error,
-    paginate_data,
-    search_fields,
-    get_field_summary,
-    estimate_tokens,
-    truncate_for_tokens,
-    MAX_ITEMS_DEFAULT,
-    # New fast lookup functions
-    get_quick_reference,
-    lookup_field,
-    get_filter_format,
-    get_market_fields_summary,
-    get_screener_preset_names,
-    get_code_example_names,
-    validate_market,
-    build_error_with_format,
-    ALL_MARKETS,
-    FIELD_CATEGORIES,
-    FILTER_OPS,
+from tradingview_mcp.tools.reference import (
+    ai_get_reference,
+    search_available_fields,
+    get_code_example,
+    list_fields_for_market,
+    get_common_fields_summary,
+    lookup_single_field,
+    get_filter_example,
+    check_market,
+    get_help,
+    get_field_info,
+    get_screener_preset,
+    get_market_metainfo,
+)
+from tradingview_mcp.resources import (
+    list_markets,
+    list_columns,
+    list_crypto_exchanges,
+    list_scanner_presets,
+    docs_params,
+    docs_screeners,
+    docs_stock_screeners,
+    docs_stock_screeners_failed,
+    docs_fields,
+    docs_markets,
+    docs_ai_reference,
+    docs_code_examples,
 )
 
 # Initialize MCP Server
@@ -166,12 +148,6 @@ def _build_error_response(tool_name: str, exc: Exception, context: dict[str, Any
     return payload
 
 
-def _error_response(exc: Exception, context: dict[str, Any] | None = None) -> dict[str, Any]:
-    frame = inspect.currentframe()
-    caller = frame.f_back.f_code.co_name if frame and frame.f_back else "unknown"
-    return _build_error_response(caller, exc, context or {})
-
-
 def debug_tool(fn):
     """Decorator to return structured debug responses on failure."""
 
@@ -197,7 +173,7 @@ def debug_tool(fn):
                     {"args": args, "kwargs": kwargs, "note": "error returned by tool"},
                 )
             return result
-        except Exception as exc:  # pragma: no cover - defensive guard
+        except Exception as exc: 
             context = {"args": args, "kwargs": kwargs}
             return _build_error_response(fn.__name__, exc, context)
 
@@ -220,1396 +196,54 @@ mcp.tool = _debug_mcp_tool
 
 
 # =============================================================================
-# MCP Resources - Compact summaries only, use tools for full data
-# =============================================================================
-
-
-@mcp.resource("markets://list")
-def list_markets() -> str:
-    """Available markets summary."""
-    return json.dumps({
-        "stock_markets": ["america", "uk", "germany", "japan", "china", "hongkong", "taiwan", "korea", "india", "australia", "canada", "brazil", "france", "singapore"],
-        "other_markets": ["crypto", "coin", "forex", "futures", "bonds", "cfd", "options"],
-        "total_stock_markets": 68,
-        "hint": "Use validate_market(name) to check if a market is valid",
-    }, indent=2)
-
-
-@mcp.resource("columns://list")
-def list_columns() -> str:
-    """Field categories summary."""
-    return json.dumps({
-        "categories": FIELD_CATEGORIES,
-        "hint": "Use lookup_field(name) or search_fields(query) for details",
-    }, indent=2)
-
-
-@mcp.resource("exchanges://crypto")
-def list_crypto_exchanges() -> str:
-    """Crypto exchanges."""
-    exchanges = [ex for ex, screener in EXCHANGE_SCREENER.items() if screener == "crypto"]
-    return json.dumps({"exchanges": sorted(exchanges)[:20], "total": len(exchanges)}, indent=2)
-
-
-@mcp.resource("scanners://presets")
-def list_scanner_presets() -> str:
-    """Scanner presets summary."""
-    return json.dumps({
-        "stock_scanners": Scanner.names(),
-        "crypto_scanners": CryptoScanner.names(),
-        "hint": "Use run_scanner_preset(name) to execute",
-    }, indent=2)
-
-
-@mcp.resource("docs://params")
-def docs_params() -> str:
-    """Screener parameter format."""
-    return json.dumps({
-        "filter_format": {"column": "field_name", "operation": "op", "value": "value"},
-        "operations": ["gt", "gte", "lt", "lte", "eq", "neq", "between", "isin"],
-        "examples": [
-            {"column": "change", "operation": "gt", "value": 5},
-            {"column": "volume", "operation": "gt", "value": 1000000},
-            {"column": "RSI", "operation": "between", "value": [20, 30]},
-        ],
-        "hint": "Use get_filter_format(type) for specific type formats",
-    }, indent=2)
-
-
-@mcp.resource("docs://screeners")
-def docs_screeners() -> str:
-    """Screener presets (names only)."""
-    names = get_screener_preset_names()
-    return json.dumps({"presets": names, "hint": "Use get_screener_preset(name) for full details"}, indent=2)
-
-
-@mcp.resource("docs://stock-screeners")
-def docs_stock_screeners() -> str:
-    """Stock screener markets (summary)."""
-    data = get_stock_screeners()
-    markets = [{"market": d.get("market"), "title": d.get("title"), "group": d.get("group")} for d in data[:30]]
-    return json.dumps({"markets": markets, "total": len(data)}, indent=2)
-
-
-@mcp.resource("docs://stock-screeners-failed")
-def docs_stock_screeners_failed() -> str:
-    """Failed stock screener markets (summary)."""
-    data = get_stock_screeners_failed()
-    return json.dumps({"count": len(data), "markets": [d.get("market") for d in data][:20]}, indent=2)
-
-
-@mcp.resource("docs://fields")
-def docs_fields() -> str:
-    """Field categories only."""
-    return json.dumps({
-        "categories": FIELD_CATEGORIES,
-        "hint": "Use lookup_field(name) or search_fields(query) for details",
-    }, indent=2)
-
-
-@mcp.resource("docs://markets")
-def docs_markets() -> str:
-    """Markets summary."""
-    return json.dumps({
-        "stock_markets_count": 68,
-        "other_markets": ["crypto", "coin", "forex", "futures", "bonds", "cfd", "options"],
-        "hint": "Use validate_market(name) to check if a market is valid",
-    }, indent=2)
-
-
-@mcp.tool()
-def get_field_info(field: str) -> dict[str, Any]:
-    """Get display name and type for a field."""
-    return lookup_field(field)
-
-
-@mcp.tool()
-def get_screener_preset(name: str) -> dict[str, Any]:
-    """Return a full screener preset (query + code) by name."""
-    presets = get_screener_presets()
-    for preset in presets:
-        if preset.get("name", "").lower() == name.lower():
-            return preset
-    return {
-        "error": f"Preset '{name}' not found.",
-        "available": get_screener_preset_names(),
-    }
-
-
-@mcp.tool()
-def list_stock_screener_presets(market: str | None = None, limit: int = 20) -> dict[str, Any]:
-    """List stock screener presets."""
-    data = get_stock_screener_presets(market)
-    if isinstance(data, dict):
-        keys = list(data.keys())[:limit]
-        return {"presets": keys, "total": len(data), "market": market}
-    return {"data": data[:limit] if isinstance(data, list) else data, "market": market}
-
-
-@mcp.tool()
-def list_stock_screeners(limit: int = 30) -> dict[str, Any]:
-    """List stock screener markets."""
-    data = get_stock_screeners()
-    markets = [{"market": d.get("market"), "title": d.get("title")} for d in data[:limit]]
-    return {"markets": markets, "total": len(data)}
-
-
-@mcp.tool()
-def list_failed_stock_screeners() -> dict[str, Any]:
-    """List failed stock screener markets."""
-    data = get_stock_screeners_failed()
-    return {"markets": [d.get("market") for d in data], "total": len(data)}
-
-
-@mcp.tool()
-def get_market_metainfo(market: str, limit: int = 30) -> dict[str, Any]:
-    """Return metainfo summary for a market."""
-    validation = validate_market(market)
-    if not validation.get("valid"):
-        return validation
-    
-    market = validation.get("market", market)
-    return get_market_fields_summary(market)
-
-
-# =============================================================================
-# AI-Friendly Tools - Fast Lookup (no large data dumps)
-# =============================================================================
-
-
-@mcp.resource("docs://ai-reference")
-def docs_ai_reference() -> str:
-    """AI quick reference (compact)."""
-    return json.dumps({
-        "field_categories": FIELD_CATEGORIES,
-        "filter_operations": ["gt", "gte", "lt", "lte", "eq", "neq", "between", "isin"],
-        "common_markets": ["america", "crypto", "forex", "uk", "germany", "japan"],
-        "tools": ["lookup_field", "search_fields", "validate_market", "get_filter_format"],
-    }, indent=2)
-
-
-@mcp.resource("docs://code-examples")  
-def docs_code_examples() -> str:
-    """Code example names only."""
-    names = get_code_example_names()
-    return json.dumps({"examples": names, "hint": "Use get_code_example(name) for code"}, indent=2)
-
-
-@mcp.tool()
-def ai_get_reference() -> dict[str, Any]:
-    """Get quick reference for markets and fields."""
-    return get_quick_reference()
-
-
-@mcp.tool()
-def search_available_fields(query: str, market: str = "stocks", limit: int = 15) -> dict[str, Any]:
-    """Search fields by name or display name."""
-    results = search_fields(query, market, min(limit, 30))
-    return {
-        "query": query,
-        "market": market,
-        "count": len(results),
-        "fields": results,
-        "hint": "Use the 'name' field as the column name in queries." if results else "No matches. Try different keywords.",
-    }
-
-
-@mcp.tool()
-def get_code_example(screener_name: str) -> dict[str, Any]:
-    """Get code example for a screener type."""
-    examples = get_screener_code_examples()
-    
-    if screener_name in examples:
-        return {"name": screener_name, "code": examples[screener_name]}
-    
-    for name, code in examples.items():
-        if name.lower() == screener_name.lower():
-            return {"name": name, "code": code}
-    
-    return {"error": f"'{screener_name}' not found.", "available": list(examples.keys())}
-
-
-@mcp.tool()
-def list_fields_for_market(market: str = "stocks", category: str | None = None, limit: int = 30) -> dict[str, Any]:
-    """List fields for a market."""
-    validation = validate_market(market)
-    if not validation.get("valid"):
-        return validation
-    
-    fields = get_fields_by_market(validation.get("market", market))
-    if not fields:
-        return {"error": f"No fields for '{market}'.", "use": "search_fields(query) instead"}
-    
-    if category and isinstance(fields, list):
-        fields = [f for f in fields if category.lower() in f.get("type", "").lower()]
-    
-    if isinstance(fields, list):
-        return {"fields": [f.get("name") for f in fields[:limit]], "total": len(fields)}
-    return {"note": "Use search_fields() for this market"}
-
-
-@mcp.tool()
-def get_common_fields_summary(category: str | None = None) -> dict[str, Any]:
-    """Get common fields by category."""
-    if category:
-        fields = FIELD_CATEGORIES.get(category.lower())
-        if fields:
-            return {"category": category, "fields": fields}
-        return {"error": f"Category '{category}' not found.", "available": list(FIELD_CATEGORIES.keys())}
-    return {"categories": FIELD_CATEGORIES}
-
-
-# =============================================================================
-# Fast Lookup Tools - Direct answers
-# =============================================================================
-
-
-@mcp.tool()
-def lookup_single_field(field_name: str) -> dict[str, Any]:
-    """Lookup a single field by exact name."""
-    return lookup_field(field_name)
-
-
-@mcp.tool()
-def get_filter_example(field_type: str = "number") -> dict[str, Any]:
-    """Get correct filter format for a field type."""
-    return get_filter_format(field_type)
-
-
-@mcp.tool()
-def check_market(market: str) -> dict[str, Any]:
-    """Validate market name and get correct format."""
-    return validate_market(market)
-
-
-# =============================================================================
-# Help Tool - Compact guide
-# =============================================================================
-
-
-@mcp.tool()
-def get_help(topic: str | None = None) -> dict[str, Any]:
-    """Usage guide."""
-    guide = {
-        "quick_start": {
-            "1": "get_top_gainers('america', 10) - top gainers",
-            "2": "search_symbols('apple', 'america') - find symbols",
-            "3": "get_symbol_info('NASDAQ:AAPL') - symbol details",
-        },
-        "markets": {
-            "stocks": ["america", "uk", "germany", "japan", "china"],
-            "crypto": ["crypto", "coin"],
-            "others": ["forex", "futures", "bonds"],
-        },
-        "tools": {
-            "screening": ["screen_market", "get_top_gainers", "get_top_losers", "get_most_active"],
-            "lookup": ["search_symbols", "get_symbol_info", "get_technical_analysis"],
-            "reference": ["lookup_field", "search_fields", "check_market", "get_filter_example"],
-        },
-        "columns": FIELD_CATEGORIES,
-        "filters": {
-            "format": {"column": "field", "operation": "op", "value": "val"},
-            "operations": ["gt", "gte", "lt", "lte", "eq", "neq", "between", "isin"],
-        },
-    }
-    
-    if topic:
-        t = topic.lower()
-        if t in guide:
-            return {topic: guide[t]}
-        return {"error": f"Topic '{topic}' not found", "available": list(guide.keys())}
-    
-    return guide
-
-
-@mcp.tool()
-def search_symbols(
-    query: str,
-    market: str = "america",
-    limit: int = 25,
-) -> dict[str, Any]:
-    """Search symbols by name or ticker."""
-    market = sanitize_market(market)
-    limit = max(1, min(limit, 100))
-    
-    # Search fields: name (ticker) and description (full name)
-    cols = ["name", "description", "close", "change", "volume", "market_cap_basic", "type", "exchange"]
-    
-    try:
-        # Use TradingView text search
-        # Search description (company name)
-        query_obj = (
-            Query()
-            .set_markets(market)
-            .select(*cols)
-            .where(Column("description").like(query))
-            .order_by("market_cap_basic", ascending=False)
-            .limit(limit)
-        )
-        
-        total, df = query_obj.get_scanner_data()
-        results = df.to_dict("records")
-        
-        # If nothing found, try searching the name (ticker) field
-        if not results:
-            query_obj2 = (
-                Query()
-                .set_markets(market)
-                .select(*cols)
-                .where(Column("name").like(query))
-                .order_by("market_cap_basic", ascending=False)
-                .limit(limit)
-            )
-            total, df = query_obj2.get_scanner_data()
-            results = df.to_dict("records")
-        
-        return {
-            "query": query,
-            "market": market,
-            "total_found": total,
-            "returned": len(results),
-            "results": results,
-            "hint": "Use 'name' field as symbol for other tools (e.g., get_symbol_info)" if results else "No matches found. Try different keywords.",
-        }
-    except Exception as e:
-        # If LIKE isn't supported, use fallback
-        return _search_symbols_fallback(query, market, limit, cols, str(e))
-
-
-def _search_symbols_fallback(
-    query: str, market: str, limit: int, cols: list[str], original_error: str
-) -> dict[str, Any]:
-    """Fallback search when LIKE is not supported."""
-    try:
-        # Fetch more data and filter locally
-        query_obj = (
-            Query()
-            .set_markets(market)
-            .select(*cols)
-            .order_by("market_cap_basic", ascending=False)
-            .limit(500)  # Fetch top 500
-        )
-        
-        total, df = query_obj.get_scanner_data()
-        
-        # Local filter
-        query_lower = query.lower()
-        filtered = df[
-            df["name"].str.lower().str.contains(query_lower, na=False) |
-            df["description"].str.lower().str.contains(query_lower, na=False)
-        ].head(limit)
-        
-        results = filtered.to_dict("records")
-        
-        return {
-            "query": query,
-            "market": market,
-            "total_found": len(results),
-            "returned": len(results),
-            "results": results,
-            "note": "Results from local filtering of top 500 by market cap",
-            "hint": "Use 'name' field as symbol for other tools" if results else "No matches found",
-        }
-    except Exception as e:
-        return {
-            "error": f"Search failed: {str(e)}",
-            "original_error": original_error,
-            "hint": "Try using screen_market with specific filters instead",
-        }
-
-
-@mcp.tool()
-def get_symbol_info(
-    symbol: str,
-    include_technical: bool = False,
-) -> dict[str, Any]:
-    """Get detailed information for a symbol."""
-    cols = [
-        "name", "description", "close", "open", "high", "low", 
-        "change", "change_abs", "volume", "market_cap_basic",
-        "price_earnings_ttm", "earnings_per_share_basic_ttm",
-        "dividend_yield_recent", "sector", "industry", "exchange", "type",
-    ]
-    
-    if include_technical:
-        cols.extend([
-            "RSI", "RSI7", "MACD.macd", "MACD.signal",
-            "SMA20", "SMA50", "SMA200", "EMA20", "EMA50", "EMA200",
-            "BB.upper", "BB.lower", "ATR", "ADX",
-            "Recommend.All", "Recommend.MA", "Recommend.Other",
-        ])
-    
-    try:
-        # Determine market
-        if ":" in symbol:
-            exchange, ticker = symbol.split(":", 1)
-            market = EXCHANGE_SCREENER.get(exchange.lower(), "america")
-        else:
-            ticker = symbol
-            market = "america"
-        
-        query = (
-            Query()
-            .set_markets(market)
-            .select(*cols)
-            .where(Column("name").isin([symbol, ticker, symbol.upper(), ticker.upper()]))
-            .limit(5)
-        )
-        
-        total, df = query.get_scanner_data()
-        
-        if df.empty:
-            # Fallback to search
-            return search_symbols(ticker, market, 5)
-        
-        results = df.to_dict("records")
-        
-        if len(results) == 1:
-            return {"symbol": symbol, "found": True, "data": results[0]}
-        else:
-            return {"symbol": symbol, "found": True, "matches": results}
-            
-    except Exception as e:
-        return {
-            "error": f"Failed to get symbol info: {str(e)}",
-            "hint": "Try using search_symbols to find the correct symbol format",
-        }
-
-
-# =============================================================================
-# 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 = 25,
-    filters: Optional[list[dict[str, Any]]] = None,
-) -> dict[str, Any]:
-    """Run a custom market screening query."""
-    market = sanitize_market(market)
-    limit = max(1, min(limit, 500))
-    
-    # Ensure description is always included
-    cols = columns or DEFAULT_COLUMNS
-    if "description" not in cols:
-        cols = ["description"] + list(cols)
-
-    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),
-            "market": market,
-            "data": results,
-        }
-    except Exception as e:
-        return {"error": str(e), "market": market}
-
-
-@mcp.tool()
-def get_top_gainers(market: str = "america", limit: int = 25) -> dict[str, Any]:
-    """Get top gainers for a market."""
-    market = sanitize_market(market)
-    limit = max(1, min(limit, 100))
-
-    # Ensure description is included
-    cols = ["name", "description", "close", "change", "change_abs", "volume", "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()
-        results = df.to_dict("records")
-        return {
-            "market": market,
-            "type": "top_gainers",
-            "total_found": total,
-            "returned": len(results),
-            "data": results,
-        }
-    except Exception as e:
-        return {"error": str(e), "market": market}
-
-
-@mcp.tool()
-def get_top_losers(market: str = "america", limit: int = 25) -> dict[str, Any]:
-    """Get top losers for a market."""
-    market = sanitize_market(market)
-    limit = max(1, min(limit, 100))
-
-    # Ensure description is included
-    cols = ["name", "description", "close", "change", "change_abs", "volume", "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()
-        results = df.to_dict("records")
-        return {
-            "market": market,
-            "type": "top_losers",
-            "total_found": total,
-            "returned": len(results),
-            "data": results,
-        }
-    except Exception as e:
-        return {"error": str(e), "market": market}
-
-
-@mcp.tool()
-def get_most_active(market: str = "america", limit: int = 25) -> dict[str, Any]:
-    """Get most active by volume."""
-    market = sanitize_market(market)
-    limit = max(1, min(limit, 100))
-
-    cols = ["name", "description", "close", "change", "volume", "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()
-        results = df.to_dict("records")
-        return {
-            "market": market,
-            "type": "most_active",
-            "total_found": total,
-            "returned": len(results),
-            "data": results,
-        }
-    except Exception as e:
-        return {"error": str(e), "market": market}
-
-
-@mcp.tool()
-def get_premarket_movers(
-    scan_type: str = "gainers", limit: int = 25
-) -> dict[str, Any]:
-    """Get pre-market movers (US only)."""
-    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 only)."""
-    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."""
-    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."""
-    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."""
-    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."""
-    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."""
-    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."""
-    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 symbol."""
-    # 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."""
-    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
+# Register Tools
 # =============================================================================
 
+mcp.tool()(search_symbols)
+mcp.tool()(get_symbol_info)
+mcp.tool()(screen_market)
+mcp.tool()(get_top_gainers)
+mcp.tool()(get_top_losers)
+mcp.tool()(get_most_active)
 
-@mcp.tool()
-def get_all_market_symbols(market: str = "america") -> dict[str, Any]:
-    """Get available symbols for a market."""
-    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."""
-    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 AND/OR logic."""
-    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."""
-    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."""
-    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."""
-    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)}]
+mcp.tool()(get_technical_analysis)
+mcp.tool()(scan_rsi_extremes)
+mcp.tool()(scan_bollinger_bands)
+mcp.tool()(scan_macd_crossover)
 
+mcp.tool()(ai_get_reference)
+mcp.tool()(search_available_fields)
+mcp.tool()(get_code_example)
+mcp.tool()(list_fields_for_market)
+mcp.tool()(get_common_fields_summary)
+mcp.tool()(lookup_single_field)
+mcp.tool()(get_field_info)
+mcp.tool()(get_filter_example)
+mcp.tool()(check_market)
+mcp.tool()(get_help)
+mcp.tool()(get_screener_preset)
+mcp.tool()(get_market_metainfo)
 
 # =============================================================================
-# Server Entry Point
+# Register Resources
 # =============================================================================
 
+mcp.resource("markets://list")(list_markets)
+mcp.resource("columns://list")(list_columns)
+mcp.resource("exchanges://crypto")(list_crypto_exchanges)
+mcp.resource("scanners://presets")(list_scanner_presets)
+mcp.resource("docs://params")(docs_params)
+mcp.resource("docs://screeners")(docs_screeners)
+mcp.resource("docs://stock-screeners")(docs_stock_screeners)
+mcp.resource("docs://stock-screeners-failed")(docs_stock_screeners_failed)
+mcp.resource("docs://fields")(docs_fields)
+mcp.resource("docs://markets")(docs_markets)
+mcp.resource("docs://ai-reference")(docs_ai_reference)
+mcp.resource("docs://code-examples")(docs_code_examples)
 
-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")
 
+def main():
+    mcp.run()
 
 if __name__ == "__main__":
     main()