Building a Sentiment-Driven Trading Agent:
From News to Positions

import requests

CRYPTOCOMPARE_API = "https://min-api.cryptocompare.com/data/v2/news/?lang=EN"

def fetch_headlines(asset: str = "BTC", limit: int = 10) -> list[str]:
    """Fetch recent crypto headlines filtered by asset."""
    r = requests.get(
        CRYPTOCOMPARE_API,
        params={"categories": asset, "lTs": 0},
        timeout=10,
    )
    r.raise_for_status()
    articles = r.json()["Data"][:limit]
    return [a["title"] for a in articles]


# Example output:
# ["Bitcoin ETF Approved by SEC — Markets React",
#  "BTC breaks $100K resistance on institutional flows",
#  "Whale moves 10,000 BTC to exchange — sell signal?"]

import anthropic, json

CLIENT = anthropic.Anthropic()  # uses ANTHROPIC_API_KEY env var

SCORE_PROMPT = """You are a crypto trading analyst. Given these recent headlines about {asset},
return a JSON object with:
  - "direction": "long" or "short" or "neutral"
  - "score": float from -1.0 (strongly bearish) to +1.0 (strongly bullish)
  - "confidence": float from 0.0 (uncertain) to 1.0 (high confidence)
  - "rationale": one sentence explaining the signal

Headlines:
{headlines}

Respond ONLY with valid JSON."""


def score_sentiment(asset: str, headlines: list[str]) -> dict:
    """Score sentiment of headlines using Claude. Returns structured signal."""
    prompt = SCORE_PROMPT.format(
        asset=asset,
        headlines="\n".join(f"- {h}" for h in headlines),
    )
    msg = CLIENT.messages.create(
        model="claude-opus-4-6",
        max_tokens=256,
        messages=[{"role": "user", "content": prompt}],
    )
    return json.loads(msg.content[0].text)


# Example: "Bitcoin ETF Approved by SEC" headlines
# Returns: {"direction": "long", "score": 0.87, "confidence": 0.91,
#           "rationale": "SEC ETF approval is a strong institutional bullish catalyst."}

def kelly_fraction(
    confidence: float,
    score: float,
    win_loss_ratio: float = 1.5,
    kelly_divisor: float = 2.0,
    max_fraction: float = 0.05,
) -> float:
    """
    Compute fractional Kelly position size as a fraction of portfolio.

    Args:
        confidence: LLM confidence score 0.0-1.0
        score: sentiment score -1.0 to +1.0 (absolute value used)
        win_loss_ratio: expected win / expected loss (default 1.5:1)
        kelly_divisor: fraction of full Kelly to use (2.0 = half-Kelly)
        max_fraction: hard cap on position size (default 5%)
    """
    # Use confidence as win probability, modulated by score magnitude
    p = confidence * abs(score)  # effective probability
    q = 1.0 - p
    b = win_loss_ratio

    full_kelly = (p * b - q) / b
    fractional = full_kelly / kelly_divisor

    # Never go negative (no trade if signal is weak)
    return max(0.0, min(fractional, max_fraction))


# Example:
# score=0.87, confidence=0.91 → p=0.79, kelly=0.26, half-kelly=0.13, capped at 0.05
# score=0.30, confidence=0.50 → p=0.15, kelly negative → no trade

import os, requests

TRADING_BASE = "https://trading.purpleflea.com"
TRADING_KEY  = os.environ["PURPLE_FLEA_TRADING_KEY"]


def get_portfolio_value() -> float:
    """Fetch current portfolio USDC value."""
    r = requests.get(
        f"{TRADING_BASE}/api/v1/account",
        headers={"Authorization": f"Bearer {TRADING_KEY}"},
    )
    r.raise_for_status()
    return float(r.json()["equity_usdc"])


