initial deploy

.gitignore

@@ -0,0 +1,6 @@
+__pycache__/
+*.py[cod]
+.env
+temp_* 
+*.txt
+*.pdf

Dockerfile

@@ -0,0 +1,15 @@
+FROM python:3.9-slim
+
+WORKDIR /app
+
+# Copy requirements from root directory
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy backend files  
+COPY backend/ .
+
+# Copy frontend files
+COPY frontend/dist/ ./static/
+
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,8 @@
+---
+title: FastAPI RAG Application
+emoji: 📚
+colorFrom: blue
+colorTo: green
+sdk: docker
+app_port: 7860
+---

backend/main.py

@@ -0,0 +1,128 @@
+from fastapi import FastAPI, UploadFile, File, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import FileResponse
+from pydantic import BaseModel
+from typing import List
+import os
+from dotenv import load_dotenv
+
+# Import our local utilities instead of aimakerspace
+from text_utils import CharacterTextSplitter, TextFileLoader, PDFLoader
+from openai_utils import SystemRolePrompt, UserRolePrompt, ChatOpenAI
+from vector_store import VectorDatabase
+
+load_dotenv()
+
+app = FastAPI()
+
+# Configure CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Prompt templates
+system_template = """\
+Use the following context to answer a users question. If you cannot find the answer in the context, say you don't know the answer."""
+system_role_prompt = SystemRolePrompt(system_template)
+
+user_prompt_template = """\
+Context:
+{context}
+
+Question:
+{question}
+"""
+user_role_prompt = UserRolePrompt(user_prompt_template)
+
+# Initialize components
+text_splitter = CharacterTextSplitter()
+chat_openai = ChatOpenAI()
+
+# Store vector databases for each session
+vector_dbs = {}
+
+class QueryRequest(BaseModel):
+    session_id: str
+    query: str
+
+@app.post("/upload")
+async def upload_file(file: UploadFile = File(...)):
+    try:
+        # Save file temporarily
+        file_path = f"temp_{file.filename}"
+        with open(file_path, "wb") as f:
+            content = await file.read()
+            f.write(content)
+
+        # Process file
+        loader = PDFLoader(file_path) if file.filename.lower().endswith('.pdf') else TextFileLoader(file_path)
+        documents = loader.load_documents()
+        texts = text_splitter.split_texts(documents)
+
+        # Create vector database
+        vector_db = VectorDatabase()
+        vector_db = await vector_db.abuild_from_list(texts)
+
+        # Generate session ID and store vector_db
+        import uuid
+        session_id = str(uuid.uuid4())
+        vector_dbs[session_id] = vector_db
+
+        # Cleanup
+        os.remove(file_path)
+
+        return {"session_id": session_id, "message": "File processed successfully"}
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/query")
+async def query(request: QueryRequest):
+    try:
+        vector_db = vector_dbs.get(request.session_id)
+        if not vector_db:
+            raise HTTPException(status_code=404, detail="Session not found")
+
+        # Retrieve context
+        context_list = await vector_db.search_by_text(request.query, k=4)
+        context_prompt = "\n".join([str(context[0]) for context in context_list])
+
+        # Generate prompts
+        formatted_system_prompt = system_role_prompt.create_message()
+        formatted_user_prompt = user_role_prompt.create_message(
+            question=request.query, 
+            context=context_prompt
+        )
+
+        # Get response
+        response = await chat_openai.acomplete(
+            [formatted_system_prompt, formatted_user_prompt]
+        )
+
+        return {
+            "answer": str(response),
+            "context": [str(context[0]) for context in context_list]
+        }
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+# Optional: Cleanup endpoint
+@app.delete("/session/{session_id}")
+async def cleanup_session(session_id: str):
+    if session_id in vector_dbs:
+        del vector_dbs[session_id]
+        return {"message": "Session cleaned up successfully"}
+    raise HTTPException(status_code=404, detail="Session not found")
+
+# Serve static files from static directory
+app.mount("/static", StaticFiles(directory="static"), name="static")
+
+@app.get("/")
+async def read_root():
+    return FileResponse('static/index.html') 

backend/openai_utils.py

@@ -0,0 +1,34 @@
+from typing import List, Dict
+from openai import AsyncOpenAI
+import os
+
+class SystemRolePrompt:
+    def __init__(self, template: str):
+        self.template = template
+
+    def create_message(self) -> Dict[str, str]:
+        return {
+            "role": "system",
+            "content": self.template
+        }
+
+class UserRolePrompt:
+    def __init__(self, template: str):
+        self.template = template
+
+    def create_message(self, **kwargs) -> Dict[str, str]:
+        return {
+            "role": "user",
+            "content": self.template.format(**kwargs)
+        }
+
+class ChatOpenAI:
+    def __init__(self):
+        self.client = AsyncOpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+
+    async def acomplete(self, messages: List[Dict[str, str]]) -> str:
+        response = await self.client.chat.completions.create(
+            model="gpt-3.5-turbo",
+            messages=messages
+        )
+        return response.choices[0].message.content 

backend/static/index.html

@@ -0,0 +1,274 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>RAG Application</title>
+    <style>
+        body {
+            font-family: Arial, sans-serif;
+            max-width: 800px;
+            margin: 0 auto;
+            padding: 20px;
+        }
+        .container {
+            display: flex;
+            flex-direction: column;
+            gap: 20px;
+        }
+        .query-section {
+            display: none;
+        }
+        .response-section {
+            margin-top: 20px;
+            border-top: 1px solid #ccc;
+            padding-top: 20px;
+        }
+        textarea {
+            width: 100%;
+            height: 100px;
+        }
+        button {
+            padding: 10px 20px;
+            background-color: #007bff;
+            color: white;
+            border: none;
+            border-radius: 4px;
+            cursor: pointer;
+        }
+        button:disabled {
+            background-color: #ccc;
+        }
+        .context {
+            background-color: #f8f9fa;
+            padding: 10px;
+            margin-top: 10px;
+            border-radius: 4px;
+        }
+        .loading {
+            opacity: 0.5;
+            pointer-events: none;
+        }
+        
+        .spinner {
+            display: none;
+            margin-left: 10px;
+            color: #007bff;
+        }
+        
+        .loading .spinner {
+            display: inline;
+        }
+
+        /* Radio toggle styles */
+        .toggle-radio {
+            display: none;  /* Initially hidden */
+            align-items: center;
+            gap: 10px;
+            margin: 10px 0;
+        }
+
+        .toggle-radio input[type="radio"] {
+            margin-right: 5px;
+        }
+
+        .toggle-radio label {
+            display: flex;
+            align-items: center;
+            margin-right: 15px;
+            color: #666;
+            cursor: pointer;
+        }
+
+        #contextSection {
+            display: none;  /* Initially hidden */
+        }
+
+        /* Initially hide these sections */
+        .query-section,
+        .response-section,
+        .toggle-radio,
+        #contextSection {
+            display: none;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>RAG Application</h1>
+        
+        <div class="upload-section">
+            <h2>Upload Document</h2>
+            <input type="file" id="fileInput" accept=".txt,.pdf">
+            <button id="uploadButton" onclick="uploadFile()">Upload</button>
+            <span id="uploadSpinner" class="spinner">Processing...</span>
+        </div>
+
+        <div id="querySection" class="query-section">
+            <h2>Ask a Question</h2>
+            <textarea id="queryInput" placeholder="Enter your question here..."></textarea>
+            <button id="queryButton" onclick="submitQuery()">Submit Query</button>
+            <span id="querySpinner" class="spinner">Processing...</span>
+        </div>
+
+        <div id="responseSection" class="response-section">
+            <h2>Response</h2>
+            <div id="answer"></div>
+            
+            <!-- Add radio toggle -->
+            <div class="toggle-radio">
+                <span>Context: </span>
+                <label>
+                    <input type="radio" name="contextToggle" value="show" onchange="toggleContext(this)"> Show
+                </label>
+                <label>
+                    <input type="radio" name="contextToggle" value="hide" onchange="toggleContext(this)" checked> Hide
+                </label>
+            </div>
+            
+            <div id="contextSection">
+                <h3>Context</h3>
+                <div id="context"></div>
+            </div>
+        </div>
+    </div>
+
+    <script>
+        let currentSessionId = null;
+
+        function setLoading(isLoading, action) {
+            const button = document.getElementById(action === 'upload' ? 'uploadButton' : 'queryButton');
+            const spinner = document.getElementById(action === 'upload' ? 'uploadSpinner' : 'querySpinner');
+            
+            if (isLoading) {
+                button.classList.add('loading');
+                spinner.style.display = 'inline';
+                button.disabled = true;
+            } else {
+                button.classList.remove('loading');
+                spinner.style.display = 'none';
+                button.disabled = false;
+            }
+        }
+
+        async function uploadFile() {
+            const fileInput = document.getElementById('fileInput');
+            const file = fileInput.files[0];
+            if (!file) {
+                alert('Please select a file first');
+                return;
+            }
+
+            setLoading(true, 'upload');
+
+            // Hide all sections during upload and processing
+            document.getElementById('querySection').style.display = 'none';
+            document.getElementById('responseSection').style.display = 'none';
+            document.getElementById('contextSection').style.display = 'none';
+            document.querySelector('.toggle-radio').style.display = 'none';
+
+            // Clear any previous content
+            document.getElementById('answer').innerHTML = '';
+            document.getElementById('context').innerHTML = '';
+            document.getElementById('queryInput').value = '';
+
+            const formData = new FormData();
+            formData.append('file', file);
+
+            try {
+                const response = await fetch('/upload', {
+                    method: 'POST',
+                    body: formData
+                });
+                
+                if (!response.ok) {
+                    throw new Error(`HTTP error! status: ${response.status}`);
+                }
+                
+                const data = await response.json();
+                currentSessionId = data.session_id;
+                
+                // Only show query section after successful upload
+                document.getElementById('querySection').style.display = 'block';
+                
+                alert('File uploaded successfully! You can now ask questions.');
+            } catch (error) {
+                console.error('Error:', error);
+                alert('Error uploading file: ' + error.message);
+            } finally {
+                setLoading(false, 'upload');
+            }
+        }
+
+        function toggleContext(radio) {
+            const contextSection = document.getElementById('contextSection');
+            contextSection.style.display = radio.value === 'show' ? 'block' : 'none';
+        }
+
+        async function submitQuery() {
+            if (!currentSessionId) {
+                alert('Please upload a document first');
+                return;
+            }
+
+            const queryInput = document.getElementById('queryInput');
+            const query = queryInput.value.trim();
+            
+            if (!query) {
+                alert('Please enter a query');
+                return;
+            }
+
+            setLoading(true, 'query');
+
+            // Show response section but hide context initially
+            document.getElementById('responseSection').style.display = 'block';
+            document.getElementById('contextSection').style.display = 'none';
+            document.querySelector('.toggle-radio').style.display = 'none';
+            // Reset radio to "Hide"
+            document.querySelector('input[value="hide"]').checked = true;
+
+            try {
+                const response = await fetch('/query', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                    body: JSON.stringify({
+                        session_id: currentSessionId,
+                        query: query
+                    })
+                });
+                
+                if (!response.ok) {
+                    throw new Error(`HTTP error! status: ${response.status}`);
+                }
+                
+                const data = await response.json();
+                
+                // Display response
+                document.getElementById('answer').innerHTML = `<p><strong>Answer:</strong> ${data.answer}</p>`;
+                
+                // Handle context display with error checking
+                if (data.context && Array.isArray(data.context)) {
+                    const validContexts = data.context.filter(c => c != null && c !== '');
+                    const contextHtml = validContexts.length > 0 
+                        ? validContexts.join('<br><br>')
+                        : 'No context available';
+                    document.getElementById('context').innerHTML = `<div class="context">${contextHtml}</div>`;
+                    
+                    // Show the radio toggle only after we have a valid response with context
+                    document.querySelector('.toggle-radio').style.display = 'flex';
+                } else {
+                    document.getElementById('context').innerHTML = `<div class="context">No context available</div>`;
+                }
+            } catch (error) {
+                console.error('Error:', error);
+                alert('Error submitting query: ' + error.message);
+            } finally {
+                setLoading(false, 'query');
+            }
+        }
+    </script>
+</body>
+</html> 

