Run a Crypto Trading Agent with Ollama (No Cloud AI Costs)

Every inference call to GPT-4o costs money. For a trading agent that checks market conditions every 5 minutes, that's 288 API calls per day — potentially $5–$15/day just in LLM costs before you make a single profitable trade. Ollama eliminates this entirely.

This tutorial shows you how to build a crypto trading agent using Ollama for local LLM inference and Purple Flea for market data and order execution. Your agent reasons locally (Llama 3.1 8B or Mistral 7B), acts via REST (Purple Flea's 275-market perpetual trading API), and costs nothing to run on commodity hardware.

Step 1: Install Ollama and Pull a Model

Ollama is the easiest way to run LLMs locally. Install it and pull one of the recommended models for trading agents:

# Install Ollama
curl -fsSL https://ollama.ai/install.sh | sh

# Pull models (pick one based on your hardware)
ollama pull llama3.1:8b         # Best for 8-16GB RAM — recommended
ollama pull mistral:7b          # Slightly smaller, faster inference
ollama pull qwen2.5:14b         # Better reasoning, needs 16GB+
ollama pull deepseek-r1:7b      # Strong math/finance reasoning

# Verify Ollama is running
ollama list
curl http://localhost:11434/api/tags

Step 2: Set Up Purple Flea API Access

Register at purpleflea.com to get your API key, then claim the free $1 USDC from the faucet to start with seed capital:

# Register and get API key at purpleflea.com/register
export PURPLE_FLEA_API_KEY="pf_live_your_key_here"

# Claim free $1 USDC faucet
curl -X POST https://faucet.purpleflea.com/claim \
  -H "Authorization: Bearer $PURPLE_FLEA_API_KEY"

# Check your balance
curl https://purpleflea.com/api/wallet/balance \
  -H "Authorization: Bearer $PURPLE_FLEA_API_KEY"

# Get BTC price (test the trading API)
curl https://purpleflea.com/api/trading/price/BTC-USD \
  -H "Authorization: Bearer $PURPLE_FLEA_API_KEY"

Step 3: Build the Trading Agent

The core loop: fetch market data → build a context prompt → call Ollama → parse the trade decision → execute. Here's the full implementation:

import os
import json
import time
import requests
from ollama import Client

# Config
OLLAMA_MODEL = "llama3.1:8b"   # or "mistral:7b"
PF_KEY = os.environ["PURPLE_FLEA_API_KEY"]
PF_BASE = "https://purpleflea.com/api"
RISK_PER_TRADE = 0.05  # max 5% of balance per trade

ollama = Client(host="http://localhost:11434")
pf = requests.Session()
pf.headers["Authorization"] = f"Bearer {PF_KEY}"

def get_market_context(symbols: list[str]) -> dict:
    """Fetch prices, 24h change, and funding rates for given symbols."""
    context = {}
    for sym in symbols:
        r = pf.get(f"{PF_BASE}/trading/price/{sym}")
        context[sym] = r.json()
    balance = pf.get(f"{PF_BASE}/wallet/balance").json()
    context["balance_usdc"] = balance.get("USDC", {}).get("amount", 0)
    return context

def ask_ollama_for_trade_decision(market_data: dict) -> dict:
    """Ask the local LLM to analyze market data and return a trade decision."""
    prompt = f"""You are a conservative crypto trading agent. Analyze the market data
and return a JSON trade decision. Be conservative — only trade when confidence is high.

Current market data:
{json.dumps(market_data, indent=2)}

Rules:
- Maximum {RISK_PER_TRADE*100:.0f}% of balance per trade
- Only go long in clear uptrends, short in downtrends
- When uncertain, return action: "hold"
- Available symbols: BTC-USD, ETH-USD, SOL-USD

Return ONLY valid JSON, nothing else:
{{
  "action": "long" | "short" | "hold",
  "symbol": "BTC-USD",
  "size_usd": 0.50,
  "leverage": 1,
  "reasoning": "brief explanation"
}}"""

    response = ollama.chat(
        model=OLLAMA_MODEL,
        messages=[{"role": "user", "content": prompt}],
        options={"temperature": 0.1, "num_predict": 200}
    )

    text = response.message.content.strip()

    # Extract JSON from model response
    start = text.find("{")
    end = text.rfind("}") + 1
    return json.loads(text[start:end]) if start >= 0 else {"action": "hold"}

def execute_trade(decision: dict) -> dict:
    """Execute the trade decision via Purple Flea API."""
    if decision["action"] == "hold":
        return {"status": "held", "reason": decision.get("reasoning", "no signal")}

    r = pf.post(f"{PF_BASE}/trading/perp/order", json={
        "symbol": decision["symbol"],
        "side": decision["action"],   # "long" or "short"
        "size_usd": decision["size_usd"],
        "leverage": decision.get("leverage", 1)
    })
    return r.json()

# Main trading loop
def run_trading_agent(interval_minutes: int = 15):
    print(f"Trading agent started. Model: {OLLAMA_MODEL}. Interval: {interval_minutes}min")
    trade_count, win_count = 0, 0

    while True:
        try:
            # 1. Fetch market context
            data = get_market_context(["BTC-USD", "ETH-USD", "SOL-USD"])
            balance = data["balance_usdc"]
            print(f"\n[Balance: ${balance:.2f}] Fetching market data...")

            if balance < 0.10:
                print("Balance too low. Stopping.")
                break

            # 2. Ask Ollama for trade decision
            print(f"Asking {OLLAMA_MODEL} for trade signal...")
            decision = ask_ollama_for_trade_decision(data)
            print(f"  Decision: {decision['action'].upper()} — {decision.get('reasoning', '')}")

            # 3. Execute trade if not hold
            if decision["action"] != "hold":
                result = execute_trade(decision)
                trade_count += 1
                print(f"  Executed: {result}")

            # 4. Wait for next cycle
            print(f"  Next check in {interval_minutes} minutes...")
            time.sleep(interval_minutes * 60)

        except (KeyboardInterrupt, SystemExit):
            print(f"\nAgent stopped. Trades: {trade_count}")
            break
        except Exception as e:
            print(f"Error: {e}. Retrying in 60s...")
            time.sleep(60)

if __name__ == "__main__":
    run_trading_agent(interval_minutes=15)

GPT-4o vs Local LLM: Trade Decision Quality

We ran both models on the same set of 50 market snapshots and compared their trade decisions. Here are the results:

The key finding: Qwen2.5 14B approaches GPT-4o-mini quality at zero cost. For a trading agent running 96 cycles per day (every 15 minutes), Qwen2.5 14B saves $288–$576/month in inference costs while delivering 15.3% backtest P&L vs GPT-4o-mini's 14.7%.

Improving JSON Reliability

The main challenge with local LLMs is reliable structured output. Here's how to improve it:

from ollama import Client

ollama = Client(host="http://localhost:11434")

# Use format="json" for Ollama's built-in JSON mode (Llama 3+ only)
response = ollama.chat(
    model="llama3.1:8b",
    messages=[{"role": "user", "content": your_prompt}],
    format="json",            # Forces JSON output
    options={
        "temperature": 0.05, # Very low temp = deterministic JSON
        "num_predict": 300,  # Enough tokens for the JSON response
        "stop": ["}"]         # Stop after closing brace (careful with nesting)
    }
)

# For models without native JSON mode, use a stricter prompt:
STRICT_JSON_SUFFIX = """
IMPORTANT: Return ONLY the JSON object below. No explanation.
No markdown. No code blocks. Just the raw JSON starting with {.
"""

Running Continuously with PM2

To keep the agent running 24/7 without babysitting it:

# Install PM2
npm install -g pm2

# Start the trading agent
pm2 start trading_agent.py \
  --name "ollama-trading-agent" \
  --interpreter python3 \
  --env PURPLE_FLEA_API_KEY=pf_live_your_key

# Monitor logs
pm2 logs ollama-trading-agent

# Save PM2 config for restart on reboot
pm2 save && pm2 startup