def open_position(
    market: str,
    direction: str,
    size_usdc: float,
    stop_loss_pct: float = 0.02,
) -> dict:
    """Open a perpetual futures position with stop-loss."""
    side = "buy" if direction == "long" else "sell"

    # Place market order
    order = requests.post(
        f"{TRADING_BASE}/api/v1/orders",
        headers={"Authorization": f"Bearer {TRADING_KEY}"},
        json={
            "market": market,
            "side": side,
            "type": "market",
            "size_usdc": size_usdc,
            "stop_loss_pct": stop_loss_pct,
        },
    )
    order.raise_for_status()
    result = order.json()
    print(f"Opened {direction} {market}: ${size_usdc:.2f} @ {result['fill_price']}")
    print(f"Stop-loss set at {result['stop_loss_price']}")
    return result

import os, time, json, requests, anthropic

# Config
TRADING_BASE = "https://trading.purpleflea.com"
TRADING_KEY  = os.environ["PURPLE_FLEA_TRADING_KEY"]
CLIENT       = anthropic.Anthropic()
ASSETS       = {"BTC": "BTC/USDC", "ETH": "ETH/USDC", "SOL": "SOL/USDC"}
MIN_CONFIDENCE = 0.65  # only trade if LLM is 65%+ confident
POLL_INTERVAL  = 300   # check every 5 minutes

def fetch_headlines(asset):
    r = requests.get("https://min-api.cryptocompare.com/data/v2/news/?lang=EN",
                     params={"categories": asset}, timeout=10)
    return [a["title"] for a in r.json()["Data"][:10]]

def score_sentiment(asset, headlines):
    prompt = f"""Analyze these {asset} headlines. Return JSON only:
{{"direction":"long"|"short"|"neutral","score":-1.0..1.0,"confidence":0..1,"rationale":"..."}}
Headlines:
{chr(10).join("- "+h for h in headlines)}"""
    msg = CLIENT.messages.create(model="claude-opus-4-6", max_tokens=200,
                                 messages=[{"role":"user","content":prompt}])
    return json.loads(msg.content[0].text)

def kelly_size(confidence, score, portfolio):
    p = confidence * abs(score)
    full_kelly = (p * 1.5 - (1 - p)) / 1.5
    fraction = max(0.0, min(full_kelly / 2.0, 0.05))
    return round(portfolio * fraction, 2)

def get_portfolio():
    r = requests.get(f"{TRADING_BASE}/api/v1/account",
                     headers={"Authorization": f"Bearer {TRADING_KEY}"})
    return float(r.json()["equity_usdc"])

def open_trade(market, direction, size):
    side = "buy" if direction == "long" else "sell"
    r = requests.post(f"{TRADING_BASE}/api/v1/orders",
                      headers={"Authorization": f"Bearer {TRADING_KEY}"},
                      json={"market":market,"side":side,"type":"market",
                            "size_usdc":size,"stop_loss_pct":0.02})
    r.raise_for_status()
    return r.json()

if __name__ == "__main__":
    print("Sentiment trading agent running...")
    while True:
        portfolio = get_portfolio()
        for asset, market in ASSETS.items():
            headlines = fetch_headlines(asset)
            signal    = score_sentiment(asset, headlines)
            print(f"{asset}: {signal['direction']} (score={signal['score']:.2f}, conf={signal['confidence']:.2f})")
            print(f"  {signal['rationale']}")

            if signal["direction"] != "neutral" and signal["confidence"] >= MIN_CONFIDENCE:
                size = kelly_size(signal["confidence"], signal["score"], portfolio)
                if size >= 1.0:  # minimum $1 trade
                    result = open_trade(market, signal["direction"], size)
                    print(f"  Traded: ${size:.2f} {signal['direction']} @ {result['fill_price']}")
        time.sleep(POLL_INTERVAL)

# Register
curl -s -X POST https://trading.purpleflea.com/api/v1/auth/register \
  -H 'Content-Type: application/json' \
  -d '{"agent_name": "my-sentiment-agent"}'

# Returns: {"agent_id":"ag_xxx","api_key":"pf_xxx","equity_usdc":"100.00"}