Add application file

app.py

@@ -0,0 +1,156 @@
+# main.py
+import os
+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 langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+from langchain_community.llms import HuggingFaceHub
+from langdetect import detect, DetectorFactory
+
+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
+
+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)
+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})
+
+# FastAPI app
+app = FastAPI(title="DevAssist AI Backend (FastAPI + LangChain)")
+
+# CORS (allow only your Vercel domain in production)
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=[FRONTEND_ORIGIN] if FRONTEND_ORIGIN != "*" else ["*"],
+    allow_credentials=True,
+    allow_methods=["GET", "POST", "OPTIONS"],
+    allow_headers=["Authorization", "Content-Type"],
+)
+
+# --------- PROMPT TEMPLATES ----------
+chat_template = """You are DevAssist, an AI coding assistant.
+- Help fix bugs and explain clearly.
+- Provide complete, working code in markdown.
+- Be friendly yet professional; break down problems step by step.
+Question: {question}
+Answer:"""
+
+stt_chat_template = """You are DevAssist, an AI coding assistant.
+- The input is transcribed speech. Interpret it as a dev question.
+- Provide clear answers with code examples (use markdown triple backticks).
+- If input is unclear, ask a clarifying question.
+Spoken Question: {speech}
+Answer:"""
+
+autodoc_template = """You are DevAssist DocBot.
+- Read the code and produce professional documentation in markdown.
+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))
+
+# --------- REQUEST MODELS ----------
+class ChatRequest(BaseModel):
+    question: str
+
+class AutoDocRequest(BaseModel):
+    code: str
+
+# --------- AUTH ----------
+def check_auth(authorization: str | None):
+    if not PROJECT_API_KEY:
+        return  # you can disable for local dev (but set in production)
+    if not authorization or not authorization.startswith("Bearer "):
+        raise HTTPException(status_code=401, detail="Missing bearer token")
+    token = authorization.split(" ", 1)[1]
+    if token != PROJECT_API_KEY:
+        raise HTTPException(status_code=403, detail="Invalid token")
+
+# --------- ENDPOINTS ----------
+@app.get("/")
+def root():
+    return {"status": "DevAssist AI Backend running"}
+
+@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()}
+
+# 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
+        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)
+
+    return {
+        "transcription": transcription,
+        "detected_language": detected_lang,
+        "translation": translation,
+        "reply": reply.strip()
+    }
+
+@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()}

requirements.txt

@@ -0,0 +1,8 @@
+fastapi
+uvicorn[standard]
+pydantic
+spitch
+langchain
+langchain-community
+langdetect
+httpx