Update app.py

app.py

@@ -147,41 +147,43 @@ async def fetch_ohlcv(session, tools, symbol, timeframe, exchange, total):
     return out.to_dict("records")
 
 
-# ----------------------------------------------------------------- 2. MCP: crypto-market-data-mcp (türev verisi)
-# Kurulum:  git clone https://github.com/eliasfire617/crypto-market-data-mcp
-#           (kendi venv'inde) pip install -r requirements.txt
-# Sonra ortam değişkenleri:
-#   CRYPTO_MCP_SERVER=/yol/crypto-market-data-mcp/server.py
-#   CRYPTO_MCP_PYTHON=/yol/crypto-market-data-mcp/.venv/bin/python   (opsiyonel; yoksa bu uygulamanın python'u)
-DERIV_PATH = os.environ.get("CRYPTO_MCP_SERVER", "")
-
-
-def _perp(symbol):
-    s = symbol.strip().upper()
-    if "/" in s and ":" not in s:
-        s = f"{s}:{s.split('/')[1]}"
-    return s
-
-
-def parse_funding(payload):
-    """Funding geçmişi çıktısında (şemadan bağımsız) zaman + oran kolonlarını bulur."""
-    def find_rows(o):
-        if isinstance(o, list) and len(o) >= 5 and all(isinstance(x, dict) for x in o[:3]):
-            return o
-        if isinstance(o, dict):
-            for v in o.values():
-                r = find_rows(v)
-                if r:
-                    return r
-        return None
+# ----------------------------------------------------------------- 2. MCP: LiquidVision (türev verisi)
+# Uzak (HTTP) MCP, kurulum yok: https://liquidvision.app/mcp
+#  - Anahtarsız: yalnızca "sonuç" araçları (brief, positioning regime, cascades...) -> canlı bağlam.
+#  - Funding / OI GEÇMİŞİ (eğitim özelliği) ham-satır araçlarıdır; Pro/Bot anahtarı ister:
+#        LIQUIDVISION_API_KEY=lv_...   (X-API-Key olarak gönderilir)
+DERIV_URL = os.environ.get("LIQUIDVISION_URL", "https://liquidvision.app/mcp")
+DERIV_KEY = os.environ.get("LIQUIDVISION_API_KEY", "")
+LIVE_TOOLS = ["get_market_brief", "get_positioning_regime", "get_liquidation_cascades",
+              "get_microstructure", "get_funding_arbitrage", "get_funding_dispersion"]
+
+
+def _usdt(symbol):
+    """BTC/USDT veya BTC/USDT:USDT -> BTCUSDT"""
+    return symbol.strip().upper().split(":")[0].replace("/", "")
+
+
+def _find_rows(o):
+    if isinstance(o, list) and len(o) >= 5 and all(isinstance(x, dict) for x in o[:3]):
+        return o
+    if isinstance(o, dict):
+        for v in o.values():
+            r = _find_rows(v)
+            if r:
+                return r
+    return None
 
-    rows = find_rows(payload)
+
+def parse_series(payload, vkeys):
+    """Geçmiş çıktısında (şemadan bağımsız) zaman + değer kolonlarını bulup ts/v tablosu döndürür."""
+    rows = _find_rows(payload)
     if not rows:
         return None
     d = pd.DataFrame(rows)
-    tcol = next((c for c in ("timestamp", "fundingTime", "time", "ts", "datetime") if c in d), None)
-    rcol = next((c for c in ("fundingRate", "funding_rate", "rate", "value") if c in d), None)
-    if tcol is None or rcol is None:
+    tcol = next((c for c in ("timestamp", "time", "ts", "t", "datetime", "fundingTime", "ts_ms", "hour", "bucket")
+                 if c in d), None)
+    vcol = next((c for c in vkeys if c in d), None)
+    if tcol is None or vcol is None:
         return None
     ts = d[tcol]
     if pd.api.types.is_numeric_dtype(ts):
@@ -190,67 +192,98 @@ def parse_funding(payload):
         ts = pd.to_datetime(ts)
     if getattr(ts.dt, "tz", None) is not None:
         ts = ts.dt.tz_convert(None)
