DEV Community: qrak

LLM TRADER BOT

qrak — Wed, 29 Jul 2026 23:13:41 +0000

Let me tell you a story about failure.

Late 2024. I'm sitting in my Wrocław apartment after an 8-hour warehouse shift. My back hurts. I've been trying to make a trading bot work for two weeks. Every night, same result: the LLM generates beautiful-sounding analysis. Confident. Articulate. Completely wrong.

"RSI is 28, oversold. BUY."

Next morning: -4.2%.

The problem wasn't the LLM being stupid. It was me being lazy. I was dumping numbers into a prompt and hoping for magic — the exact thing every "LLM trading bot" tutorial on YouTube tells you to do.

I had three options: give up, buy a course, or do what nobody else was doing — read the actual research papers. I chose option three. 77 papers later, I understood the real problem. And I built something that fixes it.

1. Chart Vision — The LLM Reads Candlestick Images

Every cycle, the bot generates a 4K PNG candlestick chart with 5 overlay indicators (SMA, RSI, Volume, CMF, OBV). This image goes directly to Google Gemini 3.6 Flash. Not as bytes. Not as a data URL. As a visual inference.

I spent two weeks coding pattern detection algorithms — head and shoulders, wedges, trendlines. Then I compared the AI's visual reads against my code. The AI was better. By a lot. I deleted 900 lines of pattern detection code. Never looked back.

2. Bull vs Bear Debate — One Prompt, Two Sides

TradingAgents spawns separate agents for bull and bear analysis. Smart, but each one costs an API call. My bot gives the LLM a single instruction: argue the bullish case first (with evidence), then argue the bearish case (with the same rigor). Then decide.

One prompt. Both perspectives. Zero extra tokens. The model holds both arguments in context simultaneously — it can't "forget" the counter-argument halfway through.

3. EV Framework — What Optiver Said LLMs Can't Do

Optiver found LLMs can explain expected value but can't execute it. My EV Framework computes:

Win rate from trade history, filtered by similarity to current setup
Average win size vs average loss size
Expected P&L = (win_rate × avg_win) - ((1 - win_rate) × avg_loss)
Kelly fraction sizing based on account equity
Risk/reward validation before signal acceptance

The LLM provides the reasoning. The EV Framework provides the math. If the LLM says "strong buy" but EV comes back negative — HOLD.

4. Falsification Check — Name the Price That Proves You Wrong

Before any signal is accepted, the LLM must write one sentence:

"This signal would be proven wrong if [specific price level or indicator condition] occurs."

If it can't name one — rejected. If the named condition triggers — position closed early. If the condition is vague — rejected, try again. This single prompt addition improved signal quality more than any other change.

5. Vector Memory — The Bot Remembers Its Mistakes

Every closed trade gets embedded as a vector with 15+ metadata fields: symbol, direction, entry price, exit price, P&L percentage, max adverse excursion, timeframe, ADX at entry, trend strength, RSI, volume trend, pattern detected, news sentiment score, surprise ratio, and closed timestamp.

On every new analysis cycle, the bot queries ChromaDB (now on BAAI/bge-base-en-v1.5 768D embeddings): "Find me the 5 most similar trades to this current setup." These 5 trades are injected into the LLM prompt with their outcomes. Time-decay ensures recent trades carry 3x more weight than old ones.

6. Eight AI Agents Maintaining the Codebase

In the .ai/ directory, eight specialized agent prompts — one Supervisor plus seven workers. Each has a dedicated scope, journal, and personality. They've produced real commits:

Supervisor — Routes work, scans codebase via vector search
Bolt — Performance: found a sync file read in an async loop (40ms fix)
Palette — UX: ARIA labels, toast notifications, collapsible panels
Sentinel — Security: rate limiting, CSP headers, API key isolation
Refactor — Clean code: killed 27 isinstance chains, enforced DI pattern
Concise — Code reduction: cut 380 lines across the prompt builder
Bugfixer — Regressions: caught 3 bugs before they hit main
Smoke Tests — Pre-flight: syntax, import scan, ruff lint before every commit

133 commits since the agent system was introduced. Every one tested. Every one documented.

8. Validation Pipeline — Never Trust Raw LLM Output

Every AI response passes through:

TrendValidator — cross-checks LLM-reported trend against actual ADX calculations
PatternQualityScorer — deterministic score from real detection, not self-reporting
Falsification Check — reject signals that can't name their failure condition
6 Risk Guards — symbol whitelist, max position, cooldown, min R:R, SL/TP validity

