feat: Implement initial RAG chatbot core functionalities including PDF processing, vector store, and RAG pipeline.

.env.example

@@ -0,0 +1,22 @@
+# Model Configuration
+MODEL_NAME=THUDM/chatglm3-6b
+EMBEDDING_MODEL=sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2
+
+# Device Configuration (auto/cuda/cpu)
+DEVICE=auto
+
+# Text Processing
+CHUNK_SIZE=500
+CHUNK_OVERLAP=50
+
+# Retrieval Configuration
+TOP_K_RETRIEVAL=3
+
+# Generation Parameters
+MAX_LENGTH=2048
+TEMPERATURE=0.7
+TOP_P=0.9
+
+# Storage Paths
+UPLOAD_DIR=data/uploads
+VECTOR_DB_DIR=data/vector_db

.gitignore

@@ -0,0 +1,33 @@
+# Environment
+.env
+*.env
+.llm_env
+
+# Data & Uploads
+data/uploads/*
+data/vector_db/*
+!data/.gitkeep
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+venv/
+env/
+ENV/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# Models (jika download lokal)
+models/
+*.bin
+*.safetensors
+
+# Logs
+*.log

QUICKSTART.md

@@ -0,0 +1,98 @@
+# Quick Start Guide - RAG ChatBot
+
+Panduan cepat untuk menjalankan RAG ChatBot.
+
+## 📦 Instalasi Dependencies
+
+```bash
+# Install semua dependencies (membutuhkan waktu beberapa menit)
+pip install -r requirements.txt
+```
+
+**Catatan**: Dependencies cukup besar (~2-3GB), terutama PyTorch dan Transformers.
+
+## 🚀 Menjalankan Aplikasi
+
+```bash
+python app.py
+```
+
+Aplikasi akan:
+1. Load konfigurasi dari `.env`
+2. Inisialisasi vector database
+3. Launch Gradio interface di `http://localhost:7860`
+
+**Catatan**: Model GLM akan di-download otomatis saat pertama kali digunakan (ukuran ~13GB untuk ChatGLM3-6B).
+
+## 📚 Workflow Penggunaan
+
+### 1. Upload PDF
+- Buka tab "📤 Upload Dokumen"
+- Pilih file PDF
+- Klik "Process PDF"
+- Tunggu hingga selesai
+
+### 2. Chat
+- Buka tab "💬 Chat"
+- Ketik pertanyaan tentang dokumen
+- Model akan load otomatis (pertama kali akan lambat)
+- Sistem akan mencari konteks relevan dan menjawab
+
+### 3. Lihat Sumber
+- Source citations ditampilkan di bawah jawaban
+- Klik untuk melihat chunk yang digunakan
+
+## ⚙️ Konfigurasi
+
+Edit `.env` untuk mengubah settings:
+
+```bash
+# Jika tidak punya GPU
+DEVICE=cpu
+
+# Untuk mengurangi memory usage
+CHUNK_SIZE=300
+TOP_K_RETRIEVAL=2
+```
+
+## 🐛 Troubleshooting
+
+### Error: CUDA out of memory
+```bash
+# Gunakan CPU
+DEVICE=cpu
+```
+
+### Error: Model download terlalu lambat
+```bash
+# Set HuggingFace mirror (untuk Indonesia)
+export HF_ENDPOINT=https://hf-mirror.com
+```
+
+### PDF tidak ter-extract
+- Pastikan PDF berisi text (bukan scan)
+- Coba PDF lain untuk testing
+- Check logs untuk error detail
+
+## 📝 Testing
+
+Sebelum testing full app, verify imports dulu:
+
+```bash
+# Install pytest
+pip install pytest
+
+# Run basic tests
+pytest tests/test_pdf_processor.py -v
+```
+
+## 💡 Tips
+
+1. **First Run**: Model download membutuhkan waktu, bersabar
+2. **GPU Recommended**: CPU bisa digunakan tapi lebih lambat
+3. **PDF Quality**: Gunakan PDF dengan text yang jelas
+4. **Chunk Size**: Sesuaikan berdasarkan panjang dokumen
+
+## 📞 Need Help?
+
+Check README.md untuk dokumentasi lengkap atau buat issue di repository.

README.md

@@ -1,17 +1,244 @@
+# RAG ChatBot dengan GLM Model 🤖
+
+<div align="center">
+
+![License](https://img.shields.io/badge/license-MIT-blue.svg)
+![Python](https://img.shields.io/badge/python-3.8+-brightgreen.svg)
+![Gradio](https://img.shields.io/badge/gradio-5.42.0-orange.svg)
+
+**Chat dengan dokumen PDF Anda menggunakan AI dengan teknologi RAG (Retrieval-Augmented Generation)**
+
+[Demo](#demo) • [Fitur](#fitur) • [Instalasi](#instalasi) • [Penggunaan](#penggunaan) • [Arsitektur](#arsitektur)
+
+</div>
+
 ---
-title: LLM ChatBot Document
-emoji: 💬
-colorFrom: yellow
-colorTo: purple
-sdk: gradio
-sdk_version: 5.42.0
-app_file: app.py
-pinned: false
-hf_oauth: true
-hf_oauth_scopes:
-- inference-api
-license: mit
-short_description: Chat with your own document for practice
+
+## 📖 Deskripsi
+
+RAG ChatBot adalah aplikasi AI yang memungkinkan Anda untuk mengupload dokumen PDF dan melakukan tanya jawab interaktif tentang isi dokumen tersebut. Sistem menggunakan:
+
+- **ChatGLM3-6B**: Model bahasa generatif untuk menghasilkan jawaban
+- **RAG (Retrieval-Augmented Generation)**: Teknik untuk mencari informasi relevan dari dokumen
+- **ChromaDB**: Vector database untuk penyimpanan dan pencarian semantic
+- **Gradio**: Interface web yang modern dan interaktif
+
+## ✨ Fitur
+
+- 📤 **Upload Multiple PDF**: Upload satu atau beberapa file PDF sekaligus
+- 🔍 **Semantic Search**: Pencarian konteks menggunakan embeddings
+- 💬 **Interactive Chat**: Chat dengan streaming response
+- 📚 **Source Citations**: Lihat sumber informasi dari dokumen
+- 🎨 **Modern UI**: Interface premium dengan gradients dan animasi
+- ⚙️ **Configurable**: Atur parameters seperti temperature, top-p, dan retrieval count
+- 💾 **Persistent Storage**: Dokumen tersimpan di vector database
+- 🌐 **Bahasa Indonesia**: Full support untuk bahasa Indonesia
+
+## 🚀 Instalasi
+
+### Prerequisites
+
+- Python 3.8 atau lebih tinggi
+- (Opsional) NVIDIA GPU dengan CUDA untuk performa optimal
+
+### Langkah Instalasi
+
+1. **Clone repository**
+```bash
+git clone <repository-url>
+cd LLM-ChatBot-Document
+```
+
+2. **Buat virtual environment**
+```bash
+python -m venv venv
+source venv/bin/activate  # Linux/Mac
+# atau
+venv\Scripts\activate  # Windows
+```
+
+3. **Install dependencies**
+```bash
+pip install -r requirements.txt
+```
+
+4. **Setup environment variables**
+```bash
+cp .env.example .env
+# Edit .env sesuai kebutuhan
+```
+
+## 📋 Penggunaan
+
+### Menjalankan Aplikasi
+
+```bash
+python app.py
+```
+
+Aplikasi akan berjalan di `http://localhost:7860`
+
+### Workflow
+
+1. **Upload Dokumen** (Tab 📤 Upload Dokumen)
+   - Pilih file PDF dari komputer Anda
+   - Klik "Process PDF"
+   - Tunggu hingga proses ekstraksi dan indexing selesai
+
+2. **Chat dengan Dokumen** (Tab 💬 Chat)
+   - Ketik pertanyaan Anda tentang isi dokumen
+   - Sistem akan mencari informasi relevan dan menjawab
+   - Lihat source citations untuk referensi
+
+3. **Kelola Dokumen** (Tab 📚 Kelola Dokumen)
+   - Lihat daftar dokumen yang tersimpan
+   - Hapus dokumen jika diperlukan
+   - Clear all untuk reset database
+
+4. **Info & Settings** (Tab ℹ️ Info & Pengaturan)
+   - Lihat informasi sistem
+   - Dokumentasi dan tips
+
+## 🏗️ Arsitektur
+
+```
+┌─────────────────┐
+│   PDF Upload    │
+└────────┬────────┘
+         │
+         ▼
+┌─────────────────┐
+│ Text Extraction │  (PyPDF2 + pdfplumber)
+└────────┬────────┘
+         │
+         ▼
+┌─────────────────┐
+│  Text Chunking  │  (LangChain)
+└────────┬────────┘
+         │
+         ▼
+┌─────────────────┐
+│   Embeddings    │  (SentenceTransformers)
+└────────┬────────┘
+         │
+         ▼
+┌─────────────────┐
+│   ChromaDB      │  (Vector Storage)
+└────────┬────────┘
+         │
+    ┌────┴─────┐
+    │   RAG    │
+    └────┬─────┘
+         │
+    ┌────▼─────┐
+    │ChatGLM3  │  (Response Generation)
+    └──────────┘
+```
+
+## 📁 Struktur Project
+
+```
+LLM-ChatBot-Document/
+│
+├── app.py                 # Main application
+├── requirements.txt       # Dependencies
+├── .env.example          # Environment template
+├── .gitignore            # Git ignore rules
+│
+├── config/
+│   ├── __init__.py
+│   └── model_config.py   # Model & app configuration
+│
+├── utils/
+│   ├── __init__.py
+│   ├── pdf_processor.py  # PDF extraction & chunking
+│   ├── vector_store.py   # ChromaDB management
+│   ├── rag_pipeline.py   # RAG implementation
+│   └── ui_components.py  # Gradio UI components
+│
+├── data/
+│   ├── uploads/          # Temporary PDF storage
+│   └── vector_db/        # ChromaDB persistent storage
+│
+└── tests/                # Unit & integration tests
+```
+
+## ⚙️ Konfigurasi
+
+Edit file `.env` untuk mengatur konfigurasi:
+
+```bash
+# Model
+MODEL_NAME=THUDM/chatglm3-6b
+EMBEDDING_MODEL=sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2
+
+# Device (auto/cuda/cpu)
+DEVICE=auto
+
+# Text Processing
+CHUNK_SIZE=500
+CHUNK_OVERLAP=50
+
+# Retrieval
+TOP_K_RETRIEVAL=3
+
+# Generation
+MAX_LENGTH=2048
+TEMPERATURE=0.7
+TOP_P=0.9
+```
+
+## 🔧 Requirements
+
+Berikut dependencies utama yang digunakan:
+
+- `gradio==5.42.0` - Web interface
+- `torch>=2.0.0` - Deep learning framework
+- `transformers>=4.35.0` - Model loading
+- `sentence-transformers>=2.2.2` - Embeddings
+- `chromadb>=0.4.22` - Vector database
+- `langchain>=0.1.0` - Text processing
+- `PyPDF2>=3.0.0` - PDF extraction
+- `pdfplumber>=0.10.0` - Alternative PDF extraction
+
+## 💡 Tips & Best Practices
+
+1. **Ukuran PDF**: Untuk hasil terbaik, gunakan PDF < 50MB
+2. **Format PDF**: Pastikan PDF berisi teks yang bisa di-extract (bukan scan gambar)
+3. **Chunk Size**: Sesuaikan `CHUNK_SIZE` berdasarkan jenis dokumen (500-1000 optimal)
+4. **GPU**: Gunakan GPU untuk loading model yang lebih cepat
+5. **Temperature**: Nilai lebih rendah (0.3-0.5) untuk jawaban lebih faktual
+
+## 🐛 Troubleshooting
+
+### Model Loading Error
+```bash
+# Jika model terlalu besar, gunakan quantized version
+MODEL_NAME=THUDM/chatglm3-6b-32k
+```
+
+### PDF Extraction Error
+- Coba method alternatif dengan edit `pdf_processor.py`
+- Pastikan PDF tidak ter-password
+
+### Memory Error
+- Reduce `CHUNK_SIZE` and `BATCH_SIZE`
+- Use CPU instead of GPU if OOM on GPU
+
+## 📝 License
+
+MIT License - lihat file LICENSE untuk detail
+
+## 🤝 Contributing
+
+Contributions welcome! Silakan buat issue atau pull request.
+
+## 📧 Contact
+
+Untuk pertanyaan dan support, silakan buat issue di repository ini.
+
 ---
 
-An example chatbot using [Gradio](https://gradio.app), [`huggingface_hub`](https://huggingface.co/docs/huggingface_hub/v0.22.2/en/index), and the [Hugging Face Inference API](https://huggingface.co/docs/api-inference/index).
+<div align="center">
+Made with ❤️ using Gradio and ChatGLM
+</div>

app.py

@@ -1,70 +1,415 @@
+"""
+RAG ChatBot dengan GLM Model dan Dashboard Gradio
+Main application file
+"""
+import os
 import gradio as gr
-from huggingface_hub import InferenceClient
+from pathlib import Path
 
+from config.model_config import config
+from utils.pdf_processor import PDFProcessor
+from utils.vector_store import VectorStore
+from utils.rag_pipeline import RAGPipeline
+from utils.ui_components import (
+    CUSTOM_CSS,
+    format_sources,
+    create_document_card,
+    create_status_message
+)
 
-def respond(
-    message,
-    history: list[dict[str, str]],
-    system_message,
-    max_tokens,
-    temperature,
-    top_p,
-    hf_token: gr.OAuthToken,
-):
-    """
-    For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
-    """
-    client = InferenceClient(token=hf_token.token, model="openai/gpt-oss-20b")
+# Initialize components
+pdf_processor = PDFProcessor()
+vector_store = VectorStore()
+rag_pipeline = RAGPipeline(vector_store)
 
-    messages = [{"role": "system", "content": system_message}]
+# Global state
+chat_history = []
 
-    messages.extend(history)
+# ========== Event Handlers ==========
 
-    messages.append({"role": "user", "content": message})
+def upload_pdf(files, progress=gr.Progress()):
+    """Handle PDF upload and processing"""
+    if not files:
+        return create_status_message("Tidak ada file yang dipilih", "error"), ""
+    
+    results = []
+    
+    for i, file in enumerate(files):
+        try:
+            progress((i + 1) / len(files), desc=f"Memproses {Path(file.name).name}...")
+            
+            # Process PDF
+            pdf_info = pdf_processor.process_pdf(file.name)
+            
+            # Add to vector store
+            vector_store.add_document(
+                filename=pdf_info["filename"],
+                chunks=pdf_info["chunks"],
+                metadata={
+                    "total_chars": pdf_info["total_chars"],
+                    "num_chunks": pdf_info["num_chunks"]
+                }
+            )
+            
+            results.append(
+                f"✓ {pdf_info['filename']}: {pdf_info['num_chunks']} chunks, {pdf_info['total_chars']} karakter"
+            )
+            
+        except Exception as e:
+            results.append(f"✗ {Path(file.name).name}: Error - {str(e)}")
+    
+    summary = "\n".join(results)
+    status_msg = create_status_message(
+        f"Berhasil memproses {len(files)} file",
+        "success"
+    )
+    
+    # Update document list
+    doc_list = get_document_list()
+    
+    return status_msg + f"\n\n{summary}", doc_list
 
-    response = ""
+def chat_with_rag(message, history, use_rag, temperature, top_p, top_k):
+    """Handle chat interaction with RAG"""
+    if not message.strip():
+        return history, ""
+    
+    # Convert history format for display
+    history = history or []
+    
+    # Check if we need to load model
+    if rag_pipeline.model is None:
+        history.append({
+            "role": "assistant",
+            "content": "⏳ Loading model untuk pertama kali, mohon tunggu..."
+        })
+        yield history, ""
+        
+        try:
+            rag_pipeline.load_model()
+        except Exception as e:
+            history[-1] = {
+                "role": "assistant",
+                "content": f"❌ Error loading model: {str(e)}"
+            }
+            yield history, ""
+            return
+    
+    # Add user message
+    history.append({"role": "user", "content": message})
+    yield history, ""
+    
+    # Prepare chat history for GLM (convert from Gradio format)
+    glm_history = []
+    for msg in history[:-1]:  # Exclude current message
+        if msg["role"] == "user":
+            glm_history.append([msg["content"], ""])
+        elif msg["role"] == "assistant" and glm_history:
+            glm_history[-1][1] = msg["content"]
+    
+    # Generate response
+    sources = []
+    full_response = ""
+    
+    try:
+        for response, src in rag_pipeline.stream_response(
+            message,
+            history=glm_history,
+            use_rag=use_rag,
+            temperature=temperature,
+            top_p=top_p
+        ):
+            full_response = response
+            sources = src
+            
+            # Update assistant message
+            if len(history) > 0 and history[-1]["role"] == "assistant":
+                history[-1]["content"] = response
+            else:
+                history.append({"role": "assistant", "content": response})
+            
+            yield history, ""
+    
+    except Exception as e:
+        error_msg = f"❌ Error: {str(e)}"
+        if len(history) > 0 and history[-1]["role"] == "assistant":
+            history[-1]["content"] = error_msg
+        else:
+            history.append({"role": "assistant", "content": error_msg})
+        yield history, ""
+        return
+    
+    # Format sources
+    if sources and use_rag:
+        sources_html = format_sources(sources)
+        yield history, sources_html
+    else:
+        yield history, ""
 
-    for message in client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
-        stream=True,
-        temperature=temperature,
-        top_p=top_p,
-    ):
-        choices = message.choices
-        token = ""
-        if len(choices) and choices[0].delta.content:
-            token = choices[0].delta.content
+def get_document_list():
+    """Get list of uploaded documents"""
+    docs = vector_store.list_documents()
+    
+    if not docs:
+        return create_status_message("Belum ada dokumen yang di-upload", "info")
+    
+    html = "<div style='margin-top: 1rem;'>"
+    html += f"<h3 style='color: #667eea;'>📚 Dokumen Tersimpan ({len(docs)})</h3>"
+    
+    for doc in docs:
+        html += create_document_card(doc)
+    
+    html += "</div>"
+    return html
 
-        response += token
-        yield response
+def delete_document(filename):
+    """Delete a document from vector store"""
+    try:
+        vector_store.delete_document(filename)
+        return (
+            create_status_message(f"Berhasil menghapus: {filename}", "success"),
+            get_document_list()
+        )
+    except Exception as e:
+        return (
+            create_status_message(f"Error: {str(e)}", "error"),
+            get_document_list()
+        )
 
+def clear_all_documents():
+    """Clear all documents"""
+    try:
+        vector_store.clear_all()
+        return (
+            create_status_message("Semua dokumen berhasil dihapus", "success"),
+            get_document_list()
+        )
+    except Exception as e:
+        return (
+            create_status_message(f"Error: {str(e)}", "error"),
+            get_document_list()
+        )
 
-"""
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
-"""
-chatbot = gr.ChatInterface(
-    respond,
-    type="messages",
-    additional_inputs=[
-        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
-        gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
-            step=0.05,
-            label="Top-p (nucleus sampling)",
-        ),
-    ],
-)
+# ========== Gradio Interface ==========
 
-with gr.Blocks() as demo:
-    with gr.Sidebar():
-        gr.LoginButton()
-    chatbot.render()
+with gr.Blocks(css=CUSTOM_CSS, theme=gr.themes.Soft(), title="RAG ChatBot - GLM") as demo:
+    
+    # Header
+    gr.HTML("""
+    <div class='header-container'>
+        <h1 class='header-title'>🤖 RAG ChatBot dengan GLM</h1>
+        <p class='header-subtitle'>Chat dengan dokumen PDF Anda menggunakan AI</p>
+    </div>
+    """)
+    
+    with gr.Tabs() as tabs:
+        
+        # ===== Tab 1: Upload Documents =====
+        with gr.Tab("📤 Upload Dokumen"):
+            gr.Markdown("""
+            ### Upload PDF untuk Analisis
+            Upload satu atau beberapa file PDF. Sistem akan mengekstrak teks, membuat chunks, dan menyimpannya untuk retrieval.
+            """)
+            
+            with gr.Row():
+                with gr.Column(scale=2):
+                    file_upload = gr.File(
+                        label="Pilih PDF Files",
+                        file_types=[".pdf"],
+                        file_count="multiple"
+                    )
+                    upload_btn = gr.Button("🚀 Process PDF", variant="primary", size="lg")
+                
+                with gr.Column(scale=1):
+                    gr.Markdown("""
+                    **Tips:**
+                    - Ukuran optimal: < 50MB per file
+                    - Format: PDF dengan teks (bukan scan)
+                    - Multiple files: Upload sekaligus
+                    """)
+            
+            upload_status = gr.HTML(label="Status")
+            upload_btn.click(
+                upload_pdf,
+                inputs=[file_upload],
+                outputs=[upload_status, gr.HTML(visible=False)]
+            )
+        
+        # ===== Tab 2: Chat Interface =====
+        with gr.Tab("💬 Chat"):
+            gr.Markdown("""
+            ### Tanya Jawab dengan Dokumen
+            Ajukan pertanyaan tentang dokumen yang telah di-upload.
+            """)
+            
+            chatbot = gr.Chatbot(
+                label="Conversation",
+                type="messages",
+                height=500,
+                avatar_images=(None, "🤖")
+            )
+            
+            with gr.Row():
+                msg_input = gr.Textbox(
+                    label="Pesan Anda",
+                    placeholder="Tanyakan sesuatu tentang dokumen...",
+                    scale=4
+                )
+                send_btn = gr.Button("📨 Send", variant="primary", scale=1)
+            
+            sources_display = gr.HTML(label="Sumber Informasi")
+            
+            with gr.Accordion("⚙️ Parameter Chat", open=False):
+                with gr.Row():
+                    use_rag = gr.Checkbox(
+                        label="Gunakan RAG (Retrieval)",
+                        value=True,
+                        info="Matikan untuk chat biasa tanpa dokumen"
+                    )
+                    temperature = gr.Slider(
+                        minimum=0.1,
+                        maximum=2.0,
+                        value=config.TEMPERATURE,
+                        step=0.1,
+                        label="Temperature",
+                        info="Kreativitas respons"
+                    )
+                with gr.Row():
+                    top_p = gr.Slider(
+                        minimum=0.1,
+                        maximum=1.0,
+                        value=config.TOP_P,
+                        step=0.05,
+                        label="Top-p",
+                        info="Nucleus sampling"
+                    )
+                    top_k = gr.Slider(
+                        minimum=1,
+                        maximum=10,
+                        value=config.TOP_K_RETRIEVAL,
+                        step=1,
+                        label="Top-K Retrieval",
+                        info="Jumlah chunks yang diambil"
+                    )
+            
+            clear_btn = gr.Button("🗑️ Clear Chat")
+            
+            # Chat interactions
+            send_btn.click(
+                chat_with_rag,
+                inputs=[msg_input, chatbot, use_rag, temperature, top_p, top_k],
+                outputs=[chatbot, sources_display]
+            ).then(
+                lambda: "",
+                outputs=[msg_input]
+            )
+            
+            msg_input.submit(
+                chat_with_rag,
+                inputs=[msg_input, chatbot, use_rag, temperature, top_p, top_k],
+                outputs=[chatbot, sources_display]
+            ).then(
+                lambda: "",
+                outputs=[msg_input]
+            )
+            
+            clear_btn.click(
+                lambda: ([], ""),
+                outputs=[chatbot, sources_display]
+            )
+        
+        # ===== Tab 3: Document Management =====
+        with gr.Tab("📚 Kelola Dokumen"):
+            gr.Markdown("""
+            ### Dokumen yang Tersimpan
+            Lihat dan kelola dokumen yang telah di-upload.
+            """)
+            
+            doc_list_display = gr.HTML()
+            
+            with gr.Row():
+                refresh_btn = gr.Button("🔄 Refresh List", variant="secondary")
+                clear_all_btn = gr.Button("🗑️ Hapus Semua", variant="stop")
+            
+            doc_status = gr.HTML()
+            
+            # Load documents on tab open
+            demo.load(
+                get_document_list,
+                outputs=[doc_list_display]
+            )
+            
+            refresh_btn.click(
+                get_document_list,
+                outputs=[doc_list_display]
+            )
+            
+            clear_all_btn.click(
+                clear_all_documents,
+                outputs=[doc_status, doc_list_display]
+            )
+        
+        # ===== Tab 4: About & Settings =====
+        with gr.Tab("ℹ️ Info & Pengaturan"):
+            gr.Markdown(f"""
+            ### RAG ChatBot - Informasi Sistem
+            
+            **Model yang Digunakan:**
+            - 🤖 LLM: `{config.MODEL_NAME}`
+            - 🔍 Embeddings: `{config.EMBEDDING_MODEL}`
+            - 💾 Vector DB: ChromaDB (Persistent)
+            
+            **Konfigurasi:**
+            - Chunk Size: {config.CHUNK_SIZE}
+            - Chunk Overlap: {config.CHUNK_OVERLAP}
+            - Top-K Retrieval: {config.TOP_K_RETRIEVAL}
+            - Device: {config.DEVICE}
+            
+            **Fitur:**
+            ✓ Upload multiple PDF files  
+            ✓ Automatic text extraction & chunking  
+            ✓ Semantic search dengan embeddings  
+            ✓ Context-aware responses  
+            ✓ Source citations  
+            ✓ Persistent storage  
+            
+            **Tech Stack:**
+            - Framework: Gradio
+            - LLM: ChatGLM3 (Transformers)
+            - Embeddings: Sentence Transformers
+            - Vector DB: ChromaDB
+            - PDF Processing: PyPDF2 + pdfplumber
+            """)
+            
+            with gr.Accordion("🔧 Advanced Settings", open=False):
+                gr.Markdown("""
+                Untuk mengubah konfigurasi model, edit file `.env`:
+                ```bash
+                MODEL_NAME=THUDM/chatglm3-6b
+                DEVICE=auto
+                CHUNK_SIZE=500
+                CHUNK_OVERLAP=50
+                ```
+                Kemudian restart aplikasi.
+                """)
 
+# ========== Launch ==========
 
 if __name__ == "__main__":
-    demo.launch()
+    # Ensure directories exist
+    os.makedirs(config.UPLOAD_DIR, exist_ok=True)
+    os.makedirs(config.VECTOR_DB_DIR, exist_ok=True)
+    
+    print("=" * 60)
+    print("🚀 Launching RAG ChatBot dengan GLM")
+    print("=" * 60)
+    print(f"Model: {config.MODEL_NAME}")
+    print(f"Device: {config.DEVICE}")
+    print(f"Vector DB: {config.VECTOR_DB_DIR}")
+    print("=" * 60)
+    
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False
+    )

config/__init__.py

@@ -0,0 +1 @@
+"""Config package for RAG ChatBot"""

config/model_config.py

@@ -0,0 +1,52 @@
+"""
+Configuration settings for RAG ChatBot
+"""
+import os
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+class Config:
+    """Configuration class for RAG ChatBot"""
+    
+    # Model Settings
+    MODEL_NAME = os.getenv("MODEL_NAME", "THUDM/chatglm3-6b")
+    EMBEDDING_MODEL = os.getenv("EMBEDDING_MODEL", "sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2")
+    
+    # Device Configuration
+    DEVICE = os.getenv("DEVICE", "auto")
+    
+    # Text Processing
+    CHUNK_SIZE = int(os.getenv("CHUNK_SIZE", "500"))
+    CHUNK_OVERLAP = int(os.getenv("CHUNK_OVERLAP", "50"))
+    
+    # Retrieval Configuration
+    TOP_K_RETRIEVAL = int(os.getenv("TOP_K_RETRIEVAL", "3"))
+    
+    # Generation Parameters
+    MAX_LENGTH = int(os.getenv("MAX_LENGTH", "2048"))
+    TEMPERATURE = float(os.getenv("TEMPERATURE", "0.7"))
+    TOP_P = float(os.getenv("TOP_P", "0.9"))
+    
+    # Storage Paths
+    UPLOAD_DIR = os.getenv("UPLOAD_DIR", "data/uploads")
+    VECTOR_DB_DIR = os.getenv("VECTOR_DB_DIR", "data/vector_db")
+    
+    # Prompt Template
+    RAG_PROMPT_TEMPLATE = """Berdasarkan konteks berikut, jawab pertanyaan dengan akurat dan informatif.
+
+Konteks:
+{context}
+
+Pertanyaan: {question}
+
+Jawaban:"""
+
+    SYSTEM_PROMPT = """Kamu adalah asisten AI yang membantu pengguna memahami dokumen mereka. 
+Selalu gunakan informasi dari konteks yang diberikan untuk menjawab pertanyaan.
+Jika informasi tidak ada dalam konteks, katakan dengan jelas bahwa informasi tersebut tidak tersedia dalam dokumen yang di-upload.
+Jawab dalam bahasa Indonesia dengan jelas dan ringkas."""
+
+# Create instance
+config = Config()

requirements.txt

@@ -0,0 +1,20 @@
+# Core Dependencies
+gradio==5.42.0
+torch>=2.0.0
+transformers>=4.35.0
+accelerate>=0.25.0
+
+# RAG & Embeddings
+sentence-transformers>=2.2.2
+chromadb>=0.4.22
+langchain>=0.1.0
+langchain-community>=0.0.20
+
+# PDF Processing
+PyPDF2>=3.0.0
+pdfplumber>=0.10.0
+
+# Utilities
+python-dotenv>=1.0.0
+numpy>=1.24.0
+tqdm>=4.66.0

tests/__init__.py

@@ -0,0 +1 @@
+"""Tests package"""

tests/test_imports.py

@@ -0,0 +1,28 @@
+"""Simple script to verify basic imports"""
+import sys
+print("Testing imports...")
+
+try:
+    # Test core imports
+    print("✓ Testing config import...")
+    from config.model_config import config
+    print(f"  Model: {config.MODEL_NAME}")
+    
+    print("✓ Testing PDF processor import...")
+    from utils.pdf_processor import PDFProcessor
+    pdf_proc = PDFProcessor()
+    print(f"  Chunk size: {config.CHUNK_SIZE}")
+    
+    print("✓ Testing UI components import...")
+    from utils.ui_components import CUSTOM_CSS
+    print(f"  CSS loaded: {len(CUSTOM_CSS)} chars")
+    
+    print("\n✅ All basic imports successful!")
+    print("\nNote: Model and vector store imports require additional dependencies")
+    print("Run: pip install -r requirements.txt")
+    
+except Exception as e:
+    print(f"\n❌ Import error: {e}")
+    print("\nPlease install dependencies:")
+    print("pip install -r requirements.txt")
+    sys.exit(1)

tests/test_pdf_processor.py

@@ -0,0 +1,24 @@
+"""
+Basic tests for PDF processor
+"""
+import pytest
+from utils.pdf_processor import PDFProcessor
+
+def test_pdf_processor_init():
+    """Test PDF processor initialization"""
+    processor = PDFProcessor()
+    assert processor is not None
+    assert processor.text_splitter is not None
+
+def test_chunk_text():
+    """Test text chunking"""
+    processor = PDFProcessor()
+    
+    sample_text = "This is a test. " * 100
+    chunks = processor.chunk_text(sample_text)
+    
+    assert len(chunks) > 0
+    assert all(isinstance(chunk, str) for chunk in chunks)
+
+# Note: Full PDF tests require actual PDF files
+# Add integration tests with sample PDFs as needed

utils/__init__.py

@@ -0,0 +1 @@
+"""Utils package for RAG ChatBot"""

utils/pdf_processor.py

@@ -0,0 +1,134 @@
+"""
+PDF Processing utilities for extracting and chunking text from PDF files
+"""
+import os
+from typing import List, Dict
+import PyPDF2
+import pdfplumber
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from config.model_config import config
+
+class PDFProcessor:
+    """Handle PDF text extraction and processing"""
+    
+    def __init__(self):
+        self.text_splitter = RecursiveCharacterTextSplitter(
+            chunk_size=config.CHUNK_SIZE,
+            chunk_overlap=config.CHUNK_OVERLAP,
+            length_function=len,
+            separators=["\n\n", "\n", " ", ""]
+        )
+    
+    def extract_text_from_pdf(self, pdf_path: str, method: str = "pdfplumber") -> str:
+        """
+        Extract text from PDF file
+        
+        Args:
+            pdf_path: Path to PDF file
+            method: Extraction method ('pypdf2' or 'pdfplumber')
+            
+        Returns:
+            Extracted text as string
+        """
+        text = ""
+        
+        try:
+            if method == "pdfplumber":
+                text = self._extract_with_pdfplumber(pdf_path)
+            else:
+                text = self._extract_with_pypdf2(pdf_path)
+        except Exception as e:
+            print(f"Error extracting text from {pdf_path}: {e}")
+            # Fallback to alternative method
+            if method == "pdfplumber":
+                text = self._extract_with_pypdf2(pdf_path)
+            else:
+                text = self._extract_with_pdfplumber(pdf_path)
+        
+        return text
+    
+    def _extract_with_pypdf2(self, pdf_path: str) -> str:
+        """Extract text using PyPDF2"""
+        text = ""
+        with open(pdf_path, 'rb') as file:
+            pdf_reader = PyPDF2.PdfReader(file)
+            for page in pdf_reader.pages:
+                text += page.extract_text() + "\n"
+        return text
+    
+    def _extract_with_pdfplumber(self, pdf_path: str) -> str:
+        """Extract text using pdfplumber (better for complex PDFs)"""
+        text = ""
+        with pdfplumber.open(pdf_path) as pdf:
+            for page in pdf.pages:
+                page_text = page.extract_text()
+                if page_text:
+                    text += page_text + "\n"
+        return text
+    
+    def chunk_text(self, text: str) -> List[str]:
+        """
+        Split text into chunks
+        
+        Args:
+            text: Input text to chunk
+            
+        Returns:
+            List of text chunks
+        """
+        chunks = self.text_splitter.split_text(text)
+        return chunks
+    
+    def process_pdf(self, pdf_path: str) -> Dict:
+        """
+        Complete processing pipeline: extract and chunk PDF
+        
+        Args:
+            pdf_path: Path to PDF file
+            
+        Returns:
+            Dictionary with filename, text, and chunks
+        """
+        filename = os.path.basename(pdf_path)
+        
+        # Extract text
+        text = self.extract_text_from_pdf(pdf_path)
+        
+        if not text.strip():
+            raise ValueError(f"No text extracted from {filename}")
+        
+        # Chunk text
+        chunks = self.chunk_text(text)
+        
+        return {
+            "filename": filename,
+            "full_text": text,
+            "chunks": chunks,
+            "num_chunks": len(chunks),
+            "total_chars": len(text)
+        }
+    
+    def get_pdf_info(self, pdf_path: str) -> Dict:
+        """
+        Get metadata about PDF file
+        
+        Args:
+            pdf_path: Path to PDF file
+            
+        Returns:
+            Dictionary with PDF metadata
+        """
+        info = {
+            "filename": os.path.basename(pdf_path),
+            "file_size": os.path.getsize(pdf_path),
+            "num_pages": 0
+        }
+        
+        try:
+            with open(pdf_path, 'rb') as file:
+                pdf_reader = PyPDF2.PdfReader(file)
+                info["num_pages"] = len(pdf_reader.pages)
+        except Exception as e:
+            print(f"Error getting PDF info: {e}")
+        
+        return info

utils/rag_pipeline.py

@@ -0,0 +1,228 @@
+"""
+RAG Pipeline for retrieving relevant context and generating responses
+"""
+from typing import List, Dict, Optional
+import torch
+from transformers import AutoTokenizer, AutoModel
+from config.model_config import config
+from utils.vector_store import VectorStore
+
+class RAGPipeline:
+    """RAG pipeline integrating retrieval and generation"""
+    
+    def __init__(self, vector_store: VectorStore):
+        """
+        Initialize RAG pipeline
+        
+        Args:
+            vector_store: VectorStore instance for retrieval
+        """
+        self.vector_store = vector_store
+        self.model = None
+        self.tokenizer = None
+        self.device = self._get_device()
+        
+    def _get_device(self) -> str:
+        """Determine device (cuda/cpu) to use"""
+        if config.DEVICE == "auto":
+            return "cuda" if torch.cuda.is_available() else "cpu"
+        return config.DEVICE
+    
+    def load_model(self):
+        """Load GLM model and tokenizer"""
+        if self.model is not None:
+            print("Model already loaded")
+            return
+        
+        print(f"Loading model: {config.MODEL_NAME}")
+        print(f"Using device: {self.device}")
+        
+        try:
+            self.tokenizer = AutoTokenizer.from_pretrained(
+                config.MODEL_NAME,
+                trust_remote_code=True
+            )
+            
+            self.model = AutoModel.from_pretrained(
+                config.MODEL_NAME,
+                trust_remote_code=True,
+                torch_dtype=torch.float16 if self.device == "cuda" else torch.float32
+            ).to(self.device)
+            
+            # Set to evaluation mode
+            self.model = self.model.eval()
+            
+            print(f"✓ Model loaded successfully on {self.device}")
+            
+        except Exception as e:
+            print(f"Error loading model: {e}")
+            raise
+    
+    def retrieve_relevant_chunks(self, query: str, top_k: Optional[int] = None) -> Dict:
+        """
+        Retrieve relevant document chunks for query
+        
+        Args:
+            query: User query
+            top_k: Number of chunks to retrieve
+            
+        Returns:
+            Dictionary with retrieved documents and metadata
+        """
+        return self.vector_store.query(query, top_k=top_k)
+    
+    def build_context_prompt(self, query: str, retrieved_docs: List[str]) -> str:
+        """
+        Build prompt with retrieved context
+        
+        Args:
+            query: User query
+            retrieved_docs: List of retrieved document chunks
+            
+        Returns:
+            Formatted prompt string
+        """
+        if not retrieved_docs:
+            return f"Pertanyaan: {query}\n\nJawaban:"
+        
+        # Combine retrieved documents as context
+        context = "\n\n".join([
+            f"[Dokumen {i+1}]\n{doc}"
+            for i, doc in enumerate(retrieved_docs)
+        ])
+        
+        # Use template from config
+        prompt = config.RAG_PROMPT_TEMPLATE.format(
+            context=context,
+            question=query
+        )
+        
+        return prompt
+    
+    def generate_response(
+        self,
+        query: str,
+        history: Optional[List] = None,
+        use_rag: bool = True,
+        max_length: Optional[int] = None,
+        temperature: Optional[float] = None,
+        top_p: Optional[float] = None
+    ) -> tuple:
+        """
+        Generate response using RAG pipeline
+        
+        Args:
+            query: User query
+            history: Chat history (for ChatGLM format)
+            use_rag: Whether to use RAG retrieval
+            max_length: Maximum response length
+            temperature: Sampling temperature
+            top_p: Nucleus sampling parameter
+            
+        Returns:
+            Tuple of (response, sources)
+        """
+        if self.model is None:
+            self.load_model()
+        
+        # Set default parameters
+        max_length = max_length or config.MAX_LENGTH
+        temperature = temperature or config.TEMPERATURE
+        top_p = top_p or config.TOP_P
+        
+        sources = []
+        
+        if use_rag:
+            # Retrieve relevant chunks
+            retrieval_results = self.retrieve_relevant_chunks(query)
+            retrieved_docs = retrieval_results["documents"]
+            sources = retrieval_results["metadatas"]
+            
+            if not retrieved_docs:
+                return "Maaf, tidak ada dokumen yang relevan ditemukan. Silakan upload dokumen terlebih dahulu.", []
+            
+            # Build prompt with context
+            prompt = self.build_context_prompt(query, retrieved_docs)
+        else:
+            prompt = query
+        
+        # Generate response using ChatGLM
+        try:
+            response, history = self.model.chat(
+                self.tokenizer,
+                prompt,
+                history=history or [],
+                max_length=max_length,
+                temperature=temperature,
+                top_p=top_p
+            )
+            
+            return response, sources
+            
+        except Exception as e:
+            print(f"Error generating response: {e}")
+            return f"Maaf, terjadi kesalahan saat menggenerate respons: {str(e)}", []
+    
+    def stream_response(
+        self,
+        query: str,
+        history: Optional[List] = None,
+        use_rag: bool = True,
+        max_length: Optional[int] = None,
+        temperature: Optional[float] = None,
+        top_p: Optional[float] = None
+    ):
+        """
+        Generate streaming response
+        
+        Args:
+            query: User query
+            history: Chat history
+            use_rag: Whether to use RAG retrieval
+            max_length: Maximum response length
+            temperature: Sampling temperature
+            top_p: Nucleus sampling parameter
+            
+        Yields:
+            Tuples of (response_chunk, sources)
+        """
+        if self.model is None:
+            self.load_model()
+        
+        # Set default parameters
+        max_length = max_length or config.MAX_LENGTH
+        temperature = temperature or config.TEMPERATURE
+        top_p = top_p or config.TOP_P
+        
+        sources = []
+        
+        if use_rag:
+            # Retrieve relevant chunks
+            retrieval_results = self.retrieve_relevant_chunks(query)
+            retrieved_docs = retrieval_results["documents"]
+            sources = retrieval_results["metadatas"]
+            
+            if not retrieved_docs:
+                yield "Maaf, tidak ada dokumen yang relevan ditemukan. Silakan upload dokumen terlebih dahulu.", []
+                return
+            
+            # Build prompt with context
+            prompt = self.build_context_prompt(query, retrieved_docs)
+        else:
+            prompt = query
+        
+        # Stream response using ChatGLM
+        try:
+            for response, history in self.model.stream_chat(
+                self.tokenizer,
+                prompt,
+                history=history or [],
+                max_length=max_length,
+                temperature=temperature,
+                top_p=top_p
+            ):
+                yield response, sources
+                
+        except Exception as e:
+            print(f"Error streaming response: {e}")
+            yield f"Maaf, terjadi kesalahan: {str(e)}", []

utils/ui_components.py

@@ -0,0 +1,272 @@
+"""
+UI Components and styling for Gradio interface
+"""
+
+# Custom CSS for premium design
+CUSTOM_CSS = """
+/* Main theme */
+:root {
+    --primary-gradient: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    --success-gradient: linear-gradient(135deg, #11998e 0%, #38ef7d 100%);
+    --card-bg: rgba(255, 255, 255, 0.05);
+    --glass-bg: rgba(255, 255, 255, 0.1);
+}
+
+/* Header styling */
+.header-container {
+    background: var(--primary-gradient);
+    padding: 2rem;
+    border-radius: 12px;
+    margin-bottom: 1.5rem;
+    box-shadow: 0 8px 32px rgba(102, 126, 234, 0.3);
+}
+
+.header-title {
+    color: white;
+    font-size: 2.5rem;
+    font-weight: 700;
+    text-align: center;
+    margin-bottom: 0.5rem;
+}
+
+.header-subtitle {
+    color: rgba(255, 255, 255, 0.9);
+    text-align: center;
+    font-size: 1.1rem;
+}
+
+/* Tab styling */
+.tab-nav button {
+    font-size: 1rem;
+    font-weight: 600;
+    padding: 0.75rem 1.5rem;
+    border-radius: 8px;
+    transition: all 0.3s ease;
+}
+
+.tab-nav button:hover {
+    transform: translateY(-2px);
+    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
+}
+
+/* Card styling */
+.info-card {
+    background: var(--card-bg);
+    backdrop-filter: blur(10px);
+    border-radius: 12px;
+    padding: 1.5rem;
+    margin: 1rem 0;
+    border: 1px solid rgba(255, 255, 255, 0.1);
+}
+
+/* Upload area */
+.upload-area {
+    border: 2px dashed rgba(102, 126, 234, 0.5);
+    border-radius: 12px;
+    padding: 2rem;
+    text-align: center;
+    transition: all 0.3s ease;
+}
+
+.upload-area:hover {
+    border-color: #667eea;
+    background: rgba(102, 126, 234, 0.05);
+}
+
+/* Chat messages */
+.message-bubble {
+    border-radius: 18px;
+    padding: 0.75rem 1rem;
+    margin: 0.5rem 0;
+    animation: slideIn 0.3s ease;
+}
+
+@keyframes slideIn {
+    from {
+        opacity: 0;
+        transform: translateY(10px);
+    }
+    to {
+        opacity: 1;
+        transform: translateY(0);
+    }
+}
+
+/* Source citations */
+.source-citation {
+    background: var(--glass-bg);
+    border-left: 3px solid #667eea;
+    padding: 0.75rem;
+    margin: 0.5rem 0;
+    border-radius: 6px;
+    font-size: 0.9rem;
+}
+
+/* Buttons */
+.primary-button {
+    background: var(--primary-gradient) !important;
+    color: white !important;
+    border: none !important;
+    padding: 0.75rem 2rem !important;
+    border-radius: 8px !important;
+    font-weight: 600 !important;
+    transition: all 0.3s ease !important;
+}
+
+.primary-button:hover {
+    transform: translateY(-2px) !important;
+    box-shadow: 0 6px 20px rgba(102, 126, 234, 0.4) !important;
+}
+
+/* Status indicators */
+.status-success {
+    color: #38ef7d;
+    font-weight: 600;
+}
+
+.status-error {
+    color: #ff6b6b;
+    font-weight: 600;
+}
+
+/* Loading animation */
+.loading {
+    display: inline-block;
+    animation: pulse 1.5s ease-in-out infinite;
+}
+
+@keyframes pulse {
+    0%, 100% { opacity: 1; }
+    50% { opacity: 0.5; }
+}
+
+/* Document cards */
+.doc-card {
+    background: var(--glass-bg);
+    border-radius: 12px;
+    padding: 1rem;
+    margin: 0.75rem 0;
+    border: 1px solid rgba(255, 255, 255, 0.1);
+    transition: all 0.3s ease;
+}
+
+.doc-card:hover {
+    transform: translateX(5px);
+    border-color: #667eea;
+    box-shadow: 0 4px 12px rgba(102, 126, 234, 0.2);
+}
+
+/* Responsive */
+@media (max-width: 768px) {
+    .header-title {
+        font-size: 2rem;
+    }
+    
+    .tab-nav button {
+        font-size: 0.9rem;
+        padding: 0.5rem 1rem;
+    }
+}
+"""
+
+def format_sources(sources: list) -> str:
+    """
+    Format source citations for display
+    
+    Args:
+        sources: List of source metadata
+        
+    Returns:
+        Formatted HTML string
+    """
+    if not sources:
+        return ""
+    
+    html = "<div style='margin-top: 1rem; padding-top: 1rem; border-top: 1px solid rgba(255,255,255,0.1);'>"
+    html += "<h4 style='color: #667eea; margin-bottom: 0.5rem;'>📚 Sumber:</h4>"
+    
+    for i, source in enumerate(sources, 1):
+        filename = source.get('filename', 'Unknown')
+        chunk_idx = source.get('chunk_index', 0)
+        preview = source.get('chunk_text', '')[:150]
+        
+        html += f"""
+        <div class='source-citation'>
+            <strong>#{i} {filename}</strong> (Chunk {chunk_idx})
+            <br><span style='color: rgba(255,255,255,0.7); font-size: 0.85rem;'>{preview}...</span>
+        </div>
+        """
+    
+    html += "</div>"
+    return html
+
+def format_file_size(size_bytes: int) -> str:
+    """Format file size in human-readable format"""
+    for unit in ['B', 'KB', 'MB', 'GB']:
+        if size_bytes < 1024.0:
+            return f"{size_bytes:.1f} {unit}"
+        size_bytes /= 1024.0
+    return f"{size_bytes:.1f} TB"
+
+def create_document_card(doc_info: dict) -> str:
+    """
+    Create HTML card for document display
+    
+    Args:
+        doc_info: Document information dictionary
+        
+    Returns:
+        HTML string
+    """
+    filename = doc_info.get('filename', 'Unknown')
+    num_chunks = doc_info.get('num_chunks', 0)
+    
+    html = f"""
+    <div class='doc-card'>
+        <div style='display: flex; justify-content: space-between; align-items: center;'>
+            <div>
+                <h4 style='margin: 0; color: #667eea;'>📄 {filename}</h4>
+                <p style='margin: 0.25rem 0 0 0; color: rgba(255,255,255,0.7); font-size: 0.9rem;'>
+                    {num_chunks} chunks
+                </p>
+            </div>
+        </div>
+    </div>
+    """
+    return html
+
+def create_status_message(message: str, status_type: str = "info") -> str:
+    """
+    Create styled status message
+    
+    Args:
+        message: Status message text
+        status_type: Type of status (success, error, info, warning)
+        
+    Returns:
+        HTML string
+    """
+    icons = {
+        "success": "✓",
+        "error": "✗",
+        "info": "ℹ",
+        "warning": "⚠"
+    }
+    
+    colors = {
+        "success": "#38ef7d",
+        "error": "#ff6b6b",
+        "info": "#667eea",
+        "warning": "#ffd93d"
+    }
+    
+    icon = icons.get(status_type, "ℹ")
+    color = colors.get(status_type, "#667eea")
+    
+    html = f"""
+    <div style='padding: 1rem; border-radius: 8px; background: rgba(255,255,255,0.05); 
+                border-left: 4px solid {color}; margin: 1rem 0;'>
+        <span style='color: {color}; font-weight: 600; font-size: 1.1rem;'>{icon} {message}</span>
+    </div>
+    """
+    return html

utils/vector_store.py

@@ -0,0 +1,187 @@
+"""
+Vector store management for document embeddings
+"""
+import os
+import json
+from typing import List, Dict, Optional
+from sentence_transformers import SentenceTransformer
+import chromadb
+from chromadb.config import Settings
+from config.model_config import config
+
+class VectorStore:
+    """Manage document embeddings and vector database"""
+    
+    def __init__(self):
+        """Initialize embedding model and vector database"""
+        print(f"Loading embedding model: {config.EMBEDDING_MODEL}")
+        self.embedding_model = SentenceTransformer(config.EMBEDDING_MODEL)
+        
+        # Initialize ChromaDB
+        self.client = chromadb.PersistentClient(
+            path=config.VECTOR_DB_DIR,
+            settings=Settings(anonymized_telemetry=False)
+        )
+        
+        # Get or create collection
+        self.collection = self.client.get_or_create_collection(
+            name="document_chunks",
+            metadata={"hnsw:space": "cosine"}
+        )
+        
+        # Metadata file to track documents
+        self.metadata_file = os.path.join(config.VECTOR_DB_DIR, "documents_metadata.json")
+        self.documents_metadata = self._load_metadata()
+    
+    def _load_metadata(self) -> Dict:
+        """Load documents metadata from file"""
+        if os.path.exists(self.metadata_file):
+            with open(self.metadata_file, 'r', encoding='utf-8') as f:
+                return json.load(f)
+        return {}
+    
+    def _save_metadata(self):
+        """Save documents metadata to file"""
+        os.makedirs(os.path.dirname(self.metadata_file), exist_ok=True)
+        with open(self.metadata_file, 'w', encoding='utf-8') as f:
+            json.dump(self.documents_metadata, f, ensure_ascii=False, indent=2)
+    
+    def create_embeddings(self, texts: List[str]) -> List[List[float]]:
+        """
+        Create embeddings for text chunks
+        
+        Args:
+            texts: List of text chunks
+            
+        Returns:
+            List of embedding vectors
+        """
+        embeddings = self.embedding_model.encode(texts, show_progress_bar=True)
+        return embeddings.tolist()
+    
+    def add_document(self, filename: str, chunks: List[str], metadata: Optional[Dict] = None):
+        """
+        Add document chunks to vector store
+        
+        Args:
+            filename: Name of the document
+            chunks: List of text chunks
+            metadata: Additional metadata about the document
+        """
+        if not chunks:
+            raise ValueError("No chunks provided")
+        
+        # Generate unique IDs for chunks
+        doc_id = filename.replace(" ", "_").replace(".", "_")
+        chunk_ids = [f"{doc_id}_chunk_{i}" for i in range(len(chunks))]
+        
+        # Create embeddings
+        print(f"Creating embeddings for {len(chunks)} chunks...")
+        embeddings = self.create_embeddings(chunks)
+        
+        # Prepare metadata for each chunk
+        chunk_metadata = []
+        for i, chunk in enumerate(chunks):
+            chunk_meta = {
+                "filename": filename,
+                "chunk_index": i,
+                "chunk_text": chunk[:200]  # Store preview
+            }
+            if metadata:
+                chunk_meta.update(metadata)
+            chunk_metadata.append(chunk_meta)
+        
+        # Add to collection
+        self.collection.add(
+            ids=chunk_ids,
+            embeddings=embeddings,
+            documents=chunks,
+            metadatas=chunk_metadata
+        )
+        
+        # Update documents metadata
+        self.documents_metadata[filename] = {
+            "num_chunks": len(chunks),
+            "doc_id": doc_id,
+            **(metadata or {})
+        }
+        self._save_metadata()
+        
+        print(f"✓ Added {len(chunks)} chunks from '{filename}' to vector store")
+    
+    def query(self, query_text: str, top_k: int = None) -> Dict:
+        """
+        Query vector store for relevant chunks
+        
+        Args:
+            query_text: Query string
+            top_k: Number of results to return
+            
+        Returns:
+            Dictionary with results
+        """
+        if top_k is None:
+            top_k = config.TOP_K_RETRIEVAL
+        
+        # Create query embedding
+        query_embedding = self.embedding_model.encode([query_text])[0].tolist()
+        
+        # Query collection
+        results = self.collection.query(
+            query_embeddings=[query_embedding],
+            n_results=top_k
+        )
+        
+        return {
+            "documents": results["documents"][0] if results["documents"] else [],
+            "metadatas": results["metadatas"][0] if results["metadatas"] else [],
+            "distances": results["distances"][0] if results["distances"] else []
+        }
+    
+    def delete_document(self, filename: str):
+        """
+        Delete all chunks of a document from vector store
+        
+        Args:
+            filename: Name of document to delete
+        """
+        if filename not in self.documents_metadata:
+            raise ValueError(f"Document '{filename}' not found")
+        
+        doc_id = self.documents_metadata[filename]["doc_id"]
+        
+        # Get all chunk IDs for this document
+        results = self.collection.get(
+            where={"filename": filename}
+        )
+        
+        if results["ids"]:
+            self.collection.delete(ids=results["ids"])
+            print(f"✓ Deleted {len(results['ids'])} chunks from '{filename}'")
+        
+        # Remove from metadata
+        del self.documents_metadata[filename]
+        self._save_metadata()
+    
+    def list_documents(self) -> List[Dict]:
+        """
+        List all documents in vector store
+        
+        Returns:
+            List of document metadata
+        """
+        return [
+            {"filename": name, **meta}
+            for name, meta in self.documents_metadata.items()
+        ]
+    
+    def clear_all(self):
+        """Clear all documents from vector store"""
+        self.client.delete_collection("document_chunks")
+        self.collection = self.client.get_or_create_collection(
+            name="document_chunks",
+            metadata={"hnsw:space": "cosine"}
+        )
+        self.documents_metadata = {}
+        self._save_metadata()
+        print("✓ Cleared all documents from vector store")