Upload 11 files

cryptopanic_news.py

@@ -0,0 +1,44 @@
+import requests
+
+def get_posts(
+    auth_token: str,
+    kind: str = None,          # e.g. "news", "blogs", "videos"
+    currencies: list = None,   # e.g. ["BTC", "ETH"]
+    regions: list = None,      # e.g. ["en"] or country codes
+    public: bool = True,        # whether to include public posts
+    filter_duplicates: bool = True,
+    page: int = 1,
+    filter: str = None          # a general filter string
+) -> dict:
+    """
+    Fetch posts from CryptoPanic.
+    """
+    API_BASE = "https://cryptopanic.com/api/developer/v2"
+    #url = f"{API_BASE}/posts/"
+    url = "https://cryptopanic.com/api/developer/v2/posts/"
+    headers = {
+        "Accept": "application/json"
+    }
+    params = {
+        "auth_token": auth_token,
+        "public": "true" if public else "false",
+        "page": page,
+    }
+    if kind:
+        params["kind"] = kind
+    if currencies:
+        print(currencies)
+        # CryptoPanic expects multiple items comma-separated or repeated parameters
+        # Checking docs: uses comma-separated list.  
+        params["currencies"] = ",".join(currencies)
+    if regions:
+        params["regions"] = ",".join(regions)
+    if filter_duplicates:
+        params["filter_duplicates"] = "true"
+    if filter:
+        params["filter"] = filter
+
+    response = requests.get(url, params=params, headers=headers)
+    response.raise_for_status()
+    print(url)
+    return response.json()

cryptopanic_news_server.py

@@ -0,0 +1,45 @@
+from mcp.server.fastmcp import FastMCP
+from cryptopanic_news import get_posts
+import os
+
+mcp = FastMCP("cryptopanic_news_server")
+
+@mcp.tool()
+async def get_crypto_news(currencies_ls: list | str | None = None) -> str:
+    """Fetch latest cryptocurrency news from CryptoPanic.
+
+    Args:
+        currencies_ls: The list of cryptocurrency symbols to filter news by. Accepts a single string (e.g. "BTC") or a list of symbols (e.g. ["HYPE", "ETC", "BTC", "XRP"]). 
+
+        If set to None, retrieves the general CryptoPanic news feed 
+        without filtering by any specific currency.
+    """
+    token = os.getenv("CRYPTOPANIC_API_KEY")
+    if not token:
+        return "Error: CRYPTOPANIC_API_KEY not set."
+
+    # Allow a single string or a list
+    if isinstance(currencies_ls, str):
+        currencies_ls = [currencies_ls]
+
+    data = get_posts(
+        auth_token=token,
+        kind="news",
+        currencies=currencies_ls,
+        page=1
+    )
+
+    if not isinstance(data, dict):
+        return f"Error: Unexpected API response: {data!r}"
+
+    results = []
+    for post in data.get("results", []):
+        title = post.get("title") or "No title"
+        desc = post.get("description") or ""
+        pub  = post.get("published_at") or "Unknown time"
+        results.append(f"title: {title}\n{desc[:200]}\npublished at: {pub}\n")
+
+    return "\n".join(results) if results else "No recent crypto news found."
+
+if __name__ == "__main__":
+    mcp.run(transport='stdio')

hl_indicators.py

@@ -0,0 +1,530 @@
+# hl_indicators.py
+# pip install: hyperliquid-python-sdk pandas numpy
+
+from __future__ import annotations
+from typing import Dict, Any, List, Tuple, Literal, Iterable
+import time
+import numpy as np
+import pandas as pd
+
+from hyperliquid.info import Info
+from hyperliquid.utils import constants
+
+Interval = Literal["1m", "5m", "15m", "1h", "4h", "1d"]
+
+_MS = {"1m": 60_000, "5m": 5*60_000, "15m": 15*60_000, "1h": 60*60_000, "4h": 4*60*60_000, "1d": 24*60*60_000}
+
+def _now_ms() -> int:
+    return int(time.time() * 1000)
+
+def _start_end_from_limit(interval: Interval, limit: int, end_ms: int | None = None) -> tuple[int, int]:
+    end_ms = end_ms or _now_ms()
+    span = (limit + 2) * _MS[interval]  # small buffer for smoothing windows
+    start_ms = max(0, end_ms - span)
+    return start_ms, end_ms
+
+# ---------------- Data fetch via candles_snapshot ---------------- #
+
+def fetch_candles(
+    name: str,
+    interval: Interval = "1h",
+    limit: int = 600,
+    testnet: bool = True,
+    end_ms: int | None = None,
+) -> pd.DataFrame:
+    """
+    Fetch OHLCV candles via Info.candles_snapshot(name, interval, startTime, endTime).
+    Returns DataFrame with ['timestamp','open','high','low','close','volume'] sorted by time.
+    """
+    api_url = constants.TESTNET_API_URL if testnet else constants.MAINNET_API_URL
+    info = Info(api_url, skip_ws=True)
+
+    start_ms, end_ms = _start_end_from_limit(interval, limit, end_ms)
+    raw = info.candles_snapshot(name, interval, start_ms, end_ms)
+    if not raw:
+        raise ValueError(f"No candles returned for {name} {interval}")
+
+    df = pd.DataFrame(raw).rename(columns={
+        "t": "timestamp", "o": "open", "h": "high", "l": "low", "c": "close", "v": "volume",
+        "T": "close_time", "i": "interval", "s": "symbol", "n": "trades",
+    })
+
+    needed = ["timestamp", "open", "high", "low", "close", "volume"]
+    for k in needed:
+        if k not in df.columns:
+            raise ValueError(f"Missing '{k}' in candles_snapshot payload. Got: {list(df.columns)}")
+
+    df["timestamp"] = pd.to_datetime(df["timestamp"], unit="ms", errors="coerce")
+    for k in ["open","high","low","close","volume"]:
+        df[k] = pd.to_numeric(df[k], errors="coerce")
+
+    df = df.dropna(subset=["timestamp","close"]).sort_values("timestamp").reset_index(drop=True)
+    if len(df) > limit:
+        df = df.iloc[-limit:].reset_index(drop=True)
+    return df
+
+# ---------------- Base indicators ---------------- #
+
+def ema(series: pd.Series, period: int) -> pd.Series:
+    return series.ewm(span=period, adjust=False).mean()
+
+def macd(series: pd.Series, fast: int = 12, slow: int = 26, signal: int = 9) -> Tuple[pd.Series, pd.Series, pd.Series]:
+    fast_ema, slow_ema = ema(series, fast), ema(series, slow)
+    line = fast_ema - slow_ema
+    sig = ema(line, signal)
+    hist = line - sig
+    return line, sig, hist
+
+def rsi(series: pd.Series, period: int = 14) -> pd.Series:
+    delta = series.diff()
+    up = pd.Series(np.where(delta > 0, delta, 0.0), index=series.index)
+    down = pd.Series(np.where(delta < 0, -delta, 0.0), index=series.index)
+    avg_up = up.ewm(alpha=1/period, adjust=False).mean()
+    avg_down = down.ewm(alpha=1/period, adjust=False).mean()
+    rs = avg_up / avg_down.replace(0, np.nan)
+    return (100 - (100 / (1 + rs))).fillna(0)
+
+def stoch_rsi(series: pd.Series, rsi_length: int = 14, stoch_length: int = 14, k_smooth: int = 3, d_smooth: int = 3
+) -> Tuple[pd.Series, pd.Series, pd.Series]:
+    r = rsi(series, rsi_length)
+    r_low, r_high = r.rolling(stoch_length).min(), r.rolling(stoch_length).max()
+    base = (r - r_low) / (r_high - r_low)
+    k = base.rolling(k_smooth).mean() * 100.0
+    d = k.rolling(d_smooth).mean()
+    return base * 100.0, k, d
+
+# ---------------- Volume/volatility family ---------------- #
+
+def adl(high: pd.Series, low: pd.Series, close: pd.Series, volume: pd.Series) -> pd.Series:
+    """
+    Chaikin Accumulation/Distribution Line.
+    mfm = ((close - low) - (high - close)) / (high - low), guarded for zero range.
+    ADL = cumulative sum(mfm * volume)
+    """
+    hl_range = (high - low).replace(0, np.nan)
+    mfm = ((close - low) - (high - close)) / hl_range
+    mfm = mfm.fillna(0.0)
+    mfv = mfm * volume
+    return mfv.cumsum()
+
+def obv(close: pd.Series, volume: pd.Series) -> pd.Series:
+    """
+    On-Balance Volume.
+    """
+    sign = np.sign(close.diff()).fillna(0)
+    return (volume * sign).cumsum()
+
+def true_range(high: pd.Series, low: pd.Series, close: pd.Series) -> pd.Series:
+    prev_close = close.shift(1)
+    tr = pd.concat([(high - low).abs(), (high - prev_close).abs(), (low - prev_close).abs()], axis=1).max(axis=1)
+    return tr
+
+def atr(high: pd.Series, low: pd.Series, close: pd.Series, period: int = 14) -> pd.Series:
+    tr = true_range(high, low, close)
+    return tr.ewm(alpha=1/period, adjust=False).mean()
+
+def di_adx(high: pd.Series, low: pd.Series, close: pd.Series, period: int = 14
+) -> Tuple[pd.Series, pd.Series, pd.Series]:
+    up_move = high.diff()
+    down_move = -low.diff()
+    plus_dm = pd.Series(np.where((up_move > down_move) & (up_move > 0), up_move, 0.0), index=high.index)
+    minus_dm = pd.Series(np.where((down_move > up_move) & (down_move > 0), down_move, 0.0), index=high.index)
+    atr_series = atr(high, low, close, period)
+
+    plus_di = 100 * (plus_dm.ewm(alpha=1/period, adjust=False).mean() / atr_series.replace(0, np.nan))
+    minus_di = 100 * (minus_dm.ewm(alpha=1/period, adjust=False).mean() / atr_series.replace(0, np.nan))
+    dx = (100 * (plus_di - minus_di).abs() / (plus_di + minus_di).replace(0, np.nan)).fillna(0)
+    adx = dx.ewm(alpha=1/period, adjust=False).mean()
+    return plus_di.fillna(0), minus_di.fillna(0), adx.fillna(0)
+
+def bbands(series: pd.Series, period: int = 20, std_mult: float = 2.0
+) -> Tuple[pd.Series, pd.Series, pd.Series, pd.Series, pd.Series]:
+    ma = series.rolling(period).mean()
+    sd = series.rolling(period).std(ddof=0)
+    upper = ma + std_mult * sd
+    lower = ma - std_mult * sd
+    pct_b = (series - lower) / (upper - lower)
+    bandwidth = (upper - lower) / ma
+    return ma, upper, lower, pct_b, bandwidth
+
+def mfi(high: pd.Series, low: pd.Series, close: pd.Series, volume: pd.Series, period: int = 14) -> pd.Series:
+    tp = (high + low + close) / 3.0
+    rmf = tp * volume
+    pos_flow = pd.Series(np.where(tp > tp.shift(1), rmf, 0.0), index=tp.index).rolling(period).sum()
+    neg_flow = pd.Series(np.where(tp < tp.shift(1), rmf, 0.0), index=tp.index).rolling(period).sum()
+    money_ratio = pos_flow / neg_flow.replace(0, np.nan)
+    out = 100 - (100 / (1 + money_ratio))
+    return out.fillna(0)
+
+def vwap_cumulative(high: pd.Series, low: pd.Series, close: pd.Series, volume: pd.Series) -> pd.Series:
+    """
+    Cumulative VWAP over the full series: sum(TP*V)/sum(V) where TP=(H+L+C)/3.
+    Resets only at the beginning (not each day).
+    """
+    tp = (high + low + close) / 3.0
+    cum_v = volume.cumsum().replace(0, np.nan)
+    cum_tp_v = (tp * volume).cumsum()
+    return (cum_tp_v / cum_v).fillna(method="bfill").fillna(0)
+
+def vwap_daily(high: pd.Series, low: pd.Series, close: pd.Series, volume: pd.Series, timestamps: pd.Series) -> pd.Series:
+    """
+    Session VWAP that resets daily (by calendar date of 'timestamps').
+    """
+    tp = (high + low + close) / 3.0
+    dates = pd.to_datetime(timestamps).dt.date
+    df = pd.DataFrame({"tp": tp, "v": volume, "date": dates})
+    df["tpv"] = df["tp"] * df["v"]
+    cum = df.groupby("date")[["tpv", "v"]].cumsum()
+    vwap = (cum["tpv"] / cum["v"].replace(0, np.nan)).values
+    return pd.Series(vwap, index=high.index).fillna(method="bfill").fillna(0)
+
+# ---------------- JSON helpers ---------------- #
+
+def _pts(ts: pd.Series, vals: pd.Series) -> List[Dict[str, float]]:
+    out: List[Dict[str, float]] = []
+    for t, v in zip(ts, vals):
+        if pd.isna(t) or pd.isna(v):
+            continue
+        out.append({"t": int(pd.Timestamp(t).timestamp() * 1000), "v": float(v)})
+    return out
+
+def _tail_pts(ts: pd.Series, vals: pd.Series, n: int) -> List[Dict[str, float]]:
+    """Return only the last n timestamp/value points (safe if n > len)."""
+    if n is None or n <= 0:
+        return _pts(ts, vals)
+    tail_ts = ts.iloc[-n:] if len(ts) > n else ts
+    tail_vals = vals.iloc[-n:] if len(vals) > n else vals
+    return _pts(tail_ts, tail_vals)
+
+# ---------------- MCP-friendly functions (per indicator) ---------------- #
+
+def get_ema(
+    name: str,
+    periods: List[int] | None = None,
+    interval: Interval = "1h",
+    limit: int = 300,
+    testnet: bool = False,
+    output_tail: int = 30,   # NEW
+) -> Dict[str, Any]:
+    periods = periods or [20, 200]
+    df = fetch_candles(name, interval, limit, testnet)
+    res: Dict[str, Any] = {
+        "coin": name,
+        "interval": interval,
+        "ema": {},
+        "close": _tail_pts(df["timestamp"], df["close"], output_tail),  # sliced
+        "last": {"close": float(df["close"].iloc[-1])},
+    }
+    for p in periods:
+        e = ema(df["close"], p)
+        res["ema"][str(p)] = _tail_pts(df["timestamp"], e, output_tail)  # sliced
+        res["last"][f"ema_{p}"] = float(e.iloc[-1])
+    return res
+
+
+def get_macd(
+    name: str,
+    fast: int = 12,
+    slow: int = 26,
+    signal: int = 9,
+    interval: Interval = "1h",
+    limit: int = 300,
+    testnet: bool = False,
+    output_tail: int = 30,   # NEW
+) -> Dict[str, Any]:
+    df = fetch_candles(name, interval, limit, testnet)
+    line, sig, hist = macd(df["close"], fast, slow, signal)
+    return {
+        "coin": name,
+        "interval": interval,
+        "params": {"fast": fast, "slow": slow, "signal": signal},
+        "macd_line": _tail_pts(df["timestamp"], line, output_tail),      # sliced
+        "signal":    _tail_pts(df["timestamp"], sig, output_tail),       # sliced
+        "histogram": _tail_pts(df["timestamp"], hist, output_tail),      # sliced
+        "last": {
+            "macd_line": float(line.iloc[-1]),
+            "signal": float(sig.iloc[-1]),
+            "histogram": float(hist.iloc[-1]),
+            "close": float(df["close"].iloc[-1]),
+        },
+    }
+
+
+def get_stoch_rsi(
+    name: str,
+    rsi_length: int = 14,
+    stoch_length: int = 14,
+    k_smooth: int = 3,
+    d_smooth: int = 3,
+    interval: Interval = "1h",
+    limit: int = 300,
+    testnet: bool = False,
+    output_tail: int = 30,   # NEW
+) -> Dict[str, Any]:
+    df = fetch_candles(name, interval, limit, testnet)
+    stoch, k, d = stoch_rsi(df["close"], rsi_length, stoch_length, k_smooth, d_smooth)
+    return {
+        "coin": name,
+        "interval": interval,
+        "params": {
+            "rsi_length": rsi_length,
+            "stoch_length": stoch_length,
+            "k_smooth": k_smooth,
+            "d_smooth": d_smooth,
+        },
+        "stoch_rsi": _tail_pts(df["timestamp"], stoch, output_tail),  # sliced
+        "%K":        _tail_pts(df["timestamp"], k, output_tail),      # sliced
+        "%D":        _tail_pts(df["timestamp"], d, output_tail),      # sliced
+        "last": {
+            "stoch_rsi": float(stoch.iloc[-1]),
+            "k": float(k.iloc[-1]),
+            "d": float(d.iloc[-1]),
+            "close": float(df["close"].iloc[-1]),
+        },
+    }
+
+
+def get_adl(
+    name: str,
+    interval: Interval = "1h",
+    limit: int = 300,
+    testnet: bool = False,
+    output_tail: int = 30,   # NEW
+) -> Dict[str, Any]:
+    df = fetch_candles(name, interval, limit, testnet)
+    series = adl(df["high"], df["low"], df["close"], df["volume"])
+    return {
+        "coin": name,
+        "interval": interval,
+        "adl": _tail_pts(df["timestamp"], series, output_tail),  # sliced
+        "last": {"adl": float(series.iloc[-1])},
+    }
+
+
+def get_obv(
+    name: str,
+    interval: Interval = "1h",
+    limit: int = 300,
+    testnet: bool = False,
+    output_tail: int = 30,   # NEW
+) -> Dict[str, Any]:
+    df = fetch_candles(name, interval, limit, testnet)
+    series = obv(df["close"], df["volume"])
+    return {
+        "coin": name,
+        "interval": interval,
+        "obv": _tail_pts(df["timestamp"], series, output_tail),  # sliced
+        "last": {"obv": float(series.iloc[-1])},
+    }
+
+
+def get_atr_adx(
+    name: str,
+    period: int = 14,
+    interval: Interval = "1h",
+    limit: int = 300,
+    testnet: bool = False,
+    output_tail: int = 30,   # NEW
+) -> Dict[str, Any]:
+    df = fetch_candles(name, interval, limit, testnet)
+    plus_di, minus_di, adx_series = di_adx(df["high"], df["low"], df["close"], period)
+    atr_series = atr(df["high"], df["low"], df["close"], period)
+    return {
+        "coin": name,
+        "interval": interval,
+        "params": {"period": period},
+        "+DI": _tail_pts(df["timestamp"], plus_di, output_tail),   # sliced
+        "-DI": _tail_pts(df["timestamp"], minus_di, output_tail),  # sliced
+        "ADX": _tail_pts(df["timestamp"], adx_series, output_tail),# sliced
+        "ATR": _tail_pts(df["timestamp"], atr_series, output_tail),# sliced
+        "last": {
+            "+DI": float(plus_di.iloc[-1]),
+            "-DI": float(minus_di.iloc[-1]),
+            "ADX": float(adx_series.iloc[-1]),
+            "ATR": float(atr_series.iloc[-1]),
+        },
+    }
+
+
+def get_bbands(
+    name: str,
+    period: int = 20,
+    std_mult: float = 2.0,
+    interval: Interval = "1h",
+    limit: int = 300,
+    testnet: bool = False,
+    output_tail: int = 30,   # NEW
+) -> Dict[str, Any]:
+    df = fetch_candles(name, interval, limit, testnet)
+    ma, upper, lower, pct_b, bandwidth = bbands(df["close"], period, std_mult)
+    return {
+        "coin": name,
+        "interval": interval,
+        "params": {"period": period, "std_mult": std_mult},
+        "basis":     _tail_pts(df["timestamp"], ma, output_tail),        # sliced
+        "upper":     _tail_pts(df["timestamp"], upper, output_tail),     # sliced
+        "lower":     _tail_pts(df["timestamp"], lower, output_tail),     # sliced
+        "%b":        _tail_pts(df["timestamp"], pct_b, output_tail),     # sliced
+        "bandwidth": _tail_pts(df["timestamp"], bandwidth, output_tail), # sliced
+        "last": {
+            "basis": float(ma.iloc[-1]),
+            "upper": float(upper.iloc[-1]),
+            "lower": float(lower.iloc[-1]),
+            "%b": float(pct_b.iloc[-1]),
+            "bandwidth": float(bandwidth.iloc[-1]),
+        },
+    }
+
+
+def get_mfi(
+    name: str,
+    period: int = 14,
+    interval: Interval = "1h",
+    limit: int = 300,
+    testnet: bool = False,
+    output_tail: int = 30,   # NEW
+) -> Dict[str, Any]:
+    df = fetch_candles(name, interval, limit, testnet)
+    series = mfi(df["high"], df["low"], df["close"], df["volume"], period)
+    return {
+        "coin": name,
+        "interval": interval,
+        "params": {"period": period},
+        "mfi": _tail_pts(df["timestamp"], series, output_tail),  # sliced
+        "last": {"mfi": float(series.iloc[-1])},
+    }
+
+
+def get_vwap(
+    name: str,
+    daily_reset: bool = False,
+    interval: Interval = "1h",
+    limit: int = 300,
+    testnet: bool = False,
+    output_tail: int = 30,   # NEW
+) -> Dict[str, Any]:
+    df = fetch_candles(name, interval, limit, testnet)
+    series = (
+        vwap_daily(df["high"], df["low"], df["close"], df["volume"], df["timestamp"])
+        if daily_reset else
+        vwap_cumulative(df["high"], df["low"], df["close"], df["volume"])
+    )
+    return {
+        "coin": name,
+        "interval": interval,
+        "params": {"daily_reset": bool(daily_reset)},
+        "vwap": _tail_pts(df["timestamp"], series, output_tail),  # sliced
+        "last": {"vwap": float(series.iloc[-1])},
+    }
+
+
+def get_volume(
+    name: str,
+    interval: Interval = "1h",
+    limit: int = 300,
+    testnet: bool = False,
+    output_tail: int = 30,   # NEW
+) -> Dict[str, Any]:
+    df = fetch_candles(name, interval, limit, testnet)
+    return {
+        "coin": name,
+        "interval": interval,
+        "volume": _tail_pts(df["timestamp"], df["volume"], output_tail),  # sliced
+        "last": {"volume": float(df["volume"].iloc[-1])},
+    }
+
+
+def get_bundle(
+    name: str,
+    interval: Interval = "1h",
+    limit: int = 300,
+    testnet: bool = False,
+    include: Iterable[str] = ("ema","macd","stoch_rsi","adl","obv","atr_adx","bbands","mfi","vwap","volume"),
+    ema_periods: List[int] | None = None,
+    macd_fast: int = 12, macd_slow: int = 26, macd_signal: int = 9,
+    stoch_rsi_len: int = 14, stoch_len: int = 14, k_smooth: int = 3, d_smooth: int = 3,
+    bb_period: int = 20, bb_std: float = 2.0,
+    mfi_period: int = 14,
+    vwap_daily_reset: bool = False,
+    output_tail: int = 30,   # NEW
+) -> Dict[str, Any]:
+    df = fetch_candles(name, interval, limit, testnet)
+    out: Dict[str, Any] = {
+        "coin": name,
+        "interval": interval,
+        "close": _tail_pts(df["timestamp"], df["close"], output_tail),  # sliced
+        "last": {"close": float(df["close"].iloc[-1])},
+    }
+
+    if "ema" in include:
+        ema_periods = ema_periods or [20, 200]
+        out["ema"] = {}
+        for p in ema_periods:
+            e = ema(df["close"], p)
+            out["ema"][str(p)] = _tail_pts(df["timestamp"], e, output_tail)  # sliced
+            out["last"][f"ema_{p}"] = float(e.iloc[-1])
+
+    if "macd" in include:
+        line, sig, hist = macd(df["close"], macd_fast, macd_slow, macd_signal)
+        out["macd"] = {
+            "params": {"fast": macd_fast, "slow": macd_slow, "signal": macd_signal},
+            "macd_line": _tail_pts(df["timestamp"], line, output_tail),   # sliced
+            "signal":    _tail_pts(df["timestamp"], sig, output_tail),    # sliced
+            "histogram": _tail_pts(df["timestamp"], hist, output_tail),   # sliced
+            "last": {"macd_line": float(line.iloc[-1]), "signal": float(sig.iloc[-1]), "histogram": float(hist.iloc[-1])},
+        }
+
+    if "stoch_rsi" in include:
+        st, k, d = stoch_rsi(df["close"], stoch_rsi_len, stoch_len, k_smooth, d_smooth)
+        out["stoch_rsi"] = {
+            "params": {"rsi_length": stoch_rsi_len, "stoch_length": stoch_len, "k_smooth": k_smooth, "d_smooth": d_smooth},
+            "stoch_rsi": _tail_pts(df["timestamp"], st, output_tail),  # sliced
+            "%K":        _tail_pts(df["timestamp"], k, output_tail),   # sliced
+            "%D":        _tail_pts(df["timestamp"], d, output_tail),   # sliced
+            "last": {"stoch_rsi": float(st.iloc[-1]), "k": float(k.iloc[-1]), "d": float(d.iloc[-1])},
+        }
+
+    if "adl" in include:
+        series = adl(df["high"], df["low"], df["close"], df["volume"])
+        out["adl"] = {"series": _tail_pts(df["timestamp"], series, output_tail), "last": float(series.iloc[-1])}
+
+    if "obv" in include:
+        series = obv(df["close"], df["volume"])
+        out["obv"] = {"series": _tail_pts(df["timestamp"], series, output_tail), "last": float(series.iloc[-1])}
+
+    if "atr_adx" in include:
+        plus_di, minus_di, adx_series = di_adx(df["high"], df["low"], df["close"])
+        atr_series = atr(df["high"], df["low"], df["close"])
+        out["atr_adx"] = {
+            "+DI": _tail_pts(df["timestamp"], plus_di, output_tail),     # sliced
+            "-DI": _tail_pts(df["timestamp"], minus_di, output_tail),    # sliced
+            "ADX": _tail_pts(df["timestamp"], adx_series, output_tail),  # sliced
+            "ATR": _tail_pts(df["timestamp"], atr_series, output_tail),  # sliced
+            "last": {"+DI": float(plus_di.iloc[-1]), "-DI": float(minus_di.iloc[-1]), "ADX": float(adx_series.iloc[-1]), "ATR": float(atr_series.iloc[-1])},
+        }
+
+    if "bbands" in include:
+        ma, up, lo, pct_b, bw = bbands(df["close"], bb_period, bb_std)
+        out["bbands"] = {
+            "params": {"period": bb_period, "std_mult": bb_std},
+            "basis":     _tail_pts(df["timestamp"], ma, output_tail),   # sliced
+            "upper":     _tail_pts(df["timestamp"], up, output_tail),   # sliced
+            "lower":     _tail_pts(df["timestamp"], lo, output_tail),   # sliced
+            "%b":        _tail_pts(df["timestamp"], pct_b, output_tail),# sliced
+            "bandwidth": _tail_pts(df["timestamp"], bw, output_tail),   # sliced
+            "last": {"basis": float(ma.iloc[-1]), "upper": float(up.iloc[-1]), "lower": float(lo.iloc[-1]), "%b": float(pct_b.iloc[-1]), "bandwidth": float(bw.iloc[-1])},
+        }
+
+    if "mfi" in include:
+        series = mfi(df["high"], df["low"], df["close"], df["volume"], mfi_period)
+        out["mfi"] = {"params": {"period": mfi_period}, "series": _tail_pts(df["timestamp"], series, output_tail), "last": float(series.iloc[-1])}
+
+    if "vwap" in include:
+        series = vwap_daily(df["high"], df["low"], df["close"], df["volume"], df["timestamp"]) if vwap_daily_reset else \
+                 vwap_cumulative(df["high"], df["low"], df["close"], df["volume"])
+        out["vwap"] = {"params": {"daily_reset": bool(vwap_daily_reset)}, "series": _tail_pts(df["timestamp"], series, output_tail), "last": float(series.iloc[-1])}
+
+    if "volume" in include:
+        out["volume"] = {"series": _tail_pts(df["timestamp"], df["volume"], output_tail), "last": float(df["volume"].iloc[-1])}
+
+    return out