7. Zero-Cost Sentiment — No API Keys

Reddit JSON (free, no auth), X/Twitter via Nitter (public feeds), RSS from CoinDesk, CoinTelegraph, Decrypt, CryptoSlate — enriched via Crawl4AI. All processed through a RAG engine built on ChromaDB. No monthly bills. No API rate limits.

The Test Suite

1,324 tests. Fully mocked — no network, no ChromaDB, no LLM API. They run in about 60 seconds on any machine. Codacy CLI v2 + ruff for automated quality gates. AST-based codebase vector search for semantic navigation.

Coverage includes: LLM output corruption, async race conditions, rate limiting with exponential backoff, vector DB boundaries, friction reporting for all 6 guard types, closed-loop feedback injection, ticker retry with network timeout handling.

When Optiver says LLMs "fail to incorporate new information after acting" — my tests verify the bot doesn't do that. When the arXiv survey says reproducibility is the bottleneck — my tests are deterministic.

☕ This project is 100% self-funded. No company. No investors. Just a warehouse worker paying for servers and API keys. If this gave you an idea or saved you time — Buy Me a Coffee helps keep it running. qrak.org has more free content (AdSense-supported — every visit helps).

What It Costs

Google Gemini 3.6 Flash: free tier (1,500 requests/day)
Technical indicators: CPU only (Numba JIT, microseconds)
News + Sentiment: free (Reddit JSON, Nitter, RSS + Crawl4AI enrichment)
Vector database: local ChromaDB, BAAI/bge-base-en-v1.5 768D embeddings
Hosting: home server (Ryzen 5700G, 32 GB RAM)
Dashboard: Cloudflare Tunnel (free tier)

Month-to-month cost: 0 zł. Not "almost free." Free.

Quick Start

git clone https://github.com/qrak/LLM_trader.git
cd LLM_trader
python -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
cp keys.env.example keys.env
python start.py

Dashboard at localhost:8000. Windows users: scripts/experimental_branch.ps1.

Honest Limitations

What this bot IS:

A research-grade, open-source LLM trading engine
Paper trading only (real execution via separate CCXT service)
Fully transparent — every prompt, response, and trade log is inspectable
Self-improving through reflection engine

What it's NOT:

A get-rich-quick scheme
A production trading system (yet)
Something you should trust with real money without extensive testing

Links

Source: github.com/qrak/LLM_trader
Live Dashboard: semanticsignal.qrak.org
Landing Page: qrak.org
Buy Me a Coffee: buymeacoffee.com/qrak
Email: contact@qrak.org

Built in Wrocław, Poland. No degree. No bootcamp. Just Python, asyncio, and thousands of hours after warehouse shifts.

☕ Support: buymeacoffee.com/qrak — every coffee = real API calls

📊 Live: semanticsignal.qrak.org — watch it trade in real time

📚 More: qrak.org — research, articles, free resources (AdSense-supported)

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

qrak — Wed, 29 Jul 2026 22:22:34 +0000

Let me tell you a story about failure.

December 2024. I'm sitting in my Wrocław apartment after an 8-hour warehouse shift. My back hurts. I've been trying to make a trading bot work for two weeks. Every night, same result: the LLM generates beautiful-sounding analysis. Confident. Articulate. Completely wrong.

"RSI is 28, oversold. BUY." Next morning: -4.2%.

I had three options: give up, buy a course, or do what nobody else was doing — read the actual research papers.

I chose option three. 77 papers later, I understood the real problem. And I built something that fixes it.

The Research Rabbit Hole

Here's what 77 academic papers and industry reports taught me about LLM trading:

TradingAgents (UCLA/MIT, 95k GitHub stars) — brilliant framework. Multi-agent debate, specialized analyst roles. But three dealbreakers: stocks only (no crypto), zero chart vision (raw numbers only), and every analysis costs 5+ API calls. Beautiful architecture, expensive to run.

Optiver's 2026 research — LLMs pass their intern trading exam. They understand EV. They can explain market making. But when it's time to actually execute? They freeze. Too conservative. Leave money on the table. The gap between understanding EV and maximizing EV is where real trading lives — and LLMs fail there.

Agentic Trading Survey (arXiv 2026) — 77 studies reviewed. Only 2 had proper time-consistent data splits. Zero reached reproducibility level R3. Most academic LLM trading papers are architecturally impressive PowerPoint slides with cherry-picked backtests. Try running their code.

