Updated

main.py

@@ -4,10 +4,9 @@ import tempfile
 from fastapi import FastAPI, UploadFile, File, Header, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel
-from spitch import Spitch         # Spitch Python SDK (docs use this pattern)
+from spitch import Spitch
 from langchain.prompts import PromptTemplate
-from langchain.chains import LLMChain
-from langchain_community.llms import HuggingFaceHub
+from langchain_huggingface import HuggingFaceEndpoint   # ✅ updated import
 from langdetect import detect, DetectorFactory
 
 DetectorFactory.seed = 0
@@ -15,23 +14,27 @@ DetectorFactory.seed = 0
 # --------- BASIC CONFIG ----------
 SPITCH_API_KEY = os.getenv("SPITCH_API_KEY")
 HF_MODEL = os.getenv("HF_MODEL", "google/flan-t5-base")
-FRONTEND_ORIGIN = os.getenv("ALLOWED_ORIGIN", "*")  # set to Vercel domain in production
-PROJECT_API_KEY = os.getenv("PROJECT_API_KEY", "")  # simple bearer key for frontend -> backend auth
+FRONTEND_ORIGIN = os.getenv("ALLOWED_ORIGIN", "*")
+PROJECT_API_KEY = os.getenv("PROJECT_API_KEY", "")
 
 if not SPITCH_API_KEY:
     raise RuntimeError("Set SPITCH_API_KEY in environment before starting.")
 
-# Init Spitch (SDK reads env var; docs show this pattern)
+# Init Spitch
 os.environ["SPITCH_API_KEY"] = SPITCH_API_KEY
 spitch_client = Spitch()
 
-# Init LLM
-llm = HuggingFaceHub(repo_id=HF_MODEL, model_kwargs={"temperature": 0.2, "max_length": 512})
+# ✅ Use new HuggingFaceEndpoint instead of deprecated HuggingFaceHub
+llm = HuggingFaceEndpoint(
+    repo_id=HF_MODEL,
+    temperature=0.2,
+    max_length=512
+)
 
 # FastAPI app
 app = FastAPI(title="DevAssist AI Backend (FastAPI + LangChain)")
 
-# CORS (allow only your Vercel domain in production)
+# CORS
 app.add_middleware(
     CORSMiddleware,
     allow_origins=[FRONTEND_ORIGIN] if FRONTEND_ORIGIN != "*" else ["*"],
@@ -60,9 +63,14 @@ autodoc_template = """You are DevAssist DocBot.
 Code: {code}
 Documentation:"""
 
-chat_chain = LLMChain(llm=llm, prompt=PromptTemplate(input_variables=["question"], template=chat_template))
-stt_chain = LLMChain(llm=llm, prompt=PromptTemplate(input_variables=["speech"], template=stt_chat_template))
-autodoc_chain = LLMChain(llm=llm, prompt=PromptTemplate(input_variables=["code"], template=autodoc_template))
+# ✅ Use RunnableSequence instead of LLMChain
+chat_prompt = PromptTemplate(input_variables=["question"], template=chat_template)
+stt_prompt = PromptTemplate(input_variables=["speech"], template=stt_chat_template)
+autodoc_prompt = PromptTemplate(input_variables=["code"], template=autodoc_template)
+
+chat_chain = chat_prompt | llm
+stt_chain = stt_prompt | llm
+autodoc_chain = autodoc_prompt | llm
 
 # --------- REQUEST MODELS ----------
 class ChatRequest(BaseModel):
@@ -74,7 +82,7 @@ class AutoDocRequest(BaseModel):
 # --------- AUTH ----------
 def check_auth(authorization: str | None):
     if not PROJECT_API_KEY:
-        return  # you can disable for local dev (but set in production)
+        return
     if not authorization or not authorization.startswith("Bearer "):
         raise HTTPException(status_code=401, detail="Missing bearer token")
     token = authorization.split(" ", 1)[1]
@@ -89,68 +97,58 @@ def root():
 @app.post("/chat")
 def chat(req: ChatRequest, authorization: str | None = Header(None)):
     check_auth(authorization)
-    answer = chat_chain.run(question=req.question)
-    return {"reply": answer.strip()}
+    answer = chat_chain.invoke({"question": req.question})
+    return {"reply": answer.strip() if isinstance(answer, str) else str(answer)}
 
-# Speech endpoint: full pipeline speech -> transcription -> translation (if needed) -> LLM
 @app.post("/stt")
 async def stt_audio(file: UploadFile = File(...), lang_hint: str | None = None, authorization: str | None = Header(None)):
-    """
-    POST /stt with form-data file=@audio.mp3
-    Optional query/form field lang_hint: two-letter code (e.g. 'yo' for Yoruba) if frontend knows spoken language
-    Returns: transcription, detected_language, translation (to en), reply
-    """
     check_auth(authorization)
 
-    # save uploaded file to temp file
     suffix = os.path.splitext(file.filename)[1] or ".wav"
     with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as tf:
         content = await file.read()
         tf.write(content)
         tmp_path = tf.name
 
-    # 1) Transcribe using Spitch SDK (docs show client.speech.transcribe)
-    # If lang_hint provided, pass it; else attempt without language param and fallback
     try:
         if lang_hint:
             resp = spitch_client.speech.transcribe(language=lang_hint, content=open(tmp_path, "rb").read())
         else:
-            # attempt transcribe without explicit language (SDK may auto-detect)
             resp = spitch_client.speech.transcribe(content=open(tmp_path, "rb").read())
-    except Exception as e:
-        # fallback: try English transcription as last resort
+    except Exception:
         resp = spitch_client.speech.transcribe(language="en", content=open(tmp_path, "rb").read())
 
     transcription = getattr(resp, "text", "") or resp.get("text", "") if isinstance(resp, dict) else ""
 
-    # 2) Detect language of transcription if not provided
     try:
         detected_lang = detect(transcription) if transcription.strip() else "en"
     except Exception:
         detected_lang = "en"
 
-    # 3) If detected_lang != 'en', translate to English so LLM reasons in English
     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", "") if isinstance(translation_resp, dict) else translation
         except Exception:
-            # if translation fails, fallback to transcription
             translation = transcription
 
-    # 4) Pass translated text to LLM (LLM assumes English)
-    reply = stt_chain.run(speech=translation)
+    reply = stt_chain.invoke({"speech": translation})
 
     return {
         "transcription": transcription,
         "detected_language": detected_lang,
         "translation": translation,
-        "reply": reply.strip()
+        "reply": reply.strip() if isinstance(reply, str) else str(reply)
     }
 
 @app.post("/autodoc")
 def autodoc(req: AutoDocRequest, authorization: str | None = Header(None)):
     check_auth(authorization)
-    docs = autodoc_chain.run(code=req.code)
-    return {"documentation": docs.strip()}
+    docs = autodoc_chain.invoke({"code": req.code})
+    return {"documentation": docs.strip() if isinstance(docs, str) else str(docs)}
+
+# ✅ Hugging Face requires port 7860, not 8000
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run("main:app", host="0.0.0.0", port=7860, reload=False)

requirements.txt

@@ -7,4 +7,5 @@ langchain-community
 langdetect
 httpx
 huggingface_hub
-python-multipart
+python-multipart
+langchain-huggingface>=0.0.8