backend/text_utils.py

@@ -0,0 +1,44 @@
+from typing import List
+import PyPDF2
+import io
+
+class CharacterTextSplitter:
+    def __init__(self, chunk_size=1000, chunk_overlap=200):
+        self.chunk_size = chunk_size
+        self.chunk_overlap = chunk_overlap
+
+    def split_texts(self, documents: List[str]) -> List[str]:
+        texts = []
+        for doc in documents:
+            if not doc.strip():
+                continue
+                
+            # Split the text into chunks
+            start = 0
+            while start < len(doc):
+                end = start + self.chunk_size
+                chunk = doc[start:end]
+                texts.append(chunk)
+                start = end - self.chunk_overlap
+                
+        return texts
+
+class TextFileLoader:
+    def __init__(self, file_path: str):
+        self.file_path = file_path
+
+    def load_documents(self) -> List[str]:
+        with open(self.file_path, 'r', encoding='utf-8') as file:
+            return [file.read()]
+
+class PDFLoader:
+    def __init__(self, file_path: str):
+        self.file_path = file_path
+
+    def load_documents(self) -> List[str]:
+        with open(self.file_path, 'rb') as file:
+            pdf_reader = PyPDF2.PdfReader(file)
+            text = ""
+            for page in pdf_reader.pages:
+                text += page.extract_text() + "\n"
+            return [text] 

