Upload 10 files

app.py

@@ -0,0 +1,522 @@
+# app.py
+import os
+import re
+import asyncio
+from datetime import datetime
+from zoneinfo import ZoneInfo
+
+import gradio as gr
+import pandas as pd
+
+from dotenv import load_dotenv
+from agents import Agent, Runner, trace, Tool
+from agents.mcp import MCPServerStdio
+
+# Your local helper modules
+import hype_accounts_server
+from memory_utils import load_memories, save_memory, load_memories_df
+
+load_dotenv(override=True)
+
+# === Time / Locale ===
+SGT = ZoneInfo("Asia/Singapore")
+def now_sgt():
+    return datetime.now(SGT)
+
+# === MCP Server Factories ===
+def make_hyperliquid_trader_mcp_servers():
+    return [MCPServerStdio(
+        {"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"),
+         }},
+        client_session_timeout_seconds=30
+    )]
+
+def make_crypto_news_mcp_servers():
+    # Uses your scraper-based news MCP to avoid API plan limits
+    return [MCPServerStdio(
+        {"command": "python3", "args": ["-u", "crypto_news_scraper_server.py"]},
+        client_session_timeout_seconds=30
+    )]
+
+def make_technical_analyst_mcp_servers():
+    return [MCPServerStdio(
+        {"command": "python3", "args": ["-u", "hl_indicators_server.py"]},
+        client_session_timeout_seconds=30
+    )]
+
+# === Utils for MCP lifecycle ===
+async def connect_all(servers):
+    for s in servers:
+        await s.connect()
+
+async def close_all(servers):
+    for s in servers:
+        try:
+            await s.close()
+        except Exception:
+            pass
+
+# === Agent Builders ===
+async def build_news_tool(news_servers) -> Tool:
+    instructions = (
+        "You are a cryptocurrency researcher. You can search and summarise the most relevant, "
+        "recent crypto news. If the user asks about a specific coin (e.g., HYPE, BTC, ETH, XRP), "
+        "focus on that. Otherwise, highlight notable events and potential long/short opportunities. "
+        f"Current datetime (SGT): {now_sgt():%Y-%m-%d %H:%M:%S}."
+    )
+    agent = Agent(
+        name="Crypto news researcher",
+        instructions=instructions,
+        model="gpt-4.1-mini",
+        mcp_servers=news_servers,
+    )
+    return agent.as_tool(
+        tool_name="crypto_news_researcher",
+        tool_description="Research crypto news and opportunities for a coin or broad scan."
+    )
+
+async def build_ta_tool(ta_servers) -> Tool:
+    instructions = (
+        "You are a cryptocurrency perpetuals technical trading researcher.\n"
+        "Default interval: 1h; default lookback: 36.\n"
+        "Indicators: EMA(20,200), MACD(12,26,9), StochRSI(14,14,3,3), ADL, Volume.\n"
+        "Given a coin/interval/lookback, compute indicator state, infer trend, and propose entries, "
+        "exits, and stop-loss/take-profit with reasoning.\n"
+        f"Current datetime (SGT): {now_sgt():%Y-%m-%d %H:%M:%S}."
+    )
+    agent = Agent(
+        name="Crypto technical researcher",
+        instructions=instructions,
+        model="gpt-4.1-mini",
+        mcp_servers=ta_servers,
+    )
+    return agent.as_tool(
+        tool_name="crypto_technical_researcher",
+        tool_description="Run TA (EMA, MACD, StochRSI, ADL, Volume)."
+    )
+
+async def build_trader(hyper_servers, tools: list[Tool]) -> Agent:
+    # Pull short memory + balances so the agent can context-switch well
+    past_memories = load_memories(5)
+    memory_text = "\n".join(past_memories) if past_memories else "No prior memories."
+    try:
+        account_details = await hype_accounts_server.get_account_details()
+    except Exception as e:
+        account_details = f"(Could not fetch account details: {e})"
+
+    instructions = f"""
+You are a cryptocurrency perpetuals trader that can:
+- Query account balances/positions (via MCP servers on Hyperliquid).
+- Do market/news research and TA using attached tools.
+- Place long/short orders when the setup has clear edge. Transaction cost: 0.04%.
+- If signals are unclear, do NOT trade.
+
+Recent notes:
+{memory_text}
+
+Account state:
+{account_details}
+
+General rules:
+- Prefer confluence: trend + momentum + volume/ADL agreement.
+- Always suggest stop-loss and take-profit levels.
+- Keep risk per trade modest. Avoid overtrading.
+"""
+    trader = Agent(
+        name="crypto_trader",
+        instructions=instructions,
+        tools=tools,
+        mcp_servers=hyper_servers,  # these expose trading actions
+        model="gpt-4.1-mini",
+    )
+    return trader
+
+# === Intent Routing ===
+COMMAND_HELP = """\
+You can ask in natural language, e.g.:
+• "Balance" / "portfolio" — show Hyperliquid balances/positions
+• "News on BTC and ETH" — market research
+• "TA HYPE 1h lookback 48" — technical analysis
+• "Long HYPE 500 at market, SL 2% TP 4%" — execute trade
+• "Short BTC 0.01 at 68000, SL 69000 TP 66000" — limit order example
+• "Summarize opportunities today" — broad scan (news + TA)
+"""
+
+RE_TA = re.compile(r"\bTA\s+([A-Za-z0-9_\-]+)(?:\s+(\d+[mhHdD]))?(?:\s+lookback\s+(\d+))?", re.IGNORECASE)
+RE_LONG = re.compile(r"\bLONG\s+([A-Za-z0-9_\-]+)\s+([\d.]+)(?:\s+at\s+(market|mkt|[\d.]+))?(?:.*?\bSL\s+([\d.%]+))?(?:.*?\bTP\s+([\d.%]+))?", re.IGNORECASE)
+RE_SHORT = re.compile(r"\bSHORT\s+([A-Za-z0-9_\-]+)\s+([\d.]+)(?:\s+at\s+(market|mkt|[\d.]+))?(?:.*?\bSL\s+([\d.%]+))?(?:.*?\bTP\s+([\d.%]+))?", re.IGNORECASE)
+
+def pct_or_price(s):
+    if not s:
+        return None
+    s = s.strip().lower()
+    if s.endswith("%"):
+        try:
+            return {"type": "percent", "value": float(s[:-1])}
+        except:
+            return None
+    try:
+        return {"type": "price", "value": float(s)}
+    except:
+        return None
+
+# === Core Chatbot Handler ===
+async def handle_message(message: str, history: list[tuple[str, str]]):
+    """
+    Routes user intent to: balance, news, TA, or trade execution.
+    Returns markdown text.
+    """
+    text = (message or "").strip()
+    ts = now_sgt().strftime("%Y-%m-%d %H:%M:%S %Z")
+
+    # Quick help
+    if text.lower() in {"help", "/help", "commands"}:
+        return f"### Commands\n{COMMAND_HELP}"
+
+    # 1) Balance / portfolio
+    if re.search(r"\b(balance|portfolio|positions?)\b", text, re.IGNORECASE):
+        try:
+            acct = await hype_accounts_server.get_account_details()
+            save_memory(f"[{now_sgt():%Y-%m-%d %H:%M:%S %Z}] User checked balance.")
+            return format_account_for_chat(acct)
+        except Exception as e:
+            return f"❌ Error fetching account details: `{e}`"
+
+    # 2) TA intent
+    m = RE_TA.search(text)
+    if m:
+        coin = m.group(1).upper()
+        interval = (m.group(2) or "1h").lower()
+        lookback = int(m.group(3) or 36)
+
+        news_servers = []  # not needed here
+        ta_servers = []
+        try:
+            ta_servers = make_technical_analyst_mcp_servers()
+            await connect_all(ta_servers)
+
+            ta_tool = await build_ta_tool(ta_servers)
+
+            # Build a "TA-only" agent so we don't touch trading MPC here
+            researcher = Agent(
+                name="crypto_ta_agent",
+                instructions=f"Focus on TA for {coin} at interval {interval}, lookback {lookback}. Output indicator values and strategy.",
+                tools=[ta_tool],
+                model="gpt-4.1-mini",
+            )
+
+            prompt = f"Run TA for {coin} on {interval}, lookback {lookback}. Return indicators and actionable plan."
+            with trace("crypto_ta"):
+                result = await Runner.run(researcher, prompt, max_turns=12)
+
+            save_memory(f"[{ts}] TA {coin} {interval} lookback {lookback}")
+            return f"### 🔬 TA — {coin} ({interval}, lookback {lookback})\n\n{result.final_output}"
+        except Exception as e:
+            return f"❌ TA error: `{e}`"
+        finally:
+            await close_all(ta_servers)
+
+    # 3) Trade intent (LONG / SHORT)
+    mm = RE_LONG.search(text) or RE_SHORT.search(text)
+    if mm:
+        is_long = bool(RE_LONG.search(text))
+        side = "LONG" if is_long else "SHORT"
+        coin = mm.group(1).upper()
+        qty = float(mm.group(2))
+        at = mm.group(3)  # "market"/"mkt" or price
+        sl_raw = mm.group(4)
+        tp_raw = mm.group(5)
+        sl = pct_or_price(sl_raw)
+        tp = pct_or_price(tp_raw)
+
+        price_desc = "market" if (at is None or str(at).lower() in {"market", "mkt"}) else at
+        order_desc = f"{side} {coin} {qty} at {price_desc}"
+        if sl: order_desc += f", SL {sl_raw}"
+        if tp: order_desc += f", TP {tp_raw}"
+
+        hyper_servers = []
+        news_servers = []
+        ta_servers = []
+        try:
+            # Tools available to the *trader*: news + TA
+            news_servers = make_crypto_news_mcp_servers()
+            ta_servers = make_technical_analyst_mcp_servers()
+            hyper_servers = make_hyperliquid_trader_mcp_servers()
+
+            await asyncio.gather(
+                connect_all(news_servers),
+                connect_all(ta_servers),
+                connect_all(hyper_servers),
+            )
+
+            news_tool = await build_news_tool(news_servers)
+            ta_tool = await build_ta_tool(ta_servers)
+
+            trader = await build_trader(hyper_servers, [news_tool, ta_tool])
+
+            # Natural-language trade instruction to the trader agent.
+            trade_prompt = f"""
+            User requested: {order_desc}.
+            If safe and reasonable given risk rules, place the order via Hyperliquid MCP.
+            - If price specified (numeric), treat as limit; otherwise market.
+            - Always include stop-loss and take-profit (convert % to prices).
+            - Confirm the exact order(s) you placed and rationale in the output.
+            """
+            with trace("trade_execution"):
+                result = await Runner.run(trader, trade_prompt, max_turns=20)
+
+            save_memory(f"[{ts}] Executed: {order_desc}")
+            return f"### 🧾 Execution — {order_desc}\n\n{result.final_output}"
+        except Exception as e:
+            return f"❌ Trade execution error: `{e}`"
+        finally:
+            await asyncio.gather(
+                close_all(news_servers),
+                close_all(ta_servers),
+                close_all(hyper_servers),
+            )
+
+    # 4) News intent (e.g., "news on BTC", "what's happening to HYPE")
+    if re.search(r"\b(news|headline|what's happening|what is happening|happening)\b", text, re.IGNORECASE):
+        # Try to pick coins mentioned
+        coins = re.findall(r"\b([A-Z]{2,6})\b", text.upper())
+        coins = [c for c in coins if c not in {"NEWS", "HELP"}]
+        topic = ", ".join(coins) if coins else "broad market"
+        news_servers = []
+        try:
+            news_servers = make_crypto_news_mcp_servers()
+            await connect_all(news_servers)
+            news_tool = await build_news_tool(news_servers)
+
+            researcher = Agent(
+                name="crypto_news_agent",
+                instructions=f"Focus news on: {topic}. Be concise and actionable.",
+                tools=[news_tool],
+                model="gpt-4.1-mini",
+            )
+            prompt = f"Summarize the most relevant crypto news for {topic}. Include potential trade angles."
+            with trace("crypto_news"):
+                result = await Runner.run(researcher, prompt, max_turns=12)
+
+            save_memory(f"[{ts}] News requested: {topic}")
+            return f"### 🗞️ News — {topic}\n\n{result.final_output}"
+        except Exception as e:
+            return f"❌ News error: `{e}`"
+        finally:
+            await close_all(news_servers)
+
+    # 5) Summary scan (news + TA picks)
+    if re.search(r"\b(opportunit|ideas|setup|summary|today)\b", text, re.IGNORECASE):
+        hyper_servers = []
+        news_servers = []
+        ta_servers = []
+        try:
+            news_servers = make_crypto_news_mcp_servers()
+            ta_servers = make_technical_analyst_mcp_servers()
+            hyper_servers = make_hyperliquid_trader_mcp_servers()
+            await asyncio.gather(
+                connect_all(news_servers),
+                connect_all(ta_servers),
+                connect_all(hyper_servers),
+            )
+            news_tool = await build_news_tool(news_servers)
+            ta_tool = await build_ta_tool(ta_servers)
+            trader = await build_trader(hyper_servers, [news_tool, ta_tool])
+
+            prompt = (
+                "Step 1: Broad news scan for major catalysts.\n"
+                "Step 2: Pick 3–5 coins with potential edges; run compact TA summary (1h, lookback 36).\n"
+                "Step 3: Recommend 1–2 best setups with entry, SL, TP and rationale. Do NOT place orders."
+            )
+            with trace("daily_opportunities"):
+                result = await Runner.run(trader, prompt, max_turns=24)
+
+            save_memory(f"[{ts}] Opportunity summary requested.")
+            return f"### 📌 Opportunities — {ts}\n\n{result.final_output}"
+        except Exception as e:
+            return f"❌ Summary error: `{e}`"
+        finally:
+            await asyncio.gather(
+                close_all(news_servers),
+                close_all(ta_servers),
+                close_all(hyper_servers),
+            )
+
+    # Fallback: clarify + brief help
+    return (
+        "I can help with balance, news, TA, and trade execution.\n\n"
+        + COMMAND_HELP
+    )
+
+# ---------- Pretty printing for account/positions ----------
+
+from math import isnan
+
+def _fnum(x, decimals=2):
+    try:
+        v = float(x)
+        return f"{v:,.{decimals}f}"
+    except Exception:
+        return str(x)
+
+def _fpct(x, decimals=2):
+    try:
+        v = float(x) * 100  # input is ROE like 0.0036 -> 0.36%
+        sign = "🟢" if v > 0 else ("🔴" if v < 0 else "⚪️")
+        return f"{sign} {v:.{decimals}f}%"
+    except Exception:
+        return "—"
+
+def _pnl(x, decimals=2):
+    try:
+        v = float(x)
+        sign = "🟢" if v > 0 else ("🔴" if v < 0 else "⚪️")
+        return f"{sign} ${abs(v):,.{decimals}f}"
+    except Exception:
+        return "—"
+
+def _side_and_abs_size(szi):
+    try:
+        v = float(szi)
+        side = "LONG" if v > 0 else ("SHORT" if v < 0 else "FLAT")
+        return side, abs(v)
+    except Exception:
+        return "—", szi
+
+def format_account_for_chat(acct: dict) -> str:
+    """
+    Converts the get_account_details() dict into a nice Markdown summary.
+    """
+    if not isinstance(acct, dict):
+        return f"```\n{acct}\n```"
+
+    holdings = acct.get("holdings", []) or []
+    cash = acct.get("cash_balance", "0")
+    realized_pnl = acct.get("profit_and_loss", None)
+
+    # Totals
+    total_pos_value = 0.0
+    total_margin_used = 0.0
+    total_upnl = 0.0
+
+    rows_md = []
+    for h in holdings:
+        pos = h.get("position", {})
+        coin = pos.get("coin", "—")
+        szi = pos.get("szi", 0)
+        side, abs_size = _side_and_abs_size(szi)
+        entry = pos.get("entryPx", "—")
+        pval = pos.get("positionValue", 0)
+        u = pos.get("unrealizedPnl", 0)
+        roe = pos.get("returnOnEquity", 0)
+        lev = pos.get("leverage", {})
+        lev_str = f"{lev.get('type','—')}×{lev.get('value','—')}"
+        liq = pos.get("liquidationPx", None)
+        m_used = pos.get("marginUsed", 0)
+        fund = pos.get("cumFunding", {}).get("sinceOpen", None)
+
+        # Totals
+        try: total_pos_value += float(pval)
+        except: pass
+        try: total_margin_used += float(m_used)
+        except: pass
+        try: total_upnl += float(u)
+        except: pass
+
+        rows_md.append(
+            f"| {coin} | {side} | {_fnum(abs_size, 6)} | ${_fnum(entry, 2)} | ${_fnum(pval, 2)} | {_pnl(u, 2)} | {_fpct(roe, 2)} | {lev_str} | {('—' if liq in (None, 'None') else '$'+_fnum(liq, 2))} | ${_fnum(m_used, 2)} | {('—' if fund in (None, 'None') else _fnum(fund, 6))} |"
+        )
+
+    header = (
+        "### 📊 Account / Positions\n"
+        f"- **Cash balance:** ${_fnum(cash, 2)}\n"
+        f"- **Total pos. value:** ${_fnum(total_pos_value, 2)}\n"
+        f"- **Unrealized PnL:** {_pnl(total_upnl, 2)}\n"
+        f"- **Margin used (total):** ${_fnum(total_margin_used, 2)}\n"
+    )
+    if realized_pnl is not None:
+        header += f"- **Realized PnL (session/period):** {_pnl(realized_pnl, 2)}\n"
+
+    table_head = (
+        "\n| Coin | Side | Size | Entry Px | Pos. Value | uPnL | ROE | Leverage | Liq Px | Margin Used | Funding (since open) |\n"
+        "|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|\n"
+    )
+    table_body = "\n".join(rows_md) if rows_md else "_No open positions_"
+
+    return header + table_head + table_body
+
+
+# === Gradio UI ===
+with gr.Blocks(fill_height=True) as demo:
+    gr.Markdown("# 🤖 Crypto Trading Copilot")
+    gr.Markdown(
+        f"Local time: **{now_sgt():%Y-%m-%d %H:%M:%S %Z}**  \n"
+        "[OpenAI Traces](https://platform.openai.com/logs?api=traces) · "
+        "[Hyperliquid](https://app.hyperliquid.xyz/trade)"
+    )
+
+    with gr.Row():
+        quick1 = gr.Button("📊 Balance")
+        quick2 = gr.Button("🗞️ News: BTC, ETH")
+        quick3 = gr.Button("🔬 TA: HYPE 1h")
+        quick4 = gr.Button("🧾 Long HYPE 500 @ market (SL 2% TP 4%)")
+
+    chatbot = gr.Chatbot(height=480, type="messages", show_copy_button=True)
+    user_in = gr.Textbox(placeholder="Try: TA HYPE 1h lookback 48  •  News on BTC  •  Long HYPE 500 at market, SL 2% TP 4%", scale=1)
+    send_btn = gr.Button("Send", variant="primary")
+
+    with gr.Accordion("Memory (last 10)", open=False):
+        mem_table = gr.Dataframe(value=load_memories_df(10), interactive=False, wrap=True, show_label=False)
+
+    async def _respond(user_msg, chat_state):
+        bot_md = await handle_message(user_msg, chat_state or [])
+        # Log short memory line
+        save_memory(f"[{now_sgt():%Y-%m-%d %H:%M}] {user_msg[:80]}")
+        # Update display memory table
+        latest_mem = load_memories_df(10)
+        return chat_state + [{"role":"user","content":user_msg},{"role":"assistant","content":bot_md}], "", latest_mem
+
+    send_btn.click(_respond, inputs=[user_in, chatbot], outputs=[chatbot, user_in, mem_table])
+    user_in.submit(_respond, inputs=[user_in, chatbot], outputs=[chatbot, user_in, mem_table])
+
+    # Quick actions
+    async def _qa_balance(chat_state):
+        msg = "balance"
+        bot_md = await handle_message(msg, chat_state or [])
+        save_memory(f"[{now_sgt():%Y-%m-%d %H:%M}] Quick: balance")
+        latest_mem = load_memories_df(10)
+        return chat_state + [{"role":"user","content":msg},{"role":"assistant","content":bot_md}], latest_mem
+
+    async def _qa_news(chat_state):
+        msg = "news on BTC and ETH"
+        bot_md = await handle_message(msg, chat_state or [])
+        save_memory(f"[{now_sgt():%Y-%m-%d %H:%M}] Quick: news BTC ETH")
+        latest_mem = load_memories_df(10)
+        return chat_state + [{"role":"user","content":msg},{"role":"assistant","content":bot_md}], latest_mem
+
+    async def _qa_ta(chat_state):
+        msg = "TA HYPE 1h lookback 48"
+        bot_md = await handle_message(msg, chat_state or [])
+        save_memory(f"[{now_sgt():%Y-%m-%d %H:%M}] Quick: TA HYPE")
+        latest_mem = load_memories_df(10)
+        return chat_state + [{"role":"user","content":msg},{"role":"assistant","content":bot_md}], latest_mem
+
+    async def _qa_long(chat_state):
+        msg = "Long HYPE 500 at market, SL 2% TP 4%"
+        bot_md = await handle_message(msg, chat_state or [])
+        save_memory(f"[{now_sgt():%Y-%m-%d %H:%M}] Quick: long HYPE")
+        latest_mem = load_memories_df(10)
+        return chat_state + [{"role":"user","content":msg},{"role":"assistant","content":bot_md}], latest_mem
+
+    quick1.click(_qa_balance, inputs=[chatbot], outputs=[chatbot, mem_table])
+    quick2.click(_qa_news, inputs=[chatbot], outputs=[chatbot, mem_table])
+    quick3.click(_qa_ta, inputs=[chatbot], outputs=[chatbot, mem_table])
+    quick4.click(_qa_long, inputs=[chatbot], outputs=[chatbot, mem_table])
+
+if __name__ == "__main__":
+    # No deprecated args; queue() OK without concurrency_count
+    demo.queue().launch()

crypto_news_scraper.py

@@ -0,0 +1,48 @@
+import pandas as pd
+import feedparser
+import html
+import re
+
+def scrape_crypto_news(urls: list = None, num_entries: int = 10) -> pd.DataFrame:
+    if urls is None:
+        urls = ["https://cointelegraph.com/rss","https://cryptopotato.com/feed/","https://cryptonews.com/news/feed/"]
+    if num_entries is None:
+        num_entries = 10
+    news_dict = {}
+    for url in urls:
+        try:
+            feed = feedparser.parse(url, request_headers={
+                "User-Agent": "Mozilla/5.0 (CryptoNewsBot; +https://example.com)"
+            })
+
+            # Check if the feed was parsed correctly
+            if getattr(feed, "bozo", 0):
+                print("[warn] bozo_exception:", getattr(feed, "bozo_exception", None))
+
+            # Helper to extract the best text field per entry
+            def get_text(entry):
+                if "content" in entry and entry.content:
+                    for c in entry.content:
+                        if c.get("value"):
+                            return c["value"]
+                if entry.get("summary"):
+                    return entry["summary"]
+                if entry.get("description"):
+                    return entry["description"]
+                return ""
+
+            # Print the first few articles
+            for i, e in enumerate(feed.entries[:num_entries], 1):
+                title = e.get("title", "").strip()
+                link = e.get("link", "")
+                raw_html = get_text(e)
+                plain = re.sub(r"<[^>]+>", " ", html.unescape(raw_html))
+                plain = re.sub(r"\s+", " ", plain).strip()
+                pub = e.get("published", "")
+                news_dict[title] = {"link": link, "published": pub, "description": plain, "source": url}
+
+        except:
+            pass
+        news_df = pd.DataFrame(news_dict).T
+        news_df = news_df.reset_index().rename(columns={"index":"title"})
+    return news_df

crypto_news_scraper_server.py

@@ -0,0 +1,30 @@
+from mcp.server.fastmcp import FastMCP
+from crypto_news_scraper import scrape_crypto_news
+import pandas as pd
+from dotenv import load_dotenv
+load_dotenv(override=True)
+
+mcp = FastMCP("cryptopanic_news_server")
+
+@mcp.tool()
+async def get_crypto_news(urls: list = None, num_entries: int = 10) -> str:
+    """Scrape and aggregate the latest cryptocurrency news articles from multiple RSS feeds.
+
+    Args:
+        urls: Optional list of RSS feed URLs to scrape.
+            - Accepts a list of strings, each being a valid RSS feed URL.
+            - Example: ["https://cointelegraph.com/rss", "https://cryptopotato.com/feed/"].
+            - If set to None, defaults to:
+              [
+                  "https://cointelegraph.com/rss",
+                  "https://cryptopotato.com/feed/",
+                  "https://cryptonews.com/news/feed/"
+              ].
+        num_entries: The maximum number of news entries to retrieve per feed.
+            - Defaults to 10.
+            - Example: setting num_entries=5 retrieves the 5 most recent articles per source.
+    """
+    return scrape_crypto_news(urls=None, num_entries=10).to_string()
+
+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,63 @@
+# 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 dotenv import load_dotenv
+from datetime import datetime, timezone
+
+
+# Load environment variables
+load_dotenv(override=True)
+
+# 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,59 @@
+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')

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]

requirements.txt

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