Lopez-Lira at Bank of Finland — LLM agents can trade. But they don't give a damn about losing money unless you explicitly program them to care. They'll follow losing instructions straight to zero, smiling in their probabilistic way the whole time.

So I asked: what if one bot fixed all of this? Chart vision for pattern recognition. EV computation from real history. Falsification checks that reject hallucinated signals. Vector memory that remembers every trade outcome. And bull/bear debate that costs zero extra API calls.

That's what I built. Here's exactly how.

1. Chart Vision — The LLM Reads Candlestick Images

Why? Because I spent two weeks coding pattern detection algorithms — head and shoulders, wedges, trendlines, support/resistance. Then I compared the AI's visual reads against my code. The AI was better. By a lot.

I deleted 900 lines of pattern detection code. Never looked back.

2. 50+ Indicators, JIT-Compiled Locally

No pandas-ta. No TA-Lib. I built the entire indicator engine from scratch using NumPy and Numba. Every EMA, SMA, MACD, ADX, Stochastic, Bollinger Band, TTM Squeeze, Ichimoku component, and 11 moving average variants compiles to machine code on first call and caches the result.

@njit(cache=True)
def _ema_numba(prices, period):
    alpha = 2.0 / (period + 1)
    result = np.empty_like(prices)
    result[0] = prices[0]
    for i in range(1, len(prices)):
        result[i] = alpha * prices[i] + (1 - alpha) * result[i - 1]
    return result

50 indicators. All custom. All JIT-compiled. All running in microseconds on a CPU. No CUDA. No cloud. Just a Ryzen 5700G on my desk.

3. Bull vs Bear Debate — One Prompt, Two Sides, Zero Extra Cost

TradingAgents spawns separate agents for bull and bear analysis. Smart, but each one costs an API call. My bot gives the LLM a single instruction: argue the bullish case first (with evidence from the chart, indicators, and news), then argue the bearish case (with the same rigor). Then decide.

One prompt. Both perspectives. Zero extra tokens. The result is less biased because the model has to hold both arguments in context simultaneously — it can't "forget" the counter-argument halfway through.

4. EV Framework — What Optiver Said LLMs Can't Do

Optiver found LLMs can explain expected value but can't execute it. My EV Framework computes:

Win rate from trade history (filtered by similarity to current setup)
Average win size vs average loss size
Expected P&L = (win_rate × avg_win) — ((1 — win_rate) × avg_loss)
Kelly fraction sizing based on account equity
Risk/reward validation before signal acceptance

The LLM provides the reasoning. The EV Framework provides the math. Neither trusts the other blindly. If the LLM says "strong buy" but EV comes back negative — HOLD.

5. Falsification Check — Name the Price That Proves You Wrong

Before any signal is accepted, the LLM must write one sentence: "This signal would be proven wrong if [specific price level or indicator condition] occurs."

If it can't name one — signal rejected. If the named condition triggers before the next cycle — position closed early. If the named condition is vague ("if the market turns bearish") — rejected, try again with specificity.

This single prompt addition improved signal quality more than any other change. Hallucinated signals can't produce falsifiable claims.

6. ChromaDB Vector Memory — The Bot Remembers Its Mistakes

Every closed trade gets embedded as a vector with 15+ metadata fields:

symbol, direction, entry price, exit price, P&L percentage, max adverse excursion, timeframe, ADX at entry, trend strength, RSI, volume trend, pattern detected, news sentiment score, surprise ratio, and closed timestamp.

On every new analysis cycle, the bot queries: "Find me the 5 most similar trades to this current setup." These 5 trades are injected into the LLM prompt with their outcomes. The AI sees real results from similar past conditions.

Time-decay ensures recency matters: a trade from last week carries 3x more weight than one from two months ago, even if the indicators look identical.

7. Seven AI Agents that Maintain Their Own Codebase

In the .ai directory you'll find seven specialized agent prompts. Each has a dedicated scope, a journal, and a personality. They've produced real commits.

Bolt (performance): Found a sync file read in an async loop — 40ms latency fix
Palette (UX): Added ARIA labels, toast notifications, collapsible panels
Sentinel (security): Rate limiting middleware, CSP headers, API key isolation
Refactor (clean code): Killed 27 isinstance chains, enforced DI pattern across 14 modules
Concise (code reduction): Reduced 380 lines across the prompt builder
Bugfixer (regressions): Caught 3 bugs before they hit main — verified by reading ALL journals
Smoke Tests (pre-flight): Syntax check, import scan, and ruff lint before every commit

133 commits since the agent system was introduced. Every one of them tested and documented.

