Update app.py

app.py

@@ -6,10 +6,6 @@ from fastapi import FastAPI, Request, HTTPException
 from fastapi.responses import StreamingResponse
 from fastapi.middleware.cors import CORSMiddleware
 
-# --- New imports for LangChain + langchain_ollama ---
-from pydantic import BaseModel
-from langchain_ollama import ChatOllama
-
 # Configure logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -33,23 +29,12 @@ app.add_middleware(
 API_KEY = os.environ.get("API_KEY", "change_me")
 logger.info(f"API key loaded: {API_KEY}")
 
-# URL of the running Ollama server (adjust as needed)
-OLLAMA_SERVER_URL = "http://localhost:11434/api/generate"
-
-# --- Initialize a single Ollama instance via langchain_ollama ---
-#    This is the "LangChain" style interface to the Ollama server.
-ollama_llm = ChatOllama(
-    model="hf.co/abanm/Dubs-Q8_0-GGUF:latest",  # same model as before
-    base_url="http://localhost:11434",          # base URL for Ollama server
-    request_timeout=120                         # Increase if model loading is slow
-)
+# NOTE: Ollama’s default endpoint is often "/generate", not "/api/generate"
+OLLAMA_SERVER_URL = "http://localhost:11434/generate"
 
-# --------------------------------
-# Original endpoint: /api/generate
-# --------------------------------
 @app.post("/api/generate")
 async def generate(request: Request):
-    """Endpoint that generates text based on the prompt (direct HTTP call to Ollama)."""
+    """Endpoint that generates text based on the prompt."""
     try:
         # 1. Parse the incoming request
         body = await request.json()
@@ -83,56 +68,36 @@ async def generate(request: Request):
             try:
                 async with httpx.AsyncClient() as client:
                     async with client.stream(
-                        "POST", OLLAMA_SERVER_URL, json=payload, headers={"Content-Type": "application/json"}
+                        "POST",
+                        OLLAMA_SERVER_URL,
+                        json=payload,
+                        headers={"Content-Type": "application/json"}
                     ) as response:
+                        # If we get 4xx or 5xx, raise_for_status() triggers HTTPStatusError
                         response.raise_for_status()
+
+                        # Stream out the content as it arrives
                         async for chunk in response.aiter_text():
                             yield chunk
+
             except httpx.RequestError:
                 logger.exception("Request error while communicating with Ollama")
                 yield json.dumps({"error": "Unable to communicate with Ollama"})
+
             except httpx.HTTPStatusError as exc:
-                logger.error(f"HTTP error from Ollama: {exc.response.status_code} - {exc.response.text}")
-                yield json.dumps({"error": f"HTTP error: {exc.response.text}"})
+                # Read the remaining body so we can log the error text
+                error_bytes = await exc.response.aread()
+                error_text = error_bytes.decode("utf-8", errors="replace")
+
+                logger.error(f"HTTP error from Ollama: {exc.response.status_code} - {error_text}")
+                yield json.dumps({"error": f"HTTP error: {error_text}"})
 
         return StreamingResponse(stream_response(), media_type="application/json")
 
-    except Exception as exc:
+    except Exception:
         logger.exception("Unhandled exception in /api/generate")
         raise HTTPException(status_code=500, detail="Internal server error")
 
-# ------------------------------
-# New endpoint: /api/langchain-generate
-# ------------------------------
-class LangChainRequest(BaseModel):
-    prompt: str
-
-@app.post("/api/langchain-generate")
-async def langchain_generate(request: LangChainRequest):
-    """
-    Endpoint that uses langchain_ollama to generate text.
-    This is an alternative approach that uses the Ollama() class from langchain_ollama.
-    """
-    # Check for API key (similar logic as above, or unify the code)
-    # ... or just omit it if your environment is already secure
-    # If re-using the same approach:
-    #  (In real code, you'd unify these checks in a shared function)
-    #  
-    # auth_header = ...
-    # if token != API_KEY:
-    #    raise HTTPException(...)
-    
-    prompt = request.prompt
-    logger.info(f"LangChain request: {prompt}")
-
-    # Directly call the Ollama LLM via langchain_ollama
-    try:
-        response_text = ollama_llm(prompt)
-        return {"response": response_text}
-    except Exception as e:
-        logger.exception("Unhandled exception in /api/langchain-generate")
-        raise HTTPException(status_code=500, detail=str(e))
-
 @app.get("/health")
 async def health():
     """Health check endpoint."""
@@ -143,3 +108,4 @@ if __name__ == "__main__":
     import uvicorn
     logger.info("Starting server on http://0.0.0.0:7860")
     uvicorn.run(app, host="0.0.0.0", port=7860)
+