backend/vector_store.py

@@ -0,0 +1,73 @@
+from typing import List, Tuple
+import numpy as np
+from openai import AsyncOpenAI
+import os
+
+def cosine_similarity(a, b):
+    """Calculate cosine similarity between two vectors."""
+    a = np.array(a)
+    b = np.array(b)
+    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))
+
+class VectorDatabase:
+    def __init__(self):
+        self.embeddings = []
+        self.texts = []
+        self.client = AsyncOpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+
+    async def abuild_from_list(self, texts):
+        self.texts = texts
+        self.embeddings = []  # Clear existing embeddings
+        
+        try:
+            for text in texts:
+                if not text.strip():  # Skip empty texts
+                    continue
+                    
+                response = await self.client.embeddings.create(
+                    model="text-embedding-ada-002",
+                    input=text.replace("\n", " ")  # Replace newlines with spaces
+                )
+                if response and response.data and len(response.data) > 0:
+                    self.embeddings.append(response.data[0].embedding)
+                else:
+                    print(f"Warning: No embedding generated for text: {text[:100]}...")
+            
+            return self
+        except Exception as e:
+            print(f"Error in abuild_from_list: {str(e)}")
+            raise e
+
+    async def search_by_text(self, query, k=4):
+        if not query.strip():
+            return []
+            
+        try:
+            # Get query embedding
+            response = await self.client.embeddings.create(
+                model="text-embedding-ada-002",
+                input=query.replace("\n", " ")  # Replace newlines with spaces
+            )
+            
+            if not response or not response.data or len(response.data) == 0:
+                print("Warning: No embedding generated for query")
+                return []
+                
+            query_embedding = response.data[0].embedding
+            
+            # Calculate similarities
+            similarities = []
+            for idx, embedding in enumerate(self.embeddings):
+                if embedding:  # Check if embedding exists
+                    similarity = cosine_similarity(query_embedding, embedding)
+                    similarities.append((self.texts[idx], similarity))
+            
+            # Sort by similarity
+            similarities.sort(key=lambda x: x[1], reverse=True)
+            
+            # Return top k results
+            return similarities[:k]
+            
+        except Exception as e:
+            print(f"Error in search_by_text: {str(e)}")
+            raise e 

frontend/dist/css/style.css

@@ -0,0 +1,120 @@
+body {
+    font-family: Arial, sans-serif;
+    max-width: 800px;
+    margin: 0 auto;
+    padding: 20px;
+}
+
+.container {
+    max-width: 800px;
+    margin: 0 auto;
+    padding: 20px;
+}
+
+.query-section {
+    display: none;
+}
+
+#responseSection {
+    display: none;
+    margin-top: 20px;
+    border-top: 1px solid #ccc;
+    padding-top: 20px;
+}
+
+textarea {
+    width: 100%;
+    height: 100px;
+}
+
+button {
+    padding: 10px 20px;
+    background-color: #007bff;
+    color: white;
+    border: none;
+    border-radius: 4px;
+    cursor: pointer;
+}
+
+button:disabled {
+    background-color: #ccc;
+}
+
+.context {
+    background-color: #f8f9fa;
+    padding: 10px;
+    margin-top: 10px;
+    border-radius: 4px;
+}
+
+.loading {
+    opacity: 0.5;
+    pointer-events: none;
+}
+
+.spinner {
+    display: none;
+}
+
+.loading .spinner {
+    display: inline;
+}
+
+/* Switch styles */
+.switch-container {
+    margin: 10px 0;
+}
+
+.switch {
+    position: relative;
+    display: inline-block;
+    width: 60px;
+    height: 34px;
+}
+
+.switch input {
+    opacity: 0;
+    width: 0;
+    height: 0;
+}
+
+.slider {
+    position: absolute;
+    cursor: pointer;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    background-color: #ccc;
+    transition: .4s;
+    border-radius: 34px;
+}
+
+.slider:before {
+    position: absolute;
+    content: "";
+    height: 26px;
+    width: 26px;
+    left: 4px;
+    bottom: 4px;
+    background-color: white;
+    transition: .4s;
+    border-radius: 50%;
+}
+
+input:checked + .slider {
+    background-color: #007bff;
+}
+
+input:checked + .slider:before {
+    transform: translateX(26px);
+}
+
+.switch-label {
+    font-size: 0.9em;
+    color: #666;
+}
+
+#contextSection {
+    display: none;
+} 