8. Validation Pipeline — Never Trust Raw LLM Output

Every AI response passes through:

TrendValidator: cross-checks LLM-reported trend strength against actual ADX calculations. Discrepancy over 15 points — computed value wins
PatternQualityScorer: deterministic 0-100 score from actual pattern detection, not LLM self-reporting
Falsification Check: reject signals that can't name their own failure condition
Risk Guards: symbol whitelist, max position size, cooldown window, minimum risk/reward, SL/TP validity, wrong-side SL/TP detection

9. Zero-Cost Sentiment — No API Keys, No Paid Services

Reddit JSON (free, no auth needed), X/Twitter through Nitter instances (public feeds), RSS from CoinDesk, CoinTelegraph, Decrypt, CryptoSlate. All processed through a RAG engine built on ChromaDB. No monthly bills. No API rate limits. Just free internet data, curated.

The Test Suite (The Part Nobody Talks About)

1,324 tests. Fully mocked — no network calls, no ChromaDB, no LLM API. They run in about 60 seconds on any machine.

What It Costs to Run

Google Gemini 3.6 Flash: free tier (1,500 requests/day)
Technical indicators: CPU (Numba JIT, microseconds)
News and Sentiment: free (Reddit JSON, Nitter, RSS)
Vector database: local ChromaDB (~50 MB disk, ~200 MB RAM)
Hosting: home server (Ryzen 5700G, 32 GB RAM)
Dashboard: Cloudflare Tunnel (free tier)

Month-to-month cost: exactly 0 zł. Not "almost free." Free.

Quick Start

git clone https://github.com/qrak/LLM_trader.git
cd LLM_trader
python -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
cp keys.env.example keys.env
python start.py

Dashboard at http://localhost:8000. Windows users: run scripts/experimental_branch.ps1.

Honest Limitations

What this bot IS: a research-grade, open-source LLM trading engine. Paper trading only. Fully transparent — every prompt, response, and trade log is inspectable. Self-improving through reflection engine.

What it's NOT: a get-rich-quick scheme, a production trading system (yet), or something you should trust with real money without extensive testing.

Links

Source: github.com/qrak/LLM_trader
Live Dashboard: semanticsignal.qrak.org
Landing Page: qrak.org
Buy Me a Coffee: buymeacoffee.com/qrak
Email: contact@qrak.org

Built in Wroclaw, Poland. No degree. No bootcamp. Just Python, asyncio, and thousands of hours after warehouse shifts.

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!
`

DEV Community: qrak

LLM TRADER BOT

1. Chart Vision — The LLM Reads Candlestick Images

2. Bull vs Bear Debate — One Prompt, Two Sides

3. EV Framework — What Optiver Said LLMs Can't Do

4. Falsification Check — Name the Price That Proves You Wrong

5. Vector Memory — The Bot Remembers Its Mistakes

6. Eight AI Agents Maintaining the Codebase

8. Validation Pipeline — Never Trust Raw LLM Output

7. Zero-Cost Sentiment — No API Keys

The Test Suite

What It Costs

Quick Start

Honest Limitations

Links

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

The Research Rabbit Hole

1. Chart Vision — The LLM Reads Candlestick Images

2. 50+ Indicators, JIT-Compiled Locally

3. Bull vs Bear Debate — One Prompt, Two Sides, Zero Extra Cost

4. EV Framework — What Optiver Said LLMs Can't Do

5. Falsification Check — Name the Price That Proves You Wrong

6. ChromaDB Vector Memory — The Bot Remembers Its Mistakes

7. Seven AI Agents that Maintain Their Own Codebase

8. Validation Pipeline — Never Trust Raw LLM Output

9. Zero-Cost Sentiment — No API Keys, No Paid Services

The Test Suite (The Part Nobody Talks About)

What It Costs to Run

Quick Start

Honest Limitations

Links

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

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

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

📊 What the AI Actually Sees (Real Example)

🧠 Multi-Model Intelligence & Local Privacy

🧬 Persistent Learning: The Trading Brain

📡 Discord Integration (Already Live)

⚙️ The Tech Stack

🚀 Get Started (Open Source & Beta)

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

Base URL for local LM Studio instance

OpenRouter

Google AI Studio

💬 Join the Community

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

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

1. Visual Pattern Recognition

2. Multi-Timeframe Context

3. Community Engagement Features

🛠️ The Tech Behind the Bot

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

🌐 Global Scale

🧪 Try It Live

🏁 Join the Future of Market Research