Easy fix. Nothing in your idea is “crypto-only” — we just need to tell the code (and DeepSite) to:

Support both crypto and forex symbols, and

Use the right data source depending on the market.

I’ll show you:

What to change in the logic

EXACT text to add to your DeepSite prompt so it builds crypto + forex together

1️⃣ What needs to work for Forex?

You want:

/api/analyze/market to handle:

BTCUSDT (crypto)

ETHUSDT (crypto)

EURUSD, GBPUSD, XAUUSD, USDJPY, etc. (forex)

Same signal 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": {} }
}


So we just make the market analysis layer asset-agnostic:

asset_type: "crypto" or "forex"

Use:

Binance klines for crypto

yfinance (or similar) for forex

2️⃣ How the backend logic should work

In backend/timeseries_analysis.py, instead of only fetch_klines for Binance, you want:

async def fetch_ohlcv(
symbol: str,
timeframe: str,
asset_type: str = "crypto",
limit: int = 200
):
if asset_type == "crypto":
# Use Binance public klines, e.g. BTCUSDT
return await fetch_binance_klines(symbol, timeframe, limit)
elif asset_type == "forex":
# Use yfinance (EURUSD -> "EURUSD=X")
return fetch_yfinance_fx(symbol, timeframe, limit)
else:
raise ValueError("Unsupported asset_type")


And your FastAPI route:

class MarketRequest(BaseModel):
symbol: str
timeframe: str = "1h"
asset_type: str = "crypto" # "crypto" | "forex"

@app .post("/api/analyze/market", response_model=SignalResponse)
async def analyze_market(req: MarketRequest):
ohlcv = await fetch_ohlcv(
symbol=req.symbol,
timeframe=req.timeframe,
asset_type=req.asset_type,
)
technicals = compute_technicals(ohlcv)
signal = await generate_signal_from_market(
symbol=req.symbol,
timeframe=req.timeframe,
asset_type=req.asset_type,
ohlcv=ohlcv,
technicals=technicals,
)
return signal


Example request body for forex:

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


That’s it. Same UI, same panel — just more markets.

3️⃣ What to add to your DeepSite prompt (copy–paste)

You don’t need a whole new prompt — just extend the one I gave you.

👉 In your DeepSite master prompt, right after the project description, add this block:

IMPORTANT – MARKETS (CRYPTO + FOREX)

This app MUST support both:

1. Crypto markets
- Examples: BTCUSDT, ETHUSDT, SOLUSDT
- Data source: Binance public klines (no API key)

2. Forex markets
- Examples: EURUSD, GBPUSD, USDJPY, XAUUSD, NAS100, etc.
- Implement an `asset_type` flag with allowed values `"crypto"` or `"forex"`.
- For `asset_type="forex"`, fetch OHLCV using a free public data source such as `yfinance`:
- Map `"EURUSD"` → `"EURUSD=X"`, `"GBPUSD"` → `"GBPUSD=X"`, `"XAUUSD"` → `"XAUUSD=X"`, etc.
- Implement a helper `normalize_forex_symbol(symbol: str) -> str` that returns the proper yfinance ticker.
- The technical analysis (EMA, RSI, MACD, ATR, support/resistance, bias) should be applied the same way to forex and crypto.

Update the backend so that:

- `backend/timeseries_analysis.py` exposes:
- `fetch_ohlcv(symbol: str, timeframe: str, asset_type: str = "crypto", limit: int = 200)`
- It internally calls:
- `fetch_binance_klines(...)` for `"crypto"`
- `fetch_yfinance_fx(...)` for `"forex"`
- The `/api/analyze/market` endpoint accepts an `asset_type` field in the JSON body with default `"crypto"`.

The signal JSON schema remains exactly the same and is **asset-agnostic**, so the frontend and webhooks work for both crypto and forex with no change.


If you want the frontend to make it obvious, you can also tell DeepSite this (add to the frontend section of the prompt):

In the frontend `PairSelector` component, add a simple toggle or dropdown:
- Market type: "Crypto" or "Forex"
Pass this as `asset_type` in the `/api/analyze/market` request.

4️⃣ TL;DR for you

Yes, it can work for forex, not just Bitcoin.

Add asset_type (crypto/forex) everywhere: request, timeseries fetcher, signal engine.

Use Binance for crypto, yfinance (or similar) for forex candles.

Update the DeepSite prompt with the block I gave you, then regenerate.

backend/main.py

@@ -94,14 +94,30 @@ 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
+    timeframe: str = "1h"
+    asset_type: str = "crypto"  # "crypto" | "forex"
 
 @app.post("/api/analyze/market")
-async def analyze_market(data: dict):
+async def analyze_market(request: MarketRequest):
     try:
-        symbol = data.get("symbol", "BTCUSDT")
-        timeframe = data.get("timeframe", "1h")
-        return await generate_signal_from_market(symbol, timeframe)
-    except Exception as e:
+        ohlcv = await fetch_ohlcv(
+            symbol=request.symbol,
+            timeframe=request.timeframe,
+            asset_type=request.asset_type
+        )
+        technicals = compute_technicals(ohlcv)
+        return await generate_signal_from_market(
+            symbol=request.symbol,
+            timeframe=request.timeframe,
+            asset_type=request.asset_type,
+            ohlcv=ohlcv,
+            technicals=technicals
+        )
+except Exception as e:
         raise HTTPException(500, detail=str(e))
 
 @app.post("/api/webhook/signal")

