Build a DeepSeek R1 Trading Agent for 20x Less Cost Than GPT-4

pip install openai httpx python-dotenv

# Switch between providers by changing MODEL_PROVIDER
MODEL_PROVIDER=deepseek          # or: openai
DEEPSEEK_API_KEY=sk-...
OPENAI_API_KEY=sk-...
PURPLE_FLEA_KEY=pf_live_your_key_here

import os
from openai import OpenAI

def get_llm_client():
    provider = os.getenv("MODEL_PROVIDER", "deepseek")

    if provider == "deepseek":
        return OpenAI(
            api_key=os.getenv("DEEPSEEK_API_KEY"),
            base_url="https://api.deepseek.com/v1",
        ), "deepseek-reasoner"   # R1 model

    elif provider == "openai":
        return OpenAI(
            api_key=os.getenv("OPENAI_API_KEY"),
        ), "gpt-4o"

    else:
        raise ValueError(f"Unknown provider: {provider}")

# One-line switch: set MODEL_PROVIDER=openai in .env to use GPT-4o
client, MODEL = get_llm_client()

TRADING_SYSTEM_PROMPT = """You are a quantitative trading agent operating on Purple Flea's
perpetual futures market (275 instruments). You manage a portfolio
with strict risk controls.

DECISION PROCESS - work through these steps before deciding:
1. MARKET STATE: What is the current trend (bullish/bearish/neutral)?
   Look at the price relative to 20-period and 50-period moving averages.
2. MOMENTUM: Is RSI above 60 (bullish), below 40 (bearish), or neutral?
3. FUNDING RATE: Positive funding = crowded long. Negative = crowded short.
   Extreme funding (>0.1% per 8h) is a contrarian signal.
4. RISK CHECK: Is the proposed position within the 2% account risk rule?
   (position_size * entry_price * stop_distance / account_value <= 0.02)
5. DECISION: Based on the above, output a JSON action.

OUTPUT FORMAT (JSON only, no markdown):
{
  "reasoning_summary": "2-3 sentence summary of your analysis",
  "action": "BUY" | "SELL" | "HOLD",
  "symbol": "BTC-PERP",
  "size_usd": 500,
  "leverage": 2,
  "stop_loss_pct": 0.025,
  "take_profit_pct": 0.05,
  "confidence": 0.72
}

If action is HOLD, size_usd should be 0. Never exceed 5x leverage.
Never risk more than 2% of account on a single trade."""

import os, json, time, logging
import httpx
from dotenv import load_dotenv
from client import client, MODEL
from prompts import TRADING_SYSTEM_PROMPT

load_dotenv()
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
log = logging.getLogger("trading-agent")

PF_KEY  = os.getenv("PURPLE_FLEA_KEY")
PF_BASE = "https://api.purpleflea.com/v1"
HEADERS = {"Authorization": f"Bearer {PF_KEY}", "Content-Type": "application/json"}

def get_market_context(symbol: str) -> dict:
    "Fetch OHLCV, funding rate, and open positions for the symbol."
    with httpx.Client() as http:
        ohlcv = http.get(f"{PF_BASE}/markets/{symbol}/candles",
                          params={"interval": "15m", "limit": 50},
                          headers=HEADERS).json()
        funding = http.get(f"{PF_BASE}/markets/{symbol}/funding",
                             headers=HEADERS).json()
        positions = http.get(f"{PF_BASE}/account/positions",
                                headers=HEADERS).json()
        account = http.get(f"{PF_BASE}/account",
                              headers=HEADERS).json()
    candles = ohlcv["candles"][-20:]
    closes  = [c["close"] for c in candles]
    return {
        "symbol": symbol,
        "current_price": closes[-1],
        "sma20": sum(closes) / len(closes),
        "price_change_pct_1h": (closes[-1] - closes[-4]) / closes[-4] * 100,
        "funding_rate_8h": funding["rate"],
        "open_position": next((p for p in positions["positions"] if p["symbol"] == symbol), None),
        "account_value_usd": account["equity"],
    }

def decide_trade(context: dict) -> dict:
    "Ask the LLM (DeepSeek R1 or GPT-4o) for a trading decision."
    user_msg = f"""Analyze {context['symbol']} and decide:

Current price: ${context['current_price']:,.2f}
20-period SMA: ${context['sma20']:,.2f}
1h price change: {context['price_change_pct_1h']:+.2f}%
Funding rate (8h): {context['funding_rate_8h']*100:.4f}%
Open position: {context['open_position'] or 'None'}
Account equity: ${context['account_value_usd']:,.2f}

Work through the decision process in your reasoning, then output JSON."""

    log.info(f"Calling {MODEL} for {context['symbol']} decision...")
    resp = client.chat.completions.create(
        model=MODEL,
        messages=[
            {"role": "system", "content": TRADING_SYSTEM_PROMPT},
            {"role": "user",   "content": user_msg},
        ],
        temperature=0.1,   # low temp for consistent decisions
        max_tokens=1024,
    )
    # R1 exposes reasoning in resp.choices[0].message.reasoning_content
    reasoning = getattr(resp.choices[0].message, "reasoning_content", "")
    if reasoning:
        log.debug(f"[Reasoning] {reasoning[:400]}...")
    content = resp.choices[0].message.content.strip()
    # Strip markdown fences if model adds them
    if content.startswith("```"):
        content = content.split("\n", 1)[1].rsplit("```", 1)[0]
    return json.loads(content)

def execute_trade(decision: dict) -> None:
    if decision["action"] == "HOLD":
        log.info("Decision: HOLD — no trade placed")
        return
    side = "long" if decision["action"] == "BUY" else "short"
    payload = {
        "symbol":     decision["symbol"],
        "side":       side,
        "size_usd":   decision["size_usd"],
        "leverage":   decision["leverage"],
        "stop_loss":  decision["stop_loss_pct"],
        "take_profit": decision["take_profit_pct"],
    }
    with httpx.Client() as http:
        r = http.post(f"{PF_BASE}/trading/order", json=payload, headers=HEADERS)
    r.raise_for_status()
    log.info(f"Order placed: {side} {decision['symbol']} ${decision['size_usd']} @ {decision['leverage']}x")

def run_agent(symbol="BTC-PERP", interval_seconds=900):
    log.info(f"Agent starting | model={MODEL} | symbol={symbol} | interval={interval_seconds}s")
    while True:
        try:
            ctx      = get_market_context(symbol)
            decision = decide_trade(ctx)
            log.info(f"Decision: {decision['action']} | confidence={decision.get('confidence',0):.0%} | {decision.get('reasoning_summary','')}")
            if decision.get("confidence", 0) >= 0.60:
                execute_trade(decision)
            else:
                log.info("Low confidence — skipping execution")
        except Exception as e:
            log.error(f"Agent error: {e}")
        time.sleep(interval_seconds)

if __name__ == "__main__":
    run_agent()

LOG_LEVEL=DEBUG python agent.py

[Reasoning] The current price $95,420 is above the 20-period SMA of
$94,180, suggesting a mild uptrend. The 1h change of +1.2% is positive
but not extreme. The funding rate of +0.023% per 8h is slightly elevated,
indicating modest long bias in the market — not extreme enough to be
a strong contrarian signal. RSI context is not provided directly but
the price vs SMA relationship suggests bullish momentum... I'll take
a small long with tight stop at 2.5% to stay within the 2% account
risk rule at $500 position size...

# Use DeepSeek R1 (default, cheapest)
export MODEL_PROVIDER=deepseek

# Switch to GPT-4o for high-stakes sessions
export MODEL_PROVIDER=openai

# No code changes needed — the client factory handles the rest
python agent.py