Delete app.py

app.py

@@ -1,236 +0,0 @@
-import os
-import shutil
-from fastapi.responses import FileResponse
-import asyncio
-import json
-from fastapi import FastAPI, UploadFile, File, Form, HTTPException, BackgroundTasks
-from fastapi.responses import StreamingResponse
-from pydantic import BaseModel
-from fastapi.middleware.cors import CORSMiddleware
-from utils import STT, TTS
-from data_ingestion import Ingest_Data 
-from RAG import app as rag_app, Ragbot_State, reload_vector_store
-
-# Initialize FastAPI
-app = FastAPI(title="LangGraph RAG Chatbot", version="1.0")
-
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-# --- Pydantic Models ---
-class ChatRequest(BaseModel):
-    query: str
-    thread_id: str = "default_user"
-    use_rag: bool = False
-    use_web: bool = False
-    model_name: str = "gpt"
-
-class TTSRequest(BaseModel):
-    text: str
-    voice: str = "en-US-AriaNeural"
-
-
-# --- Endpoints ---
-
-@app.get("/")
-def health_check():
-    return {"status": "running", "message": "Bot is ready"}
-
-@app.post("/upload")
-async def upload_document(
-    file: UploadFile = File(...), 
-    background_tasks: BackgroundTasks = BackgroundTasks()
-):
-    try:
-        temp_filename = f"temp_{file.filename}"
-
-        with open(temp_filename, "wb") as buffer:
-            shutil.copyfileobj(file.file, buffer)
-
-        def process_and_reload(path):
-            try:
-                result = Ingest_Data(path)
-                print(f"Ingestion Result: {result}")
-                reload_vector_store()
-                
-            except Exception as e:
-                print(f"Error processing background task: {e}")
-            finally:
-                if os.path.exists(path):
-                    os.remove(path)
-
-        background_tasks.add_task(process_and_reload, temp_filename)
-
-        return {
-            "message": "File received. Processing started in background.", 
-            "filename": file.filename
-        }
-        
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-
-
-# ... (keep existing imports) ...
-
-# NEW: Streaming endpoint
-@app.post("/chat/stream")
-async def chat_stream_endpoint(request: ChatRequest):
-    """
-    Streaming Chat Endpoint.
-    Streams the LLM response as Server-Sent Events (SSE).
-    """
-    async def event_generator():
-        try:
-            config = {"configurable": {"thread_id": request.thread_id}}
-            inputs = {
-                "query": request.query,
-                "RAG": request.use_rag,
-                "web_search": request.use_web,
-                "model_name": request.model_name,
-                "context": [],
-                "metadata": [],
-                "web_context": "",
-            }
-            
-            # Use astream or astream_events depending on your LangGraph version
-            async for event in rag_app.astream(inputs, config=config):
-                # Extract the content from the streaming event
-                # The structure depends on your graph, adjust as needed
-                if "response" in event:
-                    messages = event["response"]
-                    if messages and len(messages) > 0:
-                        last_msg = messages[-1]
-                        if hasattr(last_msg, 'content'):
-                            chunk = {
-                                "type": "content",
-                                "data": last_msg.content,
-                                "thread_id": request.thread_id
-                            }
-                            yield f"data: {json.dumps(chunk)}\n\n"
-                
-                # If your graph streams token by token, handle it here
-                elif "chunk" in event:
-                    chunk = {
-                        "type": "token",
-                        "data": event["chunk"],
-                        "thread_id": request.thread_id
-                    }
-                    yield f"data: {json.dumps(chunk)}\n\n"
-            
-            # Send completion signal
-            yield f"data: {json.dumps({'type': 'done', 'thread_id': request.thread_id})}\n\n"
-            
-        except Exception as e:
-            error_data = {
-                "type": "error",
-                "error": str(e),
-                "thread_id": request.thread_id
-            }
-            yield f"data: {json.dumps(error_data)}\n\n"
-    
-    return StreamingResponse(
-        event_generator(),
-        media_type="text/event-stream",
-        headers={
-            "Cache-Control": "no-cache",
-            "Connection": "keep-alive",
-            "X-Accel-Buffering": "no"  # Disable nginx buffering
-        }
-    )
-
-
-# ALTERNATIVE: If you need more granular streaming with astream_events
-@app.post("/chat/stream/events")
-async def chat_stream_events_endpoint(request: ChatRequest):
-    """
-    Streaming Chat Endpoint using astream_events.
-    Provides more granular control over streaming events.
-    """
-    async def event_generator():
-        try:
-            config = {"configurable": {"thread_id": request.thread_id}}
-            inputs = {
-                "query": request.query,
-                "RAG": request.use_rag,
-                "web_search": request.use_web,
-                "model_name": request.model_name,
-                "context": [],
-                "metadata": [],
-                "web_context": "",
-            }
-            
-            # Stream events from the graph
-            async for event in rag_app.astream_events(inputs, config=config, version="v2"):
-                event_type = event.get("event")
-                
-                # Handle different event types
-                if event_type == "on_chat_model_stream":
-                    # This captures token-by-token streaming from the LLM
-                    content = event.get("data", {}).get("chunk", {})
-                    if hasattr(content, 'content') and content.content:
-                        chunk = {
-                            "type": "token",
-                            "data": content.content,
-                            "thread_id": request.thread_id
-                        }
-                        yield f"data: {json.dumps(chunk)}\n\n"
-                
-                elif event_type == "on_chain_end":
-                    # Final result
-                    output = event.get("data", {}).get("output", {})
-                    if "response" in output:
-                        messages = output["response"]
-                        if messages and len(messages) > 0:
-                            last_msg = messages[-1]
-                            chunk = {
-                                "type": "complete",
-                                "data": last_msg.content if hasattr(last_msg, 'content') else str(last_msg),
-                                "thread_id": request.thread_id
-                            }
-                            yield f"data: {json.dumps(chunk)}\n\n"
-            
-            # Send completion signal
-            yield f"data: {json.dumps({'type': 'done', 'thread_id': request.thread_id})}\n\n"
-            
-        except Exception as e:
-            error_data = {
-                "type": "error",
-                "error": str(e),
-                "thread_id": request.thread_id
-            }
-            yield f"data: {json.dumps(error_data)}\n\n"
-    
-    return StreamingResponse(
-        event_generator(),
-        media_type="text/event-stream",
-        headers={
-            "Cache-Control": "no-cache",
-            "Connection": "keep-alive",
-            "X-Accel-Buffering": "no"
-        }
-    )
-
-# ---------------- STT ---------------- #
-@app.post("/stt")
-async def transcribe_audio(file: UploadFile = File(...)):
-    try:
-        return await STT(file)
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-# ---------------- TTS ---------------- #
-@app.post("/tts")
-async def text_to_speech(req: TTSRequest):
-    try:
-        audio_path = await TTS(req.text, req.voice)
-        return FileResponse(audio_path, media_type="audio/mpeg", filename="output.mp3")
-        
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))