backend/signal_engine.py

@@ -64,27 +64,40 @@ Provide your response in this exact JSON format:
     "sentiment": {{}}
   }}
 }}"""
-async def generate_signal_from_market(symbol: str, timeframe: str) -> Dict[str, Any]:
+async def generate_signal_from_market(
+    symbol: str,
+    timeframe: str,
+    asset_type: str = "crypto",
+    ohlcv: List[List[Any]] = None,
+    technicals: Dict[str, Any] = None
+) -> Dict[str, Any]:
     """Generate trading signal from live market data."""
-    # Get technical analysis
-    ohlcv = await fetch_klines(symbol, timeframe)
-    technicals = compute_technicals(ohlcv)
+    if ohlcv is None:
+        ohlcv = await fetch_ohlcv(symbol, timeframe, asset_type)
+    if technicals is None:
+        technicals = compute_technicals(ohlcv)
     
-    # Get sentiment analysis
-    sentiment = await get_crypto_sentiment(symbol[:3])  # Extract base symbol
+    # Get sentiment analysis (only for crypto)
+    sentiment = {}
+    if asset_type == "crypto":
+        sentiment = await get_crypto_sentiment(symbol[:3])  # Extract base symbol
     
     # Prepare LLM prompt
-    prompt = build_market_prompt(technicals, sentiment, symbol, timeframe)
-    
-    # Get LLM reasoning
+    prompt = build_market_prompt(technicals, sentiment, symbol, timeframe, asset_type)
+# 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, symbol: str, timeframe: str) -> str:
-    return f"""Analyze this crypto trading situation and provide a professional trading signal in JSON format:
-
+def build_market_prompt(
+    technicals: Dict, 
+    sentiment: Dict, 
+    symbol: str, 
+    timeframe: str,
+    asset_type: str = "crypto"
+) -> 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']}

backend/timeseries_analysis.py

@@ -2,11 +2,18 @@
 import pandas as pd
 import numpy as np
 import requests
+import yfinance as yf
 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]]:
+def normalize_forex_symbol(symbol: str) -> str:
+    """Convert forex symbol to yfinance format (EURUSD -> EURUSD=X)"""
+    if symbol.endswith('=X'):
+        return symbol
+    return f"{symbol}=X"
+
+async def fetch_binance_klines(symbol: str, timeframe: str, limit: int = 200) -> List[List[Any]]:
     params = {
         "symbol": symbol.upper(),
         "interval": timeframe,
@@ -16,6 +23,42 @@ async def fetch_klines(symbol: str, timeframe: str, limit: int = 200) -> List[Li
     response.raise_for_status()
     return response.json()
 
+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', 
+        '30m': '30m', '1h': '1h', '4h': '4h', 
+        '1D': '1d', '1W': '1wk', '1M': '1mo'
+    }
+    interval = tf_map.get(timeframe, '1h')
+    
+    ticker = normalize_forex_symbol(symbol)
+    data = yf.Ticker(ticker)
+    hist = data.history(period=f"{limit}d", interval=interval)
+    
+    # Convert to same format as Binance klines
+    ohlcv = []
+    for _, row in hist.iterrows():
+        ohlcv.append([
+            int(row.name.timestamp()) * 1000,  # timestamp
+            row['Open'], row['High'], row['Low'], row['Close'], 
+            row['Volume']
+        ])
+    return ohlcv
+
+async def fetch_ohlcv(
+    symbol: str, 
+    timeframe: str, 
+    asset_type: str = "crypto", 
+    limit: int = 200
+) -> List[List[Any]]:
+    """Fetch OHLCV data for either crypto or forex markets"""
+    if asset_type == "crypto":
+        return await fetch_binance_klines(symbol, timeframe, limit)
+    elif asset_type == "forex":
+        return 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"])

index.html

@@ -58,16 +58,15 @@
                     <div>
                         <label class="block text-sm font-medium mb-1">Exchange</label>
                         <select class="w-full bg-gray-700 border border-gray-600 rounded-lg px-3 py-2 focus:ring-indigo-500 focus:border-indigo-500">
-                            <option>Binance</option>
-                            <option>Bybit</option>
-                            <option>KuCoin</option>
-                        </select>
+                        <option value="crypto">Binance (Crypto)</option>
+                        <option value="forex">Forex</option>
+</select>
                     </div>
                     <div>
                         <label class="block text-sm font-medium mb-1">Pair</label>
-                        <input type="text" placeholder="BTCUSDT" class="w-full bg-gray-700 border border-gray-600 rounded-lg px-3 py-2 focus:ring-indigo-500 focus:border-indigo-500">
+                        <input type="text" id="pair-input" placeholder="BTCUSDT" class="w-full bg-gray-700 border border-gray-600 rounded-lg px-3 py-2 focus:ring-indigo-500 focus:border-indigo-500">
                     </div>
-                    <div>
+<div>
                         <label class="block text-sm font-medium mb-1">Timeframe</label>
                         <select class="w-full bg-gray-700 border border-gray-600 rounded-lg px-3 py-2 focus:ring-indigo-500 focus:border-indigo-500">
                             <option>5m</option>

requirements.txt

@@ -10,6 +10,7 @@ feedparser==6.0.10
 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: