Pivot: Decoupled Qwen AI Intelligence Provider. Only Qwen model on HF.

Dockerfile

@@ -25,19 +25,17 @@ RUN apt-get update && apt-get install -y \
 USER user
 
 # Install Python dependencies
-COPY --chown=user requirements.txt .
+COPY --chown=user requirements.qwen.txt .
 RUN pip install --no-cache-dir --upgrade pip
 
 # CRITICAL: Use official pre-compiled CPU wheels for the Qwen engine to bypass OOM errors
 RUN pip install --no-cache-dir \
     --extra-index-url https://abetlen.github.io/llama-cpp-python/whl/cpu \
-    -r requirements.txt
+    -r requirements.qwen.txt
 
-# Ensure huggingface_hub is installed for the auto-download feature
-RUN pip install --no-cache-dir huggingface_hub
-
-# Copy the application code
-COPY --chown=user . .
+# Copy only the essential AI application files
+COPY --chown=user qwen_api.py .
+COPY --chown=user scraper.py .
 
 # Create the models directory with correct permissions
 RUN mkdir -p ml_models && chmod 777 ml_models
@@ -45,6 +43,5 @@ RUN mkdir -p ml_models && chmod 777 ml_models
 # Expose the port HF Spaces expects
 EXPOSE 7860
 
-# Run the application
-# We use one worker because HF Free Tier (CPU) is best for single-threaded Qwen inference
-CMD ["gunicorn", "app:app", "-w", "1", "-k", "uvicorn.workers.UvicornWorker", "--bind", "0.0.0.0:7860", "--timeout", "600"]
+# Run the specialized Qwen API
+CMD ["python", "qwen_api.py"]

qwen_api.py

