Forem: qrak

Stop Trading Like It's 1999: I Built an Autonomous, Vision-Capable Crypto Bot with Python 3.13 🚀

qrak — Wed, 31 Dec 2025 22:35:28 +0000

`How I "Vibe Coded" an asyncio-first trading engine that bridges the gap between technical indicators and human-scale market context.

In the world of algorithmic trading, we've been stuck in a loop. We rely on RSI, MACD, and Bollinger Bands—mathematical formulas designed for an era before high-frequency sentiment and global AI reasoning. While these indicators are foundational, they are blind to context.

A human trader doesn't just buy because an RSI hits 30. They look at the shape of the wedge, they read the fear in the headlines, and they interpret the "vibe" of the order book.

I wanted to build a bot that doesn't just calculate—it reasons.

Meet LLM_Trader v2: An autonomous, vision-capable trading engine that turns market data, news, and chart context into structured BUY/SELL/HOLD/UPDATE decision.

LLM_Trader v2 in action.

🏗️ The Architecture: A "Brain" for the Markets

Most AI bots fail because they simply dump raw numbers into a prompt. LLM_Trader v2 uses a sophisticated multi-stage pipeline designed for confluence:

The Muscles (Market Data): Using ccxt, the bot aggregates data from 5+ major exchanges (Binance, KuCoin, Gate.io, MEXC, Hyperliquid). But it doesn't stop at price—it analyzes:
- Technical Indicators: (Custom engine, built from scratch without pandas-ta).
- Order book depth & spread analysis.
- Trade flow (Buy/Sell ratio, trade velocity).
- Funding rates for perpetual futures.
- OHLCV across 7 timeframes: 4H, 12H, 24H, 3D, 7D, 30D, 365D.
The Eyes (Vision Engine): The bot renders a ~150 candlestick chart using Plotly, optimized for AI pattern recognition. This image is sent directly to Vision models (Gemini Flash) for visual pattern analysis—because sometimes, a chart pattern is worth a thousand RSI readings.
The Ears (RAG Engine): Real-time news via CryptoCompare, processed with wtpsplit for neural sentence segmentation. The bot extracts key facts and numbers, filtering noise to give the LLM a "ground truth" of current events—not just headlines, but data-rich sentences.
The Brain (Model Manager): All this context—textual data, visual charts, news snippets, and market metrics—is orchestrated by a model manager that toggles between Google Gemini, Claude (via OpenRouter), or local models via LM Studio.

🧠 From "Chat" to "Execution": The PositionExtractor

(New Feature in v2)
The magic isn't just in the prompt—it's in the parsing. I built a robust PositionExtractor that doesn't just "guess" what the AI wants. It uses standardized REGEX patterns to consistently extract:

Action: BUY / SELL / HOLD / CLOSE
Confidence: HIGH / MEDIUM / LOW (mapped to position sizing)
Rationale: A structured explanation that is logged for future "Trading Brain" learning.

📊 What the AI Actually Sees (Real Example)

Here's a glimpse of what gets sent to the AI for a single analysis cycle:

`yaml
TRADING CONTEXT:

Symbol: BTC/USDC
Current Price: $87,499
Fear & Greed Index: 24 (Extreme Fear) - 7 day history

MARKET OVERVIEW:

Total Market Cap: $3.88T | BTC Dominance: 56.52%
Order Book Imbalance: +0.180 (Moderate Buy Pressure)
Buy/Sell Ratio: 0.16 (Strong Selling)

TECHNICAL ANALYSIS (4h):

RSI: 46.65 | MACD Histogram: +112.46
ADX: 12.86 | Stochastic: 60.02/73.78
Death Cross Active (20 SMA < 50 SMA)
TTM Squeeze: Extreme Low Volatility
Volume Spike: 2.55x average

WEEKLY MACRO (200W SMA):

Trend: Bullish (100% confidence)
Cycle Phase: Early Bull Market
Distance from 200W SMA: +46.2%

DETECTED PATTERNS:

MACD bull cross 9 bars ago
Stochastic bull cross in oversold (12 bars ago)
MACD Bullish Divergence (64 bars ago)
Volume spike 2.55x average (NOW)

NEWS CONTEXT:

"Bitcoin Soars Past $89,000 Milestone..."
"Crypto Shorts Liquidated: $64M Wiped Out..." `

The AI synthesizes all of this—plus a chart image and its previous analysis—into a structured JSON decision with confluence scoring.

🧠 Multi-Model Intelligence & Local Privacy

One of the biggest upgrades in v2 is Provider Resilience. If Google's API is down, the bot automatically falls back to OpenRouter. If you want 100% privacy, it connects to LM Studio, allowing you to run the entire reasoning layer on your own hardware.

Currently supported models:

Any model with Google API (Flash, Pro, 2.5, 3.0)
Any model (preferred vision models) via OpenRouter
Any local model via LM Studio

🧬 Persistent Learning: The Trading Brain

Here's where it gets interesting. LLM_Trader v2 doesn't just trade—it learns. After every closed trade, the bot analyzes its performance and distills lessons into a persistent TradingBrain:

Confidence Calibration: Tracks win rates by confidence level. If "HIGH confidence" trades have a 0% win rate, the AI sees this and adjusts.
Distilled Insights: Stores lessons like "SL too tight (1.4%) caused early exit. Consider 1.5–2% minimum in Sideways + Weak Trend + Low Vol."
Factor Performance: Tracks which confluence factors (volume support, trend alignment) correlate with wins.
Time Decay: Recent insights weighted higher (0.95 per week), so the bot adapts to changing regimes.

This feedback loop means the bot genuinely improves over time.

📡 Discord Integration (Already Live)

Real-time signals delivered straight to your Discord server:

Trade notifications (BUY/SELL/CLOSE with reasoning)
Position status updates
Message tracking for cleanup
Configurable via config.ini

⚙️ The Tech Stack

Built with an "Asyncio-First" approach in Python 3.13:

Language: Python 3.13 (asyncio-first)
Data Aggregation: ccxt (5+ exchanges)
Charting: Plotly + Kaleido
Technical Indicators: Custom engine with numpy, pandas, numba, scipy
NLP/Segmentation: wtpsplit (backed by torch)
Market Data: CoinGecko API (global metrics, dominance, DeFi)
Sentiment: Fear & Greed Index (7-day history) (alternative.me)
Persistence: JSON-based Trading Brain
Notifications: Discord.py

🚀 Get Started (Open Source & Beta)

The project is in BETA and configured for Paper Trading. Watch the bot make decisions without risking a dollar.

Clone & Install
bash git clone https://github.com/qrak/LLM_trader.git cd LLM_trader python -m venv .venv source .venv/bin/activate # or .venv\Scripts\Activate.ps1 pip install -r requirements.txt
Configure Your Keys
Copy keys.env.example to keys.env and add your API keys (Google AI, OpenRouter, CryptoCompare, CoinGecko).
Customize Your Strategy (config.ini)
The bot is fully configurable via config/config.ini. You can switch AI providers, change timeframes, or enable/disable Discord integration without touching the code.

`ini
[ai_providers]

Options: "local", "googleai", "openrouter", "all"

provider = googleai

Base URL for local LM Studio instance

lm_studio_base_url = http://localhost:1234/v1
lm_studio_model = local-model

OpenRouter

openrouter_base_url = https://openrouter.ai/api/v1
openrouter_base_model = google/gemini-2.0-flash-exp:free

Google AI Studio

google_studio_model = gemini-3-flash-preview

[general]
crypto_pair = BTC/USDC
timeframe = 4h
candle_limit = 999
ai_chart_candle_limit = 150
discord_bot = false
`
Launch the Engine
bash python start.py

💬 Join the Community

Trading is better with friends (and more AI).

GitHub: github.com/qrak/LLM_trader
Discord: Join our Development Chat

Disclaimer: This software is for educational purposes. Crypto trading involves high risk. Always paper trade first.
`

Elevating Crypto Communities: How I Combined Discord and AI for Real-Time Market Intelligence 📊🤖

qrak — Wed, 31 Dec 2025 22:32:16 +0000

`
Managing a crypto community is a full-time job. Between the "When Moon?" questions and the "Is BTC dumping?" panic, community admins are often overwhelmed.

What if you could give your members access to a professional-grade technical analyst that never sleeps, never gets emotional, and can visually analyze charts in seconds?

I built DiscordCryptoAnalyzer to bridge this gap—a powerful, vision-powered bot that turns any Discord channel into a high-octane research lab.

🌟 Why This Isn't Just "Another Discord Bot"

Most market bots just spit out a price or a simple RSI number. DiscordCryptoAnalyzer takes a fundamentally different approach. It uses Vision Models (like Gemini Flash) to "see" the market the way a human does.

1. Visual Pattern Recognition

When a user types !analyze BTC/USDT, the bot doesn't just look at numbers. It:

Fetches real-time candles from Binance or KuCoin.
Renders a high-resolution Plotly chart with support/resistance levels and pivot points.
Sends that actual image to an AI vision model.
The AI identifies "head and shoulders," "wedges," and "breakouts" visually, providing a reasoning that humans can verify on the spot.

Short json message in action

2. Multi-Timeframe Context

The bot doesn't judge a coin by a single candle. It analyzes context across 1h, 4h, and 12h timeframes simultaneously to detect trend strength and divergence.

3. Community Engagement Features

Educational References: Technical terms in the analysis automatically link to definitions, helping community members learn as they trade.
Multilingual Support: The bot can provide analysis in English, Polish, Spanish, and more, making it perfect for global crypto groups.
Interactive Reports: Along with the Discord summary, it generates a full interactive HTML report for deep-dive research. You can see a live example of an BTC/USDT analysis report here.

Detailed technical breakdown and AI rationale.

🛠️ The Tech Behind the Bot

Built for speed and flexibility, the bot features a user-configurable AI orchestration layer. Through config.ini, users have total control over the intelligence level:

Single Provider Mode: Lock the bot to a specific provider like Google Gemini (GenAI SDK), OpenRouter, or local LM Studio for maximum control.
Fallback Chain ("All"): Enable a resilient fallback system (Google AI → LM Studio → OpenRouter) to ensure the bot continues operating even if a primary API hits a rate limit or goes offline.
Vision Optimization: Specifically tuned for vision-capable models (e.g., gemini-1.5-flash-latest) to ensure visual patterns are accurately extracted.

⚡ Performance & Engineering: It's Not Just a Script

What makes this bot truly "production-ready" isn't just the AI—it's the robust architecture behind it.

1. Numba Acceleration (Custom Engine)
We didn't just import pandas-ta. We built our own indicator engine from scratch using Native NumPy + Numba JIT.

Why? Standard libraries are bloated. Our custom @njit(cache=True) implementations for EMA, SMA, and overlap indicators calculate in microseconds, ensuring the bot handles high-frequency message spikes without blocking the asyncio event loop.

2. Smart Anti-Spam & Role Management
Community health is as important as signals. The bot includes a custom AntiSpam cog that:

Uses commands.CooldownMapping to track user message frequency bucket-style.
Automatically assigns a configurable "Muted" role to spammers.
Cleans up its own tracking references (_cleanup_user_tracking) to prevent memory leaks.

3. Layered Agent Architecture
The codebase follows a strict Instruction Hierarchy (referenced in AGENTS.md), separating the "Brain" (AnalysisEngine), "Muscles" (DiscordCryptoBot), and "Eyes" (Plotly). This makes it easy for other developers to contribute without breaking the core logic.

🌐 Global Scale

Straight out of the box, the bot supports 8 languages (English, Polish, Spanish, French, Chinese, etc.), configurable via config.ini. It automatically adapts its technical analysis explanations to the user's local language.

🧪 Try It Live

I've set up a dedicated environment where you can test the bot's features right now:

Join the Lab: Discord Invitation Link
Repo: qrak/DiscordCryptoAnalyzer

🏁 Join the Future of Market Research

AI is changing the way we interpret data. By bringing high-level reasoning directly into the social hub of crypto—Discord—we're making institutional-grade analysis accessible to everyone.

If you found this useful, feel free to star the repo or join our development chat!
`