hl_indicators_server.py

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

hype_accounts.py

@@ -0,0 +1,59 @@
+# uv pip install hyperliquid-python-sdk pandas numpy python-dotenv
+import os
+import json
+import eth_account
+import numpy as np
+import pandas as pd
+from eth_account.signers.local import LocalAccount
+
+from hyperliquid.exchange import Exchange
+from hyperliquid.info import Info
+from hyperliquid.utils import constants
+
+from datetime import datetime, timezone
+
+
+# https://github.com/hyperliquid-dex/hyperliquid-python-sdk/blob/master/examples/example_utils.py
+def setup(base_url=constants.MAINNET_API_URL, skip_ws=False, perp_dexs=None):
+    account: LocalAccount = eth_account.Account.from_key(os.getenv("HYPERLIQUID_PRIVATE_KEY"))
+    address = os.getenv("HYPERLIQUID_ACCOUNT_ADDRESS") # config["account_address"]
+    if address == "":
+        address = account.address
+    print("Running with account address:", address)
+    if address != account.address:
+        print("Running with agent address:", account.address)
+    info = Info(base_url, skip_ws, perp_dexs=perp_dexs)
+    user_state = info.user_state(address)
+    spot_user_state = info.spot_user_state(address)
+    margin_summary = user_state["marginSummary"]
+    if float(margin_summary["accountValue"]) == 0 and len(spot_user_state["balances"]) == 0:
+        print("Not running the example because the provided account has no equity.")
+        url = info.base_url.split(".", 1)[1]
+        error_string = f"No accountValue:\nIf you think this is a mistake, make sure that {address} has a balance on {url}.\nIf address shown is your API wallet address, update the config to specify the address of your account, not the address of the API wallet."
+        raise Exception(error_string)
+    exchange = Exchange(account, base_url, account_address=address, perp_dexs=perp_dexs)
+    return address, info, exchange
+
+def long_short_shares_mkt_price(symbol, value, leverage, is_buy) -> str:
+    address, info, exchange = setup()
+    end_time = int(datetime.now(timezone.utc).timestamp() * 1000)  # Current time in ms
+    start_time = int(datetime.now(timezone.utc).timestamp() * 1000)  # Current time in ms
+    close_price = float(info.candles_snapshot(symbol, "1m", start_time, end_time)[0]['c'])
+    coins_metadata_df = pd.DataFrame(info.meta()['universe'])
+    rounding_decimals = coins_metadata_df[coins_metadata_df['name']==symbol]['szDecimals'].values[0]
+    quantity = np.round(float(value)/float(close_price),rounding_decimals)
+    print(quantity)
+    mkt_order_result = exchange.market_open(
+        name=symbol, 
+        is_buy=is_buy, 
+        sz=quantity, 
+        px=None,
+        slippage=0.01
+    )
+    is_cross = True
+    user_state = info.user_state(address)
+    for asset_position in user_state["assetPositions"]:
+        if asset_position["position"]["coin"] == symbol:
+            print(f"Current leverage for {symbol}:", json.dumps(asset_position["position"]["leverage"], indent=2))
+    leverage_position = exchange.update_leverage(leverage, symbol, is_cross)
+    return {'mkt_order_result': mkt_order_result, 'leverage_position': leverage_position}

hype_accounts_server.py

@@ -0,0 +1,56 @@
+from mcp.server.fastmcp import FastMCP
+from hype_accounts import setup, long_short_shares_mkt_price
+
+mcp = FastMCP("hype_accounts_server")
+
+@mcp.tool()
+async def get_account_details() -> dict:
+    """Get cash balance, cryptocurrency holdings and PNL of hyperliquid account.
+    """
+    account_details_dict = {
+        "holdings": None,
+        "cash_balance": None,
+        "profit_and_loss": None
+    }
+    address, info, exchange = setup()
+    user_state = info.user_state(address)
+    account_details_dict["cash_balance"] = user_state['marginSummary']['accountValue']
+    if user_state['assetPositions'] == []:
+        account_details_dict["holdings"] = "No holdings"
+    else:
+        account_details_dict["holdings"] = user_state['assetPositions']
+    account_details_dict["profit_and_loss"] = exchange.info.portfolio(address)[3][1]['pnlHistory'][-1][1]
+
+    return account_details_dict
+
+@mcp.tool()
+async def long_perps_mkt_price(symbol: str, value:float, leverage:int) -> str:
+    """Create a long position for a cryptocurrency perpetual contract at market price.
+    Args:
+        symbol: The symbol of the cryptocurrency (e.g., "HYPE","ETC","BTC","XRP").
+        value: The USD value to long.
+        leverage: The leverage to use for the position.
+    """
+    return str(long_short_shares_mkt_price(symbol, value, leverage, is_buy=True))
+
+@mcp.tool()
+async def short_perps_mkt_price(symbol: str, value:float, leverage:int) -> str:
+    """Create a short position for a cryptocurrency perpetual contract at market price.
+    Args:
+        symbol: The symbol of the cryptocurrency (e.g., "HYPE","ETC","BTC").
+        value: The USD value to short.
+        leverage: The leverage to use for the position.
+    """
+    return str(long_short_shares_mkt_price(symbol, value, leverage, is_buy=False))
+
+@mcp.tool()
+async def close_perps_mkt_price(symbol: str) -> str:
+    """Close the position for a cryptocurrency perpetual contract at market price.
+    Args:
+        symbol: The symbol of the cryptocurrency (e.g., "HYPE","ETC","BTC").
+    """
+    _, _, exchange = setup()
+    return str(exchange.market_close(symbol))
+
+if __name__ == "__main__":
+    mcp.run(transport='stdio')

memories.json

@@ -0,0 +1,11 @@
+{"timestamp": "2025-10-14T00:01:08.706950", "summary": "Step 1: Current holdings and balance:\n- ETH: Long 0.0048 ETH at 4132.4 USD, cross 2x leverage, position value ~$19.85, small unrealized profit, bullish overall trend but short-term bearish signals.\n- BNB: Long 0.02 BNB at 1276.4 USD, cross 3x leverage, position value ~$25.5, slight unrealized loss, strong bullish momentum signs.\n- XRP: Long 4 XRP at 2.5872 USD, cross 2x leverage, position value ~$10.35, essentially flat PnL, showing short-term bearish momentum but longer-term support intact.\n- Cash balance: $64.84\n- Total profit and loss: +$4.84\n\nStep 2: Summary of latest crypto news:\n- Bitcoin price dropped $20B recently but recovering above $113K.\n- BNB has strong rebound with 13% gains.\n- Bitcoin whale sold 1,423 BTC.\n- Ethereum saw notable gains with institutional buying.\n- XRP gaining institutional interest and real-world use cases.\n- Overall market with some volatility but notable institutional accumulation.\n\nStep 3: Technical analysis and strategy proposal:\n\nETH (Daily):\n- EMA20 > EMA200 signals longer-term bullish, but current price below EMA20 and bearish MACD.\n- Stoch RSI near oversold levels.\n- ADL slight accumulation.\n- Strategy: Hold current long, consider adding on confirmed rebound above EMA20 with positive MACD crossover. Short positions not favored given overall bullish trend.\n\nBNB (Daily):\n- Price above EMA20 and EMA200, MACD positive, Stoch RSI coming out of oversold.\n- ADL rising with strong volume.\n- Strategy: Strong bullish signals support holding current long. Consider adding on minor pullbacks toward EMA20 (~1146). No short position recommended.\n\nBTC (Daily):\n- Price slightly below EMA20 but above EMA200; MACD bearish short-term; stochastic RSI oversold.\n- ADL indicates accumulation.\n- Strategy: Wait for bullish MACD crossover and reclaim above EMA20 for long entries. Aggressive small longs could be considered due to oversold condition, but tight stops advised.\n\nXRP (Daily):\n- Price below EMA20 but above EMA200; bearish MACD; Stoch RSI neutral to oversold.\n- Stable ADL, moderate volume.\n- Strategy: Hold current position, await confirmation of reversal above EMA20 or breakdown below EMA200 before trading changes.\n\nStep 4: Execution decisions:\n\n- ETH: No new action now; hold current long.\n- BNB: No new action; current position aligns with bullish trend.\n- BTC: No position currently held; considering opportunity if confirmed bullish signals emerge. No trade now.\n- XRP: Hold; no clear bullish or bearish trigger for new trade.\n\nSummary:\n- Maintain current longs on ETH, BNB, XRP.\n- Monitor BTC for a potential long entry if MACD and price action confirm bullish reversal.\n- No shorts executed due to unclear or unfavorable setups.\n- Preserve cash balance for better entry points.\n\nNo trades executed at this time based on current signals and risk management."}
+{"timestamp": "2025-10-14T00:31:22.935302", "summary": "Step 1: Confirmed current holdings and cash balance:\n- ETH: Long 0.0048 ETH, 2x cross leverage, entry around 4144.7 USD, small unrealized profit.\n- BNB: Long 0.02 BNB, 3x cross leverage, entry around 1278.4 USD, small unrealized profit.\n- XRP: Long 4 XRP, 2x cross leverage, entry around 2.58 USD, slight unrealized loss.\n- Cash balance approximately $65.05.\n- Total profit and loss about +$5.05.\n\nStep 2: General latest crypto news:\n- Bitcoin rebounded strongly above $114,000 after a large drop.\n- Major liquidation event ($19.38B) recently occurred, market still volatile.\n- XRP shows warning signs and encounters resistance around $2.49.\n- BNB sharply rebounding over 13%, fueled by Binance Chain utility but with regulatory risks.\n- Bitcoin whale sold 1,423 BTC, signaling portfolio rebalancing.\n- Ethena\u2019s stablecoin plummeted but stabilized.\n- Market highly volatile with opportunities amidst caution.\n\nStep 3: Technical analysis on selected cryptocurrencies (ETH, BNB, XRP, BTC) on 1-hour charts:\n\nETH:\n- Price above 20 EMA (4113.88) and near 200 EMA (4146.51).\n- MACD bearish but possibly bottoming.\n- Stoch RSI recovering from oversold.\n- ADL shows some accumulation.\n- Volume moderate.\nStrategy: Neutral to mild bullish; wait for confirmed bullish crossovers of EMA and MACD or bounce on 200 EMA support before adding long; protect with stops.\n\nBNB:\n- Price slightly below 20 EMA but above 200 EMA, indicating bullish trend.\n- MACD negative short term; Stoch RSI oversold but recovering.\n- ADL positive and rising.\n- Volume moderate-high.\nStrategy: Overall strong bullish trend; look for price to move above 20 EMA and MACD crossover to resume longs; avoid shorts; use tight stops.\n\nXRP:\n- Price near 20 EMA, below 200 EMA.\n- MACD slightly bearish; Stoch RSI oversold.\n- ADL positive but volume moderate.\nStrategy: Cautious bullish bias; potential rebound from oversold; wait for MACD confirmation; stop loss below 20 EMA; watch for breakdown.\n\nBTC:\n- Price below 20 and 200 EMAs.\n- MACD bearish; Stoch RSI oversold.\n- ADL declining, selling pressure.\n- Volume moderate.\nStrategy: No long entry until bullish confirmation; consider short on rallies with tight stops; risk cautious.\n\nStep 4: Executions:\n- Added to existing long positions on ETH ($20 at 2x leverage), BNB ($25 at 3x leverage), and XRP ($10 at 2x leverage) as conditions align with bullish recovery signals and accumulation indicators.\n- No new BTC trades due to mixed bearish signals and lack of clear confirmation.\n\nSummary: Maintained and added some longs on ETH, BNB, and XRP based on selective positive short-term signals within broader cautious market context. Preserved cash for better entries or clearer setups in BTC or if market deteriorates. No shorts taken due to unclear setups.\n\nIf you require updated monitoring or further trades, just advise."}
+{"timestamp": "2025-10-14T01:01:24.284063", "summary": "Step 1: Current holdings and balance:\n- ETH: Long 0.0096 ETH at entry ~4138.55, small unrealized profit, 2x cross leverage, position value ~$39.96.\n- BNB: Long 0.04 BNB at entry ~1277.4, negligible unrealized profit, 3x cross leverage, position value ~$51.11.\n- XRP: Long 8 XRP at entry ~2.5844, small unrealized profit, 2x cross leverage, position value ~$20.74.\n- Cash balance: ~$65.16.\n- Overall profit: +$5.16.\n\nStep 2: Latest general crypto news:\n- Bitcoin rebounded to $114,000+ after dips, with volatility and a $20 billion recent liquidation event.\n- BNB surged 13% in 24h, showing strong utility and bullish momentum despite short-term oversold indicators.\n- XRP shows mixed signals with resistance signs and caution advised.\n- Bitcoin whale sales indicate portfolio rebalancing.\n- Overall market volatility with opportunities but requiring caution.\n\nStep 3: Technical analysis on 1-hour charts:\n\nETH:\n- Price: 4162.5, above EMA 20 (~4119) and EMA 200 (~4145).\n- MACD bearish crossover but overall positive momentum.\n- Stoch RSI neutral near oversold (41.9).\n- ADL shows some accumulation.\n- Volume low, signaling possible pause.\nStrategy: Wait for MACD confirming bounce, volume surge, and price to hold above EMA 20 before adding long positions. Use stops at recent swing low or EMA 20.\n\nBNB:\n- Price: 1277.4, just below EMA 20 (~1289) but above EMA 200 (~1230).\n- MACD bearish short-term; Stoch RSI oversold.\n- ADL stable, moderate accumulation.\n- Volume recently increased.\nStrategy: Watch for price to reclaim EMA 20 and a bullish MACD crossover before adding longs. Tight stops below EMA 20 advised.\n\nXRP:\n- Price: 2.5945, above 20 EMA (~2.57) but below 200 EMA (~2.64).\n- MACD slightly bearish; Stoch RSI near oversold (30).\n- ADL indicates buying interest, but volume low.\nStrategy: Consider entering longs only if volume picks up and MACD reverts bullishly above signal line, with stops near EMA 20.\n\nBTC:\n- Price: 114,547, below 200 EMA (~117,082), slightly above 20 EMA (~114,487).\n- MACD bearish; Stoch RSI oversold.\n- ADL declining; volume low.\nStrategy: No new longs until MACD bullish crossover and price breaks 200 EMA. Consider short exposure on rallies near 20 EMA with tight stops.\n\nStep 4: Execution:\n- No strong bullish confirmation yet for adding new longs in ETH, BNB, or XRP.\n- BTC remains bearish; no shorts due to low volume and uncertain bounce.\n- Hold current positions; preserve cash for clearer signals.\n\nSummary:\nCurrent positions in ETH, BNB, and XRP show small profits with cautious bullish bias. Market volatility and mixed indicator signals warrant patience. Await confirmed MACD reversal and volume increase before adding or scaling longs. No new trades executed now.\n\nI will monitor closely and act on any clear edge."}
+{"timestamp": "2025-10-14T02:01:12.769442", "summary": "Step 1: Current holdings and balance remain unchanged with small unrealized profits in ETH, BNB, and XRP, and cash balance ~$66.37.\n\nStep 2: Latest crypto news overview:\n- Market rebound driven by easing US-China trade tensions.\n- Large whale opening major short positions, holding $4.5M unrealized profits.\n- Bitcoin and Ethereum rebounding but cautious due to extreme fear sentiment.\n- Isolated stablecoin attack on Binance.\n- XRP has a large market opportunity ahead.\n- Solana showing bullish momentum after recent sell-off.\n- General market recovering amid volatility.\n\nStep 3: Technical analysis (1-hour):\n\nETH:\n- Price: 4227.5 above EMA20 (4136.1) and EMA200 (4135.2).\n- MACD slightly bearish (line below signal, negative histogram).\n- Stoch RSI bullish but not overbought.\n- ADL shows accumulation but declining recently.\n- Volume low.\nStrategy: Wait for MACD bullish crossover and volume increase; possible long entries on dips near EMA20 (~4136) with tight stops below EMA200 (~4135).\n\nBNB:\n- Price: 1284 below EMA20 (1289.4) but above EMA200 (1232.1).\n- MACD bearish; Stoch RSI oversold (~18.7).\n- ADL shows moderate accumulation; volume low.\nStrategy: Watch for price reclaiming EMA20 with MACD bullish crossover; oversold condition could mean short-term bounce. Consider small long positions with stop losses below recent lows, else be cautious.\n\nXRP:\n- Price: 2.6219 above EMA20 (2.5751) but below EMA200 (2.6388).\n- MACD slightly bearish; Stoch RSI neutral.\n- ADL rising signaling accumulation; volume moderate to low.\nStrategy: Consider longs only if price breaks above EMA200 with MACD turning positive and volume picking up; cautious for now.\n\nBTC:\n- Price: 114,934 below EMA200 (117,009), near EMA20 (114,565).\n- MACD bearish; Stoch RSI neutral but recovering from oversold.\n- ADL negative; volume low.\nStrategy: Bearish bias; consider shorts on rallies near EMA20 with confirmation. Avoid longs until MACD bullish and price moves above EMA200 with volume.\n\nSOL:\n- Price: 205.7 above EMA20 (196.68) and EMA200 (203.62).\n- MACD bullish; Stoch RSI overbought (100).\n- ADL rising; volume low.\nStrategy: Bullish trend with strong momentum. Await pullback towards EMA20 or consolidation before adding longs to reduce risk, watch volume for confirmation.\n\nStep 4: Execution:\n- Existing ETH, BNB, and XRP positions showing small profits; hold these.\n- No clear buy/sell signals to adjust positions in ETH, BNB, XRP, BTC now.\n- SOL shows bullish momentum but overbought Stoch RSI and volume low, prefer to wait for a pullback or consolidation.\n- No new trades executed to avoid risk amid mixed signals.\n\nSummary: Hold current positions with small profits; no new trade entries given unclear momentum and low volume except possible watch on SOL pullbacks. Await clear MACD crossovers and volume confirmation for new longs or shorts."}
+{"timestamp": "2025-10-14T02:30:53.996902", "summary": "Step 1: Current holdings and balance confirmed:\n- ETH long 0.0096 @ 4138.55, unrealized PnL ~$0.85, 2x leverage\n- BNB long 0.04 @1277.4, slight unrealized loss ~$-0.01, 3x leverage\n- XRP long 8.0 @ 2.5844, unrealized PnL ~$0.30, 2x leverage\n- Cash balance: ~$66.0\n- Total PnL: ~$6.0\n\nStep 2: Latest crypto news highlights:\n- XRP remains in focus amid ETF developments, but mixed market with XRP losing some ground.\n- Large whale activity with significant short positions ongoing.\n- Market recovering moderately after recent crash and geopolitical tensions.\n- Bitcoin and Ethereum still volatile with skepticism among institutions.\n- BNB recent highs driven by real ecosystem growth.\n- Extreme fear sentiment in market currently.\n- Stablecoin issues on Binance appear isolated.\n- Overall, selective recovery amid risk appetite returning.\n\nStep 3: Technical indicator summaries and strategies:\n\nETH (1h):\n- Price (4228) above EMA20 (~4136) and EMA200 (~4135).\n- MACD mildly bearish (line below signal), but histogram near zero.\n- Stoch RSI moderately bullish, not overbought.\n- ADL turning upward indicating accumulation.\n- Volume moderate.\n- Strategy: Maintain long position, consider adding on pullback toward 20 EMA if MACD turns bullish and volume increases. Stop below 200 EMA (~4135). Target new highs.\n\nBNB (1h):\n- Price (1277) below EMA20 (1288), above EMA200 (1215).\n- MACD bearish, Stoch RSI oversold.\n- ADL flat to mildly positive; volume mixed.\n- Strategy: Wait for MACD bullish crossover and price reclaiming EMA20 before adding longs. Otherwise hold current with tight stops below recent lows.\n\nXRP (1h):\n- Price (2.625) between EMA20 (2.575) and EMA200 (2.638).\n- MACD slightly bearish, Stoch RSI neutral.\n- ADL rising (accumulation), volume moderate.\n- Strategy: Hold current position, consider longs only on price break above EMA200 with MACD confirmation. Stop near 20 EMA (~2.57).\n\nBTC (1h):\n- Price (115,225) below EMA200 (117,012), just above EMA20 (114,592).\n- MACD bearish, Stoch RSI moderately bullish but low volume.\n- ADL negative (distribution).\n- Strategy: Maintain bearish bias; consider shorts near 20 EMA resistance with tight stops; avoid longs until breakout above EMA200 with MACD confirmation.\n\nSOL (1h):\n- Price (206) above EMA20 (196.7) and EMA200 (203.6).\n- MACD bullish, Stoch RSI overbought.\n- ADL rising, volume steady.\n- Strategy: Wait for pullback to EMA20 for safer longs; avoid buying into overbought condition. Partial profit-taking on existing longs if held.\n\nStep 4: Execution:\n- Current positions in ETH and XRP show unrealized profits; hold.\n- BNB position slightly negative; hold and watch for MACD reversal.\n- No BTC or SOL positions currently.\n- No clear new trade entries with strong conviction due to mixed or overbought signals.\n- Abstain from new trades to avoid risk.\n\nSummary:\nMaintain current ETH, BNB, XRP longs. No new trades executed due to mixed/unclear momentum or overbought signals. Await clearer confirmations on MACD/video for ETH add, BNB rebound, XRP breakout, or BTC short entries. Watch SOL pullback opportunities.\n\nNo trades executed given current analysis."}
+{"timestamp": "2025-10-14T03:00:56.196126", "summary": "Step 1: Current holdings and balance:\n- ETH long 0.0096 @ 4138.55, unrealized PnL +0.85, 2x leverage\n- BNB long 0.04 @ 1277.4, unrealized PnL -0.41, 3x leverage\n- XRP long 8 @ 2.5844, unrealized PnL +0.20, 2x leverage\n- Cash balance ~$65.50\n- Total PnL +5.50\n\nStep 2: Latest crypto news summary:\n- Major short squeeze liquidations in BTC and ETH triggered bullish rebound.\n- Market crash due to geopolitical and tariff fears reversed after clarification.\n- XRP eyed for potential year-end bullish seasonal trends amid ETF news.\n- Large whale activity with significant new short positions noted.\n- Institutional skepticism on Bitcoin remains.\n- BNB rally driven by real ecosystem growth.\n- Altcoins suffered more in crash than BTC.\n- Market recovering with selective risk appetite.\n\nStep 3: Technical analysis and strategy for selected coins (ETH, BNB, XRP, BTC):\n\nETH (1h):\n- Price ~4224 above EMA20 (4144) and EMA200 (4122)\n- MACD weakly bearish, histogram slightly negative\n- Stoch RSI moderately high (68.2), not yet overbought\n- ADL shows reduction in selling pressure\n- Volume very low recently\nStrategy: Hold current long; consider adding if MACD turns positive and volume picks up, placing stop below EMA20 (~4144). Avoid new longs while momentum weakens or volume low.\n\nBNB (1h):\n- Price ~1267 below EMA20 (1286), above EMA200 (1228)\n- MACD bearish; histogram negative\n- Stoch RSI very oversold (6.5), indicating potential bounce\n- ADL steady; volume very low\nStrategy: Watch for signs of momentum reversal such as Stoch RSI rising above 20 and MACD histogram positive before adding longs. Current position hold with tight stops below recent lows.\n\nXRP (1h):\n- Price ~2.607 above EMA20 (2.577), below EMA200 (2.629)\n- MACD slightly bearish, histogram negative\n- Stoch RSI recovering (33.5), not yet bullish\n- ADL rising; volume fluctuating low\nStrategy: Hold long; consider adding on confirmed breakout and sustained price above EMA200 (~2.63) with MACD turning positive and volume increase. Use tight stop below EMA20 (~2.58).\n\nBTC (1h):\n- Price ~115,105 above EMA20 (~114,627) and EMA200 (~113,636)\n- MACD weak bearish; histogram negative\n- Stoch RSI neutral (~50)\n- ADL rising, low volume\nStrategy: Consider cautious long at dips near EMA20 support, tight stops below EMA200. Await MACD bullish crossover and volume increase before adding aggressively.\n\nStep 4: Execution:\n- Maintain all current positions (ETH, BNB, XRP) as indicators show mixed signals without clear strong new entry or exit signals.\n- No new positions opened or closed due to lack of high-confidence setups.\n- Monitor for MACD and volume confirmation on ETH and XRP for potential add.\n- Watch BNB for reversal signals before increasing exposure.\n- BTC longs can be considered on dips if stop risks are respected, but not initiating new shorts now.\n\nSummary:\nHold current ETH, BNB, XRP longs with caution. Await stronger confirmation signals for additions. No new trades executed given current mixed/inconclusive short-term momentum and low volume."}
+{"timestamp": "2025-10-14T03:30:41.740954", "summary": "Step 1 & 2: Current holdings and balance remain as follows:\n- ETH long 0.0143 @ avg price ~4246.3 (added 0.0047 ETH at $4246.3, 2x leverage)\n- BNB long 0.04 @ 1277.4, current unrealized PnL slightly negative\n- XRP long 8 @ 2.5844, small positive unrealized PnL\n- Cash balance ~$45.8 after partial ETH add\n- Total PnL +5.85\n\nLatest crypto market news:\n- Severe downturn triggered by unexpected tariffs, led to $19B liquidations.\n- XRP flash crash but quick rebound.\n- Binance compensated users for collateral asset depegging event.\n- Stablecoins injected $1.75B liquidity.\n- ETH and BTC rallied after massive liquidations on shorts.\n- BNB ecosystem growth pushing price to all-time highs.\n- Large whale short activity at play.\n- Market highly volatile, caution advised.\n\nStep 3:\nTechnical analysis (1h):\n- ETH showing bullish indications: Price above EMA20/200, positive MACD histogram, Stoch RSI nearing overbought but still bullish, recommending adding longs on dips near EMA20.\n- BNB in longer-term uptrend but short-term pullback: EMA20 above EMA200 but MACD weak bearish, Stoch RSI oversold signaling potential reversal.\n- XRP neutral with sideways movement near resistance: EMA20 slightly below EMA200, weak MACD bearish, Stoch RSI neutral.\n- BTC remains bearish with EMA20 below EMA200 and negative MACD, Stoch RSI shows possible short retracement but trend weak.\n\nStep 4: Execution\n- Added to ETH long position with an additional $20 at 2x leverage around 4246.3, increasing exposure due to strong bullish technical signals and positive momentum.\n\nNo positions added or closed on BNB, XRP, or BTC given mixed or weak signals.\n\nSummary:\n- Maintain current BNB and XRP longs.\n- Add to ETH long on dip with confirmed momentum.\n- Monitor BNB for reversal signals before adding.\n- Avoid BTC longs until stronger bullish signals appear.\n\nLet me know if you want updated technical signals or further execution."}
+{"timestamp": "2025-10-14T04:01:03.373794", "summary": "Step 1: Current holdings and balance checked. Cash balance approximately $65.94 with open longs in ETH, BNB, and XRP.\n\nStep 2: Latest news summary found:\n- Positive market sentiment due to easing US-China trade tensions.\n- ETH rallied strongly, reclaiming $4,000 and showing potential to $5,000.\n- Binance compensated users for a collateral event; XRP experienced a sharp flash crash but rebounded quickly.\n- BTC and ETH shorts heavily liquidated signaling bullish momentum.\n- Stablecoin inflows providing liquidity; altcoins pumping but with caution advised.\n\nStep 3: Technical Indicators and Strategy Summary (1h timeframe):\n- ETH: Bullish overall with EMA20 above EMA200, MACD positive, ADL rising, Stoch RSI high but still bullish. Strategy: Add to longs on dips near EMA20.\n- BNB: Long-term uptrend remains but short-term bearish with price below EMA20, MACD bearish, Stoch RSI oversold. Strategy: Wait for price to cross above EMA20 with MACD confirmation before adding longs.\n- XRP: Neutral to cautious bullish, price between EMA20 and EMA200 with weak MACD. ADL rising but volume low. Strategy: Watch for breakout above EMA200 to consider longs, else cautious.\n- BTC: Overall bearish trend below EMA200 but short-term bounce with MACD crossover and high Stoch RSI. Strategy: Cautious short-term longs with tight stops near EMA20.\n\nStep 4: Execution:\n- Added to ETH long position with $20 at 2x leverage near 4250.1 as per bullish signals and strong momentum.\n\nNo new trades executed for BNB, XRP, or BTC due to mixed or weak setups.\n\nSummary:\n- ETH longs increased on strong setup.\n- Hold BNB and XRP positions; monitor for stronger signals.\n- Avoid BTC longs until clearer bullish momentum appears.\n\nLet me know if you want additional analysis or further executions."}
+{"timestamp": "2025-10-14T04:30:49.849240", "summary": "Executed adding $20 long ETH at 2x leverage near EMA20 as expected.\n\nSummary:\n- Holding current positions in ETH, BNB, XRP.\n- Added $20 more to ETH long.\n- No trades on BNB, XRP, BTC, ADA due to weak or unclear setups.\n\nWill monitor for XRP dip near EMA20 to consider a long add if conditions improve. Abstain from BTC and ADA positions for now.\n\nLet me know if you want continuous monitoring or specific coin analysis."}
+{"timestamp": "2025-10-14T06:30:53.817960", "summary": "Step 1: Current holdings and balance:\n- ETH long 0.0182 @ entry 4190.24, position value $77.38, unrealized PNL $1.12 (2x leverage)\n- BNB long 0.04 @ entry 1277.4, position value $51.56, unrealized PNL $0.47 (3x leverage)\n- XRP long 8 @ entry 2.5844, position value $20.87, unrealized PNL $0.20 (2x leverage)\n- Cash balance: $66.63\n- Total profit and loss: $6.63\n\nStep 2: Latest crypto news highlights:\n- BTC bullish momentum with surge to $115K and possible major breakout.\n- ADA shows whale buying and bullish momentum breaking resistance at $0.75.\n- XRP formed capitulation wick but finding support near $2.70-$2.80, potential bullish monthly close.\n- SOL has sharp fall but strong treasury accumulation, potential upside.\n- Stablecoins stable; market volatility and sentiment remain cautious.\n\nStep 3: Technical analysis and indicator summary (1-hour timeframe, last 100 candles):\n\nBTC:\n- Price $115,525 above 20EMA but below 200EMA; short-term bullish, longer-term resistance.\n- MACD bullish crossover with moderate momentum.\n- Stoch RSI overbought (~81), caution of pullback.\n- ADL negative, volume low.\nStrategy: Cautious longs with tight stops below 20EMA, target break above 200EMA.\n\nADA:\n- Price $0.731 above 20EMA but below 200EMA; short-term bullish, overall slightly bearish.\n- MACD near bearish crossover.\n- Stoch RSI neutral; ADL rising, volume moderate.\nStrategy: Await MACD bullish crossover or price above 200EMA for strong long entries; cautious longs possible.\n\nXRP:\n- Price $2.61 slightly below 200EMA but above 20EMA; transitional trend.\n- MACD weakening, negative histogram.\n- Stoch RSI oversold but rising.\n- ADL rising but volume down.\nStrategy: Wait for confirmation of reversal/bounce above 200EMA and MACD crossover to long; cautious neutral-bullish bias.\n\nSOL:\n- Price $207.94 above 20 and 200EMA; strong bullish trend.\n- MACD positive, stochastic RSI overbought.\n- ADL showing accumulation, volume moderate.\nStrategy: Long on trend with stops below 20EMA; watch for overbought pullbacks.\n\nETH:\n- Price $4252 above 20 and 200EMA; bullish trend.\n- MACD positive though histogram slightly shrinking.\n- Stoch RSI strong but not extreme.\n- ADL rising, volume lower recently.\nStrategy: Long on dips near 20EMA (~4177) with confirmation from stochastic RSI and volume; cautious for momentum easing.\n\nStep 4: Strategy and trade execution:\n\n- BTC: No new positions due to overbought Stoch RSI and weak volume despite bullish setup.\n- ADA: No trades; waiting for MACD crossover or price confirmation above 200EMA.\n- XRP: Hold current long; no add due to weak MACD, low volume; watch for bounce confirmation.\n- SOL: Current no position; opportunity identified for a long setup but will wait for minor pullback or confirmation due to overbought Stoch RSI.\n- ETH: Already holding long; no changes needed; monitor for dip near 20EMA for possible small adder if signals remain bullish.\n\nNo new trades executed at this time due to mixed signals or risk management considerations. Holding current positions with close monitoring suggested.\n\nSummary:\n- Maintain ETH, BNB, XRP longs.\n- No new longs or shorts now; watch BTC, ADA, XRP for clearer signals.\n- Potential long opportunity on SOL after pullback.\n- Continue monitoring indicators and volume for entries."}
+{"timestamp": "2025-10-14T07:01:08.925098", "summary": "Step 1: Current holdings and balance (as of now):\n- ETH long 0.0182 at $4190.24, position value ~$77.66, unrealized PNL ~$1.40 (2x leverage)\n- BNB long 0.04 at $1277.4, position value $51.66, unrealized PNL $0.57 (3x leverage)\n- XRP long 8 at $2.5844, position value $20.85, unrealized PNL $0.17 (2x leverage)\n- Cash balance: $66.99\n- Total profit and loss: ~$6.99\n\nStep 2: Latest general crypto news highlights:\n- Bitcoin price surged to $115,000 amid talk of a strong upcoming bull market.\n- Bitcoin Core v30.0 release sparks fork speculation.\n- Tether CEO praises USDT stability during crashes.\n- Binance CEO defends BNB amid manipulation rumors.\n- XRP shows signs of a potentially bullish monthly close supported by whale activity.\n- Solana (SOL) dropped 20% due to correction and geopolitical concerns but shows buying interest.\n- Cardano (ADA) whales buying dips, signaling possible recovery.\n- Stellar (XLM) poised for bullish rally.\n- Grayscale's move may boost an AI-related altcoin.\n- Mental health awareness raised due to a trader's death amid market crash.\n\nStep 3: Technical analysis and strategy summary (1-hour timeframe):\n\nBTC:\n- Price $115,381 above 20 EMA but below 200 EMA.\n- MACD shows weakening bullish momentum (negative histogram and MACD below signal).\n- Stoch RSI moderate (68.5), volume low, ADL recovering from bearish.\n- Strategy: Wait for breakout above 200 EMA with volume to long. Watch for short if price drops below 20 EMA with bearish MACD and volume increase.\n- No trade now due to mixed signals and low volume.\n\nETH:\n- Price $4265 above 20 and 200 EMA; EMA 20 > EMA 200 (bullish).\n- MACD positive, histogram positive.\n- Stoch RSI strong but not extreme (~78).\n- ADL increasing, volume low.\n- Strategy: Maintain/increase long on dips near 20 EMA ~$4187 with tight stops.\n- No immediate new trade; hold current long.\n\nXRP:\n- Price $2.6063 below 200 EMA but above 20 EMA.\n- MACD weakening, negative histogram.\n- Stoch RSI near oversold (~31).\n- ADL stable, volume low.\n- Strategy: Wait for bounce confirmation above 200 EMA and MACD crossover before new long. Current position hold.\n\nADA:\n- Price $0.731 above 20 EMA but below 200 EMA.\n- MACD weak bearish crossover.\n- Stoch RSI neutral.\n- ADL rising, volume low.\n- Strategy: Wait for MACD bullish crossover or price break above 200 EMA for long entry. Otherwise, avoid new trades.\n\nSOL:\n- Price $208 above 20 EMA but slightly below 200 EMA.\n- 20 EMA crossed above 200 EMA (golden cross).\n- MACD bullish.\n- Stoch RSI overbought (~93).\n- ADL up, volume low.\n- Strategy: Possible long on dips to 20 EMA ($201) with tight stop, target recent highs $208-210. Watch overbought RSI for pullback risk.\n\nStep 4: Trade execution:\n- Hold current ETH, BNB, XRP longs.\n- No new trades on BTC, ADA due to unclear signals.\n- No new long on XRP until stronger confirmation.\n- No new long on SOL now; watch for pullback or volume confirmation.\n\nSummary:\n- No new trades executed now due to mixed or cautious signals and low volumes.\n- Continue monitoring for stronger signals especially on BTC, ADA, SOL.\n- Maintain current positions with tight risk management.\n\nNo trade executions at this time."}

memory_utils.py

@@ -0,0 +1,39 @@
+# memory_utils.py
+import json
+import pandas as pd
+from datetime import datetime
+from pathlib import Path
+from typing import Optional, List, Dict, Any
+
+
+MEMORY_FILE = Path("memories.json")
+
+def load_memories(n: int = 3) -> list[str]:
+    """
+    Load the last n summarized memories from the JSONL file.
+    Returns a list of summary strings.
+    """
+    if not MEMORY_FILE.exists():
+        return []
+    with open(MEMORY_FILE, "r", encoding="utf-8") as f:
+        lines = [json.loads(l) for l in f if l.strip()]
+    return [m["summary"] for m in lines[-n:]]
+
+def save_memory(summary: str):
+    """
+    Append a new memory summary to the JSONL file.
+    Each line is a JSON object: {"timestamp": "...", "summary": "..."}
+    """
+    entry = {"timestamp": datetime.now().isoformat(), "summary": summary}
+    with open(MEMORY_FILE, "a", encoding="utf-8") as f:
+        f.write(json.dumps(entry) + "\n")
+
+def load_memories_df(n: Optional[int] = None):
+    """
+    Return recent memories as a pandas DataFrame (newest first).
+    """
+    with open("memories.json", "r", encoding="utf-8") as f:
+        lines = [json.loads(line) for line in f if line.strip()]
+    df = pd.DataFrame(lines)
+
+    return df.tail(n).iloc[::-1] if n else df.iloc[::-1]

production.ipynb

@@ -0,0 +1,727 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 1,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import os\n",
+    "import asyncio\n",
+    "import importlib\n",
+    "import hype_accounts_server\n",
+    "import gradio as gr\n",
+    "import pandas as pd\n",
+    "\n",
+    "from datetime import datetime\n",
+    "from dotenv import load_dotenv\n",
+    "from agents import Agent, Runner, trace, Tool\n",
+    "from agents.mcp import MCPServerStdio\n",
+    "from IPython.display import display, Markdown\n",
+    "from memory_utils import load_memories, save_memory, load_memories_df\n",
+    "\n",
+    "load_dotenv(override=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# --- MCP Server Factories ---\n",
+    "def make_hyperliquid_trader_mcp_servers():\n",
+    "    return [MCPServerStdio(\n",
+    "        {\"command\": \"python3\", \"args\": [\"-u\", \"hype_accounts_server.py\"], \"env\": {\"HYPERLIQUID_API_KEY\": os.getenv(\"HYPERLIQUID_API_KEY\"), \"HYPERLIQUID_PRIVATE_KEY\": os.getenv(\"HYPERLIQUID_PRIVATE_KEY\"), \"HYPERLIQUID_ACCOUNT_ADDRESS\": os.getenv(\"HYPERLIQUID_ACCOUNT_ADDRESS\")}},\n",
+    "        client_session_timeout_seconds=30\n",
+    "    )]\n",
+    "\n",
+    "def make_crypto_news_mcp_servers():\n",
+    "    return [MCPServerStdio(\n",
+    "        {\"command\": \"python3\", \"args\": [\"-u\", \"cryptopanic_news_server.py\"], \"env\": {\"CRYPTOPANIC_API_PLAN\": \"developer\", \"CRYPTOPANIC_API_KEY\": os.getenv(\"CRYPTOPANIC_API_KEY\")}},\n",
+    "        client_session_timeout_seconds=30\n",
+    "    )]\n",
+    "\n",
+    "def make_technical_analyst_mcp_servers():\n",
+    "    return [MCPServerStdio(\n",
+    "        {\"command\": \"python3\", \"args\": [\"-u\", \"hl_indicators_server.py\"]},\n",
+    "        client_session_timeout_seconds=30\n",
+    "    )]\n",
+    "\n",
+    "# --- Utilities ---\n",
+    "async def connect_all(servers):\n",
+    "    for s in servers:\n",
+    "        await s.connect()\n",
+    "\n",
+    "async def close_all(servers):\n",
+    "    for s in servers:\n",
+    "        try:\n",
+    "            await s.close()\n",
+    "        except Exception:\n",
+    "            pass\n",
+    "\n",
+    "# --- Researcher Tools ---\n",
+    "async def get_crypto_news_researcher(mcp_servers) -> Agent:\n",
+    "    instructions = f\"\"\"You are a cryptocurrency researcher. You have the tools to search for interesting cryptocurrency news,\n",
+    "    look for possible trading opportunities, and help with research.\n",
+    "    Default None if there are no specific cryptocurrency news or opportunities in the user request.\n",
+    "    Otherwise, indicate the symbol of specific cryptocurrency if there are specific requests (e.g. HYPE, BTC, ETH, XRP).\n",
+    "    Take time to make multiple searches, then summarize findings.\n",
+    "    If there isn't a specific request, respond with long/short opportunities based on the latest news.\n",
+    "    The current datetime is {datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")}\"\"\"\n",
+    "    return Agent(name=\"Crypto news researcher\", instructions=instructions, model=\"gpt-4.1-mini\", mcp_servers=mcp_servers)\n",
+    "\n",
+    "async def get_crypto_news_researcher_tool(mcp_servers) -> Tool:\n",
+    "    researcher = await get_crypto_news_researcher(mcp_servers)\n",
+    "    return researcher.as_tool(\n",
+    "        tool_name=\"crypto_news_researcher\",\n",
+    "        tool_description=(\"Research cryptocurrency news and opportunities based on a specific coin request \"\n",
+    "                          \"or scan broadly for notable news.\")\n",
+    "    )\n",
+    "\n",
+    "async def get_technical_analyst_researcher(mcp_servers) -> Agent:\n",
+    "    instructions = f\"\"\"You are a cryptocurrency perpetuals technical trading researcher.\n",
+    "    Default analysis interval: 1h; default lookback: 36.\n",
+    "    Indicators/strategies:\n",
+    "      - EMA (20, 200)\n",
+    "      - MACD (12, 26, 9)\n",
+    "      - stochastic RSI (14, 14, 3, 3)\n",
+    "      - Accumulation/Distribution (ADL)\n",
+    "      - Volume\n",
+    "    Based on the indicators, find long/short opportunities and propose strategies.\n",
+    "    The current datetime is {datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")}\"\"\"\n",
+    "    return Agent(name=\"Crypto technical researcher\", instructions=instructions, model=\"gpt-4.1-mini\", mcp_servers=mcp_servers)\n",
+    "\n",
+    "async def get_technical_analyst_researcher_tool(mcp_servers) -> Tool:\n",
+    "    # ✅ fix: call the *technical* researcher, not the news one\n",
+    "    researcher = await get_technical_analyst_researcher(mcp_servers)\n",
+    "    return researcher.as_tool(\n",
+    "        tool_name=\"crypto_technical_researcher\",\n",
+    "        tool_description=(\"Research technical indicators (EMA, MACD, Stoch RSI, ADL, Volume) for trading opportunities. \"\n",
+    "                          \"Specify coin/interval/lookback if needed.\")\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# --- Main Trader Logic ---\n",
+    "async def run_trader():\n",
+    "    hyper_servers = []; news_servers = []; ta_servers = []\n",
+    "    try:\n",
+    "        print(f\"\\n🕒 Starting trading cycle at {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\")\n",
+    "        # Load memory\n",
+    "        past_memories = load_memories(1)\n",
+    "        memory_text = \"\\n\".join(past_memories) if past_memories else \"No prior memories.\"\n",
+    "        account_details = await hype_accounts_server.get_account_details()\n",
+    "\n",
+    "        instructions = f\"\"\"\n",
+    "            You are a cryptocurrency perpetuals trader. \n",
+    "            Here are your past insights:\n",
+    "            {memory_text}\n",
+    "            Your current holdings and balance is:\n",
+    "            {account_details}\n",
+    "            You have tools for crypto news, hourly technical indicators, holdings/balance, and execution on Hyperliquid.\n",
+    "            Carry out trades as you see fit — take profits and cut losses as needed.\n",
+    "            Do not wait for instructions or ask for confirmation.\n",
+    "            Each transaction costs 0.04%.\n",
+    "            However, do not execute any trades if market signals are unclear or you are not confident in the setup.\n",
+    "        \"\"\"\n",
+    "\n",
+    "        prompt = f\"\"\"\n",
+    "        Step 1: Check current holdings and balance.\n",
+    "        Step 2: Research general latest crypto news.\n",
+    "        Step 3: Select 3–5 cryptocurrencies based on latest news and current holdings. Analyze price + hourly indicators (EMA20/200, MACD 12-26-9, StochRSI 14-14-3-3, ADL, Volume); propose strategies.\n",
+    "        Step 4: Execute long/short if edge exists; otherwise abstain. Carry out trades as you see fit; do not wait for instructions or ask for confirmation.\n",
+    "        Return: research, indicator values, strategy, executions (if any).\n",
+    "        Now: {datetime.now().strftime(\"%Y-%m-%d %H:%M\")}\n",
+    "        \"\"\"\n",
+    "\n",
+    "        # Fresh servers each run\n",
+    "        hyper_servers = make_hyperliquid_trader_mcp_servers()\n",
+    "        news_servers  = make_crypto_news_mcp_servers()\n",
+    "        ta_servers    = make_technical_analyst_mcp_servers()\n",
+    "\n",
+    "        await connect_all(hyper_servers)\n",
+    "        await connect_all(news_servers)\n",
+    "        await connect_all(ta_servers)\n",
+    "\n",
+    "        # Bind tools to *their* servers\n",
+    "        crypto_news_tool = await get_crypto_news_researcher_tool(news_servers)\n",
+    "        ta_tool = await get_technical_analyst_researcher_tool(ta_servers)\n",
+    "\n",
+    "        trader = Agent(\n",
+    "            name=\"crypto_trader\",\n",
+    "            instructions=instructions,\n",
+    "            tools=[crypto_news_tool, ta_tool],\n",
+    "            mcp_servers=hyper_servers,  # servers that expose trading actions\n",
+    "            model=\"gpt-4.1-mini\",\n",
+    "        )\n",
+    "\n",
+    "        async def _run():\n",
+    "            with trace(\"crypto_trader\"):\n",
+    "                return await Runner.run(trader, prompt, max_turns=30)\n",
+    "\n",
+    "        # Hard timeout so a wedged tool doesn't block the UI\n",
+    "        result = await asyncio.wait_for(_run(), timeout=120)\n",
+    "\n",
+    "        save_memory(result.final_output)\n",
+    "        mem_df = load_memories_df(10) if len(load_memories(1)) else pd.DataFrame(columns=[\"ts\",\"summary\"])\n",
+    "        output = f\"\"\"### ✅ Trade Completed {datetime.now().strftime(\"%Y-%m-%d %H:%M\")}\\n\\n{result.final_output}\"\"\"\n",
+    "        return output, mem_df\n",
+    "\n",
+    "    except asyncio.TimeoutError:\n",
+    "        return \"❌ Timed out (120s). Consider raising timeout or reducing tool work per cycle.\", pd.DataFrame(columns=[\"ts\",\"summary\"])\n",
+    "    except Exception as e:\n",
+    "        return f\"❌ Error during trading cycle: {e}\", pd.DataFrame(columns=[\"ts\",\"summary\"])\n",
+    "    finally:\n",
+    "        await close_all(hyper_servers)\n",
+    "        await close_all(news_servers)\n",
+    "        await close_all(ta_servers)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "* Running on local URL:  http://127.0.0.1:7861\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">[10/13/25 23:57:02] </span><span style=\"color: #000080; text-decoration-color: #000080\">INFO    </span> HTTP Request: <span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\">GET</span> <span style=\"color: #0000ff; text-decoration-color: #0000ff; text-decoration: underline\">http://127.0.0.1:7861/gradio_api/startup-events</span>      <a href=\"file:///Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/httpx/_client.py\" target=\"_blank\"><span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">_client.py</span></a><span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">:</span><a href=\"file:///Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/httpx/_client.py#1025\" target=\"_blank\"><span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">1025</span></a>\n",
+       "<span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">                    </span>         <span style=\"color: #008000; text-decoration-color: #008000\">\"HTTP/1.1 200 OK\"</span>                                                      <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">               </span>\n",
+       "</pre>\n"
+      ],
+      "text/plain": [
+       "\u001b[2;36m[10/13/25 23:57:02]\u001b[0m\u001b[2;36m \u001b[0m\u001b[34mINFO    \u001b[0m HTTP Request: \u001b[1;33mGET\u001b[0m \u001b[4;94mhttp://127.0.0.1:7861/gradio_api/startup-events\u001b[0m      \u001b]8;id=172711;file:///Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/httpx/_client.py\u001b\\\u001b[2m_client.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=992343;file:///Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/httpx/_client.py#1025\u001b\\\u001b[2m1025\u001b[0m\u001b]8;;\u001b\\\n",
+       "\u001b[2;36m                    \u001b[0m         \u001b[32m\"HTTP/1.1 200 OK\"\u001b[0m                                                      \u001b[2m               \u001b[0m\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">                    </span><span style=\"color: #000080; text-decoration-color: #000080\">INFO    </span> HTTP Request: <span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\">HEAD</span> <span style=\"color: #0000ff; text-decoration-color: #0000ff; text-decoration: underline\">http://127.0.0.1:7861/</span> <span style=\"color: #008000; text-decoration-color: #008000\">\"HTTP/1.1 200 OK\"</span>            <a href=\"file:///Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/httpx/_client.py\" target=\"_blank\"><span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">_client.py</span></a><span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">:</span><a href=\"file:///Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/httpx/_client.py#1025\" target=\"_blank\"><span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">1025</span></a>\n",
+       "</pre>\n"
+      ],
+      "text/plain": [
+       "\u001b[2;36m                   \u001b[0m\u001b[2;36m \u001b[0m\u001b[34mINFO    \u001b[0m HTTP Request: \u001b[1;33mHEAD\u001b[0m \u001b[4;94mhttp://127.0.0.1:7861/\u001b[0m \u001b[32m\"HTTP/1.1 200 OK\"\u001b[0m            \u001b]8;id=174034;file:///Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/httpx/_client.py\u001b\\\u001b[2m_client.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=851874;file:///Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/httpx/_client.py#1025\u001b\\\u001b[2m1025\u001b[0m\u001b]8;;\u001b\\\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "--- Logging error ---\n",
+      "Traceback (most recent call last):\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/rich/logging.py\", line 178, in emit\n",
+      "    self.console.print(log_renderable)\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/rich/console.py\", line 1697, in print\n",
+      "    with self:\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/rich/console.py\", line 870, in __exit__\n",
+      "    self._exit_buffer()\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/rich/console.py\", line 826, in _exit_buffer\n",
+      "    self._check_buffer()\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/rich/console.py\", line 2038, in _check_buffer\n",
+      "    self._write_buffer()\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/rich/console.py\", line 2054, in _write_buffer\n",
+      "    display(self._buffer, self._render_buffer(self._buffer[:]))\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/rich/jupyter.py\", line 91, in display\n",
+      "    ipython_display(jupyter_renderable)\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/IPython/core/display_functions.py\", line 285, in display\n",
+      "    publish_display_data(data=format_dict, metadata=md_dict, **kwargs)\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/IPython/core/display_functions.py\", line 73, in publish_display_data\n",
+      "    display_pub.publish(\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/ipykernel/zmqshell.py\", line 135, in publish\n",
+      "    msg = self.session.msg(msg_type, json_clean(content), parent=self.parent_header)\n",
+      "                                                                 ^^^^^^^^^^^^^^^^^^\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/ipykernel/zmqshell.py\", line 69, in parent_header\n",
+      "    return self._parent_header.get()\n",
+      "           ^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "LookupError: <ContextVar name='parent_header' at 0x10dec1cb0>\n",
+      "Call stack:\n",
+      "  File \"/usr/local/Cellar/python@3.11/3.11.14/Frameworks/Python.framework/Versions/3.11/lib/python3.11/threading.py\", line 1002, in _bootstrap\n",
+      "    self._bootstrap_inner()\n",
+      "  File \"/usr/local/Cellar/python@3.11/3.11.14/Frameworks/Python.framework/Versions/3.11/lib/python3.11/threading.py\", line 1045, in _bootstrap_inner\n",
+      "    self.run()\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/ipykernel/ipkernel.py\", line 788, in run_closure\n",
+      "    _threading_Thread_run(self)\n",
+      "  File \"/usr/local/Cellar/python@3.11/3.11.14/Frameworks/Python.framework/Versions/3.11/lib/python3.11/threading.py\", line 982, in run\n",
+      "    self._target(*self._args, **self._kwargs)\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/gradio/analytics.py\", line 91, in version_check\n",
+      "    latest_pkg_version = httpx.get(url=PKG_VERSION_URL, timeout=3).json()[\"version\"]\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/httpx/_api.py\", line 195, in get\n",
+      "    return request(\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/httpx/_api.py\", line 109, in request\n",
+      "    return client.request(\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/httpx/_client.py\", line 825, in request\n",
+      "    return self.send(request, auth=auth, follow_redirects=follow_redirects)\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/httpx/_client.py\", line 914, in send\n",
+      "    response = self._send_handling_auth(\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/httpx/_client.py\", line 942, in _send_handling_auth\n",
+      "    response = self._send_handling_redirects(\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/httpx/_client.py\", line 979, in _send_handling_redirects\n",
+      "    response = self._send_single_request(request)\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/httpx/_client.py\", line 1025, in _send_single_request\n",
+      "    logger.info(\n",
+      "  File \"/usr/local/Cellar/python@3.11/3.11.14/Frameworks/Python.framework/Versions/3.11/lib/python3.11/logging/__init__.py\", line 1489, in info\n",
+      "    self._log(INFO, msg, args, **kwargs)\n",
+      "  File \"/usr/local/Cellar/python@3.11/3.11.14/Frameworks/Python.framework/Versions/3.11/lib/python3.11/logging/__init__.py\", line 1634, in _log\n",
+      "    self.handle(record)\n",
+      "  File \"/usr/local/Cellar/python@3.11/3.11.14/Frameworks/Python.framework/Versions/3.11/lib/python3.11/logging/__init__.py\", line 1644, in handle\n",
+      "    self.callHandlers(record)\n",
+      "  File \"/usr/local/Cellar/python@3.11/3.11.14/Frameworks/Python.framework/Versions/3.11/lib/python3.11/logging/__init__.py\", line 1706, in callHandlers\n",
+      "    hdlr.handle(record)\n",
+      "  File \"/usr/local/Cellar/python@3.11/3.11.14/Frameworks/Python.framework/Versions/3.11/lib/python3.11/logging/__init__.py\", line 978, in handle\n",
+      "    self.emit(record)\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/rich/logging.py\", line 180, in emit\n",
+      "    self.handleError(record)\n",
+      "Message: 'HTTP Request: %s %s \"%s %d %s\"'\n",
+      "Arguments: ('GET', URL('https://api.gradio.app/pkg-version'), 'HTTP/1.1', 200, 'OK')\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">[10/13/25 23:57:03] </span><span style=\"color: #000080; text-decoration-color: #000080\">INFO    </span> HTTP Request: <span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\">GET</span> <span style=\"color: #0000ff; text-decoration-color: #0000ff; text-decoration: underline\">https://api.gradio.app/v3/tunnel-request</span> <span style=\"color: #008000; text-decoration-color: #008000\">\"HTTP/1.1 </span>  <a href=\"file:///Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/httpx/_client.py\" target=\"_blank\"><span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">_client.py</span></a><span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">:</span><a href=\"file:///Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/httpx/_client.py#1025\" target=\"_blank\"><span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">1025</span></a>\n",
+       "<span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">                    </span>         <span style=\"color: #008000; text-decoration-color: #008000\">200 OK\"</span>                                                                <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">               </span>\n",
+       "</pre>\n"
+      ],
+      "text/plain": [
+       "\u001b[2;36m[10/13/25 23:57:03]\u001b[0m\u001b[2;36m \u001b[0m\u001b[34mINFO    \u001b[0m HTTP Request: \u001b[1;33mGET\u001b[0m \u001b[4;94mhttps://api.gradio.app/v3/tunnel-request\u001b[0m \u001b[32m\"HTTP/1.1 \u001b[0m  \u001b]8;id=299345;file:///Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/httpx/_client.py\u001b\\\u001b[2m_client.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=555061;file:///Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/httpx/_client.py#1025\u001b\\\u001b[2m1025\u001b[0m\u001b]8;;\u001b\\\n",
+       "\u001b[2;36m                    \u001b[0m         \u001b[32m200 OK\"\u001b[0m                                                                \u001b[2m               \u001b[0m\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "* Running on public URL: https://85810c0a582ea7122c.gradio.live\n",
+      "\n",
+      "This share link expires in 1 week. For free permanent hosting and GPU upgrades, run `gradio deploy` from the terminal in the working directory to deploy to Hugging Face Spaces (https://huggingface.co/spaces)\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">[10/13/25 23:57:05] </span><span style=\"color: #000080; text-decoration-color: #000080\">INFO    </span> HTTP Request: <span style=\"color: #808000; text-decoration-color: #808000; font-weight: bold\">HEAD</span> <span style=\"color: #0000ff; text-decoration-color: #0000ff; text-decoration: underline\">https://85810c0a582ea7122c.gradio.live</span> <span style=\"color: #008000; text-decoration-color: #008000\">\"HTTP/1.1 </span>   <a href=\"file:///Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/httpx/_client.py\" target=\"_blank\"><span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">_client.py</span></a><span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">:</span><a href=\"file:///Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/httpx/_client.py#1025\" target=\"_blank\"><span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">1025</span></a>\n",
+       "<span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">                    </span>         <span style=\"color: #008000; text-decoration-color: #008000\">200 OK\"</span>                                                                <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">               </span>\n",
+       "</pre>\n"
+      ],
+      "text/plain": [
+       "\u001b[2;36m[10/13/25 23:57:05]\u001b[0m\u001b[2;36m \u001b[0m\u001b[34mINFO    \u001b[0m HTTP Request: \u001b[1;33mHEAD\u001b[0m \u001b[4;94mhttps://85810c0a582ea7122c.gradio.live\u001b[0m \u001b[32m\"HTTP/1.1 \u001b[0m   \u001b]8;id=92393;file:///Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/httpx/_client.py\u001b\\\u001b[2m_client.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=538708;file:///Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/httpx/_client.py#1025\u001b\\\u001b[2m1025\u001b[0m\u001b]8;;\u001b\\\n",
+       "\u001b[2;36m                    \u001b[0m         \u001b[32m200 OK\"\u001b[0m                                                                \u001b[2m               \u001b[0m\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div><iframe src=\"https://85810c0a582ea7122c.gradio.live\" width=\"100%\" height=\"500\" allow=\"autoplay; camera; microphone; clipboard-read; clipboard-write;\" frameborder=\"0\" allowfullscreen></iframe></div>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[23:57:12] 💓 🟡 Idle\n",
+      "[23:57:17] 💓 🟡 Idle\n",
+      "[23:57:22] 💓 🟡 Idle\n",
+      "[23:57:27] 💓 🟡 Idle\n",
+      "[23:57:32] 💓 🟡 Idle\n",
+      "[23:57:37] 💓 🟡 Idle\n",
+      "[23:57:42] 💓 🟡 Idle\n",
+      "[23:57:47] 💓 🟡 Idle\n",
+      "[23:57:52] 💓 🟡 Idle\n",
+      "[23:57:57] 💓 🟡 Idle\n",
+      "[23:58:02] 💓 🟡 Idle\n",
+      "[23:58:07] 💓 🟡 Idle\n",
+      "[23:58:12] 💓 🟡 Idle\n",
+      "[23:58:17] 💓 🟡 Idle\n",
+      "[23:58:22] 💓 🟡 Idle\n",
+      "[23:58:27] 💓 🟡 Idle\n",
+      "[23:58:32] 💓 🟡 Idle\n",
+      "[23:58:37] 💓 🟡 Idle\n",
+      "[23:58:42] 💓 🟡 Idle\n",
+      "[23:58:47] 💓 🟡 Idle\n",
+      "[23:58:52] 💓 🟡 Idle\n",
+      "[23:58:57] 💓 🟡 Idle\n",
+      "[23:59:02] 💓 🟡 Idle\n",
+      "[23:59:07] 💓 🟡 Idle\n",
+      "[23:59:12] 💓 🟡 Idle\n",
+      "[23:59:17] 💓 🟡 Idle\n",
+      "[23:59:22] 💓 🟡 Idle\n",
+      "[23:59:27] 💓 🟡 Idle\n",
+      "[23:59:32] 💓 🟡 Idle\n",
+      "[23:59:37] 💓 🟡 Idle\n",
+      "[23:59:42] 💓 🟡 Idle\n",
+      "[23:59:47] 💓 🟡 Idle\n",
+      "[23:59:52] 💓 🟡 Idle\n",
+      "[23:59:57] 💓 🟡 Idle\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "--- Logging error ---\n",
+      "Traceback (most recent call last):\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/rich/logging.py\", line 178, in emit\n",
+      "    self.console.print(log_renderable)\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/rich/console.py\", line 1697, in print\n",
+      "    with self:\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/rich/console.py\", line 870, in __exit__\n",
+      "    self._exit_buffer()\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/rich/console.py\", line 826, in _exit_buffer\n",
+      "    self._check_buffer()\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/rich/console.py\", line 2038, in _check_buffer\n",
+      "    self._write_buffer()\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/rich/console.py\", line 2054, in _write_buffer\n",
+      "    display(self._buffer, self._render_buffer(self._buffer[:]))\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/rich/jupyter.py\", line 91, in display\n",
+      "    ipython_display(jupyter_renderable)\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/IPython/core/display_functions.py\", line 285, in display\n",
+      "    publish_display_data(data=format_dict, metadata=md_dict, **kwargs)\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/IPython/core/display_functions.py\", line 73, in publish_display_data\n",
+      "    display_pub.publish(\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/ipykernel/zmqshell.py\", line 135, in publish\n",
+      "    msg = self.session.msg(msg_type, json_clean(content), parent=self.parent_header)\n",
+      "                                                                 ^^^^^^^^^^^^^^^^^^\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/ipykernel/zmqshell.py\", line 69, in parent_header\n",
+      "    return self._parent_header.get()\n",
+      "           ^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "LookupError: <ContextVar name='parent_header' at 0x10dec1cb0>\n",
+      "Call stack:\n",
+      "  File \"/usr/local/Cellar/python@3.11/3.11.14/Frameworks/Python.framework/Versions/3.11/lib/python3.11/threading.py\", line 1002, in _bootstrap\n",
+      "    self._bootstrap_inner()\n",
+      "  File \"/usr/local/Cellar/python@3.11/3.11.14/Frameworks/Python.framework/Versions/3.11/lib/python3.11/threading.py\", line 1045, in _bootstrap_inner\n",
+      "    self.run()\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/hyperliquid/websocket_manager.py\", line 91, in run\n",
+      "    self.ws.run_forever()\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/websocket/_app.py\", line 556, in run_forever\n",
+      "    initialize_socket()\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/websocket/_app.py\", line 422, in initialize_socket\n",
+      "    _logging.info(\"Websocket connected\")\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/websocket/_logging.py\", line 89, in info\n",
+      "    _logger.info(msg)\n",
+      "  File \"/usr/local/Cellar/python@3.11/3.11.14/Frameworks/Python.framework/Versions/3.11/lib/python3.11/logging/__init__.py\", line 1489, in info\n",
+      "    self._log(INFO, msg, args, **kwargs)\n",
+      "  File \"/usr/local/Cellar/python@3.11/3.11.14/Frameworks/Python.framework/Versions/3.11/lib/python3.11/logging/__init__.py\", line 1634, in _log\n",
+      "    self.handle(record)\n",
+      "  File \"/usr/local/Cellar/python@3.11/3.11.14/Frameworks/Python.framework/Versions/3.11/lib/python3.11/logging/__init__.py\", line 1644, in handle\n",
+      "    self.callHandlers(record)\n",
+      "  File \"/usr/local/Cellar/python@3.11/3.11.14/Frameworks/Python.framework/Versions/3.11/lib/python3.11/logging/__init__.py\", line 1706, in callHandlers\n",
+      "    hdlr.handle(record)\n",
+      "  File \"/usr/local/Cellar/python@3.11/3.11.14/Frameworks/Python.framework/Versions/3.11/lib/python3.11/logging/__init__.py\", line 978, in handle\n",
+      "    self.emit(record)\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/rich/logging.py\", line 180, in emit\n",
+      "    self.handleError(record)\n",
+      "Message: 'Websocket connected'\n",
+      "Arguments: ()\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[00:00:02] 💓 🟢 Running\n",
+      "[00:00:07] 💓 🟢 Running\n",
+      "[00:00:12] 💓 🟢 Running\n",
+      "[00:00:17] 💓 🟢 Running\n",
+      "[00:00:22] 💓 🟢 Running\n",
+      "[00:00:27] 💓 🟢 Running\n",
+      "[00:00:32] 💓 🟢 Running\n",
+      "[00:00:37] 💓 🟢 Running\n",
+      "[00:00:42] 💓 🟢 Running\n",
+      "[00:00:47] 💓 🟢 Running\n",
+      "[00:00:52] 💓 🟢 Running\n",
+      "[00:00:57] 💓 🟢 Running\n",
+      "[00:01:02] 💓 🟢 Running\n",
+      "[00:01:07] 💓 🟢 Running\n",
+      "[00:01:12] 💓 🟡 Idle\n",
+      "[00:01:17] 💓 🟡 Idle\n",
+      "[00:01:22] 💓 🟡 Idle\n",
+      "[00:01:27] 💓 🟡 Idle\n",
+      "[00:01:32] 💓 🟡 Idle\n",
+      "[00:01:37] 💓 🟡 Idle\n",
+      "[00:01:42] 💓 🟡 Idle\n",
+      "[00:01:47] 💓 🟡 Idle\n",
+      "[00:01:52] 💓 🟡 Idle\n",
+      "[00:01:57] 💓 🟡 Idle\n",
+      "[00:02:02] 💓 🟡 Idle\n",
+      "[00:02:07] 💓 🟡 Idle\n",
+      "[00:02:12] 💓 🟡 Idle\n",
+      "[00:02:17] 💓 🟡 Idle\n",
+      "[00:02:22] 💓 🟡 Idle\n",
+      "[00:02:27] 💓 🟡 Idle\n",
+      "[00:02:32] 💓 🟡 Idle\n",
+      "[00:02:37] 💓 🟡 Idle\n",
+      "[00:02:42] 💓 🟡 Idle\n",
+      "[00:02:47] 💓 🟡 Idle\n",
+      "[00:02:52] 💓 🟡 Idle\n",
+      "[00:02:57] 💓 🟡 Idle\n",
+      "[00:03:02] 💓 🟡 Idle\n",
+      "[00:03:07] 💓 🟡 Idle\n",
+      "[00:03:12] 💓 🟡 Idle\n",
+      "[00:03:17] 💓 🟡 Idle\n",
+      "[00:03:22] 💓 🟡 Idle\n",
+      "[00:03:27] 💓 🟡 Idle\n",
+      "[00:03:32] 💓 🟡 Idle\n",
+      "[00:03:37] 💓 🟡 Idle\n",
+      "[00:03:42] 💓 🟡 Idle\n",
+      "[00:03:47] 💓 🟡 Idle\n",
+      "[00:03:52] 💓 🟡 Idle\n",
+      "[00:03:57] 💓 🟡 Idle\n",
+      "[00:04:02] 💓 🟡 Idle\n",
+      "[00:04:07] 💓 🟡 Idle\n",
+      "[00:04:12] 💓 🟡 Idle\n",
+      "[00:04:17] 💓 🟡 Idle\n",
+      "[00:04:22] 💓 🟡 Idle\n",
+      "[00:04:27] 💓 🟡 Idle\n",
+      "[00:04:32] 💓 🟡 Idle\n",
+      "[00:04:37] 💓 🟡 Idle\n",
+      "[00:04:42] 💓 🟡 Idle\n",
+      "[00:04:47] 💓 🟡 Idle\n",
+      "[00:04:52] 💓 🟡 Idle\n",
+      "[00:04:57] 💓 🟡 Idle\n"
+     ]
+    }
+   ],
+   "source": [
+    "import asyncio\n",
+    "from datetime import datetime, timedelta\n",
+    "import pandas as pd\n",
+    "import gradio as gr\n",
+    "import os\n",
+    "import tempfile\n",
+    "import traceback\n",
+    "\n",
+    "# from your_module import run_trader\n",
+    "\n",
+    "LATEST_OUTPUT = \"⏳ Waiting for first scheduled run…\"\n",
+    "LATEST_MEM_DF = pd.DataFrame(columns=[\"ts\", \"summary\"])\n",
+    "NEXT_RUN_AT = None\n",
+    "IS_RUNNING = False\n",
+    "LAST_RUN_STARTED_AT = None\n",
+    "LAST_RUN_ENDED_AT = None\n",
+    "\n",
+    "_STATE_LOCK = asyncio.Lock()\n",
+    "_SCHEDULER_STARTED = False\n",
+    "_RUN_LOCK = asyncio.Lock()\n",
+    "\n",
+    "HEARTBEAT_SECS = 5\n",
+    "MAX_RUN_SECS = 110\n",
+    "CSV_PATH = os.path.join(tempfile.gettempdir(), \"memories_latest.csv\")\n",
+    "\n",
+    "# ✅ NEW\n",
+    "STOP_TRADING = False\n",
+    "\n",
+    "\n",
+    "def now(): return datetime.now()\n",
+    "\n",
+    "def next_half_hour_dt(t=None):\n",
+    "    t = t or now()\n",
+    "    if t.minute < 30:\n",
+    "        return t.replace(minute=30, second=0, microsecond=0)\n",
+    "    return (t.replace(minute=0, second=0, microsecond=0) + timedelta(hours=1))\n",
+    "\n",
+    "def eta_str(target):\n",
+    "    secs = max(0, int((target - now()).total_seconds()))\n",
+    "    m, s = divmod(secs, 60)\n",
+    "    return f\"{m:02d}:{s:02d}\"\n",
+    "\n",
+    "\n",
+    "async def safe_run_trader():\n",
+    "    global LATEST_OUTPUT, LATEST_MEM_DF, IS_RUNNING, LAST_RUN_STARTED_AT, LAST_RUN_ENDED_AT\n",
+    "    if _RUN_LOCK.locked() or STOP_TRADING:\n",
+    "        return\n",
+    "\n",
+    "    async with _RUN_LOCK:\n",
+    "        IS_RUNNING = True\n",
+    "        LAST_RUN_STARTED_AT = now()\n",
+    "        try:\n",
+    "            md, mem_df = await asyncio.wait_for(run_trader(), timeout=MAX_RUN_SECS)\n",
+    "            async with _STATE_LOCK:\n",
+    "                LATEST_OUTPUT = md or \"(no output)\"\n",
+    "                if isinstance(mem_df, pd.DataFrame) and not mem_df.empty:\n",
+    "                    LATEST_MEM_DF = mem_df.copy()\n",
+    "                else:\n",
+    "                    stamp = now().strftime(\"%Y-%m-%d %H:%M:%S\")\n",
+    "                    extra = pd.DataFrame([{\"ts\": stamp, \"summary\": \"✅ Run completed\"}])\n",
+    "                    LATEST_MEM_DF = pd.concat([LATEST_MEM_DF, extra], ignore_index=True)\n",
+    "        except Exception:\n",
+    "            err = traceback.format_exc()\n",
+    "            async with _STATE_LOCK:\n",
+    "                LATEST_OUTPUT = f\"❌ Exception\\n```\\n{err}\\n```\"\n",
+    "        finally:\n",
+    "            LAST_RUN_ENDED_AT = now()\n",
+    "            IS_RUNNING = False\n",
+    "\n",
+    "\n",
+    "async def halfhour_scheduler():\n",
+    "    global NEXT_RUN_AT\n",
+    "    NEXT_RUN_AT = next_half_hour_dt()\n",
+    "    await asyncio.sleep(max(0.0, (NEXT_RUN_AT - now()).total_seconds()))\n",
+    "    while True:\n",
+    "        if not STOP_TRADING:\n",
+    "            await safe_run_trader()\n",
+    "            NEXT_RUN_AT = next_half_hour_dt()\n",
+    "        else:\n",
+    "            NEXT_RUN_AT = None\n",
+    "        await asyncio.sleep(HEARTBEAT_SECS if STOP_TRADING else\n",
+    "                            max(0.0, (NEXT_RUN_AT - now()).total_seconds()))\n",
+    "\n",
+    "\n",
+    "async def heartbeat():\n",
+    "    while True:\n",
+    "        state = \"⏸️ Paused\" if STOP_TRADING else (\"🟢 Running\" if IS_RUNNING else \"🟡 Idle\")\n",
+    "        print(f\"[{now():%H:%M:%S}] 💓 {state}\")\n",
+    "        await asyncio.sleep(HEARTBEAT_SECS)\n",
+    "\n",
+    "\n",
+    "def write_mem_csv(df):\n",
+    "    if df is None or df.empty:\n",
+    "        df = pd.DataFrame(columns=[\"ts\", \"summary\"])\n",
+    "    df.to_csv(CSV_PATH, index=False)\n",
+    "    return CSV_PATH\n",
+    "\n",
+    "\n",
+    "async def ensure_scheduler_started():\n",
+    "    global _SCHEDULER_STARTED\n",
+    "    if not _SCHEDULER_STARTED:\n",
+    "        _SCHEDULER_STARTED = True\n",
+    "        asyncio.create_task(heartbeat())\n",
+    "        asyncio.create_task(halfhour_scheduler())\n",
+    "\n",
+    "\n",
+    "def status_markdown():\n",
+    "    lines = [f\"**Status:** {'⏸️ Paused' if STOP_TRADING else ('🟢 Running' if IS_RUNNING else '🟡 Idle')}\"]\n",
+    "    if LAST_RUN_STARTED_AT:\n",
+    "        lines.append(f\"**Last start:** {LAST_RUN_STARTED_AT:%Y-%m-%d %H:%M:%S}\")\n",
+    "    if LAST_RUN_ENDED_AT:\n",
+    "        lines.append(f\"**Last end:** {LAST_RUN_ENDED_AT:%Y-%m-%d %H:%M:%S}\")\n",
+    "    if NEXT_RUN_AT and not STOP_TRADING:\n",
+    "        lines.append(f\"**Next run:** {NEXT_RUN_AT:%Y-%m-%d %H:%M} (ETA {eta_str(NEXT_RUN_AT)})\")\n",
+    "    if STOP_TRADING:\n",
+    "        lines.append(f\"**Scheduler:** waiting for Resume\")\n",
+    "    return \"\\n\\n\".join(lines)\n",
+    "\n",
+    "\n",
+    "async def ui_poll():\n",
+    "    async with _STATE_LOCK:\n",
+    "        latest = LATEST_OUTPUT\n",
+    "        mem_df = LATEST_MEM_DF.copy()\n",
+    "    csv_path = write_mem_csv(mem_df)\n",
+    "    return latest, status_markdown(), mem_df, csv_path\n",
+    "\n",
+    "\n",
+    "# ✅ BUTTON HANDLERS\n",
+    "def _toggle_stop(flag: bool):\n",
+    "    global STOP_TRADING\n",
+    "    STOP_TRADING = flag\n",
+    "    return status_markdown()\n",
+    "\n",
+    "\n",
+    "with gr.Blocks(fill_height=True) as demo:\n",
+    "    gr.Markdown(\"## ���� Crypto Trader — Live Board\")\n",
+    "    gr.Markdown(\n",
+    "        \"\"\"\n",
+    "        [agent tracer](https://platform.openai.com/logs?api=traces)\\n\n",
+    "        [hyperliquid platform](https://app.hyperliquid.xyz/trade)\n",
+    "        \"\"\",\n",
+    "    )\n",
+    "    with gr.Row():\n",
+    "        stop_btn = gr.Button(\"🛑 Stop\", variant=\"stop\")\n",
+    "        resume_btn = gr.Button(\"▶️ Resume\", variant=\"primary\")\n",
+    "\n",
+    "    latest_md = gr.Markdown(value=LATEST_OUTPUT)\n",
+    "    status_md = gr.Markdown(value=status_markdown())\n",
+    "    mem_table = gr.Dataframe(value=LATEST_MEM_DF, interactive=False, wrap=True, show_label=False)\n",
+    "    mem_csv = gr.File(interactive=False)\n",
+    "\n",
+    "    stop_btn.click(lambda: _toggle_stop(True), outputs=[status_md])\n",
+    "    resume_btn.click(lambda: _toggle_stop(False), outputs=[status_md])\n",
+    "\n",
+    "    demo.load(ensure_scheduler_started)\n",
+    "    timer = gr.Timer(5.0, active=True)\n",
+    "    timer.tick(ui_poll, outputs=[latest_md, status_md, mem_table, mem_csv])\n",
+    "\n",
+    "if __name__ == \"__main__\":\n",
+    "    demo.queue().launch(share=True)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "venv (3.11.14)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.14"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

requirements.txt

@@ -0,0 +1,9 @@
+gradio
+pandas
+numpy
+python-dotenv
+openai
+openai-agents
+fastmcp
+hyperliquid-python-sdk
+eth-account

test.ipynb

@@ -0,0 +1,1522 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# uv pip install ipykernel -U --force-reinstall\n",
+    "# uv pip install dotenv openai-agents\n",
+    "# uv pip install gradio\n",
+    "import os\n",
+    "from datetime import datetime\n",
+    "import gradio as gr\n",
+    "from dotenv import load_dotenv\n",
+    "from agents import Agent, Runner, trace, Tool\n",
+    "from agents.mcp import MCPServerStdio\n",
+    "from IPython.display import display, Markdown\n",
+    "\n",
+    "load_dotenv(override=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Hyperliquid Trader"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Now let's use our accounts server as an MCP server\n",
+    "\n",
+    "params = {\"command\": \"python\", \"args\": [\"-u\", \"hype_accounts_server.py\"], \"env\": {\"HYPERLIQUID_API_KEY\": os.getenv(\"HYPERLIQUID_API_KEY\"), \"HYPERLIQUID_PRIVATE_KEY\": os.getenv(\"HYPERLIQUID_PRIVATE_KEY\"), \"HYPERLIQUID_ACCOUNT_ADDRESS\": os.getenv(\"HYPERLIQUID_ACCOUNT_ADDRESS\")}}\n",
+    "async with MCPServerStdio(params=params, client_session_timeout_seconds=30) as server:\n",
+    "    mcp_tools = await server.list_tools()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Failed to parse JSONRPC message from server\n",
+      "Traceback (most recent call last):\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/mcp/client/stdio/__init__.py\", line 155, in stdout_reader\n",
+      "    message = types.JSONRPCMessage.model_validate_json(line)\n",
+      "              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/pydantic/main.py\", line 746, in model_validate_json\n",
+      "    return cls.__pydantic_validator__.validate_json(\n",
+      "           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "pydantic_core._pydantic_core.ValidationError: 1 validation error for JSONRPCMessage\n",
+      "  Invalid JSON: expected value at line 1 column 1 [type=json_invalid, input_value='Running with account add...5B3D2bf7e80A886f213D08b', input_type=str]\n",
+      "    For further information visit https://errors.pydantic.dev/2.11/v/json_invalid\n",
+      "Failed to parse JSONRPC message from server\n",
+      "Traceback (most recent call last):\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/mcp/client/stdio/__init__.py\", line 155, in stdout_reader\n",
+      "    message = types.JSONRPCMessage.model_validate_json(line)\n",
+      "              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/pydantic/main.py\", line 746, in model_validate_json\n",
+      "    return cls.__pydantic_validator__.validate_json(\n",
+      "           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "pydantic_core._pydantic_core.ValidationError: 1 validation error for JSONRPCMessage\n",
+      "  Invalid JSON: expected value at line 1 column 1 [type=json_invalid, input_value='Running with agent addre...74e1ef79DAD43E8aF528e31', input_type=str]\n",
+      "    For further information visit https://errors.pydantic.dev/2.11/v/json_invalid\n"
+     ]
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Your current cash balance is approximately 64.90 USDT. You do not have any holdings at the moment. Your profit and loss value is 4.90 USDT. Let me know if you would like to take any actions."
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Process group termination failed for PID 11334: [Errno 1] Operation not permitted, falling back to simple terminate\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO:httpx:HTTP Request: POST https://api.openai.com/v1/traces/ingest \"HTTP/1.1 204 No Content\"\n",
+      "INFO:httpx:HTTP Request: POST https://api.openai.com/v1/traces/ingest \"HTTP/1.1 204 No Content\"\n",
+      "INFO:httpx:HTTP Request: POST https://api.openai.com/v1/traces/ingest \"HTTP/1.1 204 No Content\"\n",
+      "INFO:httpx:HTTP Request: POST https://api.openai.com/v1/traces/ingest \"HTTP/1.1 204 No Content\"\n",
+      "INFO:httpx:HTTP Request: POST https://api.openai.com/v1/traces/ingest \"HTTP/1.1 204 No Content\"\n",
+      "INFO:httpx:HTTP Request: POST https://api.openai.com/v1/traces/ingest \"HTTP/1.1 204 No Content\"\n",
+      "INFO:httpx:HTTP Request: POST https://api.openai.com/v1/traces/ingest \"HTTP/1.1 204 No Content\"\n",
+      "INFO:httpx:HTTP Request: POST https://api.openai.com/v1/traces/ingest \"HTTP/1.1 204 No Content\"\n",
+      "INFO:httpx:HTTP Request: POST https://api.openai.com/v1/traces/ingest \"HTTP/1.1 204 No Content\"\n",
+      "INFO:httpx:HTTP Request: POST https://api.openai.com/v1/traces/ingest \"HTTP/1.1 204 No Content\"\n",
+      "INFO:httpx:HTTP Request: POST https://api.openai.com/v1/traces/ingest \"HTTP/1.1 204 No Content\"\n",
+      "INFO:httpx:HTTP Request: POST https://api.openai.com/v1/traces/ingest \"HTTP/1.1 204 No Content\"\n",
+      "INFO:httpx:HTTP Request: POST https://api.openai.com/v1/traces/ingest \"HTTP/1.1 204 No Content\"\n",
+      "INFO:httpx:HTTP Request: POST https://api.openai.com/v1/traces/ingest \"HTTP/1.1 204 No Content\"\n",
+      "INFO:httpx:HTTP Request: POST https://api.openai.com/v1/traces/ingest \"HTTP/1.1 204 No Content\"\n",
+      "INFO:httpx:HTTP Request: POST https://api.openai.com/v1/traces/ingest \"HTTP/1.1 204 No Content\"\n",
+      "INFO:httpx:HTTP Request: POST https://api.openai.com/v1/traces/ingest \"HTTP/1.1 204 No Content\"\n",
+      "INFO:httpx:HTTP Request: POST https://api.openai.com/v1/traces/ingest \"HTTP/1.1 204 No Content\"\n"
+     ]
+    }
+   ],
+   "source": [
+    "instructions = \"You are able to manage a hyperliquid account for me, answer questions about the account, long/short cryptocurrency perpetuals, and close their positions for me.\"\n",
+    "request = \"What's my balance and my holdings?\"\n",
+    "model = \"gpt-4.1-mini\"\n",
+    "\n",
+    "async with MCPServerStdio(params=params, client_session_timeout_seconds=30) as mcp_server:\n",
+    "    agent = Agent(name=\"hyperliquid_account_manager\", instructions=instructions, model=model, mcp_servers=[mcp_server])\n",
+    "    with trace(\"hyperliquid_account_manager\"):\n",
+    "        result = await Runner.run(agent, request)\n",
+    "    display(Markdown(result.final_output))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "ERROR:mcp.client.stdio:Failed to parse JSONRPC message from server\n",
+      "Traceback (most recent call last):\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/mcp/client/stdio/__init__.py\", line 155, in stdout_reader\n",
+      "    message = types.JSONRPCMessage.model_validate_json(line)\n",
+      "              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/pydantic/main.py\", line 746, in model_validate_json\n",
+      "    return cls.__pydantic_validator__.validate_json(\n",
+      "           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "pydantic_core._pydantic_core.ValidationError: 1 validation error for JSONRPCMessage\n",
+      "  Invalid JSON: expected value at line 1 column 1 [type=json_invalid, input_value='Running with account add...5B3D2bf7e80A886f213D08b', input_type=str]\n",
+      "    For further information visit https://errors.pydantic.dev/2.11/v/json_invalid\n",
+      "ERROR:mcp.client.stdio:Failed to parse JSONRPC message from server\n",
+      "Traceback (most recent call last):\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/mcp/client/stdio/__init__.py\", line 155, in stdout_reader\n",
+      "    message = types.JSONRPCMessage.model_validate_json(line)\n",
+      "              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/pydantic/main.py\", line 746, in model_validate_json\n",
+      "    return cls.__pydantic_validator__.validate_json(\n",
+      "           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "pydantic_core._pydantic_core.ValidationError: 1 validation error for JSONRPCMessage\n",
+      "  Invalid JSON: expected value at line 1 column 1 [type=json_invalid, input_value='Running with agent addre...74e1ef79DAD43E8aF528e31', input_type=str]\n",
+      "    For further information visit https://errors.pydantic.dev/2.11/v/json_invalid\n",
+      "ERROR:mcp.client.stdio:Failed to parse JSONRPC message from server\n",
+      "Traceback (most recent call last):\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/mcp/client/stdio/__init__.py\", line 155, in stdout_reader\n",
+      "    message = types.JSONRPCMessage.model_validate_json(line)\n",
+      "              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/pydantic/main.py\", line 746, in model_validate_json\n",
+      "    return cls.__pydantic_validator__.validate_json(\n",
+      "           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "pydantic_core._pydantic_core.ValidationError: 4 validation errors for JSONRPCMessage\n",
+      "JSONRPCRequest\n",
+      "  Input should be an object [type=model_type, input_value=0.0048, input_type=float]\n",
+      "    For further information visit https://errors.pydantic.dev/2.11/v/model_type\n",
+      "JSONRPCNotification\n",
+      "  Input should be an object [type=model_type, input_value=0.0048, input_type=float]\n",
+      "    For further information visit https://errors.pydantic.dev/2.11/v/model_type\n",
+      "JSONRPCResponse\n",
+      "  Input should be an object [type=model_type, input_value=0.0048, input_type=float]\n",
+      "    For further information visit https://errors.pydantic.dev/2.11/v/model_type\n",
+      "JSONRPCError\n",
+      "  Input should be an object [type=model_type, input_value=0.0048, input_type=float]\n",
+      "    For further information visit https://errors.pydantic.dev/2.11/v/model_type\n",
+      "ERROR:mcp.client.stdio:Failed to parse JSONRPC message from server\n",
+      "Traceback (most recent call last):\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/mcp/client/stdio/__init__.py\", line 155, in stdout_reader\n",
+      "    message = types.JSONRPCMessage.model_validate_json(line)\n",
+      "              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/pydantic/main.py\", line 746, in model_validate_json\n",
+      "    return cls.__pydantic_validator__.validate_json(\n",
+      "           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "pydantic_core._pydantic_core.ValidationError: 1 validation error for JSONRPCMessage\n",
+      "  Invalid JSON: expected value at line 1 column 1 [type=json_invalid, input_value='Current leverage for ETH: {', input_type=str]\n",
+      "    For further information visit https://errors.pydantic.dev/2.11/v/json_invalid\n",
+      "ERROR:mcp.client.stdio:Failed to parse JSONRPC message from server\n",
+      "Traceback (most recent call last):\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/mcp/client/stdio/__init__.py\", line 155, in stdout_reader\n",
+      "    message = types.JSONRPCMessage.model_validate_json(line)\n",
+      "              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/pydantic/main.py\", line 746, in model_validate_json\n",
+      "    return cls.__pydantic_validator__.validate_json(\n",
+      "           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "pydantic_core._pydantic_core.ValidationError: 1 validation error for JSONRPCMessage\n",
+      "  Invalid JSON: trailing characters at line 1 column 9 [type=json_invalid, input_value='  \"type\": \"cross\",', input_type=str]\n",
+      "    For further information visit https://errors.pydantic.dev/2.11/v/json_invalid\n",
+      "ERROR:mcp.client.stdio:Failed to parse JSONRPC message from server\n",
+      "Traceback (most recent call last):\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/mcp/client/stdio/__init__.py\", line 155, in stdout_reader\n",
+      "    message = types.JSONRPCMessage.model_validate_json(line)\n",
+      "              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/pydantic/main.py\", line 746, in model_validate_json\n",
+      "    return cls.__pydantic_validator__.validate_json(\n",
+      "           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "pydantic_core._pydantic_core.ValidationError: 1 validation error for JSONRPCMessage\n",
+      "  Invalid JSON: trailing characters at line 1 column 10 [type=json_invalid, input_value='  \"value\": 3', input_type=str]\n",
+      "    For further information visit https://errors.pydantic.dev/2.11/v/json_invalid\n",
+      "ERROR:mcp.client.stdio:Failed to parse JSONRPC message from server\n",
+      "Traceback (most recent call last):\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/mcp/client/stdio/__init__.py\", line 155, in stdout_reader\n",
+      "    message = types.JSONRPCMessage.model_validate_json(line)\n",
+      "              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/pydantic/main.py\", line 746, in model_validate_json\n",
+      "    return cls.__pydantic_validator__.validate_json(\n",
+      "           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "pydantic_core._pydantic_core.ValidationError: 1 validation error for JSONRPCMessage\n",
+      "  Invalid JSON: expected value at line 1 column 1 [type=json_invalid, input_value='}', input_type=str]\n",
+      "    For further information visit https://errors.pydantic.dev/2.11/v/json_invalid\n"
+     ]
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "I have placed a market order to long $20 of ETH with 1x leverage. The position has been filled at an average price of approximately $4129.6. Let me know if you need any further assistance!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:mcp.os.posix.utilities:Process group termination failed for PID 10496: [Errno 1] Operation not permitted, falling back to simple terminate\n"
+     ]
+    }
+   ],
+   "source": [
+    "instructions = \"You are able to manage a hyperliquid account for me, answer questions about the account, long/short cryptocurrency perpetuals, and close their positions for me.\"\n",
+    "request = \"Help me long $20 of ETH, leveraged 1x.\"\n",
+    "model = \"gpt-4.1-mini\"\n",
+    "\n",
+    "async with MCPServerStdio(params=params, client_session_timeout_seconds=30) as mcp_server:\n",
+    "    agent = Agent(name=\"hyperliquid_account_manager\", instructions=instructions, model=model, mcp_servers=[mcp_server])\n",
+    "    with trace(\"hyperliquid_account_manager\"):\n",
+    "        result = await Runner.run(agent, request)\n",
+    "    display(Markdown(result.final_output))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "ERROR:mcp.client.stdio:Failed to parse JSONRPC message from server\n",
+      "Traceback (most recent call last):\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/mcp/client/stdio/__init__.py\", line 155, in stdout_reader\n",
+      "    message = types.JSONRPCMessage.model_validate_json(line)\n",
+      "              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/pydantic/main.py\", line 746, in model_validate_json\n",
+      "    return cls.__pydantic_validator__.validate_json(\n",
+      "           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "pydantic_core._pydantic_core.ValidationError: 1 validation error for JSONRPCMessage\n",
+      "  Invalid JSON: expected value at line 1 column 1 [type=json_invalid, input_value='Running with account add...5B3D2bf7e80A886f213D08b', input_type=str]\n",
+      "    For further information visit https://errors.pydantic.dev/2.11/v/json_invalid\n",
+      "ERROR:mcp.client.stdio:Failed to parse JSONRPC message from server\n",
+      "Traceback (most recent call last):\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/mcp/client/stdio/__init__.py\", line 155, in stdout_reader\n",
+      "    message = types.JSONRPCMessage.model_validate_json(line)\n",
+      "              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/pydantic/main.py\", line 746, in model_validate_json\n",
+      "    return cls.__pydantic_validator__.validate_json(\n",
+      "           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "pydantic_core._pydantic_core.ValidationError: 1 validation error for JSONRPCMessage\n",
+      "  Invalid JSON: expected value at line 1 column 1 [type=json_invalid, input_value='Running with agent addre...74e1ef79DAD43E8aF528e31', input_type=str]\n",
+      "    For further information visit https://errors.pydantic.dev/2.11/v/json_invalid\n"
+     ]
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Your ETH position has been closed. If you need any further assistance or want to manage other positions, just let me know!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "instructions = \"You are able to manage a hyperliquid account for me, answer questions about the account, long/short cryptocurrency perpetuals, and close their positions for me.\"\n",
+    "request = \"Help me close my ETH position\"\n",
+    "model = \"gpt-4.1-mini\"\n",
+    "\n",
+    "async with MCPServerStdio(params=params, client_session_timeout_seconds=30) as mcp_server:\n",
+    "    agent = Agent(name=\"hyperliquid_account_manager\", instructions=instructions, model=model, mcp_servers=[mcp_server])\n",
+    "    with trace(\"hyperliquid_account_manager\"):\n",
+    "        result = await Runner.run(agent, request)\n",
+    "    display(Markdown(result.final_output))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "https://platform.openai.com/traces"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import gradio as gr\n",
+    "\n",
+    "# Define the function to handle user requests and interact with the agent\n",
+    "async def handle_request(request: str):\n",
+    "    \"\"\"\n",
+    "    Handles user requests and interacts with the agent.\n",
+    "\n",
+    "    Args:\n",
+    "        request (str): The user's request (e.g., \"Help me close my ETH position\").\n",
+    "\n",
+    "    Returns:\n",
+    "        str: The agent's response.\n",
+    "    \"\"\"\n",
+    "    instructions = \"You are able to manage a hyperliquid account for me, answer questions about the account, long/short cryptocurrency perpetuals, and close their positions for me.\"\n",
+    "    model = \"gpt-4.1-mini\"\n",
+    "\n",
+    "    async with MCPServerStdio(params=params, client_session_timeout_seconds=30) as mcp_server:\n",
+    "        agent = Agent(name=\"hyperliquid_account_manager\", instructions=instructions, model=model, mcp_servers=[mcp_server])\n",
+    "        with trace(\"hyperliquid_account_manager\"):\n",
+    "            result = await Runner.run(agent, request)\n",
+    "        return result.final_output\n",
+    "\n",
+    "# Create the Gradio interface\n",
+    "interface = gr.Interface(\n",
+    "    fn=handle_request,\n",
+    "    inputs=gr.Textbox(label=\"Request\", placeholder=\"Type your request (e.g., Help me long/short $20 of HYPE; Help me close my ETH position)\"),\n",
+    "    outputs=gr.Textbox(label=\"Response\", lines=10),\n",
+    "    title=\"Hyperliquid Account Manager\",\n",
+    "    description=\"Interact with the Hyperliquid account manager to manage your account, trade cryptocurrency perpetuals, and close positions.\"\n",
+    ")\n",
+    "\n",
+    "# Launch the interface\n",
+    "interface.launch()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# News researcher"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# !git clone https://github.com/kukapay/cryptopanic-mcp-server.git\n",
+    "# !git clone https://github.com/kukapay/crypto-indicators-mcp.git"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# available mcp server"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Error initializing MCP server: Connection closed\n"
+     ]
+    },
+    {
+     "ename": "McpError",
+     "evalue": "Connection closed",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
+      "\u001b[31mMcpError\u001b[39m                                  Traceback (most recent call last)",
+      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[9]\u001b[39m\u001b[32m, line 4\u001b[39m\n\u001b[32m      1\u001b[39m params = {\u001b[33m\"\u001b[39m\u001b[33mcommand\u001b[39m\u001b[33m\"\u001b[39m: \u001b[33m\"\u001b[39m\u001b[33mpython\u001b[39m\u001b[33m\"\u001b[39m, \u001b[33m\"\u001b[39m\u001b[33margs\u001b[39m\u001b[33m\"\u001b[39m: [\u001b[33m\"\u001b[39m\u001b[33m--u\u001b[39m\u001b[33m\"\u001b[39m, \u001b[33m\"\u001b[39m\u001b[33mcryptopanic-mcp-server\u001b[39m\u001b[33m\"\u001b[39m], \u001b[33m\"\u001b[39m\u001b[33menv\u001b[39m\u001b[33m\"\u001b[39m: {\u001b[33m\"\u001b[39m\u001b[33mCRYPTOPANIC_API_PLAN\u001b[39m\u001b[33m\"\u001b[39m: \u001b[33m\"\u001b[39m\u001b[33mdeveloper\u001b[39m\u001b[33m\"\u001b[39m, \u001b[33m\"\u001b[39m\u001b[33mCRYPTOPANIC_API_KEY\u001b[39m\u001b[33m\"\u001b[39m: os.getenv(\u001b[33m\"\u001b[39m\u001b[33mCRYPTOPANIC_API_KEY\u001b[39m\u001b[33m\"\u001b[39m)}}\n\u001b[32m      2\u001b[39m \u001b[38;5;66;03m# params = {\"command\": \"python\", \"args\": [\"-u\", \"hype_accounts_server.py\"], \"env\": {\"HYPERLIQUID_API_KEY\": os.getenv(\"HYPERLIQUID_API_KEY\"), \"HYPERLIQUID_PRIVATE_KEY\": os.getenv(\"HYPERLIQUID_PRIVATE_KEY\"), \"HYPERLIQUID_ACCOUNT_ADDRESS\": os.getenv(\"HYPERLIQUID_ACCOUNT_ADDRESS\")}}\u001b[39;00m\n\u001b[32m----> \u001b[39m\u001b[32m4\u001b[39m \u001b[38;5;28;01masync\u001b[39;00m \u001b[38;5;28;01mwith\u001b[39;00m MCPServerStdio(params=params, client_session_timeout_seconds=\u001b[32m30\u001b[39m) \u001b[38;5;28;01mas\u001b[39;00m server:\n\u001b[32m      5\u001b[39m     mcp_tools = \u001b[38;5;28;01mawait\u001b[39;00m server.list_tools()\n\u001b[32m      6\u001b[39m mcp_tools\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/agents/mcp/server.py:237\u001b[39m, in \u001b[36m_MCPServerWithClientSession.__aenter__\u001b[39m\u001b[34m(self)\u001b[39m\n\u001b[32m    236\u001b[39m \u001b[38;5;28;01masync\u001b[39;00m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34m__aenter__\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[32m--> \u001b[39m\u001b[32m237\u001b[39m     \u001b[38;5;28;01mawait\u001b[39;00m \u001b[38;5;28mself\u001b[39m.connect()\n\u001b[32m    238\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/agents/mcp/server.py:277\u001b[39m, in \u001b[36m_MCPServerWithClientSession.connect\u001b[39m\u001b[34m(self)\u001b[39m\n\u001b[32m    266\u001b[39m read, write, *_ = transport\n\u001b[32m    268\u001b[39m session = \u001b[38;5;28;01mawait\u001b[39;00m \u001b[38;5;28mself\u001b[39m.exit_stack.enter_async_context(\n\u001b[32m    269\u001b[39m     ClientSession(\n\u001b[32m    270\u001b[39m         read,\n\u001b[32m   (...)\u001b[39m\u001b[32m    275\u001b[39m     )\n\u001b[32m    276\u001b[39m )\n\u001b[32m--> \u001b[39m\u001b[32m277\u001b[39m server_result = \u001b[38;5;28;01mawait\u001b[39;00m session.initialize()\n\u001b[32m    278\u001b[39m \u001b[38;5;28mself\u001b[39m.server_initialize_result = server_result\n\u001b[32m    279\u001b[39m \u001b[38;5;28mself\u001b[39m.session = session\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/mcp/client/session.py:151\u001b[39m, in \u001b[36mClientSession.initialize\u001b[39m\u001b[34m(self)\u001b[39m\n\u001b[32m    139\u001b[39m elicitation = (\n\u001b[32m    140\u001b[39m     types.ElicitationCapability() \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m._elicitation_callback \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m _default_elicitation_callback \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[32m    141\u001b[39m )\n\u001b[32m    142\u001b[39m roots = (\n\u001b[32m    143\u001b[39m     \u001b[38;5;66;03m# TODO: Should this be based on whether we\u001b[39;00m\n\u001b[32m    144\u001b[39m     \u001b[38;5;66;03m# _will_ send notifications, or only whether\u001b[39;00m\n\u001b[32m   (...)\u001b[39m\u001b[32m    148\u001b[39m     \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[32m    149\u001b[39m )\n\u001b[32m--> \u001b[39m\u001b[32m151\u001b[39m result = \u001b[38;5;28;01mawait\u001b[39;00m \u001b[38;5;28mself\u001b[39m.send_request(\n\u001b[32m    152\u001b[39m     types.ClientRequest(\n\u001b[32m    153\u001b[39m         types.InitializeRequest(\n\u001b[32m    154\u001b[39m             params=types.InitializeRequestParams(\n\u001b[32m    155\u001b[39m                 protocolVersion=types.LATEST_PROTOCOL_VERSION,\n\u001b[32m    156\u001b[39m                 capabilities=types.ClientCapabilities(\n\u001b[32m    157\u001b[39m                     sampling=sampling,\n\u001b[32m    158\u001b[39m                     elicitation=elicitation,\n\u001b[32m    159\u001b[39m                     experimental=\u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[32m    160\u001b[39m                     roots=roots,\n\u001b[32m    161\u001b[39m                 ),\n\u001b[32m    162\u001b[39m                 clientInfo=\u001b[38;5;28mself\u001b[39m._client_info,\n\u001b[32m    163\u001b[39m             ),\n\u001b[32m    164\u001b[39m         )\n\u001b[32m    165\u001b[39m     ),\n\u001b[32m    166\u001b[39m     types.InitializeResult,\n\u001b[32m    167\u001b[39m )\n\u001b[32m    169\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m result.protocolVersion \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m SUPPORTED_PROTOCOL_VERSIONS:\n\u001b[32m    170\u001b[39m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mRuntimeError\u001b[39;00m(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mUnsupported protocol version from the server: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mresult.protocolVersion\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m\"\u001b[39m)\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/mcp/shared/session.py:286\u001b[39m, in \u001b[36mBaseSession.send_request\u001b[39m\u001b[34m(self, request, result_type, request_read_timeout_seconds, metadata, progress_callback)\u001b[39m\n\u001b[32m    274\u001b[39m     \u001b[38;5;28;01mraise\u001b[39;00m McpError(\n\u001b[32m    275\u001b[39m         ErrorData(\n\u001b[32m    276\u001b[39m             code=httpx.codes.REQUEST_TIMEOUT,\n\u001b[32m   (...)\u001b[39m\u001b[32m    282\u001b[39m         )\n\u001b[32m    283\u001b[39m     )\n\u001b[32m    285\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(response_or_error, JSONRPCError):\n\u001b[32m--> \u001b[39m\u001b[32m286\u001b[39m     \u001b[38;5;28;01mraise\u001b[39;00m McpError(response_or_error.error)\n\u001b[32m    287\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m    288\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m result_type.model_validate(response_or_error.result)\n",
+      "\u001b[31mMcpError\u001b[39m: Connection closed"
+     ]
+    }
+   ],
+   "source": [
+    "params = {\"command\": \"python\", \"args\": [\"--directory\", \"cryptopanic-mcp-server\", \"run\", \"main.py\"], \"env\": {\"CRYPTOPANIC_API_PLAN\": \"developer\", \"CRYPTOPANIC_API_KEY\": os.getenv(\"CRYPTOPANIC_API_KEY\")}}\n",
+    "async with MCPServerStdio(params=params, client_session_timeout_seconds=30) as server:\n",
+    "    mcp_tools = await server.list_tools()\n",
+    "mcp_tools"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "instructions = f\"\"\"You are a cryptocurrency researcher. You are able the tools to search for interesting cryptocurrency news,\n",
+    "look for possible trading opportunities, and help with research.\n",
+    "Based on the request, you carry out necessary research and respond with your findings.\n",
+    "Take time to make multiple searches to get a comprehensive overview, and then summarize your findings.\n",
+    "If there isn't a specific request, then just respond with long/short opportunities based on searching latest news.\n",
+    "The current datetime is {datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")}\"\"\"\n",
+    "request = \"Give me 5 long/short opportunities in crypto based on latest news.\"\n",
+    "# request = \"Give me the current news on HYPE\"\n",
+    "model = \"gpt-4.1-mini\"\n",
+    "\n",
+    "async with MCPServerStdio(params=params, client_session_timeout_seconds=30) as mcp_server:\n",
+    "    agent = Agent(name=\"crypto_mkt_researcher\", instructions=instructions, model=model, mcp_servers=[mcp_server])\n",
+    "    with trace(\"crypto_mkt_researcher\"):\n",
+    "        result = await Runner.run(agent, request)\n",
+    "    display(Markdown(result.final_output))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# self developed mcp server"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'9b68b6ec514f537c2a0e90eb9efd34b85685ee0f'"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "os.getenv(\"CRYPTOPANIC_API_KEY\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Failed to parse JSONRPC message from server\n",
+      "Traceback (most recent call last):\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/mcp/client/stdio/__init__.py\", line 155, in stdout_reader\n",
+      "    message = types.JSONRPCMessage.model_validate_json(line)\n",
+      "              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/pydantic/main.py\", line 746, in model_validate_json\n",
+      "    return cls.__pydantic_validator__.validate_json(\n",
+      "           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "pydantic_core._pydantic_core.ValidationError: 1 validation error for JSONRPCMessage\n",
+      "  Invalid JSON: expected value at line 1 column 1 [type=json_invalid, input_value='https://cryptopanic.com/api/developer/v2/posts/', input_type=str]\n",
+      "    For further information visit https://errors.pydantic.dev/2.11/v/json_invalid\n"
+     ]
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Here are 5 long/short opportunities in crypto based on the latest news with news date/time:\n",
+       "\n",
+       "1. Long Bitcoin (BTC)\n",
+       "   - News: Bitcoin bounces back above $113,000\n",
+       "   - Insight: BTC showed resilience and bounced back above the $113,000 level.\n",
+       "   - Date/Time: 2025-10-12 15:31:02 UTC\n",
+       "\n",
+       "2. Long Ethereum (ETH)\n",
+       "   - News: Ethereum surpasses $4,000 with a 5.49% increase in 24 hours, significant profits for whale investors.\n",
+       "   - Insight: ETH is showing strong momentum and institutional buying after dip, indicating potential upside.\n",
+       "   - Date/Time: 2025-10-12 14:56:39 UTC / 15:03:46 UTC\n",
+       "\n",
+       "3. Long Binance Coin (BNB)\n",
+       "   - News: BNB surpasses $1,270 with a 12.60% increase in 24 hours.\n",
+       "   - Insight: BNB demonstrates strong bullish momentum with a sharp price increase.\n",
+       "   - Date/Time: 2025-10-12 14:55:41 UTC\n",
+       "\n",
+       "4. Short XRP\n",
+       "   - News: XRP slides below $2.40 amidst whale selling and ETF delays; rebound likely only after Bitcoin stabilizes.\n",
+       "   - Insight: XRP currently under downward pressure with uncertain short-term recovery.\n",
+       "   - Date/Time: 2025-10-12 14:44:19 UTC\n",
+       "\n",
+       "5. Short Ethereum (ETH) Potential Liquidations\n",
+       "   - News: If ETH surpasses $4,000, significant short liquidations of $221 million could trigger high volatility.\n",
+       "   - Insight: Watch for potential sharp corrections or volatility spikes post-breakout.\n",
+       "   - Date/Time: 2025-10-12 14:53:34 UTC\n",
+       "\n",
+       "Summary:\n",
+       "- Suggested longs: BTC, ETH, BNB based on strong price recoveries and institutional interest.\n",
+       "- Suggested shorts: XRP due to persistent selling pressure and short-term uncertainty; cautious short or hedge on ETH due to potential liquidation volatility.\n",
+       "\n",
+       "Let me know if you want deeper analysis or additional opportunities!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "params = {\"command\": \"python\", \"args\": [\"-u\", \"cryptopanic_news_server.py\"], \"env\": {\"CRYPTOPANIC_API_PLAN\": \"developer\", \"CRYPTOPANIC_API_KEY\": os.getenv(\"CRYPTOPANIC_API_KEY\")}}\n",
+    "async with MCPServerStdio(params=params, client_session_timeout_seconds=30) as server:\n",
+    "    mcp_tools = await server.list_tools()\n",
+    "\n",
+    "instructions = f\"\"\"You are a cryptocurrency researcher. You are able the tools to search for interesting cryptocurrency news,\n",
+    "look for possible trading opportunities, and help with research.\n",
+    "Based on the request, you carry out necessary research and respond with your findings.\n",
+    "Take time to make multiple searches to get a comprehensive overview, and then summarize your findings.\n",
+    "If there isn't a specific request, then just respond with long/short opportunities based on searching latest news.\n",
+    "The current datetime is {datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")}\"\"\"\n",
+    "request = \"Give me 5 long/short opportunities in crypto based on latest news. and the news date / time\"\n",
+    "# request = \"Give me the current news on HYPE and XRP\"\n",
+    "model = \"gpt-4.1-mini\"\n",
+    "\n",
+    "async with MCPServerStdio(params=params, client_session_timeout_seconds=30) as mcp_server:\n",
+    "    agent = Agent(name=\"crypto_mkt_researcher_local\", instructions=instructions, model=model, mcp_servers=[mcp_server])\n",
+    "    with trace(\"crypto_mkt_researcher_local\"):\n",
+    "        result = await Runner.run(agent, request)\n",
+    "    display(Markdown(result.final_output))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Technical Analyst"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Error initializing MCP server: Connection closed\n"
+     ]
+    },
+    {
+     "ename": "McpError",
+     "evalue": "Connection closed",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
+      "\u001b[31mMcpError\u001b[39m                                  Traceback (most recent call last)",
+      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[18]\u001b[39m\u001b[32m, line 4\u001b[39m\n\u001b[32m      1\u001b[39m \u001b[38;5;66;03m# Now let's use our researcher server as an MCP server\u001b[39;00m\n\u001b[32m      3\u001b[39m params = {\u001b[33m\"\u001b[39m\u001b[33mcommand\u001b[39m\u001b[33m\"\u001b[39m: \u001b[33m\"\u001b[39m\u001b[33mnode\u001b[39m\u001b[33m\"\u001b[39m, \u001b[33m\"\u001b[39m\u001b[33margs\u001b[39m\u001b[33m\"\u001b[39m: [\u001b[33m\"\u001b[39m\u001b[33mcrypto-indicators-mcp/index.js\u001b[39m\u001b[33m\"\u001b[39m], \u001b[33m\"\u001b[39m\u001b[33menv\u001b[39m\u001b[33m\"\u001b[39m: {\u001b[33m\"\u001b[39m\u001b[33mEXCHANGE_NAME\u001b[39m\u001b[33m\"\u001b[39m: \u001b[33m\"\u001b[39m\u001b[33mbinance\u001b[39m\u001b[33m\"\u001b[39m}}\n\u001b[32m----> \u001b[39m\u001b[32m4\u001b[39m \u001b[38;5;28;01masync\u001b[39;00m \u001b[38;5;28;01mwith\u001b[39;00m MCPServerStdio(params=params, client_session_timeout_seconds=\u001b[32m30\u001b[39m) \u001b[38;5;28;01mas\u001b[39;00m server:\n\u001b[32m      5\u001b[39m     mcp_tools = \u001b[38;5;28;01mawait\u001b[39;00m server.list_tools()\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/agents/mcp/server.py:237\u001b[39m, in \u001b[36m_MCPServerWithClientSession.__aenter__\u001b[39m\u001b[34m(self)\u001b[39m\n\u001b[32m    236\u001b[39m \u001b[38;5;28;01masync\u001b[39;00m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34m__aenter__\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[32m--> \u001b[39m\u001b[32m237\u001b[39m     \u001b[38;5;28;01mawait\u001b[39;00m \u001b[38;5;28mself\u001b[39m.connect()\n\u001b[32m    238\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/agents/mcp/server.py:277\u001b[39m, in \u001b[36m_MCPServerWithClientSession.connect\u001b[39m\u001b[34m(self)\u001b[39m\n\u001b[32m    266\u001b[39m read, write, *_ = transport\n\u001b[32m    268\u001b[39m session = \u001b[38;5;28;01mawait\u001b[39;00m \u001b[38;5;28mself\u001b[39m.exit_stack.enter_async_context(\n\u001b[32m    269\u001b[39m     ClientSession(\n\u001b[32m    270\u001b[39m         read,\n\u001b[32m   (...)\u001b[39m\u001b[32m    275\u001b[39m     )\n\u001b[32m    276\u001b[39m )\n\u001b[32m--> \u001b[39m\u001b[32m277\u001b[39m server_result = \u001b[38;5;28;01mawait\u001b[39;00m session.initialize()\n\u001b[32m    278\u001b[39m \u001b[38;5;28mself\u001b[39m.server_initialize_result = server_result\n\u001b[32m    279\u001b[39m \u001b[38;5;28mself\u001b[39m.session = session\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/mcp/client/session.py:151\u001b[39m, in \u001b[36mClientSession.initialize\u001b[39m\u001b[34m(self)\u001b[39m\n\u001b[32m    139\u001b[39m elicitation = (\n\u001b[32m    140\u001b[39m     types.ElicitationCapability() \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m._elicitation_callback \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m _default_elicitation_callback \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[32m    141\u001b[39m )\n\u001b[32m    142\u001b[39m roots = (\n\u001b[32m    143\u001b[39m     \u001b[38;5;66;03m# TODO: Should this be based on whether we\u001b[39;00m\n\u001b[32m    144\u001b[39m     \u001b[38;5;66;03m# _will_ send notifications, or only whether\u001b[39;00m\n\u001b[32m   (...)\u001b[39m\u001b[32m    148\u001b[39m     \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[32m    149\u001b[39m )\n\u001b[32m--> \u001b[39m\u001b[32m151\u001b[39m result = \u001b[38;5;28;01mawait\u001b[39;00m \u001b[38;5;28mself\u001b[39m.send_request(\n\u001b[32m    152\u001b[39m     types.ClientRequest(\n\u001b[32m    153\u001b[39m         types.InitializeRequest(\n\u001b[32m    154\u001b[39m             params=types.InitializeRequestParams(\n\u001b[32m    155\u001b[39m                 protocolVersion=types.LATEST_PROTOCOL_VERSION,\n\u001b[32m    156\u001b[39m                 capabilities=types.ClientCapabilities(\n\u001b[32m    157\u001b[39m                     sampling=sampling,\n\u001b[32m    158\u001b[39m                     elicitation=elicitation,\n\u001b[32m    159\u001b[39m                     experimental=\u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[32m    160\u001b[39m                     roots=roots,\n\u001b[32m    161\u001b[39m                 ),\n\u001b[32m    162\u001b[39m                 clientInfo=\u001b[38;5;28mself\u001b[39m._client_info,\n\u001b[32m    163\u001b[39m             ),\n\u001b[32m    164\u001b[39m         )\n\u001b[32m    165\u001b[39m     ),\n\u001b[32m    166\u001b[39m     types.InitializeResult,\n\u001b[32m    167\u001b[39m )\n\u001b[32m    169\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m result.protocolVersion \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m SUPPORTED_PROTOCOL_VERSIONS:\n\u001b[32m    170\u001b[39m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mRuntimeError\u001b[39;00m(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mUnsupported protocol version from the server: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mresult.protocolVersion\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m\"\u001b[39m)\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/mcp/shared/session.py:286\u001b[39m, in \u001b[36mBaseSession.send_request\u001b[39m\u001b[34m(self, request, result_type, request_read_timeout_seconds, metadata, progress_callback)\u001b[39m\n\u001b[32m    274\u001b[39m     \u001b[38;5;28;01mraise\u001b[39;00m McpError(\n\u001b[32m    275\u001b[39m         ErrorData(\n\u001b[32m    276\u001b[39m             code=httpx.codes.REQUEST_TIMEOUT,\n\u001b[32m   (...)\u001b[39m\u001b[32m    282\u001b[39m         )\n\u001b[32m    283\u001b[39m     )\n\u001b[32m    285\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(response_or_error, JSONRPCError):\n\u001b[32m--> \u001b[39m\u001b[32m286\u001b[39m     \u001b[38;5;28;01mraise\u001b[39;00m McpError(response_or_error.error)\n\u001b[32m    287\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m    288\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m result_type.model_validate(response_or_error.result)\n",
+      "\u001b[31mMcpError\u001b[39m: Connection closed"
+     ]
+    }
+   ],
+   "source": [
+    "# Now let's use our researcher server as an MCP server\n",
+    "\n",
+    "params = {\"command\": \"node\", \"args\": [\"crypto-indicators-mcp/index.js\"], \"env\": {\"EXCHANGE_NAME\": \"binance\"}}\n",
+    "async with MCPServerStdio(params=params, client_session_timeout_seconds=30) as server:\n",
+    "    mcp_tools = await server.list_tools()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for tool in mcp_tools:\n",
+    "    if 'stochastic' in tool.name.lower():\n",
+    "        print(tool.name, tool.description)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "instructions = \"\"\"You are a cryptocurrency perpetuals trading researcher. You have the tools for trend/momentum/volatility/volume technical indicators and strategies.\n",
+    "Default analysis interval is 1h, and default lookback period is 36. \n",
+    "Default indicators/strategies you have are:\n",
+    "    - EMA (20, 200)\n",
+    "    - MACD (12, 26, 9)\n",
+    "    - stochastic RSI (14, 14, 3, 3)\n",
+    "    - Accumulation/Distribution (ADL)\n",
+    "    - Volume\n",
+    "Based on the indicators, Look for possible long/short opportunities, and come up with a strategy.\n",
+    "The current datetime is {datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")}\"\"\"\n",
+    "request = \"Give me the current indicator analysis and strategies for 3 cryptocurrencies.\"\n",
+    "model = \"gpt-4.1-mini\"\n",
+    "\n",
+    "async with MCPServerStdio(params=params, client_session_timeout_seconds=30) as mcp_server:\n",
+    "    agent = Agent(name=\"crypto_technical_researcher\", instructions=instructions, model=model, mcp_servers=[mcp_server])\n",
+    "    with trace(\"crypto_technical_researcher\"):\n",
+    "        result = await Runner.run(agent, request)\n",
+    "    display(Markdown(result.final_output))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create own techinal indicator mcp server"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/markdown": [
+       "Here's the current indicator analysis and strategy suggestions for the three cryptocurrencies BTC, ETH, and HYPE on the 1-hour timeframe using the last 36 periods:\n",
+       "\n",
+       "1. BTC:\n",
+       "- Price is above both EMA 20 (114468) and EMA 200 (112207), indicating medium-term uptrend.\n",
+       "- MACD histogram is negative (-209) with MACD line below signal line, showing weak bearish momentum.\n",
+       "- Stoch RSI is oversold (around 10), suggesting potential upcoming bullish reversal.\n",
+       "- ADX is strong at about 36, indicating a strong trend, with +DI above -DI showing bullish trend dominance.\n",
+       "- Bollinger Bands %b is low (~0.15), near the lower band, indicating possible oversold conditions.\n",
+       "- MFI is moderate (~42), not showing strong volume pressure.\n",
+       "\n",
+       "Strategy: Watch for bullish reversal signals since price is in uptrend but currently with weak bearish momentum and oversold oscillators. A potential long entry could be planned on stochastic RSI turning up from oversold, confirmed by MACD histogram turning positive and increasing volume/ADL. Stops below recent lows advised.\n",
+       "\n",
+       "2. ETH:\n",
+       "- Price is above EMA 20 (4109) and EMA 200 (3876), indicating medium-term bullish trend.\n",
+       "- MACD histogram negative (-16) but MACD line is below the signal line, showing some weakening momentum.\n",
+       "- Stoch RSI is low (~18), near oversold territory, potential for reversal.\n",
+       "- ADX strong (~38) with +DI above -DI, confirming trend strength biased bullish.\n",
+       "- Bollinger Bands %b is moderate (~0.34), price neither extreme.\n",
+       "- MFI moderate (~52), no strong volume bias.\n",
+       "\n",
+       "Strategy: Similar to BTC, ETH is in an overall uptrend with weakening momentum and oversold stochastic RSI. Look for buying opportunities once stoch RSI starts rising, ideally accompanied by MACD histogram crossover to positive and volume rise. Confirm trend strength via ADX and watch volume for validation.\n",
+       "\n",
+       "3. HYPE:\n",
+       "- Price above EMA 20 (40.24) and EMA 200 (38.60), indicating bullish trend.\n",
+       "- MACD histogram slightly negative (-0.11) with MACD line below signal line, showing momentary weak bearish pressure.\n",
+       "- Stoch RSI ~28, not deeply oversold but low.\n",
+       "- ADX weak (~18), suggesting weak trend strength.\n",
+       "- Bollinger Bands %b at 0.44, mid to upper band.\n",
+       "- MFI moderate (~52), neutral volume.\n",
+       "\n",
+       "Strategy: HYPE is in a bullish phase but with weak trend strength and mild bearish momentum. This coin may lack strong directional movement currently. Wait for MACD to cross above signal line with rising momentum and stochastic RSI to turn upward to consider longs. Use cautious entry and tight stops due to low ADX.\n",
+       "\n",
+       "Summary Strategy for All:\n",
+       "- All three coins are in a medium-term uptrend (price above EMAs).\n",
+       "- Current momentum is weakening with MACD histograms negative.\n",
+       "- Stochastic RSI in BTC and ETH are oversold, indicating potential for bullish reversal soon.\n",
+       "- ADX is strong in BTC and ETH, validating strong trending environment, but weak in HYPE.\n",
+       "- Monitor for bullish confirmation signals in momentum indicators and volume (MACD crossover, stoch RSI turning up, ADL and volume increasing) before entering longs.\n",
+       "- Place stops below recent swing lows to manage risk.\n",
+       "\n",
+       "Would you like me to run any specific strategy backtests or detailed setups on these coins?"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "params = {\"command\": \"python\", \"args\": [\"-u\", \"hl_indicators_server.py\"]}\n",
+    "async with MCPServerStdio(params=params, client_session_timeout_seconds=30) as server:\n",
+    "    mcp_tools = await server.list_tools()\n",
+    "\n",
+    "instructions = \"\"\"You are a cryptocurrency perpetuals trading researcher. You have the tools for trend/momentum/volatility/volume technical indicators and strategies.\n",
+    "Default analysis interval is 1h, and default lookback period is 36. \n",
+    "Default indicators/strategies you have are:\n",
+    "    - EMA (20, 200)\n",
+    "    - MACD (12, 26, 9)\n",
+    "    - stochastic RSI (14, 14, 3, 3)\n",
+    "    - Accumulation/Distribution (ADL)\n",
+    "    - Volume\n",
+    "Based on the indicators, Look for possible long/short opportunities, and come up with a strategy.\n",
+    "The current datetime is {datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")}\"\"\"\n",
+    "request = \"Give me the current indicator analysis and strategies for 3 cryptocurrencies.\"\n",
+    "model = \"gpt-4.1-mini\"\n",
+    "\n",
+    "async with MCPServerStdio(params=params, client_session_timeout_seconds=30) as mcp_server:\n",
+    "    agent = Agent(name=\"crypto_technical_researcher_local\", instructions=instructions, model=model, mcp_servers=[mcp_server])\n",
+    "    with trace(\"crypto_technical_researcher_local\"):\n",
+    "        result = await Runner.run(agent, request)\n",
+    "    display(Markdown(result.final_output))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Create interface"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 23,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import os\n",
+    "from datetime import datetime\n",
+    "import gradio as gr\n",
+    "from dotenv import load_dotenv\n",
+    "from agents import Agent, Runner, trace, Tool\n",
+    "from agents.mcp import MCPServerStdio\n",
+    "from IPython.display import display, Markdown\n",
+    "\n",
+    "load_dotenv(override=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# hyperliquid_trader_mcp_server_params = [{\"command\": \"uv\", \"args\": [\"run\", \"hype_accounts_server.py\"]}]\n",
+    "# crypto_news_mcp_server_params = [{\"command\": \"uv\", \"args\": [\"run\", \"cryptopanic_news_server.py\"]}]\n",
+    "# technical_analyst_mcp_server_params = [{\"command\": \"node\", \"args\": [\"crypto-indicators-mcp/index.js\"], \"env\": {\"EXCHANGE_NAME\": \"binance\"}}]\n",
+    "\n",
+    "hyperliquid_trader_mcp_server_params = [{\"command\": \"python3\", \"args\": [\"-u\", \"hype_accounts_server.py\"], \"env\": {\"HYPERLIQUID_API_KEY\": os.getenv(\"HYPERLIQUID_API_KEY\"), \"HYPERLIQUID_PRIVATE_KEY\": os.getenv(\"HYPERLIQUID_PRIVATE_KEY\"), \"HYPERLIQUID_ACCOUNT_ADDRESS\": os.getenv(\"HYPERLIQUID_ACCOUNT_ADDRESS\")}}]\n",
+    "crypto_news_mcp_server_params = [{\"command\": \"python3\", \"args\": [\"-u\", \"cryptopanic_news_server.py\"], \"env\": {\"CRYPTOPANIC_API_PLAN\": \"developer\", \"CRYPTOPANIC_API_KEY\": os.getenv(\"CRYPTOPANIC_API_KEY\")}}]\n",
+    "technical_analyst_mcp_server_params = [{\"command\": \"python3\", \"args\": [\"-u\", \"hl_indicators_server.py\"]}]\n",
+    "\n",
+    "hyperliquid_trader_mcp_servers = [MCPServerStdio(params, client_session_timeout_seconds=30) for params in hyperliquid_trader_mcp_server_params]\n",
+    "crypto_news_mcp_servers = [MCPServerStdio(params, client_session_timeout_seconds=30) for params in crypto_news_mcp_server_params]\n",
+    "technical_analyst_mcp_servers = [MCPServerStdio(params, client_session_timeout_seconds=30) for params in technical_analyst_mcp_server_params]\n",
+    "\n",
+    "mcp_servers = hyperliquid_trader_mcp_servers + crypto_news_mcp_servers + technical_analyst_mcp_servers"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# putting agents together\n",
+    "async def get_crypto_news_researcher(mcp_servers) -> Agent:\n",
+    "    instructions = f\"\"\"You are a cryptocurrency researcher. You have the tools to search for interesting cryptocurrency news,\n",
+    "    look for possible trading opportunities, and help with research.\n",
+    "    Default None if there are no specific cryptocurrency news or opportunities in the user request.\n",
+    "    Otherwise, indicate the symbol of specific cryptocurrency if there are specific requests. eg. 'HYPE', 'BTC', 'ETH', 'XRP', etc.\n",
+    "    Based on the request, you carry out necessary research and respond with your findings.\n",
+    "    Take time to make multiple searches to get a comprehensive overview, and then summarize your findings.\n",
+    "    If there isn't a specific request, then just respond with long/short opportunities based on searching latest news.\n",
+    "    The current datetime is {datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")}\n",
+    "    \"\"\"\n",
+    "    researcher = Agent(\n",
+    "        name=\"Crypto news researcher\",\n",
+    "        instructions=instructions,\n",
+    "        model=\"gpt-4.1-mini\",\n",
+    "        mcp_servers=mcp_servers,\n",
+    "    )\n",
+    "    return researcher\n",
+    "\n",
+    "async def get_crypto_news_researcher_tool(mcp_servers) -> Tool:\n",
+    "    researcher = await get_crypto_news_researcher(mcp_servers)\n",
+    "    return researcher.as_tool(\n",
+    "            tool_name=\"crypto_news_researcher\",\n",
+    "            tool_description=\"This tool researches online for cryptocurrency news and opportunities, \\\n",
+    "                either based on your specific request to look into a certain cryptocurrency, \\\n",
+    "                or generally for notable cryptocurrency news and opportunities. \\\n",
+    "                Describe what kind of research you're looking for.\"\n",
+    "        )\n",
+    "\n",
+    "async def get_technical_analyst_researcher(mcp_servers) -> Agent:\n",
+    "    instructions = \"\"\"You are a cryptocurrency perpetuals technical trading researcher. You have the tools for trend/momentum/volatility/volume technical indicators and strategies.\n",
+    "    Default analysis interval is 1h, and default lookback period is 36. \n",
+    "    Default indicators/strategies you have are:\n",
+    "        - EMA (20, 200)\n",
+    "        - MACD (12, 26, 9)\n",
+    "        - stochastic RSI (14, 14, 3, 3)\n",
+    "        - Accumulation/Distribution (ADL)\n",
+    "        - Volume\n",
+    "    Based on the indicators, Look for possible long/short opportunities, and come up with a strategy.\n",
+    "    The current datetime is {datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")}\"\"\"\n",
+    "    researcher = Agent(\n",
+    "        name=\"Crypto technical researcher\",\n",
+    "        instructions=instructions,\n",
+    "        model=\"gpt-4.1-mini\",\n",
+    "        mcp_servers=mcp_servers,\n",
+    "    )\n",
+    "    return researcher\n",
+    "\n",
+    "async def get_technical_analyst_researcher_tool(mcp_servers) -> Tool:\n",
+    "    researcher = await get_crypto_news_researcher(mcp_servers)\n",
+    "    return researcher.as_tool(\n",
+    "            tool_name=\"crypto_technical_researcher\",\n",
+    "            tool_description=\"This tool researches technical indicators for trading opportunities, \\\n",
+    "                either based on your specific request to look into a certain cryptocurrency or indicator, \\\n",
+    "                or generally for notable cryptocurrency news and technical indicators EMA, MACD, stochastic RSI, Accumulation/Distribution (ADL), Volume. \\\n",
+    "                Describe what cryptocurrency and indicators you're looking for.\"\n",
+    "        )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# import importlib\n",
+    "# import cryptopanic_news_server\n",
+    "# importlib.reload(cryptopanic_news_server)\n",
+    "\n",
+    "# await cryptopanic_news_server.get_crypto_news(None)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO:httpx:HTTP Request: POST https://api.openai.com/v1/responses \"HTTP/1.1 200 OK\"\n",
+      "INFO:httpx:HTTP Request: POST https://api.openai.com/v1/responses \"HTTP/1.1 200 OK\"\n",
+      "INFO:httpx:HTTP Request: POST https://api.openai.com/v1/responses \"HTTP/1.1 200 OK\"\n"
+     ]
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "Current prices:\n",
+       "- BTC: $114,134 (1h close)\n",
+       "- ETH: $4,118.3 (1h close)\n",
+       "- XRP: $2.5766 (1h close)\n",
+       "\n",
+       "Analysis and strategies based on trend, momentum, volume, and volatility indicators (1h interval, lookback ~36):\n",
+       "\n",
+       "BTC:\n",
+       "- Price is above both EMA20 (~$114,453) and EMA200 (~$112,205), indicating an uptrend.\n",
+       "- MACD histogram is negative (-219.56) and MACD line is below the signal line, suggesting bearish momentum short term.\n",
+       "- Stoch RSI is very low (~5.3), indicating oversold conditions and potential for rebound.\n",
+       "- ADX is healthy (~35.9) showing a strong trend, +DI > -DI confirming bullish.\n",
+       "- Bollinger Bands %b is near the lower band (0.075), suggesting price might be near a support zone.\n",
+       "- Volume had a recent spike but current volume is moderate.\n",
+       "\n",
+       "Strategy: Look for a long entry on signs of momentum turning up (MACD histogram moving positive, Stoch RSI crossing upwards), targeting a continuation of the uptrend supported by strong ADX. Use stop loss just below recent lows or lower Bollinger Band.\n",
+       "\n",
+       "ETH:\n",
+       "- Price is above EMA20 (~$4,108) and EMA200 (~$3,876), confirming uptrend.\n",
+       "- MACD histogram is negative but closing to zero (-16.8).\n",
+       "- Stoch RSI is low (~15.4), suggesting possible oversold bounce.\n",
+       "- ADX is ~38.3, indicating a strong trend, with +DI > -DI.\n",
+       "- Bollinger Bands %b at ~0.29, price is above lower band but not overextended.\n",
+       "- Volume steady with some spikes.\n",
+       "\n",
+       "Strategy: Similar to BTC, consider a long position on signs of momentum improvement. Use a stop loss near the lower Bollinger Band or recent swing low to manage risk.\n",
+       "\n",
+       "XRP:\n",
+       "- Price above EMA20 (~2.56) and EMA200 (~2.41), showing bullish trend.\n",
+       "- MACD histogram slightly negative (-0.008), near neutral momentum.\n",
+       "- Stoch RSI is low (~14.3), indicating possible oversold bounce.\n",
+       "- ADX is ~37.2 with +DI > -DI, strong trend present.\n",
+       "- Bollinger Bands %b around 0.55, price near middle of range.\n",
+       "- Volume normal with occasional spikes.\n",
+       "\n",
+       "Strategy: Potential long opportunity on momentum improvements with Stoch RSI crossing up from oversold. Take profits near upper Bollinger Band and use stop losses around EMA20 or lower Bollinger Band.\n",
+       "\n",
+       "Summary:\n",
+       "All three coins show strong uptrends with correction or momentum pause signs. Best approach is to trade longs on potential momentum bounce in oversold zones with proper stops. Avoid shorts as overall trend remains bullish.\n",
+       "\n",
+       "Let me know if you want detailed entry/exit signals or additional indicator analysis."
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:mcp.os.posix.utilities:Process group termination failed for PID 11534: [Errno 3] No such process, falling back to simple terminate\n"
+     ]
+    }
+   ],
+   "source": [
+    "technical_research_question = \"What's the latest trading indicators for HYPE and XRP? Recommend some trading strategies.\"\n",
+    "technical_research_question = \"What's the current prices for BTC, ETH, and XRP? Recommend some trading strategies.\"\n",
+    "\n",
+    "for server in technical_analyst_mcp_servers:\n",
+    "    await server.connect()\n",
+    "technical_analyst = await get_technical_analyst_researcher(technical_analyst_mcp_servers)\n",
+    "with trace(\"Technical analyst\"):\n",
+    "    result = await Runner.run(technical_analyst, technical_research_question, max_turns=30)\n",
+    "display(Markdown(result.final_output))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:mcp.server.fastmcp.tools.tool_manager:Tool already exists: long_perps_mkt_price\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running with account address: 0xa0F8a0f880A49c8e15B3D2bf7e80A886f213D08b\n",
+      "Running with agent address: 0x61755bcFd93a7E5dF74e1ef79DAD43E8aF528e31\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO:websocket:Websocket connected\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'cash_balance': 64.902113,\n",
+       " 'holdings': 'No holdings',\n",
+       " 'profit_and_loss': 4.902113}"
+      ]
+     },
+     "execution_count": 35,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import importlib\n",
+    "import hype_accounts_server\n",
+    "importlib.reload(hype_accounts_server)\n",
+    "\n",
+    "account_details = await hype_accounts_server.get_account_details()\n",
+    "account_details"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:mcp.server.fastmcp.tools.tool_manager:Tool already exists: long_perps_mkt_price\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running with account address: 0xa0F8a0f880A49c8e15B3D2bf7e80A886f213D08b\n",
+      "Running with agent address: 0x61755bcFd93a7E5dF74e1ef79DAD43E8aF528e31\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO:websocket:Websocket connected\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Using MCP Servers to read resources\n",
+    "import importlib\n",
+    "import hype_accounts_server\n",
+    "importlib.reload(hype_accounts_server)\n",
+    "\n",
+    "account_details = await hype_accounts_server.get_account_details()\n",
+    "\n",
+    "instructions = f\"\"\"\n",
+    "    You are a cryptocurrency perpetuals trader. \n",
+    "    Your current holdings and balance is:\n",
+    "    {account_details}\n",
+    "    You have the tools to perform a search for relevant cryptocurrency news.\n",
+    "    You have tools to check cryptocurrency technical indicators and prices.\n",
+    "    You have tools to check your current holdings and balance.\n",
+    "    You have tools to long and short cryptocurrency perpetuals.\n",
+    "    Please make use of these tools to manage your portfolio. Carry out trades as you see fit; do not wait for instructions or ask for confirmation.\n",
+    "\"\"\"\n",
+    "\n",
+    "prompt = f\"\"\"\n",
+    "Use your tools to make decisions about your portfolio.\n",
+    "Step 1: look into your current holdings and balance.\n",
+    "Step 2: look into the latest cryptocurrency news and relevant long/short opportunities. select 3-5 cryptocurrencies to focus on.\n",
+    "Step 3: look into the current price, and technical indicators for these cryptocurrencies. Recommend a few trading strategies.\n",
+    "Step 4: make trades to long/short these cryptocurrencies based on your research and strategies.\n",
+    "You do not have to make any trades if there are no good opportunities.\n",
+    "Respond with your detailed research and actions.\n",
+    "The current datetime is {datetime.now().strftime(\"%Y-%m-%d %H:%M\")}\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO:httpx:HTTP Request: POST https://api.openai.com/v1/responses \"HTTP/1.1 200 OK\"\n",
+      "ERROR:mcp.client.stdio:Failed to parse JSONRPC message from server\n",
+      "Traceback (most recent call last):\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/mcp/client/stdio/__init__.py\", line 155, in stdout_reader\n",
+      "    message = types.JSONRPCMessage.model_validate_json(line)\n",
+      "              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/pydantic/main.py\", line 746, in model_validate_json\n",
+      "    return cls.__pydantic_validator__.validate_json(\n",
+      "           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "pydantic_core._pydantic_core.ValidationError: 1 validation error for JSONRPCMessage\n",
+      "  Invalid JSON: expected value at line 1 column 1 [type=json_invalid, input_value='Running with account add...5B3D2bf7e80A886f213D08b', input_type=str]\n",
+      "    For further information visit https://errors.pydantic.dev/2.11/v/json_invalid\n",
+      "ERROR:mcp.client.stdio:Failed to parse JSONRPC message from server\n",
+      "Traceback (most recent call last):\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/mcp/client/stdio/__init__.py\", line 155, in stdout_reader\n",
+      "    message = types.JSONRPCMessage.model_validate_json(line)\n",
+      "              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/pydantic/main.py\", line 746, in model_validate_json\n",
+      "    return cls.__pydantic_validator__.validate_json(\n",
+      "           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "pydantic_core._pydantic_core.ValidationError: 1 validation error for JSONRPCMessage\n",
+      "  Invalid JSON: expected value at line 1 column 1 [type=json_invalid, input_value='Running with agent addre...74e1ef79DAD43E8aF528e31', input_type=str]\n",
+      "    For further information visit https://errors.pydantic.dev/2.11/v/json_invalid\n",
+      "INFO:httpx:HTTP Request: POST https://api.openai.com/v1/responses \"HTTP/1.1 200 OK\"\n",
+      "ERROR:mcp.client.stdio:Failed to parse JSONRPC message from server\n",
+      "Traceback (most recent call last):\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/mcp/client/stdio/__init__.py\", line 155, in stdout_reader\n",
+      "    message = types.JSONRPCMessage.model_validate_json(line)\n",
+      "              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/pydantic/main.py\", line 746, in model_validate_json\n",
+      "    return cls.__pydantic_validator__.validate_json(\n",
+      "           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "pydantic_core._pydantic_core.ValidationError: 1 validation error for JSONRPCMessage\n",
+      "  Invalid JSON: expected value at line 1 column 1 [type=json_invalid, input_value='https://cryptopanic.com/api/developer/v2/posts/', input_type=str]\n",
+      "    For further information visit https://errors.pydantic.dev/2.11/v/json_invalid\n",
+      "INFO:httpx:HTTP Request: POST https://api.openai.com/v1/responses \"HTTP/1.1 200 OK\"\n",
+      "INFO:httpx:HTTP Request: POST https://api.openai.com/v1/responses \"HTTP/1.1 200 OK\"\n",
+      "INFO:httpx:HTTP Request: POST https://api.openai.com/v1/responses \"HTTP/1.1 200 OK\"\n",
+      "INFO:httpx:HTTP Request: POST https://api.openai.com/v1/responses \"HTTP/1.1 200 OK\"\n",
+      "INFO:httpx:HTTP Request: POST https://api.openai.com/v1/responses \"HTTP/1.1 200 OK\"\n",
+      "INFO:httpx:HTTP Request: POST https://api.openai.com/v1/responses \"HTTP/1.1 200 OK\"\n",
+      "INFO:httpx:HTTP Request: POST https://api.openai.com/v1/responses \"HTTP/1.1 200 OK\"\n",
+      "INFO:httpx:HTTP Request: POST https://api.openai.com/v1/responses \"HTTP/1.1 200 OK\"\n",
+      "INFO:httpx:HTTP Request: POST https://api.openai.com/v1/responses \"HTTP/1.1 200 OK\"\n",
+      "ERROR:mcp.client.stdio:Failed to parse JSONRPC message from server\n",
+      "Traceback (most recent call last):\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/mcp/client/stdio/__init__.py\", line 155, in stdout_reader\n",
+      "    message = types.JSONRPCMessage.model_validate_json(line)\n",
+      "              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/pydantic/main.py\", line 746, in model_validate_json\n",
+      "    return cls.__pydantic_validator__.validate_json(\n",
+      "           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "pydantic_core._pydantic_core.ValidationError: 1 validation error for JSONRPCMessage\n",
+      "  Invalid JSON: expected value at line 1 column 1 [type=json_invalid, input_value='Running with account add...5B3D2bf7e80A886f213D08b', input_type=str]\n",
+      "    For further information visit https://errors.pydantic.dev/2.11/v/json_invalid\n",
+      "ERROR:mcp.client.stdio:Failed to parse JSONRPC message from server\n",
+      "Traceback (most recent call last):\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/mcp/client/stdio/__init__.py\", line 155, in stdout_reader\n",
+      "    message = types.JSONRPCMessage.model_validate_json(line)\n",
+      "              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/pydantic/main.py\", line 746, in model_validate_json\n",
+      "    return cls.__pydantic_validator__.validate_json(\n",
+      "           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "pydantic_core._pydantic_core.ValidationError: 1 validation error for JSONRPCMessage\n",
+      "  Invalid JSON: expected value at line 1 column 1 [type=json_invalid, input_value='Running with agent addre...74e1ef79DAD43E8aF528e31', input_type=str]\n",
+      "    For further information visit https://errors.pydantic.dev/2.11/v/json_invalid\n",
+      "ERROR:mcp.client.stdio:Failed to parse JSONRPC message from server\n",
+      "Traceback (most recent call last):\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/mcp/client/stdio/__init__.py\", line 155, in stdout_reader\n",
+      "    message = types.JSONRPCMessage.model_validate_json(line)\n",
+      "              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/pydantic/main.py\", line 746, in model_validate_json\n",
+      "    return cls.__pydantic_validator__.validate_json(\n",
+      "           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "pydantic_core._pydantic_core.ValidationError: 1 validation error for JSONRPCMessage\n",
+      "  Invalid JSON: expected value at line 1 column 1 [type=json_invalid, input_value='Running with account add...5B3D2bf7e80A886f213D08b', input_type=str]\n",
+      "    For further information visit https://errors.pydantic.dev/2.11/v/json_invalid\n",
+      "ERROR:mcp.client.stdio:Failed to parse JSONRPC message from server\n",
+      "Traceback (most recent call last):\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/mcp/client/stdio/__init__.py\", line 155, in stdout_reader\n",
+      "    message = types.JSONRPCMessage.model_validate_json(line)\n",
+      "              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/pydantic/main.py\", line 746, in model_validate_json\n",
+      "    return cls.__pydantic_validator__.validate_json(\n",
+      "           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "pydantic_core._pydantic_core.ValidationError: 1 validation error for JSONRPCMessage\n",
+      "  Invalid JSON: expected value at line 1 column 1 [type=json_invalid, input_value='Running with agent addre...74e1ef79DAD43E8aF528e31', input_type=str]\n",
+      "    For further information visit https://errors.pydantic.dev/2.11/v/json_invalid\n",
+      "ERROR:mcp.client.stdio:Failed to parse JSONRPC message from server\n",
+      "Traceback (most recent call last):\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/mcp/client/stdio/__init__.py\", line 155, in stdout_reader\n",
+      "    message = types.JSONRPCMessage.model_validate_json(line)\n",
+      "              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/pydantic/main.py\", line 746, in model_validate_json\n",
+      "    return cls.__pydantic_validator__.validate_json(\n",
+      "           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "pydantic_core._pydantic_core.ValidationError: 1 validation error for JSONRPCMessage\n",
+      "  Invalid JSON: expected value at line 1 column 1 [type=json_invalid, input_value='Running with account add...5B3D2bf7e80A886f213D08b', input_type=str]\n",
+      "    For further information visit https://errors.pydantic.dev/2.11/v/json_invalid\n",
+      "ERROR:mcp.client.stdio:Failed to parse JSONRPC message from server\n",
+      "Traceback (most recent call last):\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/mcp/client/stdio/__init__.py\", line 155, in stdout_reader\n",
+      "    message = types.JSONRPCMessage.model_validate_json(line)\n",
+      "              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/pydantic/main.py\", line 746, in model_validate_json\n",
+      "    return cls.__pydantic_validator__.validate_json(\n",
+      "           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "pydantic_core._pydantic_core.ValidationError: 1 validation error for JSONRPCMessage\n",
+      "  Invalid JSON: expected value at line 1 column 1 [type=json_invalid, input_value='Running with agent addre...74e1ef79DAD43E8aF528e31', input_type=str]\n",
+      "    For further information visit https://errors.pydantic.dev/2.11/v/json_invalid\n",
+      "INFO:httpx:HTTP Request: POST https://api.openai.com/v1/responses \"HTTP/1.1 200 OK\"\n",
+      "ERROR:mcp.client.stdio:Failed to parse JSONRPC message from server\n",
+      "Traceback (most recent call last):\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/mcp/client/stdio/__init__.py\", line 155, in stdout_reader\n",
+      "    message = types.JSONRPCMessage.model_validate_json(line)\n",
+      "              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/pydantic/main.py\", line 746, in model_validate_json\n",
+      "    return cls.__pydantic_validator__.validate_json(\n",
+      "           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "pydantic_core._pydantic_core.ValidationError: 1 validation error for JSONRPCMessage\n",
+      "  Invalid JSON: expected value at line 1 column 1 [type=json_invalid, input_value='Running with account add...5B3D2bf7e80A886f213D08b', input_type=str]\n",
+      "    For further information visit https://errors.pydantic.dev/2.11/v/json_invalid\n",
+      "ERROR:mcp.client.stdio:Failed to parse JSONRPC message from server\n",
+      "Traceback (most recent call last):\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/mcp/client/stdio/__init__.py\", line 155, in stdout_reader\n",
+      "    message = types.JSONRPCMessage.model_validate_json(line)\n",
+      "              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/pydantic/main.py\", line 746, in model_validate_json\n",
+      "    return cls.__pydantic_validator__.validate_json(\n",
+      "           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "pydantic_core._pydantic_core.ValidationError: 1 validation error for JSONRPCMessage\n",
+      "  Invalid JSON: expected value at line 1 column 1 [type=json_invalid, input_value='Running with agent addre...74e1ef79DAD43E8aF528e31', input_type=str]\n",
+      "    For further information visit https://errors.pydantic.dev/2.11/v/json_invalid\n",
+      "ERROR:mcp.client.stdio:Failed to parse JSONRPC message from server\n",
+      "Traceback (most recent call last):\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/mcp/client/stdio/__init__.py\", line 155, in stdout_reader\n",
+      "    message = types.JSONRPCMessage.model_validate_json(line)\n",
+      "              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/pydantic/main.py\", line 746, in model_validate_json\n",
+      "    return cls.__pydantic_validator__.validate_json(\n",
+      "           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "pydantic_core._pydantic_core.ValidationError: 1 validation error for JSONRPCMessage\n",
+      "  Invalid JSON: expected value at line 1 column 1 [type=json_invalid, input_value='Running with account add...5B3D2bf7e80A886f213D08b', input_type=str]\n",
+      "    For further information visit https://errors.pydantic.dev/2.11/v/json_invalid\n",
+      "ERROR:mcp.client.stdio:Failed to parse JSONRPC message from server\n",
+      "Traceback (most recent call last):\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/mcp/client/stdio/__init__.py\", line 155, in stdout_reader\n",
+      "    message = types.JSONRPCMessage.model_validate_json(line)\n",
+      "              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/pydantic/main.py\", line 746, in model_validate_json\n",
+      "    return cls.__pydantic_validator__.validate_json(\n",
+      "           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "pydantic_core._pydantic_core.ValidationError: 1 validation error for JSONRPCMessage\n",
+      "  Invalid JSON: expected value at line 1 column 1 [type=json_invalid, input_value='Running with agent addre...74e1ef79DAD43E8aF528e31', input_type=str]\n",
+      "    For further information visit https://errors.pydantic.dev/2.11/v/json_invalid\n",
+      "ERROR:mcp.client.stdio:Failed to parse JSONRPC message from server\n",
+      "Traceback (most recent call last):\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/mcp/client/stdio/__init__.py\", line 155, in stdout_reader\n",
+      "    message = types.JSONRPCMessage.model_validate_json(line)\n",
+      "              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/pydantic/main.py\", line 746, in model_validate_json\n",
+      "    return cls.__pydantic_validator__.validate_json(\n",
+      "           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "pydantic_core._pydantic_core.ValidationError: 1 validation error for JSONRPCMessage\n",
+      "  Invalid JSON: expected value at line 1 column 1 [type=json_invalid, input_value='Running with account add...5B3D2bf7e80A886f213D08b', input_type=str]\n",
+      "    For further information visit https://errors.pydantic.dev/2.11/v/json_invalid\n",
+      "ERROR:mcp.client.stdio:Failed to parse JSONRPC message from server\n",
+      "Traceback (most recent call last):\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/mcp/client/stdio/__init__.py\", line 155, in stdout_reader\n",
+      "    message = types.JSONRPCMessage.model_validate_json(line)\n",
+      "              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "  File \"/Applications/Documents/agent_trading/venv/lib/python3.11/site-packages/pydantic/main.py\", line 746, in model_validate_json\n",
+      "    return cls.__pydantic_validator__.validate_json(\n",
+      "           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
+      "pydantic_core._pydantic_core.ValidationError: 1 validation error for JSONRPCMessage\n",
+      "  Invalid JSON: expected value at line 1 column 1 [type=json_invalid, input_value='Running with agent addre...74e1ef79DAD43E8aF528e31', input_type=str]\n",
+      "    For further information visit https://errors.pydantic.dev/2.11/v/json_invalid\n",
+      "INFO:httpx:HTTP Request: POST https://api.openai.com/v1/responses \"HTTP/1.1 200 OK\"\n",
+      "INFO:httpx:HTTP Request: POST https://api.openai.com/v1/responses \"HTTP/1.1 200 OK\"\n",
+      "INFO:httpx:HTTP Request: POST https://api.openai.com/v1/responses \"HTTP/1.1 200 OK\"\n"
+     ]
+    },
+    {
+     "data": {
+      "text/markdown": [
+       "I need to know which exchange or platform you want me to trade on to find the correct perpetual contract symbols. Please specify the exchange or platform name (e.g., Binance, Bybit, BitMEX), so I can identify the right symbols and proceed with trades."
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "agent_name = \"crypto_trader\"\n",
+    "for server in mcp_servers:\n",
+    "    await server.connect()\n",
+    "\n",
+    "crypto_news_researcher_tool = await get_crypto_news_researcher_tool(crypto_news_mcp_servers)\n",
+    "technical_analyst_researcher_tool = await get_technical_analyst_researcher_tool(technical_analyst_mcp_servers)\n",
+    "\n",
+    "trader = Agent(\n",
+    "    name=agent_name,\n",
+    "    instructions=instructions,\n",
+    "    tools=[crypto_news_researcher_tool, technical_analyst_researcher_tool],\n",
+    "    mcp_servers=hyperliquid_trader_mcp_servers,\n",
+    "    model=\"gpt-4.1-mini\",\n",
+    ")\n",
+    "with trace(agent_name):\n",
+    "    result = await Runner.run(trader, prompt, max_turns=30)\n",
+    "display(Markdown(result.final_output))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# store memory\n",
+    "\n",
+    "import json\n",
+    "import openai\n",
+    "from datetime import datetime\n",
+    "from pathlib import Path\n",
+    "\n",
+    "openai.api_key = os.getenv(\"OPENAI_API_KEY\")\n",
+    "MEMORY_FILE = Path(\"memories.json\")\n",
+    "\n",
+    "def load_memories(n: int = 3) -> list[str]:\n",
+    "    \"\"\"Load the last n memories from file.\"\"\"\n",
+    "    if not MEMORY_FILE.exists():\n",
+    "        return []\n",
+    "    with open(MEMORY_FILE, \"r\", encoding=\"utf-8\") as f:\n",
+    "        lines = [json.loads(l) for l in f if l.strip()]\n",
+    "    return [m[\"summary\"] for m in lines[-n:]]\n",
+    "\n",
+    "def save_memory(summary: str):\n",
+    "    \"\"\"Append a new memory summary to file.\"\"\"\n",
+    "    entry = {\"timestamp\": datetime.now().isoformat(), \"summary\": summary}\n",
+    "    with open(MEMORY_FILE, \"a\", encoding=\"utf-8\") as f:\n",
+    "        f.write(json.dumps(entry) + \"\\n\")\n",
+    "\n",
+    "async def summarize_result(result_text: str) -> str:\n",
+    "    \"\"\"Use an LLM to summarize a trading report concisely.\"\"\"\n",
+    "    client = openai.AsyncOpenAI()\n",
+    "    resp = await client.responses.create(\n",
+    "        model=\"gpt-4o-mini\",\n",
+    "        input=f\"Summarize this trading report in 3–5 bullet points focusing on reasoning and actions:\\n\\n{result_text}\",\n",
+    "        max_output_tokens=200,\n",
+    "    )\n",
+    "    return resp.output_text.strip()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import json\n",
+    "import asyncio\n",
+    "import importlib\n",
+    "import hype_accounts_server\n",
+    "from datetime import datetime\n",
+    "from IPython.display import Markdown, display\n",
+    "\n",
+    "\n",
+    "importlib.reload(hype_accounts_server)\n",
+    "\n",
+    "async def trade_loop():\n",
+    "    \"\"\"Run trading agent every 30 minutes indefinitely.\"\"\"\n",
+    "    while True:\n",
+    "        print(f\"\\n🕒 Starting trading cycle at {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\")\n",
+    "        try:\n",
+    "            # 🧠 Load past summaries\n",
+    "            past_memories = load_memories(3)\n",
+    "            memory_text = \"\\n\".join(past_memories) if past_memories else \"No prior memories.\"\n",
+    "            print(\"🧠 Loaded past memories:\\n\", memory_text)\n",
+    "            account_details = await hype_accounts_server.get_account_details()\n",
+    "\n",
+    "            instructions = f\"\"\"\n",
+    "                You are a cryptocurrency perpetuals trader. \n",
+    "                Here are your past insights:\n",
+    "                {memory_text}\n",
+    "                Your current holdings and balance is:\n",
+    "                {account_details}\n",
+    "                You have the tools to perform a search for relevant cryptocurrency news.\n",
+    "                You have tools to check cryptocurrency technical indicators and prices.\n",
+    "                You have tools to check your current holdings and balance.\n",
+    "                You have tools to long and short cryptocurrency perpetuals.\n",
+    "                Please make use of these tools to manage your portfolio. Carry out trades as you see fit; do not wait for instructions or ask for confirmation.\n",
+    "            \"\"\"\n",
+    "\n",
+    "            prompt = f\"\"\"\n",
+    "            Use your tools to make decisions about your portfolio.\n",
+    "            Step 1: look into your current holdings and balance.\n",
+    "            Step 2: research the latest cryptocurrency news and relevant long/short opportunities. select 3-5 cryptocurrencies to focus on.\n",
+    "            Step 3: analyse the current price, and technical indicators (EMA (20, 200), MACD (12, 26, 9), stochastic RSI (14, 14, 3, 3), Accumulation/Distribution (ADL), Volume) for these cryptocurrencies. Recommend a few trading strategies.\n",
+    "            Step 4: make long/short trades on these cryptocurrencies based on your research and strategies.\n",
+    "            You do not have to make any trades if there are no good opportunities.\n",
+    "            Respond with detailed information and analysis for each step - 1) research 2) detailed technical analysis with indicator values 3) trade executions.\n",
+    "            The current datetime is {datetime.now().strftime(\"%Y-%m-%d %H:%M\")}\n",
+    "            \"\"\"\n",
+    "\n",
+    "            # Connect servers\n",
+    "            for server in mcp_servers:\n",
+    "                await server.connect()\n",
+    "\n",
+    "            # Load tools\n",
+    "            crypto_news_researcher_tool = await get_crypto_news_researcher_tool(crypto_news_mcp_servers)\n",
+    "            technical_analyst_researcher_tool = await get_technical_analyst_researcher_tool(technical_analyst_mcp_servers)\n",
+    "\n",
+    "            trader = Agent(\n",
+    "                name=\"crypto_trader\",\n",
+    "                instructions=instructions,\n",
+    "                tools=[crypto_news_researcher_tool, technical_analyst_researcher_tool],\n",
+    "                mcp_servers=hyperliquid_trader_mcp_servers,\n",
+    "                model=\"gpt-4.1-mini\",\n",
+    "            )\n",
+    "\n",
+    "            with trace(\"crypto_trader\"):\n",
+    "                result = await Runner.run(trader, prompt, max_turns=30)\n",
+    "            display(Markdown(result.final_output))\n",
+    "\n",
+    "        except Exception as e:\n",
+    "            print(\"❌ Error in trading loop:\", e)\n",
+    "\n",
+    "        # Sleep for 30 minutes before next run\n",
+    "        print(\"⏸️  Sleeping for 30 minutes...\\n\")\n",
+    "        await asyncio.sleep(30 * 60)\n",
+    "\n",
+    "# Run the loop once you’re ready\n",
+    "await trade_loop()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import gradio as gr\n",
+    "\n",
+    "# Define the function to handle user requests and interact with the agent\n",
+    "async def handle_request(request: str):\n",
+    "    \"\"\"\n",
+    "    Handles user requests and interacts with the agent.\n",
+    "\n",
+    "    Args:\n",
+    "        request (str): The user's request (e.g., \"Search for possible long / short opportunities based on trend/momentum/volatility/volume strategies\").\n",
+    "\n",
+    "    Returns:\n",
+    "        str: The agent's response.\n",
+    "    \"\"\"\n",
+    "    instructions = \"\"\"You are a cryptocurrency perpetuals trading researcher. You have the tools for trend/momentum/volatility/volume technical indicators and strategies.\n",
+    "    Look for possible long / short opportunities, and help with research.\n",
+    "    Based on the request, you carry out necessary research and respond with your findings.\n",
+    "    Take time to make multiple searches to get a comprehensive overview, and then summarize your findings.\n",
+    "    If there isn't a specific request, then just respond with searching latest trends.\n",
+    "    The current datetime is {datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")}\"\"\"\n",
+    "    model = \"gpt-4.1-mini\"\n",
+    "\n",
+    "    async with MCPServerStdio(params=params, client_session_timeout_seconds=30) as mcp_server:\n",
+    "        agent = Agent(name=\"cryptocurrency_trading_researcher\", instructions=instructions, model=model, mcp_servers=[mcp_server])\n",
+    "        with trace(\"cryptocurrency_trading_researcher\"):\n",
+    "            result = await Runner.run(agent, request)\n",
+    "        return result.final_output\n",
+    "\n",
+    "# Create the Gradio interface\n",
+    "interface = gr.Interface(\n",
+    "    fn=handle_request,\n",
+    "    inputs=gr.Textbox(label=\"Request\", placeholder=\"Type your request (e.g., Help me search for long / short trading opportunities based on trend/momentum/volatility/volume strategies\"),\n",
+    "    outputs=gr.Textbox(label=\"Response\", lines=10),\n",
+    "    title=\"Crypto currency researcher\",\n",
+    "    description=\"Interact with the cryptocurrency trading researcher to get insights on trading opportunities and strategies.\"\n",
+    ")\n",
+    "\n",
+    "# Launch the interface\n",
+    "interface.launch()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Now let's use our researcher server as an MCP server\n",
+    "\n",
+    "params = {\"command\": \"uv\", \"args\": [\"--directory\", \"./crypto-sentiment-mcp\", \"run\", \"main.py\"], \"env\": {\"SANTIMENT_API_KEY\": \"binance\"}}\n",
+    "async with MCPServerStdio(params=params, client_session_timeout_seconds=30) as server:\n",
+    "    mcp_tools = await server.list_tools()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "venv (3.11.14)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.14"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}