@@ -0,0 +1,170 @@
+import os
+import uuid
+import threading
+from fastapi import FastAPI, HTTPException, Request
+from pydantic import BaseModel
+from typing import List, Optional
+from huggingface_hub import hf_hub_download
+from llama_cpp import Llama
+from datetime import datetime
+
+# Configuration
+MODEL_DIR = "ml_models"
+MODEL_NAME = "qwen-3.5-4b.gguf"
+QWEN_PATH = os.path.join(MODEL_DIR, MODEL_NAME)
+
+app = FastAPI(title="Qwen Intelligence Provider", version="1.0.0")
+
+# Global LLM instance
+_llm = None
+_lock = threading.Lock()
+
+def get_qwen():
+    global _llm
+    with _lock:
+        if _llm is None:
+            if not os.path.exists(QWEN_PATH):
+                print("📥 Downloading Qwen 3.5 (4B) from Hugging Face...")
+                os.makedirs(MODEL_DIR, exist_ok=True)
+                hf_hub_download(
+                    repo_id="bartowski/Qwen_Qwen3.5-4B-GGUF",
+                    filename="Qwen3.5-4B-Instruct-Q4_K_M.gguf",
+                    local_dir=MODEL_DIR,
+                    local_dir_use_symlinks=False
+                )
+                downloaded = os.path.join(MODEL_DIR, "Qwen3.5-4B-Instruct-Q4_K_M.gguf")
+                if os.path.exists(downloaded):
+                    os.rename(downloaded, QWEN_PATH)
+            
+            print(f"🚀 Initializing Qwen engine at {QWEN_PATH}")
+            _llm = Llama(
+                model_path=QWEN_PATH,
+                n_ctx=2048,
+                n_threads=4, # Optimized for HF Space CPUs
+                verbose=False
+            )
+        return _llm
+
+# --- Data Models ---
+
+class KeywordRequest(BaseModel):
+    idea_text: str
+
+class ValidationRequest(BaseModel):
+    title1: str
+    title2: str
+
+class OverviewRequest(BaseModel):
+    neg_reviews: List[str]
+    pos_reviews: List[str]
+
+class SynthesisRequest(BaseModel):
+    overview_text: str
+
+class BattleRequest(BaseModel):
+    app_a_name: str
+    app_a_overview: str
+    app_b_name: str
+    app_b_overview: str
+
+# --- Endpoints ---
+
+@app.get("/")
+async def root():
+    return {"status": "online", "model": "Qwen 3.5 4B", "service": "Intelligence Provider"}
+
+@app.post("/keywords")
+async def extract_keywords(req: KeywordRequest):
+    llm = get_qwen()
+    prompt = f"""<|start_header_id|>system<|end_header_id|>
+You are a expert market research assistant. 
+Extract 4-5 high-quality, comma-separated keywords or app types that would help find the most relevant competitors for the provided app idea description. 
+Output ONLY the comma-separated keywords. No conversational filler.
+<|eot_id|><|start_header_id|>user<|end_header_id|>
+App Idea: {req.idea_text}
+<|eot_id|><|start_header_id|>assistant<|end_header_id|>"""
+    res = llm(prompt, max_tokens=100, stop=["<|eot_id|>"], echo=False)
+    return {"keywords": res['choices'][0]['text'].strip()}
+
+@app.post("/validate")
+async def validate_match(req: ValidationRequest):
+    llm = get_qwen()
+    prompt = f"""<|start_header_id|>system<|end_header_id|>
+You are an expert AI product assistant. Reply ONLY with "YES" if these two titles represent the same application, or "NO" if they are clearly different products. 
+Example: "WhatsApp" and "WhatsApp Messenger" is YES. "WhatsApp" and "Instagram" is NO.
+<|eot_id|><|start_header_id|>user<|end_header_id|>
+App Name 1: {req.title1}
+App Name 2: {req.title2}
+<|eot_id|><|start_header_id|>assistant<|end_header_id|>"""
+    res = llm(prompt, max_tokens=10, stop=["<|eot_id|>"], echo=False)
+    return {"match": res['choices'][0]['text'].strip().upper()}
+
+@app.post("/overview")
+async def generate_overview(req: OverviewRequest):
+    llm = get_qwen()
+    
+    def get_mini_summary(items, sentiment):
+        if not items: return ""
+        # Keep only a sample to avoid context overflow in mini-summaries
+        sample = items[:15]
+        prompt = f"""<|start_header_id|>system<|end_header_id|>
+You are a technical analyst. Summarize the provided {sentiment} reviews into a single dense bullet point of insights. 
+Do NOT include any filler.
+<|eot_id|><|start_header_id|>user<|end_header_id|>
+Reviews: {chr(10).join(['- ' + r[:200] for r in sample])}
+<|eot_id|><|start_header_id|>assistant<|end_header_id|>"""
+        res = llm(prompt, max_tokens=150, stop=["<|eot_id|>"], echo=False)
+        return res['choices'][0]['text'].strip()
+
+    neg_mini = get_mini_summary(req.neg_reviews, "negative")
+    pos_mini = get_mini_summary(req.pos_reviews, "positive")
+
+    master_prompt = f"""<|start_header_id|>system<|end_header_id|>
+You are a senior product manager. Based on the hierarchical insights provided, write a deep 3-paragraph professional analysis. 
+Structure:
+- Paragraph 1: UX/UI and technical critical complaints.
+- Paragraph 2: Core value propositions and high-impact features.
+- Paragraph 3: Future roadmap and growth strategy.
+CRITICAL: Start response IMMEDIATELY. No intro.
+<|eot_id|><|start_header_id|>user<|end_header_id|>
+NEGATIVE THEMES: {neg_mini}
+POSITIVE THEMES: {pos_mini}
+<|eot_id|><|start_header_id|>assistant<|end_header_id|>"""
+    
+    res = llm(master_prompt, max_tokens=600, stop=["<|eot_id|>"], echo=False)
+    return {"overview": res['choices'][0]['text'].strip()}
+
+@app.post("/synthesis")
+async def generate_synthesis(req: SynthesisRequest):
+    llm = get_qwen()
+    prompt = f"""<|start_header_id|>system<|end_header_id|>
+You are a elite strategic advisor. Condense the provided multi-paragraph analysis into a single, punchy, high-impact paragraph (max 40 words). 
+Focus on the "bottom line". Output ONLY the paragraph.
+<|eot_id|><|start_header_id|>user<|end_header_id|>
+Full Analysis: {req.overview_text}
+<|eot_id|><|start_header_id|>assistant<|end_header_id|>"""
+    res = llm(prompt, max_tokens=150, stop=["<|eot_id|>"], echo=False)
+    return {"synthesis": res['choices'][0]['text'].strip()}
+
+@app.post("/battle")
+async def generate_battle(req: BattleRequest):
+    llm = get_qwen()
+    prompt = f"""<|start_header_id|>system<|end_header_id|>
+You are an elite competitive intelligence officer. Perform a "Neural Clash" analysis between two competing applications.
+Contrast their strengths, expose their fatal flaws, and declare a strategic winner.
+Structure:
+1. WINNING EDGE: Who has the superior UX?
+2. VULNERABILITY GAP: Biggest retention killer?
+3. STRATEGIC VERDICT: Superior growth trajectory?
+<|eot_id|><|start_header_id|>user<|end_header_id|>
+APP A ({req.app_a_name}): {req.app_a_overview}
+APP B ({req.app_b_name}): {req.app_b_overview}
+<|eot_id|><|start_header_id|>assistant<|end_header_id|>"""
+    res = llm(prompt, max_tokens=600, stop=["<|eot_id|>"], echo=False)
+    return {"battle": res['choices'][0]['text'].strip()}
+
+if __name__ == "__main__":
+    import uvicorn
+    # Pre-warm model cache
+    get_qwen()
+    uvicorn.run(app, host="0.0.0.0", port=7860)

