How to Use LLMs to Build Better Trading Strategies

LLMs as Trading Assistants

Most people think of LLMs as text generators. But for traders and developers, they're something more powerful: flexible reasoning engines that can analyze almost any type of information and structure it for decision-making.

Here are the key ways LLMs are being used in trading today.

1. Sentiment Analysis at Scale

Traditional sentiment analysis uses keyword counting or simple ML classifiers. LLMs understand nuance, sarcasm, and context much better.

from openai import OpenAI
import json

client = OpenAI()

def analyze_crypto_sentiment(text: str, asset: str) -> dict:
    response = client.chat.completions.create(
        model="gpt-4o-mini",  # Cost-efficient for high volume
        messages=[{
            "role": "user",
            "content": f"""Analyze this text for sentiment about {asset}.
            
Text: {text}

Return JSON:
{{
  "sentiment": "bullish|bearish|neutral",
  "score": -1.0 to 1.0,
  "key_factors": ["factor1", "factor2"],
  "urgency": "high|medium|low"
}}"""
        }],
        response_format={"type": "json_object"}
    )
    return json.loads(response.choices[0].message.content)

# Use on news articles, tweets, Reddit posts
result = analyze_crypto_sentiment(
    "Blackrock's Bitcoin ETF sees record $500M inflow despite market dip",
    "Bitcoin"
)
# {"sentiment": "bullish", "score": 0.75, ...}

2. Strategy Generation and Backtesting

Ask an LLM to brainstorm trading strategies based on a market observation:

def generate_trading_strategies(observation: str) -> list:
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{
            "role": "system",
            "content": """You are an expert quantitative trader.
            Given a market observation, generate 3 specific, testable trading strategies.
            For each strategy include: entry conditions, exit conditions, position sizing, and backtest approach."""
        }, {
            "role": "user",
            "content": f"Market observation: {observation}"
        }]
    )
    return response.choices[0].message.content

strategies = generate_trading_strategies(
    "BTC funding rates have been consistently positive for 2 weeks while price is flat"
)

3. Earnings and News Analysis

LLMs can parse financial announcements and extract trading-relevant signals:

def parse_crypto_announcement(announcement: str) -> dict:
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{
            "role": "user", 
            "content": f"""Analyze this crypto announcement for trading implications.
            
{announcement}

Extract:
1. Primary impact (bullish/bearish/neutral)
2. Affected assets
3. Timeframe (short/medium/long term)
4. Confidence level (high/medium/low)
5. Potential trading action

Return as JSON."""
        }],
        response_format={"type": "json_object"}
    )
    return json.loads(response.choices[0].message.content)

4. On-Chain Data Interpretation

Raw blockchain data is hard to interpret. LLMs can translate it:

def interpret_onchain_metrics(metrics: dict) -> str:
    context = f"""
    Whale wallets moved: {metrics['whale_movements']} BTC in last 24h
    Exchange inflows: {metrics['exchange_inflows']} BTC
    Exchange outflows: {metrics['exchange_outflows']} BTC
    Active addresses: {metrics['active_addresses']}
    MVRV ratio: {metrics['mvrv']}
    """
    
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{
            "role": "system",
            "content": "You are an expert in on-chain cryptocurrency analysis."
        }, {
            "role": "user",
            "content": f"Interpret these on-chain metrics and provide a market outlook:\n{context}"
        }]
    )
    return response.choices[0].message.content

5. Risk Assessment

Use LLMs to identify risks your quantitative models might miss:

def assess_trade_risks(trade_params: dict, market_context: str) -> dict:
    prompt = f"""
    Planned trade: {json.dumps(trade_params)}
    Current market context: {market_context}
    
    Identify top 5 risks for this trade that a quant model might miss.
    Include both market risks and execution risks.
    Rate each risk: low/medium/high.
    Return as JSON list.
    """
    # ... execute and return

Practical Pipeline: News-to-Signal

Here's a complete pipeline that monitors news and generates trading signals:

import asyncio
from rss_parser import Parser

CRYPTO_RSS_FEEDS = [
    "https://cointelegraph.com/rss",
    "https://decrypt.co/feed",
    "https://coindesk.com/arc/outboundfeeds/rss/"
]

async def news_to_signal_pipeline(assets: list[str]):
    while True:
        # 1. Fetch latest news
        articles = await fetch_latest_news(CRYPTO_RSS_FEEDS)
        
        # 2. Filter relevant articles
        relevant = [a for a in articles if any(asset.lower() in a.title.lower() for asset in assets)]
        
        # 3. Analyze each with LLM
        signals = []
        for article in relevant:
            sentiment = analyze_crypto_sentiment(article.content, article.mentioned_asset)
            if abs(sentiment['score']) > 0.6 and sentiment['urgency'] == 'high':
                signals.append({
                    'asset': article.mentioned_asset,
                    'direction': 'LONG' if sentiment['score'] > 0 else 'SHORT',
                    'confidence': abs(sentiment['score']),
                    'source': article.url
                })
        
        # 4. Execute high-confidence signals
        for signal in signals:
            if signal['confidence'] > 0.8:
                await execute_signal(signal)
        
        await asyncio.sleep(60)  # Check every minute

Cost Optimization

Running LLM analysis at scale can be expensive. Key optimizations:

• Use GPT-4o-mini for high-volume, simpler analysis ($0.15/1M input tokens)
• Use GPT-4o only for complex, high-stakes decisions
• Cache results — Don't re-analyze the same article twice
• Batch requests — Analyze multiple articles in one call
• Fine-tune a smaller model on your specific use case (cheapest at scale)

Limitations to Keep in Mind

• LLMs can hallucinate facts — always validate critical information
• Knowledge cutoffs mean they may not know about very recent events
• They're not deterministic — same prompt can give different results
• Cost at scale requires careful architecture

Get the Complete System

Our AI Trader NPM package includes pre-built LLM analysis pipelines for news, on-chain data, and market analysis — ready to plug into your bot.