Update main.py

main.py

@@ -1,34 +1,40 @@
 import os
-import logging
 import io
-from fastapi import FastAPI, Request, Header, HTTPException, UploadFile, File
+import tempfile
+import logging
+import traceback
+from fastapi import FastAPI, Header, HTTPException, UploadFile, File, Request
 from fastapi.responses import JSONResponse
 from pydantic import BaseModel
 from transformers import pipeline
+from langdetect import detect, DetectorFactory
 from PIL import Image
-from smebuilder_vector import query_vector
+from smebuilder_vector import retriever  # Local vector retriever
 
 # ==============================
 # Logging Setup
 # ==============================
 logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger("AgriCopilot")
+logger = logging.getLogger("DevAssist")
 
 # ==============================
-# App Initialization
+# FastAPI Init
 # ==============================
-app = FastAPI(title="AgriCopilot AI API", version="2.0")
+app = FastAPI(title="DevAssist AI Backend")
 
 @app.get("/")
 async def root():
-    return {"status": "AgriCopilot AI Backend is running smoothly ✅"}
+    return {"status": "✅ DevAssist AI Backend running"}
 
 # ==============================
-# AUTH CONFIGURATION
+# Auth Configuration
 # ==============================
-PROJECT_API_KEY = os.getenv("PROJECT_API_KEY", "agricopilot404")
+PROJECT_API_KEY = os.getenv("PROJECT_API_KEY", "devassist-secret")
+HF_TOKEN = os.getenv("HUGGINGFACEHUB_API_TOKEN")
+SPITCH_API_KEY = os.getenv("SPITCH_API_KEY")
 
 def check_auth(authorization: str | None):
+    """Bearer token validator."""
     if not PROJECT_API_KEY:
         return
     if not authorization or not authorization.startswith("Bearer "):
@@ -38,125 +44,169 @@ def check_auth(authorization: str | None):
         raise HTTPException(status_code=403, detail="Invalid token")
 
 # ==============================
-# Exception Handling
+# Global Error Handler
 # ==============================
 @app.exception_handler(Exception)
 async def global_exception_handler(request: Request, exc: Exception):
-    logger.error(f"Unhandled error: {exc}")
+    logger.error(f"Unhandled Exception: {exc}")
     return JSONResponse(status_code=500, content={"error": str(exc)})
 
 # ==============================
-# Request Models
+# Request Schemas
 # ==============================
 class ChatRequest(BaseModel):
-    query: str
-
-class DisasterRequest(BaseModel):
-    report: str
+    question: str
 
-class MarketRequest(BaseModel):
-    product: str
+class AutoDocRequest(BaseModel):
+    code: str
 
-class VectorRequest(BaseModel):
-    query: str
+class SMERequest(BaseModel):
+    user_prompt: str
 
 # ==============================
-# Load Hugging Face Pipelines
+# HuggingFace Pipelines
 # ==============================
-HF_TOKEN = os.getenv("HUGGINGFACEHUB_API_TOKEN")
-
 if not HF_TOKEN:
-    logger.warning("⚠️ No Hugging Face token found. Gated models may fail.")
+    logger.warning("⚠️ No Hugging Face token found. Private/gated models may fail.")
 else:
-    logger.info("✅ Hugging Face token loaded successfully.")
+    logger.info("✅ Hugging Face token detected and ready.")
 
-# General text-generation model for chat, disaster, market endpoints
-default_model = "meta-llama/Llama-3.1-8B-Instruct"
-vision_model = "meta-llama/Llama-3.2-11B-Vision-Instruct"
+HF_MODELS = {
+    "chat": "meta-llama/Llama-3.1-8B-Instruct",
+    "autodoc": "Salesforce/codegen-2B-mono",
+    "sme": "deepseek-ai/deepseek-coder-1.3b-instruct"
+}
 
-chat_pipe = pipeline("text-generation", model=default_model, token=HF_TOKEN)
-disaster_pipe = pipeline("text-generation", model=default_model, token=HF_TOKEN)
-market_pipe = pipeline("text-generation", model=default_model, token=HF_TOKEN)
+def safe_pipeline(task: str, model: str, fallback="gpt2"):
+    try:
+        return pipeline(task, model=model, token=HF_TOKEN)
+    except Exception as e:
+        logger.warning(f"Failed to load {model}: {e} → Falling back to {fallback}")
+        return pipeline(task, model=fallback)
 
-# Multimodal crop diagnostic model
-try:
-    crop_pipe = pipeline("image-text-to-text", model=vision_model, token=HF_TOKEN)
-except Exception as e:
-    logger.warning(f"Crop model load failed: {e}")
-    crop_pipe = None
+chat_pipe = safe_pipeline("text-generation", HF_MODELS["chat"])
+autodoc_pipe = safe_pipeline("text-generation", HF_MODELS["autodoc"])
+sme_pipe = safe_pipeline("text-generation", HF_MODELS["sme"])
 
 # ==============================
-# Helper Functions
+# Helper: Text Generation
 # ==============================
-def run_conversational(pipe, prompt: str):
+def run_pipeline(pipe, prompt: str, max_tokens=512):
+    """Run a text-generation pipeline with proper error capture."""
     try:
-        output = pipe(prompt, max_new_tokens=200)
+        output = pipe(prompt, max_new_tokens=max_tokens)
         if isinstance(output, list) and len(output) > 0:
-            return output[0].get("generated_text", str(output))
-        return str(output)
+            result = output[0].get("generated_text", "").strip()
+        else:
+            result = str(output).strip()
+
+        logger.info(f"\n--- PROMPT ---\n{prompt}\n--- OUTPUT ---\n{result}\n--- END ---")
+
+        if not result:
+            return {"success": False, "error": "⚠️ LLM returned empty output."}
+        return {"success": True, "data": result}
     except Exception as e:
         logger.error(f"Pipeline error: {e}")
-        return f"⚠️ Model error: {str(e)}"
-
-def run_crop_doctor(image_bytes: bytes, symptoms: str):
-    """
-    Diagnose crop issues using Meta's multimodal LLaMA Vision model.
-    """
-    if not crop_pipe:
-        return "⚠️ Crop analysis temporarily unavailable (model not loaded)."
+        return {
+            "success": False,
+            "error": f"⚠️ LLM error: {str(e)}",
+            "trace": traceback.format_exc(),
+        }
+
+# ==============================
+# Audio Processing Helper
+# ==============================
+async def process_audio(file: UploadFile, lang_hint: str | None = None):
+    import spitch
+    spitch_client = spitch.Spitch()
+    suffix = os.path.splitext(file.filename)[1] or ".wav"
+
+    with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as tf:
+        tf.write(await file.read())
+        tmp_path = tf.name
+
+    with open(tmp_path, "rb") as f:
+        audio_bytes = f.read()
+
     try:
-        image = Image.open(io.BytesIO(image_bytes)).convert("RGB")
-        prompt = (
-            f"The farmer reports: {symptoms}. "
-            "Analyze the image and diagnose the likely crop disease. "
-            "Then explain it simply and recommend possible treatment steps."
+        resp = spitch_client.speech.transcribe(
+            content=audio_bytes, language=lang_hint or "en"
         )
-        output = crop_pipe(image, prompt)
-        if isinstance(output, list) and len(output) > 0:
-            return output[0].get("generated_text", str(output))
-        return str(output)
     except Exception as e:
-        logger.error(f"Crop Doctor pipeline error: {e}")
-        return f"⚠️ Unexpected model error: {str(e)}"
+        logger.warning(f"Speech API failed: {e}")
+        resp = {"text": ""}
+
+    transcription = getattr(resp, "text", "") or (resp.get("text", "") if isinstance(resp, dict) else "")
+    detected_lang = "en"
+    try:
+        detected_lang = detect(transcription) if transcription.strip() else "en"
+    except Exception:
+        pass
+
+    # Optional translation
+    translation = transcription
+    if detected_lang != "en":
+        try:
+            translation_resp = spitch_client.text.translate(
+                text=transcription, source=detected_lang, target="en"
+            )
+            translation = getattr(translation_resp, "text", "") or translation_resp.get("text", "")
+        except Exception:
+            translation = transcription
+
+    return transcription, detected_lang, translation
 
 # ==============================
-# API ROUTES
+# Endpoints
 # ==============================
-@app.post("/multilingual-chat")
-async def multilingual_chat(req: ChatRequest, authorization: str | None = Header(None)):
+@app.post("/chat")
+async def chat_endpoint(req: ChatRequest, authorization: str | None = Header(None)):
     check_auth(authorization)
-    reply = run_conversational(chat_pipe, req.query)
-    return {"reply": reply}
+    prompt = f"You are a helpful developer assistant. Question:\n{req.question}\nAnswer clearly:"
+    result = run_pipeline(chat_pipe, prompt)
+    return result
 
-@app.post("/disaster-summarizer")
-async def disaster_summarizer(req: DisasterRequest, authorization: str | None = Header(None)):
+@app.post("/autodoc")
+async def autodoc_endpoint(req: AutoDocRequest, authorization: str | None = Header(None)):
     check_auth(authorization)
-    summary = run_conversational(disaster_pipe, req.report)
-    return {"summary": summary}
+    prompt = f"Generate Markdown documentation for the following Python code:\n{req.code}\nDocumentation:"
+    result = run_pipeline(autodoc_pipe, prompt)
+    return result
 
-@app.post("/marketplace")
-async def marketplace(req: MarketRequest, authorization: str | None = Header(None)):
+@app.post("/sme/generate")
+async def sme_generate_endpoint(req: SMERequest, authorization: str | None = Header(None)):
     check_auth(authorization)
-    recommendation = run_conversational(market_pipe, req.product)
-    return {"recommendation": recommendation}
+    try:
+        context_docs = retriever.get_relevant_documents(req.user_prompt)
+        context = "\n".join([doc.page_content for doc in context_docs]) if context_docs else "No extra context"
+        prompt = f"Generate production-grade frontend code based on this:\n{req.user_prompt}\nContext:\n{context}\nOutput:"
+        result = run_pipeline(sme_pipe, prompt)
+        return result
+    except Exception as e:
+        return {"success": False, "error": f"⚠️ LLM error: {str(e)}", "trace": traceback.format_exc()}
 
-@app.post("/vector-search")
-async def vector_search(req: VectorRequest, authorization: str | None = Header(None)):
+@app.post("/sme/speech-generate")
+async def sme_speech_endpoint(file: UploadFile = File(...), lang_hint: str | None = None, authorization: str | None = Header(None)):
     check_auth(authorization)
+    transcription, detected_lang, translation = await process_audio(file, lang_hint)
     try:
-        results = query_vector(req.query)
-        return {"results": results}
+        context_docs = retriever.get_relevant_documents(translation)
+        context = "\n".join([doc.page_content for doc in context_docs]) if context_docs else "No extra context"
+        prompt = f"Generate production-ready frontend code for this idea:\n{translation}\nContext:\n{context}\nOutput:"
+        result = run_pipeline(sme_pipe, prompt)
+        return {
+            "success": True,
+            "transcription": transcription,
+            "detected_language": detected_lang,
+            "translation": translation,
+            "output": result.get("data", ""),
+        }
     except Exception as e:
-        logger.error(f"Vector search error: {e}")
-        return {"error": f"Vector search error: {str(e)}"}
-
-@app.post("/crop-doctor")
-async def crop_doctor(
-    symptoms: str = Header(...),
-    image: UploadFile = File(...),
-    authorization: str | None = Header(None)
-):
-    check_auth(authorization)
-    image_bytes = await image.read()
-    diagnosis = run_crop_doctor(image_bytes, symptoms)
-    return {"diagnosis": diagnosis}
+        return {"success": False, "error": f"⚠️ LLM error: {str(e)}", "trace": traceback.format_exc()}
+
+# ==============================
+# Run App
+# ==============================
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run("main:app", host="0.0.0.0", port=7860)