requirements.qwen.txt

@@ -0,0 +1,11 @@
+# Optimized AI-Only Requirements for Qwen Intelligence Provider
+--prefer-binary
+--only-binary llama-cpp-python
+
+fastapi==0.128.8
+uvicorn[standard]==0.33.0
+llama_cpp_python==0.3.19
+huggingface_hub==0.36.2
+python-dotenv==1.0.0
+pydantic
+requests

scraper.py

@@ -130,8 +130,22 @@ def search_app_store(query):
 
 # Neural Config
 QWEN_PATH = "ml_models/qwen-3.5-4b.gguf"
+# Hugging Face Intelligence Provider URL (if decoupled)
+QWEN_REMOTE_URL = os.getenv("QWEN_REMOTE_URL") 
 _Qwen = None
 
+def call_remote_qwen(endpoint: str, payload: dict):
+    """Internal helper to communicate with the decoupled Qwen Intelligence Provider."""
+    if not QWEN_REMOTE_URL: return None
+    try:
+        url = f"{QWEN_REMOTE_URL.rstrip('/')}/{endpoint.lstrip('/')}"
+        res = requests.post(url, json=payload, timeout=60)
+        if res.status_code == 200:
+            return res.json()
+    except Exception as e:
+        print(f"[Remote AI Error] Failed to reach {endpoint}: {e}")
+    return None
+
 def get_qwen():
     global _Qwen
     if _Qwen: return _Qwen
@@ -197,6 +211,11 @@ Reviews to analyze:
         pos_mini = get_mini_summary(pos_clusters, "positive")
 
         # Phase 2: Master Synthesis
+        if QWEN_REMOTE_URL:
+            remote_res = call_remote_qwen("overview", {"neg_reviews": neg_clusters, "pos_reviews": pos_clusters})
+            if remote_res and "overview" in remote_res:
+                return remote_res["overview"]
+
         master_prompt = f"""<|start_header_id|>system<|end_header_id|>
 You are a senior product manager. Based on the hierarchical insights provided, write a deep 3-paragraph professional analysis. 
 Structure:
@@ -235,6 +254,12 @@ Directly output the paragraph. No filler.
 Full Analysis:
 {overview_text}
 <|eot_id|><|start_header_id|>assistant<|end_header_id|>"""
+    
+    if QWEN_REMOTE_URL:
+        remote_res = call_remote_qwen("synthesis", {"overview_text": overview_text})
+        if remote_res and "synthesis" in remote_res:
+            return remote_res["synthesis"]
+
     try:
         res = llm(prompt, max_tokens=150, stop=["<|eot_id|>"], echo=False)
         return res['choices'][0]['text'].strip(' "\n\r')
@@ -274,6 +299,14 @@ APPLICATION B: {name_b}
 INTEL ON B: {analysis_b}
 <|eot_id|><|start_header_id|>assistant<|end_header_id|>"""
 
+    if QWEN_REMOTE_URL:
+        remote_res = call_remote_qwen("battle", {
+            "app_a_name": name_a, "app_a_overview": analysis_a,
+            "app_b_name": name_b, "app_b_overview": analysis_b
+        })
+        if remote_res and "battle" in remote_res:
+            return remote_res["battle"]
+
     try:
         res = llm(prompt, max_tokens=600, stop=["<|eot_id|>"], echo=False)
         return res['choices'][0]['text'].strip(' "\n\r')
@@ -295,6 +328,12 @@ Output ONLY the comma-separated keywords. No conversational filler.
 <|eot_id|><|start_header_id|>user<|end_header_id|>
 App Idea: {idea_text}
 <|eot_id|><|start_header_id|>assistant<|end_header_id|>"""
+
+    if QWEN_REMOTE_URL:
+        remote_res = call_remote_qwen("keywords", {"idea_text": idea_text})
+        if remote_res and "keywords" in remote_res:
+            return remote_res["keywords"]
+
     try:
         res = llm(prompt, max_tokens=100, stop=["<|eot_id|>"], echo=False)
         return res['choices'][0]['text'].strip()
@@ -312,6 +351,12 @@ Example: "WhatsApp" and "WhatsApp Messenger" is YES. "WhatsApp" and "Instagram"
 App Name 1: {title1}
 App Name 2: {title2}
 <|eot_id|><|start_header_id|>assistant<|end_header_id|>"""
+
+    if QWEN_REMOTE_URL:
+        remote_res = call_remote_qwen("validate", {"title1": title1, "title2": title2})
+        if remote_res and "match" in remote_res:
+            return remote_res["match"]
+
     try:
         ans_res = llm(prompt, max_tokens=10, stop=["<|eot_id|>"], echo=False)
         ans = ans_res['choices'][0]['text'].strip().upper()