2️⃣ Prompt for DeepSite (supports Crypto + Forex)

👉 Copy everything inside this box and paste it into DeepSite:
You are a senior full-stack AI engineer.

Build a production-ready project called **CryptoSignal-Sleuth** that works for **both crypto and forex**, not just Bitcoin.

Tech stack:
- Backend: FastAPI (Python 3)
- Frontend: React + TypeScript + Vite + TailwindCSS
- Models: Hugging Face (vision, OCR, sentiment, LLM reasoning)

The app will be deployed on **Hugging Face Spaces**.

====================================================
## 1. FEATURES

The app must do all of this:

1. Let the user **upload a screenshot** of a trading chart (crypto or forex):
- Run **vision + OCR** on the image.
- Extract basic info: trend (up/down/range), key levels, patterns if visible.
- Pass these cues into an LLM to generate a trading **signal**.

2. Let the user **analyze a market live** by sending:
```json
{
"symbol": "BTCUSDT" or "EURUSD",
"timeframe": "5m" or "15m" or "1h",
"asset_type": "crypto" or "forex"
}



Fetch OHLCV data.


Run technical indicators (EMA, RSI, MACD, ATR, support/resistance).


Optionally include sentiment.


Use an LLM to synthesize a final signal.




Provide a clean REST API + webhook so I can connect:


n8n


Discord bot


Telegram bot




====================================================
2. MARKETS: CRYPTO + FOREX
The app MUST support:
2.1 Crypto


Examples: BTCUSDT, ETHUSDT, SOLUSDT


Data source: Binance public klines (no key).


Implement a helper:


fetch_binance_klines(symbol: str, timeframe: str, limit: int = 200)




2.2 Forex


Examples: EURUSD, GBPUSD, USDJPY, XAUUSD, NAS100


Data source: use yfinance (or similar free source).


Implement helpers:


normalize_forex_symbol("EURUSD") -> "EURUSD=X"


fetch_yfinance_fx(symbol: str, timeframe: str, limit: int = 200)




2.3 Common wrapper
Create in backend/timeseries_analysis.py:


fetch_ohlcv(symbol: str, timeframe: str, asset_type: str = "crypto", limit: int = 200)


Logic:


If asset_type == "crypto" → call fetch_binance_klines.


If asset_type == "forex" → normalize symbol and call fetch_yfinance_fx.


Apply the same technical analysis (EMA, RSI, MACD, ATR, support/resistance, trend, momentum) to both crypto and forex.
====================================================
3. SIGNAL SCHEMA (VERY IMPORTANT)
All signals (image or market) MUST follow this 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": "1m|5m|15m|1h|4h|1d",
"confidence": 0,
"time_horizon": "intra-day|swing|position",
"explanation": "string",
"meta": {
"sources": [],
"sentiment": {}
}
}

Use Pydantic models so FastAPI enforces this structure.
====================================================
4. PROJECT STRUCTURE
Use this exact file structure:
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
Fill ALL of these files with real, working code.
====================================================
5. BACKEND DETAILS
5.1 Config
backend/config.py:


Pydantic settings class that loads:


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)




5.2 Models Registry
backend/models_registry.py:


Functions using Hugging Face Inference API (with HF_TOKEN):


analyze_chart_image(image_bytes) -> dict


run_ocr(image_bytes) -> dict


analyze_sentiment(texts: list[str]) -> dict


llm_reason(prompt: str) -> str




5.3 Image Analysis
backend/image_analysis.py:


extract_chart_features(image_bytes) -> dict:


Use vision + OCR to infer:


trend: up/down/range


key levels


any visible pattern labels


possible timeframe if visible






5.4 Time-Series Analysis
backend/timeseries_analysis.py:


Implement:


fetch_ohlcv (crypto + forex wrapper as described above).


compute_technicals(ohlcv) -> dict:


EMA fast/slow


RSI


MACD


ATR


support/resistance


trend and momentum labels.






5.5 Sentiment Analysis
backend/sentiment_analysis.py:


Fetch recent crypto/forex headlines (e.g. with RSS or generic feed).


Run sentiment model.


Return {"bullish": x, "bearish": y, "neutral": z, "summary": "..."}


This is stored in meta["sentiment"].


5.6 Signal Engine
backend/signal_engine.py:
Implement:


generate_signal_from_image(image_bytes) -> dict


generate_signal_from_market(symbol: str, timeframe: str, asset_type: str, ohlcv, technicals) -> dict


Build a prompt for the LLM that includes:


asset_type (crypto or forex)


symbol


timeframe


recent price action


trend & momentum


volatility


sentiment summary


image cues (if using screenshot)


Ask the LLM to output a decision that maps cleanly into the Signal schema above.
5.7 Main FastAPI App
backend/main.py routes:


GET /api/health → { "status": "ok" }


GET /api/models → shows which HF models are active.


POST /api/analyze/screenshot


multipart/form-data, field name: file.


returns Signal JSON.




POST /api/analyze/market


JSON body:
{ "symbol": "EURUSD", "timeframe": "5m", "asset_type": "forex" }



returns Signal JSON.




POST /api/webhook/signal


optional header X-API-KEY == WEBHOOK_API_KEY.


accepts any valid Signal JSON and echoes it (for n8n integration).




5.8 app.py


Create FastAPI app.


Include backend router at /api.


Serve frontend static files from frontend/dist at /.


Use FRONTEND_BASE_PATH and API_BASE_URL if needed.


====================================================
6. FRONTEND (React + TypeScript + Vite + Tailwind)
Implement the frontend with a dark trading dashboard look.
6.1 API Client
frontend/src/lib/api.ts:


Base URL: import.meta.env.VITE_API_BASE_URL || "/api"


Functions:


uploadChart(file: File): Promise<SignalResponse>


getMarketSignal(symbol: string, timeframe: string, asset_type: "crypto"|"forex"): Promise<SignalResponse>


getModels()


postWebhookSignal(payload: any)




Define SignalResponse TypeScript interface using the Signal schema.
6.2 Components / Pages


Navbar + Sidebar layout.


Dashboard page:


ChartUploadCard → upload screenshot, show returned signal in SignalPanel.


PairSelector:


Input/select for symbol (BTCUSDT, ETHUSDT, EURUSD, GBPUSD, XAUUSD, etc.)


Select for timeframe.


Dropdown for asset_type ("crypto" or "forex").


Button → calls getMarketSignal.




SignalPanel displays the SignalResponse nicely (direction, entry zone, SL, TP1–3, confidence, explanation, sentiment).


HistoryTable → shows a list of signals from the current session.




Backtest:


Simple placeholder explaining that backtesting is coming later.




Settings:


Show data from /api/models.


Show current base URLs and some info text.




Docs:


Show example request/response for:


/api/analyze/market


/api/analyze/screenshot


/api/webhook/signal






====================================================
7. REQUIREMENTS + ENV
requirements.txt should include at least:


fastapi


uvicorn[standard]


python-multipart


pydantic


httpx or requests


numpy


pandas (if needed)


ta (or manual indicator math)


yfinance


feedparser (or similar)


huggingface-hub or transformers (if needed)


jinja2 (if needed)


Also output a .env.example with:


HF_TOKEN=


USE_INFERENCE_API=1


INFERENCE_LLM_MODEL=Qwen/Qwen2.5-7B-Instruct


LOCAL_LLM_MODEL=google/flan-t5-base


FRONTEND_BASE_PATH=/


API_BASE_URL=/api


WEBHOOK_API_KEY=


====================================================
8. SUMMARY
At the very end of your answer, add a short summary:


How to install and run locally:


pip install -r requirements.txt


cd frontend && npm install && npm run build


uvicorn app:app --host 0.0.0.0 --port 7860




How to deploy on Hugging Face Spaces with app.py as the entrypoint.


Generate the COMPLETE codebase with no TODOs or placeholders.

---

If you want next, I can help you with the **exact JSON body** to use in n8n, or with a **Discord bot command** like `/signal EURUSD 5m forex` that calls your new API.
::contentReference[oaicite:0]{index=0}

.env.example

@@ -11,6 +11,4 @@ API_BASE_URL=/api
 
 # Security
 WEBHOOK_API_KEY=your_secure_api_key_here
-```
-
-6. For the frontend, let's create a basic setup:
+```

app.py

@@ -22,6 +22,4 @@ app.mount(
 if __name__ == "__main__":
     import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=7860)
-```
-
-4. Let's create the requirements.txt:
+```

backend/config.py

@@ -8,7 +8,7 @@ class Settings(BaseSettings):
     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 = "/"
+    API_BASE_URL: str = "/api"
     WEBHOOK_API_KEY: Optional[str] = None
 
     class Config:

backend/main.py

@@ -5,9 +5,11 @@ 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 .signal_engine import generate_signal_from_image, generate_signal_from_market
+from .timeseries_analysis import fetch_ohlcv, compute_technicals
+from .sentiment_analysis import get_crypto_sentiment
 from .models_registry import model_registry
+from pydantic import BaseModel
 
 app = FastAPI(title="CryptoSignal Sleuth Pro API")
 
@@ -46,7 +48,7 @@ async def market_analysis(
     timeframe: str = "1h"
 ):
     try:
-        ohlcv = await fetch_klines(symbol, timeframe)
+        ohlcv = await fetch_ohlcv(symbol, timeframe)
         technicals = compute_technicals(ohlcv)
         sentiment = await get_crypto_sentiment(symbol[:3])
         
@@ -66,6 +68,7 @@ async def webhook_handler(
 ):
     # Process webhook payload here
     return {"status": "received", "data": payload}
+
 @app.get("/api/health")
 async def health_check():
     return {"status": "ok"}
@@ -94,7 +97,6 @@ async def analyze_screenshot(
     image_bytes = await file.read()
     signal = await generate_signal_from_image(image_bytes, symbol or "BTCUSDT")
     return signal
-from pydantic import BaseModel
 
 class MarketRequest(BaseModel):
     symbol: str
@@ -117,7 +119,7 @@ async def analyze_market(request: MarketRequest):
             ohlcv=ohlcv,
             technicals=technicals
         )
-except Exception as e:
+    except Exception as e:
         raise HTTPException(500, detail=str(e))
 
 @app.post("/api/webhook/signal")
@@ -132,7 +134,4 @@ async def webhook_signal(
     # Log the signal
     print(f"Received signal: {payload}")
     return {"status": "received", "signal": payload}
-```
-___METADATA_START___
-{"repoId":"Alexo19/cryptosignal-sleuth-pro","isNew":false,"userName":"Alexo19"}
-___METADATA_END___
+```

backend/models_registry.py

@@ -28,7 +28,7 @@ class ModelRegistry:
 
     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)
+            response = self.client.image_to_text(image=image_bytes)
             return {"text": response}
         else:
             # Simple fallback

backend/signal_engine.py

@@ -2,7 +2,7 @@
 from typing import Dict, Any
 import json
 from .image_analysis import extract_chart_features
-from .timeseries_analysis import fetch_klines, compute_technicals
+from .timeseries_analysis import fetch_ohlcv, compute_technicals
 from .sentiment_analysis import get_crypto_sentiment
 from .models_registry import model_registry
 
@@ -12,7 +12,7 @@ async def generate_signal_from_image(image_bytes: bytes, symbol: str = "BTCUSDT"
     
     # Get technical analysis
     timeframe = chart_features.get("timeframe", "1h")
-    ohlcv = await fetch_klines(symbol, timeframe)
+    ohlcv = await fetch_ohlcv(symbol, timeframe)
     technicals = compute_technicals(ohlcv)
     
     # Get sentiment analysis
@@ -64,6 +64,7 @@ Provide your response in this exact JSON format:
     "sentiment": {{}}
   }}
 }}"""
+
 async def generate_signal_from_market(
     symbol: str,
     timeframe: str,
@@ -84,11 +85,13 @@ async def generate_signal_from_market(
     
     # Prepare LLM prompt
     prompt = build_market_prompt(technicals, sentiment, symbol, timeframe, asset_type)
-# Get LLM reasoning
+    
+    # Get LLM reasoning
     llm_response = await model_registry.llm_reason(prompt)
     
     # Parse response into structured format
     return parse_llm_response(llm_response, {}, technicals, sentiment)
+
 def build_market_prompt(
     technicals: Dict, 
     sentiment: Dict, 
@@ -98,6 +101,7 @@ def build_market_prompt(
 ) -> str:
     asset_type_str = "cryptocurrency" if asset_type == "crypto" else "forex"
     return f"""Analyze this {asset_type_str} trading situation and provide a professional trading signal in JSON format:
+
 Technical Indicators ({timeframe} timeframe):
 - Trend: {technicals['trend']}
 - Momentum: {technicals['momentum']}
@@ -129,7 +133,7 @@ Provide your response in this exact JSON format:
 }}"""
 
 def parse_llm_response(response: str, chart_features: Dict, technicals: Dict, sentiment: Dict) -> Dict[str, Any]:
-try:
+    try:
         data = json.loads(response.strip())
         if not isinstance(data, dict):
             raise ValueError("Invalid response format")

backend/timeseries_analysis.py

@@ -22,7 +22,8 @@ async def fetch_binance_klines(symbol: str, timeframe: str, limit: int = 200) ->
     response = requests.get(BINANCE_API_URL, params=params)
     response.raise_for_status()
     return response.json()
-def fetch_yfinance_fx(symbol: str, timeframe: str, limit: int = 200) -> List[List[Any]]:
+
+async def fetch_yfinance_fx(symbol: str, timeframe: str, limit: int = 200) -> List[List[Any]]:
     """Fetch forex data using yfinance"""
     tf_map = {
         '1m': '1m', '5m': '5m', '15m': '15m', 
@@ -30,7 +31,7 @@ def fetch_yfinance_fx(symbol: str, timeframe: str, limit: int = 200) -> List[Lis
         '1D': '1d', '1W': '1wk', '1M': '1mo',
         '1d': '1d', '4h': '4h'  # Add common aliases
     }
-interval = tf_map.get(timeframe, '1h')
+    interval = tf_map.get(timeframe, '1h')
     
     ticker = normalize_forex_symbol(symbol)
     data = yf.Ticker(ticker)
@@ -56,9 +57,10 @@ async def fetch_ohlcv(
     if asset_type == "crypto":
         return await fetch_binance_klines(symbol, timeframe, limit)
     elif asset_type == "forex":
-        return fetch_yfinance_fx(symbol, timeframe, limit)
+        return await fetch_yfinance_fx(symbol, timeframe, limit)
     else:
         raise ValueError("Unsupported asset_type. Must be 'crypto' or 'forex'")
+
 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"])

requirements.txt

@@ -11,6 +11,4 @@ huggingface-hub==0.15.1
 transformers==4.29.2
 python-dotenv==1.0.0
 yfinance==0.2.28
-```
-
-5. Let's create the .env.example file:
+```