Add file upload for RAG: PDF, PPTX, TXT, ZIP support with drag & drop

- Upload zone on setup screen with drag & drop and multi-file select
- ZIP extraction: auto-extracts supported files from nested folders
- Dynamic RAG indexing without server restart
- Document list with delete capability
- PPTX support via python-pptx
- Doc count badge in chat header

https://claude.ai/code/session_015z3yZxNNfXF63JuQDuPbEG

app/main.py

@@ -3,13 +3,14 @@
 import re
 from contextlib import asynccontextmanager
 from pathlib import Path
+from typing import List
 
-from fastapi import FastAPI
+from fastapi import FastAPI, UploadFile, File
 from fastapi.responses import FileResponse
 from fastapi.staticfiles import StaticFiles
 from pydantic import BaseModel
 
-from app.rag import load_corpus, retrieve
+from app.rag import load_corpus, retrieve, add_documents, list_documents, delete_document
 from app.llm import build_system_prompt, chat, analyze_session
 
 
@@ -25,6 +26,8 @@ app = FastAPI(title="AIM Learning Companion", lifespan=lifespan)
 STATIC_DIR = Path(__file__).parent.parent / "static"
 app.mount("/static", StaticFiles(directory=str(STATIC_DIR)), name="static")
 
+ALLOWED_EXTENSIONS = {".txt", ".pdf", ".pptx", ".ppt", ".zip"}
+
 
 class ChatRequest(BaseModel):
     message: str
@@ -84,6 +87,39 @@ async def api_chat(req: ChatRequest):
     return ChatResponse(reply=reply, phase=detected_phase)
 
 
+@app.post("/api/upload")
+async def api_upload(files: List[UploadFile] = File(...)):
+    """Upload one or more files (PDF, PPTX, TXT, ZIP) to the RAG corpus."""
+    file_data = []
+    skipped = []
+
+    for f in files:
+        ext = Path(f.filename).suffix.lower() if f.filename else ""
+        if ext not in ALLOWED_EXTENSIONS:
+            skipped.append({"filename": f.filename, "reason": f"Type non supporté: {ext}"})
+            continue
+        content = await f.read()
+        file_data.append((f.filename, content))
+
+    results = add_documents(file_data) if file_data else []
+    return {"results": results, "skipped": skipped}
+
+
+@app.get("/api/documents")
+async def api_documents():
+    """List all documents in the corpus."""
+    return {"documents": list_documents()}
+
+
+@app.delete("/api/documents/{filename}")
+async def api_delete_document(filename: str):
+    """Delete a document from the corpus."""
+    ok = delete_document(filename)
+    if ok:
+        return {"status": "ok"}
+    return {"status": "error", "message": "Fichier non trouvé"}
+
+
 @app.post("/api/analyze", response_model=AnalysisResponse)
 async def api_analyze(req: AnalysisRequest):
     analysis = await analyze_session(req.history)

app/rag.py

@@ -1,6 +1,9 @@
 """RAG layer: load corpus, chunk, embed, and retrieve."""
 
 import os
+import shutil
+import tempfile
+import zipfile
 
 import chromadb
 from sentence_transformers import SentenceTransformer
@@ -13,6 +16,9 @@ TOP_K = 3
 
 _model: SentenceTransformer | None = None
 _collection: chromadb.Collection | None = None
+_client: chromadb.ClientAPI | None = None
+
+SUPPORTED_EXTENSIONS = {".txt", ".pdf", ".pptx", ".ppt"}
 
 
 def _get_model() -> SentenceTransformer:
@@ -22,6 +28,17 @@ def _get_model() -> SentenceTransformer:
     return _model
 
 
+def _get_client() -> chromadb.ClientAPI:
+    global _client
+    if _client is None:
+        _client = chromadb.Client(chromadb.config.Settings(
+            persist_directory=CHROMA_DIR,
+            anonymized_telemetry=False,
+            is_persistent=True,
+        ))
+    return _client
+
+
 def _approximate_token_split(text: str, size: int, overlap: int) -> list[str]:
     """Split text into chunks of approximately `size` words with `overlap`."""
     words = text.split()