-    out = pd.DataFrame({"ts": ts.astype("datetime64[ns]"), "r": pd.to_numeric(d[rcol], errors="coerce")})
+    out = pd.DataFrame({"ts": ts.astype("datetime64[ns]"), "v": pd.to_numeric(d[vcol], errors="coerce")})
     return out.dropna().drop_duplicates("ts").sort_values("ts").reset_index(drop=True)
 
 
+def _funding_feats(f):
+    r = f["v"]
+    f["fund"] = r * 1e4                                     # baz puan
+    f["fund_z"] = (r - r.rolling(30).mean()) / (r.rolling(30).std() + 1e-12)
+    f["fund_chg"] = r.diff() * 1e4
+    f["fund_ma9"] = r.rolling(9).mean() * 1e4
+    return f.drop(columns=["v"]).dropna().reset_index(drop=True)
+
+
+def _oi_feats(f):
+    o = f["v"]
+    for k in (1, 4, 24):
+        f[f"oi_chg{k}"] = o.pct_change(k)
+    f["oi_z"] = (o - o.rolling(48).mean()) / (o.rolling(48).std() + 1e-12)
+    return f.drop(columns=["v"]).replace([np.inf, -np.inf], np.nan).dropna().reset_index(drop=True)
+
+
 async def fetch_deriv_features(symbol, exchange, timeframe, df):
-    """2. MCP'den funding geçmişi (özellik) + OI / long-short / likidasyon (canlı bağlam) çeker.
-    Dönen: (özellik tablosu | None, df (funding kapsamına kırpılmış olabilir), ham çıktı sözlüğü)."""
-    import sys
+    """LiquidVision MCP'den canlı bağlam (ham çıktıya) + funding/OI geçmişi (özellik) çeker.
+    Dönen: (özellik tablosu | None, df (geçmiş kapsamına kırpılmış olabilir), ham çıktı sözlüğü)."""
     extra = {}
-    if not DERIV_PATH or not os.path.exists(DERIV_PATH):
-        extra["deriv_note"] = "CRYPTO_MCP_SERVER ayarlı değil / dosya yok; türev verisi atlandı"
+    try:
+        from mcp.client.streamable_http import streamablehttp_client
+    except Exception as e:  # noqa: BLE001
+        extra["deriv_error"] = f"mcp sürümü streamable HTTP desteklemiyor: {_root(e)} (pip install -U mcp)"
         return None, df, extra
-    params = StdioServerParameters(
-        command=os.environ.get("CRYPTO_MCP_PYTHON", sys.executable),
-        args=[DERIV_PATH],
-        cwd=os.path.dirname(os.path.abspath(DERIV_PATH)),
-        env={**os.environ},
-    )
-    perp = _perp(symbol)
+    headers = {"X-API-Key": DERIV_KEY} if DERIV_KEY else {}
+    sym = _usdt(symbol)
+    hist = {}
     try:
-        async with stdio_client(params) as (r, w):
+        async with streamablehttp_client(DERIV_URL, headers=headers) as (r, w, _):
             async with ClientSession(r, w) as session:
                 await session.initialize()
                 tools = {t.name: t for t in (await session.list_tools()).tools}
-                hist = await call_tool(session, tools, "get_funding_rate_history",
-                                       symbol=perp, exchange=exchange, limit=1000)
-                for name in ("get_funding_rate", "compare_funding", "get_open_interest",
-                             "get_long_short_ratio", "get_liquidations"):
+                extra["deriv_available_tools"] = list(tools)
+                for name in LIVE_TOOLS:
                     if name in tools:
                         try:
                             extra[f"deriv_{name}"] = await call_tool(
-                                session, tools, name, symbol=perp, exchange=exchange, timeframe=timeframe)
+                                session, tools, name, symbol=sym, exchange=exchange)
                         except Exception as e:  # noqa: BLE001
                             extra[f"deriv_{name}"] = {"error": _root(e)}
+                for name in ("get_funding_history", "get_open_interest_history"):
+                    if name in tools:
+                        try:
+                            hist[name] = await call_tool(session, tools, name, symbol=sym, exchange=exchange,
+                                                         timeframe=timeframe, limit=1000)
+                        except Exception as e:  # noqa: BLE001
+                            hist[name] = {"error": _root(e)}
     except Exception as e:  # noqa: BLE001
         extra["deriv_error"] = _root(e)
         return None, df, extra
 