frontend/dist/index.html

@@ -0,0 +1,45 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>RAG Application</title>
+    <link rel="stylesheet" href="css/style.css">
+</head>
+<body>
+    <div class="container">
+        <h1>RAG Application</h1>
+        
+        <div class="upload-section">
+            <h2>Upload Document</h2>
+            <input type="file" id="fileInput" accept=".txt,.pdf">
+            <button id="uploadButton" onclick="uploadFile()">Upload</button>
+            <span id="uploadSpinner" class="spinner">Processing...</span>
+        </div>
+
+        <div id="querySection" class="query-section">
+            <h2>Ask a Question</h2>
+            <textarea id="queryInput" placeholder="Enter your question here..."></textarea>
+            <button id="queryButton" onclick="submitQuery()">Submit Query</button>
+            <span id="querySpinner" class="spinner">Processing...</span>
+        </div>
+
+        <div id="responseSection">
+            <h2>Response</h2>
+            <div id="answer"></div>
+            <div class="switch-container">
+                <label class="switch">
+                    <input type="checkbox" id="contextToggle" onchange="toggleContext()">
+                    <span class="slider"></span>
+                </label>
+                <span class="switch-label">Show Context</span>
+            </div>
+            <div id="contextSection">
+                <h3>Context</h3>
+                <div id="context"></div>
+            </div>
+        </div>
+    </div>
+    <script src="js/app.js"></script>
+</body>
+</html> 

frontend/dist/js/app.js

@@ -0,0 +1,90 @@
+let sessionId = null;
+
+function setLoading(isLoading, action) {
+    const button = document.getElementById(action === 'upload' ? 'uploadButton' : 'queryButton');
+    const spinner = document.getElementById(action === 'upload' ? 'uploadSpinner' : 'querySpinner');
+    
+    if (isLoading) {
+        button.classList.add('loading');
+        spinner.style.display = 'inline';
+        button.disabled = true;
+    } else {
+        button.classList.remove('loading');
+        spinner.style.display = 'none';
+        button.disabled = false;
+    }
+}
+
+async function uploadFile() {
+    const fileInput = document.getElementById('fileInput');
+    const uploadSpinner = document.getElementById('uploadSpinner');
+    
+    if (!fileInput.files.length) {
+        alert('Please select a file first');
+        return;
+    }
+
+    const file = fileInput.files[0];
+    const formData = new FormData();
+    formData.append('file', file);
+
+    uploadSpinner.style.display = 'inline';
+    
+    try {
+        const response = await fetch('/upload', {
+            method: 'POST',
+            body: formData
+        });
+        
+        const data = await response.json();
+        sessionId = data.session_id;
+        document.getElementById('querySection').style.display = 'block';
+        
+    } catch (error) {
+        alert('Error uploading file: ' + error);
+    } finally {
+        uploadSpinner.style.display = 'none';
+    }
+}
+
+async function submitQuery() {
+    if (!sessionId) {
+        alert('Please upload a document first');
+        return;
+    }
+
+    const queryInput = document.getElementById('queryInput');
+    const querySpinner = document.getElementById('querySpinner');
+    
+    querySpinner.style.display = 'inline';
+    
+    try {
+        const response = await fetch('/query', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                session_id: sessionId,
+                query: queryInput.value
+            })
+        });
+        
+        const data = await response.json();
+        document.getElementById('answer').textContent = data.answer;
+        document.getElementById('context').innerHTML = data.context.join('<br><br>');
+        
+    } catch (error) {
+        alert('Error submitting query: ' + error);
+    } finally {
+        querySpinner.style.display = 'none';
+    }
+}
+
+function toggleContext() {
+    const contextSection = document.getElementById('contextSection');
+    contextSection.style.display = document.getElementById('contextToggle').checked ? 'block' : 'none';
+}
+
+// Initially hide the query section
+document.getElementById('querySection').style.display = 'none'; 

frontend/package-lock.json

@@ -0,0 +1,6 @@
+{
+  "name": "frontend",
+  "lockfileVersion": 2,
+  "requires": true,
+  "packages": {}
+}