@@ -36,7 +53,7 @@ def _approximate_token_split(text: str, size: int, overlap: int) -> list[str]:
 
 
 def _read_txt(path: str) -> str:
-    with open(path, "r", encoding="utf-8") as f:
+    with open(path, "r", encoding="utf-8", errors="ignore") as f:
         return f.read()
 
 
@@ -50,15 +67,65 @@ def _read_pdf(path: str) -> str:
         return ""
 
 
+def _read_pptx(path: str) -> str:
+    try:
+        from pptx import Presentation
+        prs = Presentation(path)
+        texts = []
+        for slide in prs.slides:
+            for shape in slide.shapes:
+                if shape.has_text_frame:
+                    for para in shape.text_frame.paragraphs:
+                        text = para.text.strip()
+                        if text:
+                            texts.append(text)
+        return "\n".join(texts)
+    except Exception:
+        return ""
+
+
+def _read_file(path: str) -> str:
+    """Read a file based on its extension."""
+    lower = path.lower()
+    if lower.endswith(".txt"):
+        return _read_txt(path)
+    elif lower.endswith(".pdf"):
+        return _read_pdf(path)
+    elif lower.endswith((".pptx", ".ppt")):
+        return _read_pptx(path)
+    return ""
+
+
+def _extract_zip(zip_bytes: bytes) -> list[tuple[str, bytes]]:
+    """Extract supported files from a ZIP archive. Returns list of (filename, content)."""
+    results = []
+    with tempfile.TemporaryDirectory() as tmpdir:
+        zip_path = os.path.join(tmpdir, "archive.zip")
+        with open(zip_path, "wb") as f:
+            f.write(zip_bytes)
+
+        with zipfile.ZipFile(zip_path, "r") as zf:
+            zf.extractall(tmpdir)
+
+        for root, dirs, files in os.walk(tmpdir):
+            # Skip __MACOSX and hidden directories
+            dirs[:] = [d for d in dirs if not d.startswith((".", "__"))]
+            for fname in files:
+                if fname.startswith("."):
+                    continue
+                ext = os.path.splitext(fname)[1].lower()
+                if ext in SUPPORTED_EXTENSIONS:
+                    fpath = os.path.join(root, fname)
+                    with open(fpath, "rb") as f:
+                        results.append((fname, f.read()))
+    return results
+
+
 def load_corpus() -> None:
-    """Load all .pdf and .txt files from corpus, chunk, embed, store in ChromaDB."""
+    """Load all supported files from corpus, chunk, embed, store in ChromaDB."""
     global _collection
 
-    client = chromadb.Client(chromadb.config.Settings(
-        persist_directory=CHROMA_DIR,
-        anonymized_telemetry=False,
-        is_persistent=True,
-    ))
+    client = _get_client()
 
     try:
         client.delete_collection("corpus")
@@ -76,17 +143,16 @@ def load_corpus() -> None:
     all_meta: list[dict] = []
 
     if not os.path.isdir(CORPUS_DIR):
+        os.makedirs(CORPUS_DIR, exist_ok=True)
         return
 
     for filename in sorted(os.listdir(CORPUS_DIR)):
         filepath = os.path.join(CORPUS_DIR, filename)
-        if filename.lower().endswith(".txt"):
-            text = _read_txt(filepath)
-        elif filename.lower().endswith(".pdf"):
-            text = _read_pdf(filepath)
-        else:
+        ext = os.path.splitext(filename)[1].lower()
+        if ext not in SUPPORTED_EXTENSIONS:
             continue
 
+        text = _read_file(filepath)
         if not text.strip():
             continue
 
@@ -107,6 +173,101 @@ def load_corpus() -> None:
         )
 
 
+def _add_single_file(filename: str, file_bytes: bytes) -> dict:
+    """Process a single file: save to corpus and embed."""
+    global _collection
+
+    os.makedirs(CORPUS_DIR, exist_ok=True)
+    filepath = os.path.join(CORPUS_DIR, filename)
+
+    with open(filepath, "wb") as f:
+        f.write(file_bytes)
+
+    text = _read_file(filepath)
+    if not text.strip():
+        os.remove(filepath)
+        return {"filename": filename, "status": "error", "message": "Texte non extractible"}
+
+    chunks = _approximate_token_split(text, CHUNK_SIZE, CHUNK_OVERLAP)
+    model = _get_model()
+
+    if _collection is None:
+        load_corpus()
+        return {"filename": filename, "status": "ok", "chunks": len(chunks)}
+
+    # Remove old chunks from same file if re-uploading
+    try:
+        existing = _collection.get(where={"source": filename})
+        if existing["ids"]:
+            _collection.delete(ids=existing["ids"])
+    except Exception:
+        pass
+
+    chunk_ids = [f"{filename}_{i}" for i in range(len(chunks))]
+    metas = [{"source": filename, "chunk_index": i} for i in range(len(chunks))]
+    embeddings = model.encode(chunks).tolist()
+
+    _collection.add(
+        ids=chunk_ids,
+        embeddings=embeddings,
+        documents=chunks,
+        metadatas=metas,
+    )
+
+    return {"filename": filename, "status": "ok", "chunks": len(chunks)}
+
+
+def add_documents(files: list[tuple[str, bytes]]) -> list[dict]:
+    """Add one or more uploaded files. Handles ZIP extraction automatically."""
+    results = []
+    for filename, file_bytes in files:
+        if filename.lower().endswith(".zip"):
+            extracted = _extract_zip(file_bytes)
+            if not extracted:
+                results.append({"filename": filename, "status": "error",
+                                "message": "Aucun fichier supporté trouvé dans le ZIP"})
+                continue
+            for inner_name, inner_bytes in extracted:
+                results.append(_add_single_file(inner_name, inner_bytes))
+        else:
+            results.append(_add_single_file(filename, file_bytes))
+    return results
+
+
+def list_documents() -> list[dict]:
+    """List all documents in the corpus directory."""
+    docs = []
+    if not os.path.isdir(CORPUS_DIR):
+        return docs
+    for filename in sorted(os.listdir(CORPUS_DIR)):
+        ext = os.path.splitext(filename)[1].lower()
+        if ext in SUPPORTED_EXTENSIONS:
+            filepath = os.path.join(CORPUS_DIR, filename)
+            size = os.path.getsize(filepath)
+            docs.append({"filename": filename, "size": size})
+    return docs
+
+
+def delete_document(filename: str) -> bool:
+    """Delete a document from corpus and its embeddings."""
+    global _collection
+    filepath = os.path.join(CORPUS_DIR, filename)
+    if not os.path.isfile(filepath):
+        return False
+
+    os.remove(filepath)
+
+    if _collection is not None:
+        try:
+            existing = _collection.get(where={"source": filename})
+            if existing["ids"]:
+                _collection.delete(ids=existing["ids"])
+        except Exception:
+            pass
+
+    return True
+
+
 def retrieve(query: str, top_k: int = TOP_K) -> list[str]:
     """Retrieve the top_k most relevant chunks for a query."""
     if _collection is None or _collection.count() == 0:

requirements.txt

@@ -6,4 +6,5 @@ sentence-transformers==3.3.1
 pydantic==2.10.4
 python-multipart==0.0.20
 pypdf2==3.0.1
+python-pptx==1.0.2
 python-dotenv==1.0.1

static/app.js

@@ -13,7 +13,8 @@
         phase: 0,
         history: [],      // {role, content}
         timestamps: [],   // epoch ms for every message (user & assistant alternating)
-        analysisResult: null
+        analysisResult: null,
+        uploadedDocs: []  // filenames uploaded this session
     };
 
     var PHASE_NAMES = [
@@ -35,6 +36,7 @@
 
     var modeBadge   = document.getElementById("mode-badge");
     var topicBadge  = document.getElementById("topic-badge");
+    var docsBadge   = document.getElementById("docs-badge");
     var phaseDots   = document.getElementById("phase-dots");
     var phaseLabels = document.getElementById("phase-labels");
     var messagesEl  = document.getElementById("messages");
@@ -52,6 +54,12 @@
     var btnExport   = document.getElementById("btn-export");
     var btnNewSession = document.getElementById("btn-new-session");
 
+    // Upload refs
+    var uploadZone  = document.getElementById("upload-zone");
+    var fileInput   = document.getElementById("file-input");
+    var uploadList  = document.getElementById("upload-list");
+    var uploadStatus = document.getElementById("upload-status");
+
     /* ===== Screen navigation ===== */
     function showScreen(screen) {
         setupScreen.classList.remove("active");
@@ -99,6 +107,133 @@
         if (on) messagesEl.scrollTop = messagesEl.scrollHeight;
     }
 
+    /* ===== File Upload ===== */
+
+    function formatFileSize(bytes) {
+        if (bytes < 1024) return bytes + " o";
+        if (bytes < 1024 * 1024) return (bytes / 1024).toFixed(1) + " Ko";
+        return (bytes / (1024 * 1024)).toFixed(1) + " Mo";
+    }
+
+    function renderUploadList() {
+        uploadList.innerHTML = "";
+        state.uploadedDocs.forEach(function (doc) {
+            var item = document.createElement("div");
+            item.className = "upload-item";
+
+            var icon = doc.filename.toLowerCase().endsWith(".pdf") ? "PDF" :
+                       doc.filename.toLowerCase().endsWith(".pptx") ? "PPT" :
+                       doc.filename.toLowerCase().endsWith(".ppt") ? "PPT" : "TXT";
+
+            item.innerHTML =
+                '<span class="upload-item-icon">' + icon + '</span>' +
+                '<span class="upload-item-name">' + doc.filename + '</span>' +
+                '<span class="upload-item-chunks">' + doc.chunks + ' chunks</span>' +
+                '<button class="upload-item-delete" data-filename="' + doc.filename + '">X</button>';
+            uploadList.appendChild(item);
+        });
+
+        // Bind delete buttons
+        uploadList.querySelectorAll(".upload-item-delete").forEach(function (btn) {
+            btn.addEventListener("click", function () {
+                deleteDoc(btn.dataset.filename);
+            });
+        });
+    }
+
+    function uploadFiles(fileList) {
+        if (!fileList || fileList.length === 0) return;
+
+        var formData = new FormData();
+        for (var i = 0; i < fileList.length; i++) {
+            formData.append("files", fileList[i]);
+        }
+
+        uploadStatus.textContent = "Upload en cours...";
+        uploadStatus.className = "upload-status uploading";
+        uploadZone.classList.add("uploading");
+
+        fetch("/api/upload", {
+            method: "POST",
+            body: formData
+        })
+        .then(function (res) { return res.json(); })
+        .then(function (data) {
+            uploadZone.classList.remove("uploading");
+            var ok = 0;
+            var errors = [];
+
+            (data.results || []).forEach(function (r) {
+                if (r.status === "ok") {
+                    ok++;
+                    state.uploadedDocs.push({ filename: r.filename, chunks: r.chunks });
+                } else {
+                    errors.push(r.filename + ": " + (r.message || "erreur"));
+                }
+            });
+
+            (data.skipped || []).forEach(function (s) {
+                errors.push(s.filename + ": " + s.reason);
+            });
+
+            if (ok > 0 && errors.length === 0) {
+                uploadStatus.textContent = ok + " fichier(s) ajoute(s) au corpus";
+                uploadStatus.className = "upload-status success";
+            } else if (ok > 0 && errors.length > 0) {
+                uploadStatus.textContent = ok + " OK, " + errors.length + " erreur(s): " + errors.join("; ");
+                uploadStatus.className = "upload-status warning";
+            } else {
+                uploadStatus.textContent = "Erreur: " + errors.join("; ");
+                uploadStatus.className = "upload-status error";
+            }
+
+            renderUploadList();
+        })
+        .catch(function () {
+            uploadZone.classList.remove("uploading");
+            uploadStatus.textContent = "Erreur de connexion. Reessaye.";
+            uploadStatus.className = "upload-status error";
+        });
+    }
+
+    function deleteDoc(filename) {
+        fetch("/api/documents/" + encodeURIComponent(filename), { method: "DELETE" })
+        .then(function (res) { return res.json(); })
+        .then(function () {
+            state.uploadedDocs = state.uploadedDocs.filter(function (d) {
+                return d.filename !== filename;
+            });
+            renderUploadList();
+            uploadStatus.textContent = filename + " supprime";
+            uploadStatus.className = "upload-status success";
+        });
+    }
+
+    // Upload zone events
+    uploadZone.addEventListener("click", function () {
+        fileInput.click();
+    });
+
+    fileInput.addEventListener("change", function () {
+        uploadFiles(fileInput.files);
+        fileInput.value = "";
+    });
+
+    uploadZone.addEventListener("dragover", function (e) {
+        e.preventDefault();
+        uploadZone.classList.add("dragover");
+    });
+
+    uploadZone.addEventListener("dragleave", function () {
+        uploadZone.classList.remove("dragover");
+    });
+
+    uploadZone.addEventListener("drop", function (e) {
+        e.preventDefault();
+        uploadZone.classList.remove("dragover");
+        uploadFiles(e.dataTransfer.files);
+    });
+
     /* ===== API calls ===== */
     function sendMessage(text) {
         state.history.push({ role: "user", content: text });
@@ -232,10 +367,13 @@
         state.history = [];
         state.timestamps = [];
         state.analysisResult = null;
+        state.uploadedDocs = [];
 
         topicInput.value = "";
         chatInput.value = "";
         messagesEl.querySelectorAll(".message").forEach(function (el) { el.remove(); });
+        uploadList.innerHTML = "";
+        uploadStatus.textContent = "";
 
         modeBtns.forEach(function (btn) {
             btn.classList.toggle("selected", btn.dataset.mode === "TUTOR");
@@ -245,9 +383,25 @@
         btnEnd.disabled = false;
         btnSend.disabled = false;
 
+        // Load existing documents
+        loadDocumentList();
+
         showScreen(setupScreen);
     }
 
+    /* ===== Load existing documents on page load ===== */
+    function loadDocumentList() {
+        fetch("/api/documents")
+        .then(function (res) { return res.json(); })
+        .then(function (data) {
+            state.uploadedDocs = (data.documents || []).map(function (d) {
+                return { filename: d.filename, chunks: "?" };
+            });
+            renderUploadList();
+        })
+        .catch(function () {});
+    }
+
     /* ===== Event listeners ===== */
 
     // Mode selection
@@ -273,6 +427,14 @@
         modeBadge.textContent = state.mode === "TUTOR" ? "Tuteur" : "Critique";
         topicBadge.textContent = topic;
 
+        // Show doc count badge
+        if (state.uploadedDocs.length > 0) {
+            docsBadge.textContent = state.uploadedDocs.length + " doc(s)";
+            docsBadge.style.display = "inline-block";
+        } else {
+            docsBadge.style.display = "none";
+        }
+
         renderPhaseIndicator();
         showScreen(chatScreen);
         chatInput.focus();
@@ -309,4 +471,7 @@
     // New session from analysis screen
     btnNewSession.addEventListener("click", resetSession);
 
+    // Load existing docs on startup
+    loadDocumentList();
+
 })();

static/index.html

@@ -18,6 +18,18 @@
             <input type="text" id="topic-input" placeholder="Ex : L'intelligence artificielle en formation professionnelle">
         </div>
 
+        <div class="form-group">
+            <label>Documents de reference (optionnel)</label>
+            <div class="upload-zone" id="upload-zone">
+                <div class="upload-icon">+</div>
+                <div class="upload-text">Glisse tes fichiers ici ou clique pour selectionner</div>
+                <div class="upload-hint">PDF, PPTX, TXT ou ZIP — plusieurs fichiers possibles</div>
+                <input type="file" id="file-input" multiple accept=".pdf,.pptx,.ppt,.txt,.zip" hidden>
+            </div>
+            <div class="upload-list" id="upload-list"></div>
+            <div class="upload-status" id="upload-status"></div>
+        </div>
+
         <div class="form-group">
             <label>Mode</label>
             <div class="mode-selector">
@@ -41,6 +53,7 @@
             <div class="chat-header-left">
                 <span id="mode-badge" class="badge badge-mode"></span>
                 <span id="topic-badge" class="badge badge-topic"></span>
+                <span id="docs-badge" class="badge badge-docs" style="display:none"></span>
             </div>
             <div class="chat-header-right">
                 <button id="btn-end-session" class="btn-end">Terminer la session</button>

static/style.css

@@ -127,6 +127,118 @@ body {
 .btn-primary:hover { opacity: 0.9; }
 .btn-primary:disabled { opacity: 0.5; cursor: not-allowed; }
 
+/* ===== Upload Zone ===== */
+.upload-zone {
+    width: 100%;
+    border: 2px dashed var(--border);
+    border-radius: var(--radius);
+    padding: 28px 20px;
+    text-align: center;
+    cursor: pointer;
+    transition: all 0.2s;
+    background: var(--bg-secondary);
+}
+
+.upload-zone:hover, .upload-zone.dragover {
+    border-color: var(--accent);
+    background: var(--bg-tertiary);
+}
+
+.upload-zone.uploading {
+    opacity: 0.6;
+    pointer-events: none;
+}
+
+.upload-icon {
+    font-size: 2rem;
+    color: var(--accent);
+    margin-bottom: 8px;
+    font-weight: 300;
+}
+
+.upload-text {
+    font-size: 0.92rem;
+    color: var(--text-primary);
+    margin-bottom: 4px;
+}
+
+.upload-hint {
+    font-size: 0.78rem;
+    color: var(--text-secondary);
+}
+
+.upload-list {
+    width: 100%;
+    display: flex;
+    flex-direction: column;
+    gap: 6px;
+}
+
+.upload-item {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    padding: 10px 14px;
+    background: var(--bg-secondary);
+    border: 1px solid var(--border);
+    border-radius: var(--radius-sm);
+    font-size: 0.85rem;
+}
+
+.upload-item-icon {
+    background: var(--accent);
+    color: #fff;
+    padding: 2px 8px;
+    border-radius: 4px;
+    font-size: 0.7rem;
+    font-weight: 700;
+    flex-shrink: 0;
+}
+
+.upload-item-name {
+    flex: 1;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+
+.upload-item-chunks {
+    color: var(--text-secondary);
+    font-size: 0.78rem;
+    flex-shrink: 0;
+}
+
+.upload-item-delete {
+    background: transparent;
+    border: 1px solid var(--border);
+    color: var(--text-secondary);
+    border-radius: 4px;
+    cursor: pointer;
+    padding: 2px 8px;
+    font-size: 0.75rem;
+    transition: all 0.2s;
+}
+
+.upload-item-delete:hover {
+    border-color: var(--danger);
+    color: var(--danger);
+}
+
+.upload-status {
+    font-size: 0.82rem;
+    min-height: 1.2em;
+}
+
+.upload-status.success { color: var(--success); }
+.upload-status.warning { color: var(--warning); }
+.upload-status.error { color: var(--danger); }
+.upload-status.uploading { color: var(--accent-light); }
+
+.badge-docs {
+    background: var(--success);
+    color: #fff;
+}
+
 /* ===== Chat Screen ===== */
 #chat-screen {
     height: 100vh;