-    bad = hist is None or (isinstance(hist, dict) and "error" in hist)
-    f = None if bad else parse_funding(hist)
-    if f is None or len(f) < 60:
-        extra["deriv_note"] = "Funding geçmişi okunamadı veya yetersiz; özellik eklenmedi"
-        extra["deriv_funding_raw"] = _strip_series(hist)
+    specs = {
+        "get_funding_history": (("funding_rate", "fundingRate", "rate", "funding", "value"), _funding_feats),
+        "get_open_interest_history": (("open_interest", "oi", "openInterest", "oi_usd", "value"), _oi_feats),
+    }
+    feats = {}
+    for name, (vkeys, fn) in specs.items():
+        h = hist.get(name)
+        if h is None:
+            continue
+        if isinstance(h, dict) and "error" in h:
+            extra[f"deriv_{name}_error"] = _strip_series(h)
+            continue
+        s = parse_series(h, vkeys)
+        if s is None or len(s) < 80:
+            extra[f"deriv_{name}_raw"] = _strip_series(h)   # şema beklenenden farklı
+            continue
+        feats[name] = fn(s)
+    if not feats:
+        extra["deriv_note"] = ("Geçmiş özellik eklenmedi (ham-satır araçları için Pro/Bot anahtarı gerekir: "
+                               "LIQUIDVISION_API_KEY). Canlı bağlam ham çıktıda.")
         return None, df, extra
 
-    rr = f["r"]
-    f["fund"] = rr * 1e4                                   # baz puan
-    f["fund_z"] = (rr - rr.rolling(30).mean()) / (rr.rolling(30).std() + 1e-12)
-    f["fund_chg"] = rr.diff() * 1e4
-    f["fund_ma9"] = rr.rolling(9).mean() * 1e4
-    f = f.dropna().reset_index(drop=True)
-    start = f["ts"].iloc[0]
-    d2 = df[df["ts"] >= start].reset_index(drop=True)
-    if len(d2) < 800:
-        extra["deriv_note"] = (f"Funding geçmişi mumların yalnızca {len(d2)} barını kapsıyor (<800); "
-                               "özellik eklenmedi")
+    # Geçmişin kapsamadığı eski mumları kırp; <800 bar kalıyorsa o seriyi at
+    usable = {k: v for k, v in feats.items() if (df["ts"] >= v["ts"].iloc[0]).sum() >= 800}
+    if not usable:
+        extra["deriv_note"] = "Geçmiş mum verisinin yalnızca küçük kısmını kapsıyor (<800 bar); özellik eklenmedi"
         return None, df, extra
+    start = max(v["ts"].iloc[0] for v in usable.values())
+    d2 = df[df["ts"] >= start].reset_index(drop=True)
     d2["ts"] = d2["ts"].astype("datetime64[ns]")
-    m = pd.merge_asof(d2[["ts"]], f.drop(columns=["r"]), on="ts", direction="backward")  # lookahead yok
+    m = d2[["ts"]].copy()
+    for v in usable.values():
+        m = pd.merge_asof(m, v, on="ts", direction="backward")   # lookahead yok
     m.index = d2.index
-    extra["deriv_funding_used"] = {"funding_gozlem": len(f), "baslangic": str(start), "bar": len(d2)}
+    extra["deriv_used"] = {"seriler": list(usable), "baslangic": str(start), "bar": len(d2)}
     return m.drop(columns=["ts"]).add_prefix("dv_"), d2, extra
 
 
@@ -661,7 +694,7 @@ with gr.Blocks(title="Tickscope Tahmin") as demo:
     with gr.Row():
         horizon = gr.Slider(1, 24, value=4, step=1, label="Tahmin ufku (bar)")
         limit = gr.Slider(300, 20000, value=5000, step=100, label="Mum sayısı (1000 üstü sayfalanır)")
-    use_deriv = gr.Checkbox(True, label="Türev verisi (funding; 2. MCP) — mumları funding geçmişinin kapsadığı aralığa kırpabilir")
+    use_deriv = gr.Checkbox(True, label="Türev verisi (LiquidVision MCP: funding/OI) — mumları geçmişin kapsadığı aralığa kırpabilir")
     btn = gr.Button("Tahmin et", variant="primary")
     out_md = gr.Markdown()
     out_plot = gr.Plot()