Upload 9 files

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+chat_sessions.db filter=lfs diff=lfs merge=lfs -text
+chroma_db/chroma.sqlite3 filter=lfs diff=lfs merge=lfs -text

app.py

@@ -0,0 +1,345 @@
+"""
+Law RAG Chatbot API using FastAPI, Langchain, Groq, and ChromaDB
+"""
+
+import os
+import time
+import logging
+from typing import List, Dict, Any, Optional
+from fastapi import FastAPI, HTTPException, Depends, Header
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+import uvicorn
+
+from config import *
+from rag_system import RAGSystem
+from session_manager import SessionManager
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Initialize FastAPI app
+app = FastAPI(
+    title=API_TITLE,
+    version=API_VERSION,
+    description=API_DESCRIPTION
+)
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Pydantic models for API requests/responses
+class ChatRequest(BaseModel):
+    question: str
+    context_length: int = 5  # Increased default context length
+    session_id: Optional[str] = None
+
+class ChatResponse(BaseModel):
+    answer: str
+    sources: List[Dict[str, Any]]
+    confidence: float
+    processing_time: float
+    question: str
+    session_id: str
+    chat_history_count: int
+
+class SessionCreateRequest(BaseModel):
+    user_info: Optional[str] = None
+    metadata: Optional[Dict[str, Any]] = None
+
+class SessionResponse(BaseModel):
+    session_id: str
+    created_at: str
+    user_info: str
+    metadata: Dict[str, Any]
+
+class HealthResponse(BaseModel):
+    status: str
+    message: str
+    components: Dict[str, str]
+
+# Global instances
+rag_system: RAGSystem = None
+session_manager: SessionManager = None
+
+@app.on_event("startup")
+async def startup_event():
+    """Initialize the RAG system and session manager on startup"""
+    global rag_system, session_manager
+    try:
+        logger.info("Initializing RAG system...")
+        rag_system = RAGSystem()
+        await rag_system.initialize()
+        logger.info("RAG system initialized successfully")
+        
+        logger.info("Initializing session manager...")
+        session_manager = SessionManager()
+        logger.info("Session manager initialized successfully")
+        
+    except Exception as e:
+        logger.error(f"Failed to initialize systems: {e}")
+        raise
+
+@app.get("/", response_model=HealthResponse)
+async def root():
+    """Root endpoint with health check"""
+    return HealthResponse(
+        status="healthy",
+        message="Law RAG Chatbot API is running",
+        components={
+            "api": "running",
+            "rag_system": "running" if rag_system else "not_initialized",
+            "session_manager": "running" if session_manager else "not_initialized",
+            "vector_db": "connected" if rag_system and rag_system.is_ready() else "disconnected"
+        }
+    )
+
+@app.get("/health", response_model=HealthResponse)
+async def health_check():
+    """Health check endpoint"""
+    if not rag_system:
+        raise HTTPException(status_code=503, detail="RAG system not initialized")
+    
+    if not rag_system.is_ready():
+        raise HTTPException(status_code=503, detail="RAG system not ready")
+    
+    if not session_manager:
+        raise HTTPException(status_code=503, detail="Session manager not initialized")
+    
+    return HealthResponse(
+        status="healthy",
+        message="All systems operational",
+        components={
+            "api": "running",
+            "rag_system": "ready",
+            "session_manager": "ready",
+            "vector_db": "connected",
+            "embeddings": "ready",
+            "llm": "ready"
+        }
+    )
+
+@app.post("/sessions", response_model=SessionResponse)
+async def create_session(request: SessionCreateRequest):
+    """Create a new chat session"""
+    if not session_manager:
+        raise HTTPException(status_code=503, detail="Session manager not initialized")
+    
+    try:
+        session_id = session_manager.create_session(
+            user_info=request.user_info,
+            metadata=request.metadata
+        )
+        
+        session = session_manager.get_session(session_id)
+        
+        return SessionResponse(
+            session_id=session_id,
+            created_at=session["created_at"].isoformat(),
+            user_info=session["user_info"],
+            metadata=session["metadata"]
+        )
+        
+    except Exception as e:
+        logger.error(f"Error creating session: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to create session: {str(e)}")
+
+@app.get("/sessions/{session_id}", response_model=Dict[str, Any])
+async def get_session_info(session_id: str):
+    """Get session information and statistics"""
+    if not session_manager:
+        raise HTTPException(status_code=503, detail="Session manager not initialized")
+    
+    try:
+        session_stats = session_manager.get_session_stats(session_id)
+        
+        if not session_stats:
+            raise HTTPException(status_code=404, detail="Session not found")
+        
+        return session_stats
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error getting session info: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to get session info: {str(e)}")
+
+@app.get("/sessions/{session_id}/history")
+async def get_chat_history(session_id: str, limit: int = 10):
+    """Get chat history for a session"""
+    if not session_manager:
+        raise HTTPException(status_code=503, detail="Session manager not initialized")
+    
+    try:
+        history = session_manager.get_chat_history(session_id, limit)
+        return {
+            "session_id": session_id,
+            "history": history,
+            "total": len(history)
+        }
+        
+    except Exception as e:
+        logger.error(f"Error getting chat history: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to get chat history: {str(e)}")
+
+@app.post("/chat", response_model=ChatResponse)
+async def chat(request: ChatRequest):
+    """Main chat endpoint for legal questions with session support"""
+    if not rag_system:
+        raise HTTPException(status_code=503, detail="RAG system not initialized")
+    
+    if not rag_system.is_ready():
+        raise HTTPException(status_code=503, detail="RAG system not ready")
+    
+    if not session_manager:
+        raise HTTPException(status_code=503, detail="Session manager not initialized")
+    
+    try:
+        start_time = time.time()
+        
+        # Handle session
+        if not request.session_id:
+            # Create new session if none provided
+            request.session_id = session_manager.create_session()
+            logger.info(f"Created new session: {request.session_id}")
+        
+        # Verify session exists
+        session = session_manager.get_session(request.session_id)
+        if not session:
+            raise HTTPException(status_code=404, detail="Session not found")
+        
+        # Get response from RAG system
+        response = await rag_system.get_response(
+            question=request.question,
+            context_length=request.context_length
+        )
+        
+        processing_time = time.time() - start_time
+        
+        # Store chat response in session
+        session_manager.store_chat_response(
+            session_id=request.session_id,
+            question=request.question,
+            answer=response["answer"],
+            sources=response["sources"],
+            confidence=response["confidence"],
+            processing_time=processing_time
+        )
+        
+        # Get chat history count
+        chat_history = session_manager.get_chat_history(request.session_id, limit=1)
+        chat_history_count = len(chat_history)
+        
+        return ChatResponse(
+            answer=response["answer"],
+            sources=response["sources"],
+            confidence=response["confidence"],
+            processing_time=processing_time,
+            question=request.question,
+            session_id=request.session_id,
+            chat_history_count=chat_history_count
+        )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error processing chat request: {e}")
+        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")
+
+@app.get("/search")
+async def search(query: str, limit: int = 5, session_id: Optional[str] = None):
+    """Search for relevant legal documents with optional session tracking"""
+    if not rag_system:
+        raise HTTPException(status_code=503, detail="RAG system not initialized")
+    
+    try:
+        results = await rag_system.search_documents(query, limit)
+        
+        # Store search query if session provided
+        if session_id and session_manager:
+            session_manager.store_search_query(session_id, query, len(results))
+        
+        return {
+            "query": query,
+            "results": results,
+            "total": len(results),
+            "session_id": session_id
+        }
+    except Exception as e:
+        logger.error(f"Error in search: {e}")
+        raise HTTPException(status_code=500, detail=f"Search failed: {str(e)}")
+
+@app.get("/stats")
+async def get_stats():
+    """Get system statistics"""
+    if not rag_system:
+        raise HTTPException(status_code=503, detail="RAG system not initialized")
+    
+    try:
+        rag_stats = await rag_system.get_stats()
+        
+        # Add session statistics
+        if session_manager:
+            # Get total sessions count (this would need to be implemented in session manager)
+            session_stats = {
+                "session_manager": "active",
+                "total_sessions": "available"  # Could implement actual count
+            }
+        else:
+            session_stats = {"session_manager": "not_initialized"}
+        
+        return {**rag_stats, **session_stats}
+        
+    except Exception as e:
+        logger.error(f"Error getting stats: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to get stats: {str(e)}")
+
+@app.post("/reindex")
+async def reindex():
+    """Reindex the vector database"""
+    if not rag_system:
+        raise HTTPException(status_code=503, detail="RAG system not initialized")
+    
+    try:
+        await rag_system.reindex()
+        return {"message": "Reindexing completed successfully"}
+    except Exception as e:
+        logger.error(f"Error in reindexing: {e}")
+        raise HTTPException(status_code=500, detail=f"Reindexing failed: {str(e)}")
+
+@app.delete("/sessions/{session_id}")
+async def delete_session(session_id: str):
+    """Delete a session and all its data"""
+    if not session_manager:
+        raise HTTPException(status_code=503, detail="Session manager not initialized")
+    
+    try:
+        session_manager.delete_session(session_id)
+        return {"message": f"Session {session_id} deleted successfully"}
+        
+    except Exception as e:
+        logger.error(f"Error deleting session: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to delete session: {str(e)}")
+
+if __name__ == "__main__":
+    uvicorn.run(
+        "app:app",
+        host=HOST,
+        port=PORT,
+        reload=True,
+        log_level="info"
+    )
+
+
+
+
+
+
+

chat_sessions.db

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b5d3522a84d269cac0974a1b6dfb44c2a692d54d30cb525f492f409f5d357124
+size 516096

chroma_db/ba961ef0-bc79-4ac2-97c0-6cb89b88a421/data_level0.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fdf80b989177c39e67b75605633a79a36c15f05a0759a7604aad9de8e9456ae9
+size 16760000

chroma_db/ba961ef0-bc79-4ac2-97c0-6cb89b88a421/header.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d3224fa57da8a778a9fd40be4bfce5cf573b3641f3ee57850ad29a1f05ce9a61
+size 100

chroma_db/ba961ef0-bc79-4ac2-97c0-6cb89b88a421/index_metadata.pickle

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b5bbfd4dec3468174919140b7ce1c5ddea2dd93f5f1b37828e0c85572c87e403
+size 287384

chroma_db/ba961ef0-bc79-4ac2-97c0-6cb89b88a421/length.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:05281421a401d4dcb852084dcc03c528cd38abae62b80d715d78f8891643674a
+size 40000

chroma_db/ba961ef0-bc79-4ac2-97c0-6cb89b88a421/link_lists.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f136f8d41ef27e5e51ab3bd71d5a9d56676c691236e1dfdd612b90837ae20832
+size 64104

chroma_db/chroma.sqlite3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:127fdf8c5fc37542506a3523d855c71e628158fe51792a8d170542a9ab4cae4f
+size 47648768

requirements.txt

@@ -0,0 +1,18 @@
+fastapi>=0.104.0
+uvicorn>=0.24.0
+langchain>=0.1.0
+langchain-groq>=0.0.1
+langchain-community>=0.0.10
+langchain-core>=0.1.0
+groq>=0.4.0
+sentence-transformers>=2.2.0
+chromadb>=0.4.0
+datasets>=2.14.0
+huggingface-hub>=0.16.0
+pydantic>=2.0.0
+python-multipart>=0.0.6
+python-dotenv>=1.0.0
+numpy>=1.24.0
+pandas>=2.0.0
+requests>=2.31.0
+tiktoken>=0.5.0