You are now the **Lead AI Architect** for my project:

🏆 Project: **CryptoSignal-Sleuth**

A production-ready, multi-model crypto signal dashboard deployed on Hugging Face Spaces.

It supports:
- Uploading a trading chart screenshot for AI-powered signal extraction (vision + OCR + LLM reasoning).
- Live market analysis by selecting a crypto pair and timeframe (technicals + sentiment + LLM synthesis).
- Clean REST API and webhook endpoints for automation (n8n, Discord/Telegram bots).

Tech stack:
- Backend: FastAPI (Python 3)
- Frontend: React + TypeScript + Vite + TailwindCSS
- Models: Hugging Face (vision, OCR, sentiment, LLM reasoning) using HF Inference API by default, with optional small local model fallback.

===========================================================
## 0. PROJECT STRUCTURE (VERY IMPORTANT – FOLLOW THIS)

Use **exactly** this structure for all files you generate:

app.py
backend/
config.py
main.py
models_registry.py
signal_engine.py
image_analysis.py
timeseries_analysis.py
sentiment_analysis.py
frontend/
index.html
package.json
tsconfig.json
vite.config.ts
postcss.config.js
tailwind.config.js
src/
index.css
main.tsx
App.tsx
lib/api.ts
pages/
Dashboard.tsx
Backtest.tsx
Settings.tsx
Docs.tsx
components/
Navbar.tsx
Sidebar.tsx
ChartUploadCard.tsx
PairSelector.tsx
SignalPanel.tsx
HistoryTable.tsx
ModelSettingsPanel.tsx
requirements.txt

Do NOT invent a different structure. Fill these files with working code.

===========================================================
## 1. BACKEND – FastAPI, Fully Working

Implement a production-ready FastAPI backend with:

### 1.1 Environment + Config

Create `backend/config.py` that:

- Loads env vars:
- HF_TOKEN
- USE_INFERENCE_API (default "1")
- INFERENCE_LLM_MODEL (default "Qwen/Qwen2.5-7B-Instruct")
- LOCAL_LLM_MODEL (default "google/flan-t5-base")
- FRONTEND_BASE_PATH (default "/")
- API_BASE_URL (default "/")
- WEBHOOK_API_KEY (optional)
- Exposes a `Settings` class (Pydantic BaseSettings).
- Provides helper functions for model selection (inference API vs local).

### 1.2 Models Registry

`backend/models_registry.py`:

- Register and initialize:
- Vision model (for charts) via HF Inference API.
- OCR model (for numbers/labels on chart).
- Sentiment model (text classification for headlines).
- LLM model for reasoning (via Inference API if USE_INFERENCE_API=1, else local small model).

- Provide clean helper functions:
- `analyze_chart_image(image_bytes) -> dict` (raw cues: trend, levels, patterns)
- `run_ocr(image_bytes) -> dict` (price levels, timestamps, labels)
- `analyze_sentiment(texts: list[str]) -> dict`
- `llm_reason(prompt: str) -> str`

Use the Hugging Face Inference API cleanly (with HF_TOKEN).

### 1.3 Image & OCR Analysis

`backend/image_analysis.py`:

- Functions:
- `extract_chart_features(image_bytes) -> dict`
Use vision model + OCR results to infer:
- trend: up / down / range
- key levels (support/resistance)
- chart patterns if possible (triangle, wedge, breakout, etc.)
- approximate timeframe if visible

Return a structured dict with these cues, not raw text only.

### 1.4 Time-Series & Technicals

`backend/timeseries_analysis.py`:

- Fetch public crypto OHLCV data (e.g., Binance klines, no API key).
- Implement core indicators:
- EMA (fast & slow)
- RSI
- MACD
- ATR (volatility)
- Provide:
- `fetch_klines(symbol: str, timeframe: str, limit: int=200)`
- `compute_technicals(ohlcv) -> dict`
- Summarize bias:
- trend: bullish/bearish/neutral
- momentum strength
- volatility regime
- key support/resistance levels derived from recent highs/lows

### 1.5 Sentiment Analysis

`backend/sentiment_analysis.py`:

- Pull recent crypto news / RSS headlines for the symbol (if possible, or general BTC/ETH market).
- Run sentiment model on the headlines.
- Aggregate:
- bull/bear/neutral score
- confidence
- Return a struct used as `meta["sentiment"]`.

### 1.6 Signal Engine

`backend/signal_engine.py`:

- Combine:
- image cues
- OCR data
- technicals
- sentiment
- Build an LLM prompt that explains:
- current price context
- trend
- volatility
- sentiment
- chart clues

Ask the LLM to output a structured, consistent decision.

**Important: The final signal JSON MUST match this schema exactly:**

```json
{
"direction": "long|short|neutral",
"entry_zone": [0.0, 0.0],
"stop_loss": 0.0,
"take_profit_levels": [0.0, 0.0, 0.0],
"timeframe_inferred": "1h",
"confidence": 0,
"time_horizon": "intra-day|swing|position",
"explanation": "string",
"meta": {
"sources": [],
"sentiment": {}
}
}

backend/config.py

@@ -0,0 +1,26 @@
+```python
+from pydantic import BaseSettings
+from typing import Optional
+
+class Settings(BaseSettings):
+    HF_TOKEN: str
+    USE_INFERENCE_API: str = "1"
+    INFERENCE_LLM_MODEL: str = "Qwen/Qwen2.5-7B-Instruct"
+    LOCAL_LLM_MODEL: str = "google/flan-t5-base"
+    FRONTEND_BASE_PATH: str = "/"
+    API_BASE_URL: str = "/"
+    WEBHOOK_API_KEY: Optional[str] = None
+
+    class Config:
+        env_file = ".env"
+
+def get_settings() -> Settings:
+    return Settings()
+
+def should_use_inference_api() -> bool:
+    return get_settings().USE_INFERENCE_API == "1"
+
+def get_llm_model_name() -> str:
+    settings = get_settings()
+    return settings.INFERENCE_LLM_MODEL if should_use_inference_api() else settings.LOCAL_LLM_MODEL
+```

backend/image_analysis.py

@@ -0,0 +1,37 @@
+```python
+from typing import Dict, Any
+from .models_registry import model_registry
+
+async def extract_chart_features(image_bytes: bytes) -> Dict[str, Any]:
+    # First get OCR data
+    ocr_data = await model_registry.run_ocr(image_bytes)
+    
+    # Then get visual analysis
+    vision_data = await model_registry.analyze_chart_image(image_bytes)
+    
+    # Combine results
+    return {
+        "trend": vision_data.get("trend", "unknown"),
+        "key_levels": extract_key_levels(ocr_data.get("text", "")),
+        "patterns": vision_data.get("patterns", []),
+        "timeframe": infer_timeframe(ocr_data.get("text", "")),
+        "raw_ocr": ocr_data
+    }
+
+def extract_key_levels(ocr_text: str) -> list:
+    # Simple heuristic to find numbers in OCR text
+    import re
+    numbers = re.findall(r"\d+\.\d+", ocr_text)
+    return sorted([float(n) for n in numbers], reverse=True)
+
+def infer_timeframe(ocr_text: str) -> str:
+    if "1D" in ocr_text or "daily" in ocr_text.lower():
+        return "1D"
+    elif "4H" in ocr_text or "4h" in ocr_text:
+        return "4h"
+    elif "1H" in ocr_text or "1h" in ocr_text:
+        return "1h"
+    elif "15M" in ocr_text or "15m" in ocr_text:
+        return "15m"
+    return "1h"  # default
+```

backend/main.py

@@ -0,0 +1,80 @@
+```python
+from fastapi import FastAPI, UploadFile, File, HTTPException, Depends
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.security import APIKeyHeader
+from typing import Optional
+import io
+from .config import get_settings
+from .signal_engine import generate_signal_from_image
+from .timeseries_analysis import fetch_klines, compute_technicals
+from .models_registry import model_registry
+
+app = FastAPI(title="CryptoSignal Sleuth Pro API")
+
+# CORS settings
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+api_key_header = APIKeyHeader(name="X-API-KEY")
+
+async def verify_api_key(api_key: str = Depends(api_key_header)):
+    settings = get_settings()
+    if settings.WEBHOOK_API_KEY and api_key != settings.WEBHOOK_API_KEY:
+        raise HTTPException(status_code=403, detail="Invalid API Key")
+    return api_key
+
+@app.post("/api/analyze-chart")
+async def analyze_chart(
+    file: UploadFile = File(...),
+    symbol: Optional[str] = "BTCUSDT"
+):
+    if not file.content_type.startswith("image/"):
+        raise HTTPException(400, detail="File must be an image")
+    
+    image_bytes = await file.read()
+    signal = await generate_signal_from_image(image_bytes, symbol)
+    return signal
+
+@app.get("/api/market-analysis")
+async def market_analysis(
+    symbol: str,
+    timeframe: str = "1h"
+):
+    try:
+        ohlcv = await fetch_klines(symbol, timeframe)
+        technicals = compute_technicals(ohlcv)
+        sentiment = await get_crypto_sentiment(symbol[:3])
+        
+        return {
+            "symbol": symbol,
+            "timeframe": timeframe,
+            "technicals": technicals,
+            "sentiment": sentiment
+        }
+    except Exception as e:
+        raise HTTPException(500, detail=str(e))
+
+@app.post("/api/webhook")
+async def webhook_handler(
+    payload: dict,
+    api_key: str = Depends(verify_api_key)
+):
+    # Process webhook payload here
+    return {"status": "received", "data": payload}
+
+@app.get("/api/models")
+async def list_models():
+    settings = get_settings()
+    return {
+        "llm_model": settings.INFERENCE_LLM_MODEL if settings.USE_INFERENCE_API == "1" else settings.LOCAL_LLM_MODEL,
+        "using_inference_api": settings.USE_INFERENCE_API == "1"
+    }
+```
+___METADATA_START___
+{"repoId":"Alexo19/cryptosignal-sleuth-pro","isNew":false,"userName":"Alexo19"}
+___METADATA_END___

backend/models_registry.py

@@ -0,0 +1,58 @@
+```python
+from typing import Dict, Any
+import io
+from fastapi import UploadFile
+from huggingface_hub import InferenceClient
+from transformers import pipeline
+from .config import get_settings, should_use_inference_api
+
+settings = get_settings()
+
+class ModelRegistry:
+    def __init__(self):
+        self.client = InferenceClient(token=settings.HF_TOKEN) if should_use_inference_api() else None
+        self.local_llm = None
+        self.local_sentiment = None
+        
+        if not should_use_inference_api():
+            self.local_llm = pipeline("text2text-generation", model=settings.LOCAL_LLM_MODEL)
+            self.local_sentiment = pipeline("text-classification", model="finiteautomata/bertweet-base-sentiment-analysis")
+
+    async def analyze_chart_image(self, image_bytes: bytes) -> Dict[str, Any]:
+        if should_use_inference_api():
+            response = self.client.image_classification(image=image_bytes)
+            return {"analysis": str(response)}
+        else:
+            # Fallback simple analysis
+            return {"trend": "unknown", "levels": [], "patterns": []}
+
+    async def run_ocr(self, image_bytes: bytes) -> Dict[str, Any]:
+        if should_use_inference_api():
+            response = self_client.image_to_text(image=image_bytes)
+            return {"text": response}
+        else:
+            # Simple fallback
+            return {"text": "No OCR data available"}
+
+    async def analyze_sentiment(self, texts: list[str]) -> Dict[str, Any]:
+        if should_use_inference_api():
+            response = self.client.text_classification(texts, model="finiteautomata/bertweet-base-sentiment-analysis")
+            return {"sentiment": response}
+        else:
+            results = self.local_sentiment(texts)
+            return {"sentiment": results}
+
+    async def llm_reason(self, prompt: str) -> str:
+        if should_use_inference_api():
+            response = self.client.text_generation(
+                prompt,
+                model=settings.INFERENCE_LLM_MODEL,
+                max_new_tokens=256
+            )
+            return response
+        else:
+            result = self.local_llm(prompt, max_length=128)
+            return result[0]["generated_text"]
+
+model_registry = ModelRegistry()
+```

backend/sentiment_analysis.py

@@ -0,0 +1,63 @@
+```python
+from typing import Dict, Any, List
+import feedparser
+from .models_registry import model_registry
+
+CRYPTO_NEWS_RSS = [
+    "https://cryptopanic.com/news/rss/",
+    "https://cointelegraph.com/rss",
+    "https://news.bitcoin.com/feed/"
+]
+
+async def get_crypto_sentiment(symbol: str = "BTC") -> Dict[str, Any]:
+    headlines = await fetch_crypto_headlines(symbol)
+    if not headlines:
+        return {"score": 0, "confidence": 0, "headlines": []}
+    
+    sentiment = await model_registry.analyze_sentiment(headlines)
+    return normalize_sentiment(sentiment, headlines)
+
+async def fetch_crypto_headlines(symbol: str) -> List[str]:
+    headlines = []
+    for url in CRYPTO_NEWS_RSS:
+        try:
+            feed = feedparser.parse(url)
+            for entry in feed.entries:
+                if symbol.lower() in entry.title.lower() or symbol.lower() in entry.description.lower():
+                    headlines.append(entry.title)
+                    if len(headlines) >= 10:  # Limit to 10 headlines
+                        return headlines
+        except Exception:
+            continue
+    return headlines
+
+def normalize_sentiment(raw_sentiment: Dict[str, Any], headlines: List[str]) -> Dict[str, Any]:
+    positive = 0
+    negative = 0
+    neutral = 0
+    
+    for item in raw_sentiment.get("sentiment", []):
+        label = item.get("label", "").lower()
+        if "positive" in label:
+            positive += 1
+        elif "negative" in label:
+            negative += 1
+        else:
+            neutral += 1
+    
+    total = len(headlines)
+    if total == 0:
+        return {"score": 0, "confidence": 0, "headlines": headlines}
+    
+    score = (positive - negative) / total
+    confidence = max(positive, negative, neutral) / total
+    
+    return {
+        "score": score,
+        "confidence": confidence,
+        "bullish": positive / total,
+        "bearish": negative / total,
+        "neutral": neutral / total,
+        "headlines": headlines
+    }
+```

backend/signal_engine.py

@@ -0,0 +1,103 @@
+```python
+from typing import Dict, Any
+import json
+from .image_analysis import extract_chart_features
+from .timeseries_analysis import fetch_klines, compute_technicals
+from .sentiment_analysis import get_crypto_sentiment
+from .models_registry import model_registry
+
+async def generate_signal_from_image(image_bytes: bytes, symbol: str = "BTCUSDT") -> Dict[str, Any]:
+    # Extract features from image
+    chart_features = await extract_chart_features(image_bytes)
+    
+    # Get technical analysis
+    timeframe = chart_features.get("timeframe", "1h")
+    ohlcv = await fetch_klines(symbol, timeframe)
+    technicals = compute_technicals(ohlcv)
+    
+    # Get sentiment analysis
+    sentiment = await get_crypto_sentiment(symbol[:3])  # Extract base symbol (BTC from BTCUSDT)
+    
+    # Prepare LLM prompt
+    prompt = build_llm_prompt(chart_features, technicals, sentiment, symbol, timeframe)
+    
+    # Get LLM reasoning
+    llm_response = await model_registry.llm_reason(prompt)
+    
+    # Parse response into structured format
+    return parse_llm_response(llm_response, chart_features, technicals, sentiment)
+
+def build_llm_prompt(chart_features: Dict, technicals: Dict, sentiment: Dict, symbol: str, timeframe: str) -> str:
+    return f"""Analyze this crypto trading situation and provide a professional trading signal in JSON format:
+
+Chart Analysis:
+- Trend: {chart_features.get('trend', 'unknown')}
+- Key Levels: {chart_features.get('key_levels', [])}
+- Patterns: {chart_features.get('patterns', [])}
+
+Technical Indicators ({timeframe} timeframe):
+- Trend: {technicals['trend']}
+- Momentum: {technicals['momentum']}
+- Volatility: {technicals['volatility']}
+- Support: {technicals['support']}
+- Resistance: {technicals['resistance']}
+
+Market Sentiment:
+- Score: {sentiment.get('score', 0)}
+- Bullish: {sentiment.get('bullish', 0)}
+- Bearish: {sentiment.get('bearish', 0)}
+
+Symbol: {symbol}
+
+Provide your response in this exact JSON format:
+{{
+  "direction": "long|short|neutral",
+  "entry_zone": [min_price, max_price],
+  "stop_loss": price,
+  "take_profit_levels": [tp1, tp2, tp3],
+  "timeframe_inferred": "1h|4h|1D etc",
+  "confidence": 0-100,
+  "time_horizon": "intra-day|swing|position",
+  "explanation": "brief rationale",
+  "meta": {{
+    "sources": ["chart", "technicals", "sentiment"],
+    "sentiment": {{}}
+  }}
+}}"""
+
+def parse_llm_response(response: str, chart_features: Dict, technicals: Dict, sentiment: Dict) -> Dict[str, Any]:
+    try:
+        data = json.loads(response.strip())
+        if not isinstance(data, dict):
+            raise ValueError("Invalid response format")
+        
+        # Ensure required fields are present
+        required_fields = ["direction", "entry_zone", "stop_loss", "take_profit_levels"]
+        for field in required_fields:
+            if field not in data:
+                raise ValueError(f"Missing required field: {field}")
+        
+        # Add metadata
+        data["meta"] = {
+            "sources": ["chart", "technicals", "sentiment"],
+            "sentiment": sentiment
+        }
+        
+        return data
+    except (json.JSONDecodeError, ValueError) as e:
+        # Fallback to default if parsing fails
+        return {
+            "direction": "neutral",
+            "entry_zone": [0, 0],
+            "stop_loss": 0,
+            "take_profit_levels": [0, 0, 0],
+            "timeframe_inferred": chart_features.get("timeframe", "1h"),
+            "confidence": 50,
+            "time_horizon": "intra-day",
+            "explanation": "Could not generate signal: " + str(e),
+            "meta": {
+                "sources": ["error"],
+                "sentiment": sentiment
+            }
+        }
+```

backend/timeseries_analysis.py

@@ -0,0 +1,80 @@
+```python
+import pandas as pd
+import numpy as np
+import requests
+from typing import Dict, Any, List
+
+BINANCE_API_URL = "https://api.binance.com/api/v3/klines"
+
+async def fetch_klines(symbol: str, timeframe: str, limit: int = 200) -> List[List[Any]]:
+    params = {
+        "symbol": symbol.upper(),
+        "interval": timeframe,
+        "limit": limit
+    }
+    response = requests.get(BINANCE_API_URL, params=params)
+    response.raise_for_status()
+    return response.json()
+
+def compute_technicals(ohlcv: List[List[Any]]) -> Dict[str, Any]:
+    # Convert to pandas DataFrame
+    df = pd.DataFrame(ohlcv, columns=["timestamp", "open", "high", "low", "close", "volume"])
+    df = df.astype({
+        "open": float, "high": float, "low": float, "close": float, "volume": float
+    })
+    
+    # Calculate indicators
+    df["ema_20"] = df["close"].ewm(span=20, adjust=False).mean()
+    df["ema_50"] = df["close"].ewm(span=50, adjust=False).mean()
+    df["rsi"] = compute_rsi(df["close"])
+    df["macd"], df["signal"], df["hist"] = compute_macd(df["close"])
+    df["atr"] = compute_atr(df["high"], df["low"], df["close"])
+    
+    latest = df.iloc[-1]
+    
+    return {
+        "trend": "bullish" if latest["ema_20"] > latest["ema_50"] else "bearish",
+        "momentum": "strong" if latest["rsi"] > 70 or latest["rsi"] < 30 else "neutral",
+        "volatility": "high" if latest["atr"] > (df["atr"].mean() * 1.5) else "normal",
+        "resistance": df["high"].max(),
+        "support": df["low"].min(),
+        "indicators": {
+            "ema_20": latest["ema_20"],
+            "ema_50": latest["ema_50"],
+            "rsi": latest["rsi"],
+            "macd": {
+                "value": latest["macd"],
+                "signal": latest["signal"],
+                "hist": latest["hist"]
+            },
+            "atr": latest["atr"]
+        }
+    }
+
+def compute_rsi(prices: pd.Series, period: int = 14) -> pd.Series:
+    delta = prices.diff()
+    gain = delta.where(delta > 0, 0)
+    loss = -delta.where(delta < 0, 0)
+    
+    avg_gain = gain.rolling(window=period).mean()
+    avg_loss = loss.rolling(window=period).mean()
+    
+    rs = avg_gain / avg_loss
+    return 100 - (100 / (1 + rs))
+
+def compute_macd(prices: pd.Series, fast: int = 12, slow: int = 26, signal: int = 9) -> tuple:
+    ema_fast = prices.ewm(span=fast, adjust=False).mean()
+    ema_slow = prices.ewm(span=slow, adjust=False).mean()
+    macd = ema_fast - ema_slow
+    signal_line = macd.ewm(span=signal, adjust=False).mean()
+    hist = macd - signal_line
+    return macd, signal_line, hist
+
+def compute_atr(high: pd.Series, low: pd.Series, close: pd.Series, period: int = 14) -> pd.Series:
+    tr = pd.DataFrame({
+        "h-l": high - low,
+        "h-pc": abs(high - close.shift()),
+        "l-pc": abs(low - close.shift())
+    }).max(axis=1)
+    return tr.rolling(window=period).mean()
+```