diff --git a/README.md b/README.md index 94f02c8..6ab0961 100644 --- a/README.md +++ b/README.md @@ -1,7 +1,11 @@ # APEX — AI‑Powered MT5 EA Optimizer +[![Built with Claude Opus 4.7](https://img.shields.io/badge/Built%20with-Claude%20Opus%204.7-7c3aed?style=flat-square)](https://www.anthropic.com/news/claude-opus-4-7) [![License: MIT](https://img.shields.io/badge/License-MIT-10b981?style=flat-square)](LICENSE) [![Demo Mode](https://img.shields.io/badge/Demo-No%20MT5%20required-00d4aa?style=flat-square)](demo/run_demo.py) + > **An AI trader thinking out loud while it tests, fails, and improves a strategy.** +> Built with **[Claude Opus 4.7](https://www.anthropic.com/news/claude-opus-4-7)** for the [Cerebral Valley × Anthropic — Built with Opus 4.7 hackathon](https://cerebralvalley.ai/e/built-with-4-7-hackathon). + APEX is an autonomous optimizer for MetaTrader 5 Expert Advisors. Instead of brute‑forcing parameters with grid search, an LLM reads each backtest result, decides which parameter to change and why, then runs the next backtest — iterating toward profit‑factor / drawdown / diff --git a/SUBMISSION.md b/SUBMISSION.md new file mode 100644 index 0000000..a8c9e4c --- /dev/null +++ b/SUBMISSION.md @@ -0,0 +1,131 @@ +# APEX — Cerebral Valley × Anthropic "Built with Opus 4.7" Hackathon Submission + +Copy‑paste blocks for the submission form. Every field below is also a heading +so you can `Ctrl+F` to it. + +--- + +## Project name + +**APEX** — Autonomous Performance Evaluator (AI‑driven MT5 EA Optimizer) + +--- + +## One‑liner (≤140 chars) + +> An AI trader thinking out loud — Claude Opus 4.7 reads each backtest, decides what to change, and iterates toward profit‑factor / drawdown targets. + +## Tagline (≤80 chars) + +> Watch Claude Opus 4.7 optimize a trading strategy in real time. + +--- + +## Short description (≤300 chars) + +APEX turns Claude Opus 4.7 into an autonomous trading‑strategy optimizer for MetaTrader 5. The model reads every backtest, decides what parameters to change and why, then runs the next test — streaming its reasoning live to a dashboard until quality targets are met. + +--- + +## Long description (~500 words — the "what does it do" field) + +Most strategy optimizers are brute‑force grid searches: pick a metric, sweep N parameters, pray. The user gets a winning configuration but no idea *why* it won, no confidence in *whether* it'll generalize, and no transparency into the search process. + +**APEX replaces the grid with an AI loop.** Claude Opus 4.7 reads each backtest result, looks at the full iteration history, considers the parameter schema and quality targets, and returns a structured `{changes: [{param, value, reason}], confidence, goal_status}` — concrete, bounds‑checked parameter values for the next test, plus the reasoning that produced them. Every change, every reason, and every Claude token streams live to a dashboard so the user watches the AI think. + +The pipeline runs three phases: + +1. **Exploration** — Latin‑Hypercube sampling builds a broad map of profitable parameter regions +2. **AI Iteration** — Opus 4.7 takes over, hill‑climbing toward user‑set quality targets (PF ≥ X, DD ≤ Y, Calmar ≥ Z), with stuck‑detection and random‑escape when the loop converges to a local optimum +3. **Validation** — out‑of‑sample backtest on unseen dates + ±20% sensitivity nudge on the top parameter → verdict (RECOMMENDED / RISKY / NOT_RELIABLE) + +The dashboard exposes everything the AI is doing as it happens: + +- **Live AI Thinking Feed** — Claude's reasoning streams token‑by‑token via SSE with a typing cursor +- **Parameter Changes** — every iteration shows `prev → new` with the reason +- **Validation Activity** — each OOS / sensitivity test renders with live metrics +- **Replay Scrubber** — drag through every step that led to the winning configuration with metrics and AI analysis at each step +- **Compare Runs** — side‑by‑side metric and parameter diff for any 2–4 runs +- **Early Termination** — clear banner when targets are hit, budget exhausted, or the AI is stuck +- **Discord/Slack webhook** when an optimization completes + +For judges without MT5: there's a **demo mode** (`python -m demo.run_demo`) that synthesizes deterministic‑but‑realistic backtests so the entire AI loop, validation, and verdict flow run end‑to‑end with no MT5 install. Roughly 35% of Phase 1 samples and 30% of OOS runs realistically fail, so verdicts genuinely span RECOMMENDED / RISKY / NOT_RELIABLE. + +The point isn't a better trading strategy — it's a working pattern for **AI‑as‑driver of a long‑running optimization loop**, with the AI's reasoning fully visible. That pattern transfers to any iterative search problem where humans currently grid‑sweep blindly: ML hyperparameter tuning, A/B variant generation, ad‑creative optimization, infrastructure cost tuning. + +--- + +## Built with + +Claude Opus 4.7 (the reasoning loop), Flask + Flask‑SocketIO (real‑time UI), Python 3.11, Pandas + NumPy, Pydantic, Anthropic Messages API with SSE streaming, MetaTrader 5 Strategy Tester (real backtests). + +--- + +## How Claude Opus 4.7 is used (the "what AI features did you use" field) + +- **`suggest_next_params()` — Opus 4.7 is the loop driver.** It receives the full parameter schema, the iteration history (last 15 runs with metrics + changes), and the user's quality targets, and returns structured JSON with concrete parameter values, per‑change reasoning, a confidence score, and a goal‑status breakdown (which targets are met). This is the load‑bearing call — it's what turns the optimizer from a grid search into an agent. +- **`analyze()` — Per‑run diagnostics.** A second Opus 4.7 call interprets each backtest's metrics + analyzer findings + recent run history and returns headline / diagnosis / patterns / suggestions / risk flags. Powers the AI Summary panel. +- **SSE streaming** — both calls run with `stream=true`. Each text delta forwards to the dashboard as `ai_thinking_chunk` events so the user sees Claude's reasoning type out token‑by‑token. Single growing bubble per call with a blinking cursor that finalises on `end`. +- **Hot model swap** — users can change model (`claude-opus-4-7` ↔ `claude-sonnet-4-6` ↔ `claude-haiku-4-5`) mid‑run via Settings. The next iteration uses the new model without restart. + +--- + +## GitHub URL + +https://github.com/tonnylegacy/MT5_Optimizer + +--- + +## Demo URL + +No hosted demo (the app runs locally to drive a local MT5 install). For judges: + +- **Static**: open `screenshots/apex_demo.gif` in the repo (6‑frame timelapse of one autonomous run) +- **Run it**: `git clone … && pip install -r requirements.txt && python -m demo.run_demo` → opens at `http://localhost:5000` with synthetic backtests, no MT5 required +- **With API key**: set `ANTHROPIC_API_KEY` env var to see live Claude reasoning stream into the Thinking Feed + +--- + +## Video / GIF + +`screenshots/apex_demo.gif` (438 KB, GitHub‑embedded in README hero) + +--- + +## Team + +Solo build — `tonnylegacy` + +--- + +## Tags + +`mt5` `metatrader5` `trading` `quant` `optimization` `claude-opus-4-7` `anthropic` `ai-agents` `agentic-loops` `python` `flask` `socketio` `streaming-ui` + +--- + +## Tech stack + +`Python 3.11` · `Anthropic Messages API (SSE streaming)` · `Claude Opus 4.7` · `Flask` · `Flask‑SocketIO` · `Pandas / NumPy / Pydantic` · `MetaTrader 5 Strategy Tester` + +--- + +## License + +MIT + +--- + +## Submission checklist + +- [x] Repo public on GitHub: +- [x] LICENSE file (MIT) +- [x] README with pitch + screenshots + install + architecture diagram +- [x] No leaked API keys (config.yaml git‑ignored, env‑var fallback wired, GET /api/settings masks key) +- [x] `config.example.yaml` template for users +- [x] Animated demo GIF in `screenshots/apex_demo.gif` +- [x] Demo mode that runs without MT5 (`python -m demo.run_demo`) +- [x] Opus 4.7 is the default model (config + AIReasoner class default) +- [x] Streaming reasoning visible to the user (SSE → `ai_thinking_chunk`) +- [ ] Recorded a 30–60 second screen capture for any "video" field — *do this last; the GIF can substitute* +- [ ] Submission form filled — *paste blocks above into the Cerebral Valley form when it opens* diff --git a/analysis/ai_reasoner.py b/analysis/ai_reasoner.py index 57bd950..d8d692f 100644 --- a/analysis/ai_reasoner.py +++ b/analysis/ai_reasoner.py @@ -73,11 +73,13 @@ class AIReasoner: Falls back gracefully if API key is missing or call fails. """ - MODEL = "claude-sonnet-4-6" + MODEL = "claude-opus-4-7" # default — overridden by config.ai.model when present API_URL = "https://api.anthropic.com/v1/messages" TIMEOUT = 30 # seconds - def __init__(self, api_key: Optional[str] = None): + def __init__(self, api_key: Optional[str] = None, model: Optional[str] = None): + if model: + self.MODEL = model # If the caller passes a placeholder like "${ANTHROPIC_API_KEY}" or an # empty string, treat it as missing and fall back to the env var. candidate = (api_key or "").strip() diff --git a/optimizer/pipeline.py b/optimizer/pipeline.py index d62c0c4..859cb8a 100644 --- a/optimizer/pipeline.py +++ b/optimizer/pipeline.py @@ -240,9 +240,14 @@ class OptimizationPipeline: ranker = ResultRanker(weights=cfg.scoring_weights) budget = BudgetManager(cfg.budget_minutes) - # Initialize AI reasoning layer + # Initialize AI reasoning layer (model + timeout from config) api_key = load_api_key(self.config_path) - self._ai_reasoner = AIReasoner(api_key=api_key) + ai_cfg = (self.cfg.get("ai") or {}) + model = ai_cfg.get("model") or "claude-opus-4-7" + self._ai_reasoner = AIReasoner(api_key=api_key, model=model) + if "timeout_seconds" in ai_cfg: + try: self._ai_reasoner.TIMEOUT = int(ai_cfg["timeout_seconds"]) + except Exception: pass # Stream Claude's reasoning tokens to the dashboard as they arrive. # The Live AI Thinking Feed listens for `ai_thinking_chunk` events. try: