Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,40 +1,894 @@
-import altair as alt
+import streamlit as st
+import re
 import numpy as np
+import plotly.express as px
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
 import pandas as pd
-import streamlit as st
+import io
+import time
+from typing import List, Dict, Any
+import PyPDF2
+import openpyxl
+from docx import Document
+import csv
 
-"""
-# Welcome to Streamlit!
+# Safe model loading without cache permission issues
+@st.cache_resource
+def load_sentence_transformer():
+    st.info("⚠️ Semantic chunking disabled in HuggingFace environment")
+    return None
 
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+@st.cache_resource
+def load_nltk():
+    try:
+        import nltk
+        try:
+            nltk.data.find('tokenizers/punkt')
+        except LookupError:
+            try:
+                nltk.download('punkt', quiet=True)
+            except:
+                pass  # Skip if download fails
+        return nltk
+    except ImportError:
+        return None
 
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
+class ProductionChunkVisualizer:
+    def __init__(self):
+        self.colors = [
+            '#FF6B6B', '#4ECDC4', '#45B7D1', '#96CEB4', '#FECA57',
+            '#FD79A8', '#A29BFE', '#6C5CE7', '#74B9FF', '#00B894'
+        ]
+        self.model = None
+        self.nltk = None
+    
+    def initialize_models(self):
+        """Lazy load models only when needed"""
+        if self.model is None:
+            self.model = load_sentence_transformer()
+        
+        if self.nltk is None:
+            self.nltk = load_nltk()
+    
+    def extract_text_from_pdf(self, pdf_file):
+        """Extract text from PDF file"""
+        try:
+            # Reset file pointer to beginning
+            pdf_file.seek(0)
+            pdf_reader = PyPDF2.PdfReader(pdf_file)
+            text = ""
+            
+            st.write(f"📄 Processing PDF with {len(pdf_reader.pages)} pages...")
+            
+            for page_num, page in enumerate(pdf_reader.pages):
+                try:
+                    page_text = page.extract_text()
+                    if page_text.strip():
+                        text += f"\n--- Page {page_num + 1} ---\n{page_text}\n"
+                except Exception as e:
+                    st.warning(f"Could not extract text from page {page_num + 1}: {str(e)}")
+            
+            if not text.strip():
+                st.warning("PDF appears to be image-based or empty. No text extracted.")
+                return "No extractable text found in PDF document."
+            
+            return text.strip()
+        except Exception as e:
+            st.error(f"Error reading PDF: {str(e)}")
+            return f"PDF processing error: {str(e)}"
+    
+    def extract_text_from_excel(self, excel_file):
+        """Extract text from Excel file"""
+        try:
+            # Reset file pointer to beginning
+            excel_file.seek(0)
+            
+            # Try different engines
+            try:
+                xl_data = pd.read_excel(excel_file, sheet_name=None, engine='openpyxl')
+            except:
+                try:
+                    xl_data = pd.read_excel(excel_file, sheet_name=None, engine='xlrd')
+                except:
+                    xl_data = pd.read_excel(excel_file, sheet_name=None)
+            
+            text = ""
+            sheet_count = len(xl_data)
+            st.write(f"📊 Processing Excel file with {sheet_count} sheet(s)...")
+            
+            for sheet_name, df in xl_data.items():
+                text += f"\n=== Sheet: {sheet_name} ===\n"
+                
+                if not df.empty:
+                    # Add column headers
+                    headers = " | ".join(str(col) for col in df.columns)
+                    text += f"Headers: {headers}\n"
+                    text += "-" * 50 + "\n"
+                    
+                    # Add data rows (limit to prevent massive output)
+                    max_rows = min(100, len(df))  # Limit to 100 rows per sheet
+                    for idx, row in df.head(max_rows).iterrows():
+                        row_text = " | ".join(str(val) if pd.notna(val) else "" for val in row)
+                        text += row_text + "\n"
+                    
+                    if len(df) > max_rows:
+                        text += f"... ({len(df) - max_rows} more rows)\n"
+                else:
+                    text += "Empty sheet\n"
+                
+                text += "\n"
+            
+            return text.strip()
+        except Exception as e:
+            st.error(f"Error reading Excel file: {str(e)}")
+            return f"Excel processing error: {str(e)}"
+    
+    def extract_text_from_csv(self, csv_file):
+        """Extract text from CSV file"""
+        try:
+            # Reset file pointer to beginning
+            csv_file.seek(0)
+            
+            # Try different encodings
+            for encoding in ['utf-8', 'latin-1', 'cp1252']:
+                try:
+                    csv_file.seek(0)
+                    df = pd.read_csv(csv_file, encoding=encoding)
+                    break
+                except UnicodeDecodeError:
+                    continue
+            else:
+                df = pd.read_csv(csv_file)  # Default encoding
+            
+            if df.empty:
+                return "Empty CSV file"
+            
+            st.write(f"📋 Processing CSV with {len(df)} rows and {len(df.columns)} columns...")
+            
+            # Create readable text format
+            text = "=== CSV Data ===\n"
+            headers = " | ".join(str(col) for col in df.columns)
+            text += f"Headers: {headers}\n"
+            text += "-" * 50 + "\n"
+            
+            # Limit rows to prevent massive output
+            max_rows = min(100, len(df))
+            for _, row in df.head(max_rows).iterrows():
+                row_text = " | ".join(str(val) if pd.notna(val) else "" for val in row)
+                text += row_text + "\n"
+            
+            if len(df) > max_rows:
+                text += f"... ({len(df) - max_rows} more rows)\n"
+            
+            return text.strip()
+        except Exception as e:
+            st.error(f"Error reading CSV file: {str(e)}")
+            return f"CSV processing error: {str(e)}"
+    
+    def extract_text_from_docx(self, docx_file):
+        """Extract text from Word document"""
+        try:
+            doc = Document(docx_file)
+            text = ""
+            
+            for paragraph in doc.paragraphs:
+                if paragraph.text.strip():
+                    text += paragraph.text + "\n"
+            
+            # Also extract text from tables
+            for table in doc.tables:
+                text += "\n=== Table ===\n"
+                for row in table.rows:
+                    row_text = " | ".join(cell.text.strip() for cell in row.cells)
+                    text += row_text + "\n"
+                text += "\n"
+            
+            return text.strip()
+        except Exception as e:
+            st.error(f"Error reading Word document: {str(e)}")
+            return ""
+    
+    def simple_sentence_split(self, text: str) -> List[str]:
+        """Fallback sentence splitting without NLTK"""
+        sentences = re.split(r'(?<=[.!?])\s+(?=[A-Z])', text)
+        return [s.strip() for s in sentences if s.strip()]
+    
+    def robust_sentence_split(self, text: str) -> List[str]:
+        """Use NLTK if available, fallback to regex"""
+        if self.nltk:
+            try:
+                return self.nltk.sent_tokenize(text)
+            except:
+                pass
+        return self.simple_sentence_split(text)
+    
+    def fixed_size_chunking(self, text: str, chunk_size: int, overlap_size: int = 0) -> List[Dict]:
+        """Split text into fixed-size chunks with word boundary respect"""
+        chunks = []
+        start = 0
+        
+        while start < len(text):
+            end = start + chunk_size
+            
+            if end >= len(text):
+                chunk = text[start:]
+            else:
+                chunk = text[start:end]
+                # Find last complete word
+                if not text[end].isspace():
+                    last_space = chunk.rfind(' ')
+                    if last_space > chunk_size * 0.7:
+                        chunk = chunk[:last_space]
+                        end = start + last_space
+            
+            if chunk.strip():
+                chunks.append({
+                    'text': chunk.strip(),
+                    'start': start,
+                    'end': end if end < len(text) else len(text),
+                    'method': 'Fixed Size',
+                    'word_count': len(chunk.split()),
+                    'char_count': len(chunk.strip())
+                })
+            
+            start = end - overlap_size
+            if start >= len(text):
+                break
+        
+        return chunks
+    
+    def sentence_chunking(self, text: str, sentences_per_chunk: int = 3) -> List[Dict]:
+        """Split text into sentence-based chunks"""
+        sentences = self.robust_sentence_split(text)
+        chunks = []
+        current_pos = 0
+        
+        for i in range(0, len(sentences), sentences_per_chunk):
+            chunk_sentences = sentences[i:i + sentences_per_chunk]
+            chunk_text = ' '.join(chunk_sentences)
+            
+            # Find actual position in original text
+            start_pos = text.find(chunk_sentences[0], current_pos)
+            if start_pos == -1:
+                start_pos = current_pos
+            
+            end_pos = start_pos + len(chunk_text)
+            current_pos = end_pos
+            
+            chunks.append({
+                'text': chunk_text,
+                'start': start_pos,
+                'end': min(end_pos, len(text)),
+                'method': 'Sentence-based',
+                'sentence_count': len(chunk_sentences),
+                'word_count': len(chunk_text.split()),
+                'char_count': len(chunk_text)
+            })
+        
+        return chunks
+    
+    def paragraph_chunking(self, text: str) -> List[Dict]:
+        """Split text by paragraph boundaries"""
+        paragraphs = re.split(r'\n\s*\n', text)
+        chunks = []
+        current_pos = 0
+        
+        for para in paragraphs:
+            para = para.strip()
+            if para:
+                start_pos = text.find(para, current_pos)
+                if start_pos == -1:
+                    start_pos = current_pos
+                
+                end_pos = start_pos + len(para)
+                
+                chunks.append({
+                    'text': para,
+                    'start': start_pos,
+                    'end': end_pos,
+                    'method': 'Paragraph-based',
+                    'paragraph_length': len(para),
+                    'word_count': len(para.split()),
+                    'char_count': len(para)
+                })
+                
+                current_pos = end_pos
+        
+        return chunks
+    
+    def semantic_chunking(self, text: str, similarity_threshold: float = 0.5) -> List[Dict]:
+        """Disabled semantic chunking - fallback to sentence-based"""
+        st.warning("Semantic chunking unavailable in this environment. Using sentence-based fallback.")
+        return self.sentence_chunking(text, 3)
+    
+    def recursive_chunking(self, text: str, max_chunk_size: int = 1000) -> List[Dict]:
+        """Hierarchical text splitting with multiple separators"""
+        separators = ["\n\n", "\n", ". ", "! ", "? ", "; ", ", ", " "]
+        
+        def _recursive_split(text: str, separators: List[str], max_size: int, depth: int = 0) -> List[str]:
+            if len(text) <= max_size or depth > len(separators):
+                return [text]
+            
+            separator = separators[0] if separators else " "
+            
+            if separator not in text:
+                if len(separators) > 1:
+                    return _recursive_split(text, separators[1:], max_size, depth + 1)
+                else:
+                    return [text[i:i+max_size] for i in range(0, len(text), max_size)]
+            
+            parts = text.split(separator)
+            result = []
+            current_chunk = ""
+            
+            for part in parts:
+                potential_chunk = current_chunk + part + separator
+                
+                if len(potential_chunk) <= max_size:
+                    current_chunk = potential_chunk
+                else:
+                    if current_chunk:
+                        result.append(current_chunk.rstrip(separator))
+                    
+                    if len(part) > max_size:
+                        result.extend(_recursive_split(part, separators[1:], max_size, depth + 1))
+                        current_chunk = ""
+                    else:
+                        current_chunk = part + separator
+            
+            if current_chunk:
+                result.append(current_chunk.rstrip(separator))
+            
+            return result
+        
+        split_texts = _recursive_split(text, separators, max_chunk_size)
+        chunks = []
+        current_pos = 0
+        
+        for chunk_text in split_texts:
+            if chunk_text.strip():
+                start_pos = text.find(chunk_text, current_pos)
+                if start_pos == -1:
+                    start_pos = current_pos
+                
+                end_pos = start_pos + len(chunk_text)
+                
+                chunks.append({
+                    'text': chunk_text,
+                    'start': start_pos,
+                    'end': end_pos,
+                    'method': 'Recursive',
+                    'max_size': max_chunk_size,
+                    'word_count': len(chunk_text.split()),
+                    'char_count': len(chunk_text)
+                })
+                
+                current_pos = end_pos
+        
+        return chunks
+    
+    def calculate_advanced_metrics(self, chunks: List[Dict]) -> Dict[str, Any]:
+        """Calculate comprehensive chunk metrics"""
+        if not chunks:
+            return {}
+        
+        char_counts = [chunk['char_count'] for chunk in chunks]
+        word_counts = [chunk['word_count'] for chunk in chunks]
+        
+        overlap_ratio = 0
+        if len(chunks) > 1:
+            total_chars = sum(char_counts)
+            text_length = max(chunk['end'] for chunk in chunks)
+            if text_length > 0:
+                overlap_ratio = max(0, (total_chars - text_length) / text_length)
+        
+        char_cv = np.std(char_counts) / np.mean(char_counts) if np.mean(char_counts) > 0 else 0
+        word_cv = np.std(word_counts) / np.mean(word_counts) if np.mean(word_counts) > 0 else 0
+        
+        return {
+            'total_chunks': len(chunks),
+            'avg_chars': np.mean(char_counts),
+            'std_chars': np.std(char_counts),
+            'min_chars': min(char_counts),
+            'max_chars': max(char_counts),
+            'avg_words': np.mean(word_counts),
+            'std_words': np.std(word_counts),
+            'char_cv': char_cv,
+            'word_cv': word_cv,
+            'overlap_ratio': overlap_ratio,
+            'size_consistency': 1 - char_cv,
+            'total_coverage': sum(chunk['end'] - chunk['start'] for chunk in chunks)
+        }
+    
+    def visualize_chunks_advanced(self, text: str, chunks: List[Dict]):
+        """Advanced chunk visualization"""
+        if not chunks:
+            st.write("No chunks to display")
+            return
+        
+        st.markdown("### 🎨 Interactive Chunk Visualization")
+        
+        for i, chunk in enumerate(chunks):
+            color = self.colors[i % len(self.colors)]
+            
+            words_per_sentence = chunk['word_count'] / max(1, chunk.get('sentence_count', 1))
+            
+            st.markdown(f"""
+            <div style='background: linear-gradient(135deg, {color}15, {color}25); 
+                        border-left: 5px solid {color}; 
+                        padding: 15px; 
+                        margin: 10px 0; 
+                        border-radius: 8px;
+                        box-shadow: 0 2px 4px rgba(0,0,0,0.1);'>
+                <div style='display: flex; justify-content: space-between; align-items: center; margin-bottom: 8px;'>
+                    <div style='color: {color}; font-weight: bold; font-size: 14px;'>
+                        CHUNK {i+1} • Position {chunk['start']}-{chunk['end']}
+                    </div>
+                    <div style='color: #666; font-size: 12px;'>
+                        {chunk['char_count']} chars • {chunk['word_count']} words
+                    </div>
+                </div>
+                <div style='color: #333; line-height: 1.6; font-size: 14px;'>
+                    {chunk['text'][:400]}{'...' if len(chunk['text']) > 400 else ''}
+                </div>
+                <div style='margin-top: 8px; color: #888; font-size: 11px;'>
+                    Quality: {words_per_sentence:.1f} words/sentence
+                </div>
+            </div>
+            """, unsafe_allow_html=True)
+    
+    def create_comprehensive_charts(self, all_results: Dict[str, List[Dict]]):
+        """Create detailed analysis charts"""
+        if not all_results:
+            return
+        
+        metrics_data = []
+        size_data = []
+        
+        for method, chunks in all_results.items():
+            metrics = self.calculate_advanced_metrics(chunks)
+            metrics_data.append({
+                'Method': method,
+                'Chunks': metrics.get('total_chunks', 0),
+                'Avg Size': metrics.get('avg_chars', 0),
+                'Consistency': metrics.get('size_consistency', 0),
+                'Overlap': metrics.get('overlap_ratio', 0)
+            })
+            
+            for chunk in chunks:
+                size_data.append({
+                    'Method': method,
+                    'Size': chunk['char_count'],
+                    'Words': chunk['word_count']
+                })
+        
+        fig = make_subplots(
+            rows=2, cols=2,
+            subplot_titles=(
+                'Chunk Count Comparison', 
+                'Size Consistency', 
+                'Size Distribution by Method',
+                'Words vs Characters'
+            ),
+            specs=[
+                [{"type": "bar"}, {"type": "bar"}],
+                [{"type": "box"}, {"type": "scatter"}]
+            ]
+        )
+        
+        df_metrics = pd.DataFrame(metrics_data)
+        df_sizes = pd.DataFrame(size_data)
+        
+        # Chart 1: Chunk counts
+        fig.add_trace(
+            go.Bar(x=df_metrics['Method'], y=df_metrics['Chunks'], 
+                   name='Chunk Count', marker_color='lightblue'),
+            row=1, col=1
+        )
+        
+        # Chart 2: Consistency scores
+        fig.add_trace(
+            go.Bar(x=df_metrics['Method'], y=df_metrics['Consistency'], 
+                   name='Consistency', marker_color='lightgreen'),
+            row=1, col=2
+        )
+        
+        # Chart 3: Size distribution box plots
+        for method in df_sizes['Method'].unique():
+            method_data = df_sizes[df_sizes['Method'] == method]
+            fig.add_trace(
+                go.Box(y=method_data['Size'], name=method, boxpoints='outliers'),
+                row=2, col=1
+            )
+        
+        # Chart 4: Words vs Characters scatter
+        for method in df_sizes['Method'].unique():
+            method_data = df_sizes[df_sizes['Method'] == method]
+            fig.add_trace(
+                go.Scatter(x=method_data['Words'], y=method_data['Size'], 
+                          mode='markers', name=method, opacity=0.7),
+                row=2, col=2
+            )
+        
+        fig.update_layout(height=800, showlegend=True)
+        fig.update_xaxes(tickangle=45)
+        
+        st.plotly_chart(fig, width='stretch')
 
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
+def main():
+    st.set_page_config(
+        page_title="Multi-Format RAG Chunk Visualizer",
+        page_icon="🔍",
+        layout="wide",
+        initial_sidebar_state="expanded"
+    )
+    
+    col1, col2 = st.columns([3, 1])
+    with col1:
+        st.title("🔍 Multi-Format RAG Chunk Visualizer")
+        st.markdown("**Professional chunking analysis with support for PDF, Excel, CSV, Word & Text files**")
+    
+    with col2:
+        if st.button("ℹ️ About", help="Learn about chunking strategies"):
+            with st.expander("Chunking Methods Explained", expanded=True):
+                st.markdown("""
+                **Fixed Size**: Splits text at character boundaries with word respect
+                **Sentence-based**: Groups sentences together for semantic coherence  
+                **Paragraph-based**: Respects document structure and topic boundaries
+                **Recursive**: Hierarchical splitting using multiple separators
+                
+                *Note: Semantic chunking disabled in this environment*
+                """)
+    
+    visualizer = ProductionChunkVisualizer()
+    
+    with st.sidebar:
+        st.header("⚙️ Configuration")
+        
+        input_method = st.radio(
+            "Choose input method:",
+            ["📝 Sample Text", "📁 Upload File", "✏️ Custom Input"],
+            help="Select how you want to provide text for analysis"
+        )
+        
+        sample_texts = {
+            "Research Paper Abstract": """Machine learning has fundamentally transformed the landscape of artificial intelligence research. Recent advances in deep learning architectures, particularly transformer-based models, have demonstrated unprecedented capabilities in natural language understanding and generation. These models leverage attention mechanisms to capture long-range dependencies in sequential data, enabling more sophisticated reasoning and contextual understanding. The implications extend beyond traditional NLP tasks to multimodal applications, including vision-language models and cross-modal reasoning systems. However, significant challenges remain in terms of computational efficiency, interpretability, and robustness to adversarial inputs.""",
+            
+            "Technical Documentation": """Installation Prerequisites: Before beginning the installation process, ensure your system meets the following requirements. Python 3.8 or higher must be installed with pip package manager available. Node.js version 16.x or later is required for frontend dependencies. Git version control system should be accessible from command line.\n\nStep 1: Repository Setup\nClone the project repository using the following command: git clone https://github.com/company/rag-system.git. Navigate to the project directory and create a virtual environment: python -m venv rag-env. Activate the virtual environment using the appropriate command for your operating system.\n\nStep 2: Dependency Installation\nInstall Python dependencies by running pip install -r requirements.txt. This will install all necessary packages including transformers, sentence-transformers, and streamlit. For development dependencies, additionally run pip install -r requirements-dev.txt.""",
+            
+            "Business Report": """Executive Summary: Q4 2024 Performance Analysis\n\nOur organization achieved exceptional growth in the fourth quarter of 2024, with revenue increasing by 42% year-over-year to reach $3.8 million. This growth was primarily driven by our expanded product portfolio and successful market penetration strategies in the enterprise segment.\n\nKey Performance Indicators demonstrate strong momentum across all business units. Customer acquisition costs decreased by 18% while customer lifetime value increased by 35%, indicating improved operational efficiency and customer satisfaction. Our newly launched AI-powered features contributed significantly to user engagement, with daily active users increasing by 67%.\n\nStrategic Initiatives for 2025 focus on international expansion and technology innovation. We plan to establish operations in three new markets: Germany, Japan, and Australia. Additionally, our R&D investment will increase by 50% to accelerate development of next-generation AI capabilities."""
+        }
+        
+        if input_method == "📝 Sample Text":
+            selected_sample = st.selectbox("Select sample text:", list(sample_texts.keys()))
+            text = sample_texts[selected_sample]
+            st.text_area("Preview:", value=text[:200] + "...", height=100, disabled=True)
+            
+        elif input_method == "📁 Upload File":
+            uploaded_file = st.file_uploader(
+                "Upload document", 
+                type=['txt', 'pdf', 'csv', 'xlsx', 'xls', 'docx'],
+                help="Supports: TXT, PDF, CSV, Excel (XLSX/XLS), Word (DOCX)"
+            )
+            
+            if uploaded_file:
+                file_type = uploaded_file.type
+                
+                with st.spinner(f"Processing {uploaded_file.name}..."):
+                    if file_type == "text/plain":
+                        text = str(uploaded_file.read(), "utf-8")
+                    elif file_type == "application/pdf":
+                        text = visualizer.extract_text_from_pdf(uploaded_file)
+                    elif file_type == "text/csv":
+                        text = visualizer.extract_text_from_csv(uploaded_file)
+                    elif file_type in ["application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", 
+                                       "application/vnd.ms-excel"]:
+                        text = visualizer.extract_text_from_excel(uploaded_file)
+                    elif file_type == "application/vnd.openxmlformats-officedocument.wordprocessingml.document":
+                        text = visualizer.extract_text_from_docx(uploaded_file)
+                    else:
+                        st.error(f"Unsupported file type: {file_type}")
+                        text = sample_texts["Research Paper Abstract"]
+                
+                if text and len(text.strip()) > 0:
+                    st.success(f"✅ Extracted {len(text)} characters from {uploaded_file.name}")
+                    if len(text) > 1000:
+                        st.text_area("Preview:", value=text[:500] + "...", height=100, disabled=True)
+                else:
+                    st.error("No text could be extracted from the file")
+                    text = sample_texts["Research Paper Abstract"]
+            else:
+                text = sample_texts["Research Paper Abstract"]
+                st.info("Using sample text until file is uploaded")
+        else:
+            text = st.text_area(
+                "Enter your text:", 
+                height=200, 
+                value=sample_texts["Business Document"],
+                help="Paste or type the text you want to analyze"
+            )
+        
+        st.divider()
+        
+        st.subheader("🔧 Chunking Methods")
+        
+        method_options = {
+            'Fixed Size': 'Character-based splitting with word boundaries',
+            'Sentence-based': 'Group by sentences for readability',
+            'Paragraph-based': 'Respect document structure',
+            'Recursive': 'Hierarchical splitting with multiple separators'
+        }
+        
+        selected_methods = []
+        for method, description in method_options.items():
+            if st.checkbox(method, value=method in ['Fixed Size', 'Sentence-based'], help=description):
+                selected_methods.append(method)
+        
+        if not selected_methods:
+            st.warning("⚠️ Select at least one chunking method")
+        
+        st.divider()
+        
+        st.subheader("⚙️ Parameters")
+        
+        params = {}
+        
+        if 'Fixed Size' in selected_methods:
+            st.markdown("**Fixed Size Settings**")
+            params['chunk_size'] = st.slider("Chunk size (characters)", 200, 2000, 800, step=50)
+            params['overlap'] = st.slider("Overlap (characters)", 0, 300, 100, step=25)
+        
+        if 'Sentence-based' in selected_methods:
+            st.markdown("**Sentence-based Settings**")
+            params['sentences_per_chunk'] = st.slider("Sentences per chunk", 1, 10, 4)
+        
+        if 'Recursive' in selected_methods:
+            st.markdown("**Recursive Settings**")
+            params['max_recursive_size'] = st.slider("Max chunk size", 500, 2000, 1200, step=100)
+        
+        with st.expander("🔬 Advanced Options"):
+            show_overlap_analysis = st.checkbox("Show overlap analysis", value=True)
+            show_quality_metrics = st.checkbox("Show quality metrics", value=True)
+            export_results = st.checkbox("Enable result export", value=False)
+    
+    if text and selected_methods:
+        with st.spinner("Processing chunks..."):
+            all_results = {}
+            
+            for method in selected_methods:
+                if method == 'Fixed Size':
+                    chunks = visualizer.fixed_size_chunking(
+                        text, params.get('chunk_size', 800), params.get('overlap', 100)
+                    )
+                elif method == 'Sentence-based':
+                    chunks = visualizer.sentence_chunking(
+                        text, params.get('sentences_per_chunk', 4)
+                    )
+                elif method == 'Paragraph-based':
+                    chunks = visualizer.paragraph_chunking(text)
+                elif method == 'Recursive':
+                    chunks = visualizer.recursive_chunking(
+                        text, params.get('max_recursive_size', 1200)
+                    )
+                
+                all_results[method] = chunks
+        
+        st.success(f"✅ Processed {len(text)} characters with {len(selected_methods)} methods")
+        
+        tabs = st.tabs([f"📊 {method}" for method in selected_methods] + ["📈 Comparison"])
+        
+        for i, (method, chunks) in enumerate(all_results.items()):
+            with tabs[i]:
+                metrics = visualizer.calculate_advanced_metrics(chunks)
+                
+                col1, col2, col3, col4, col5 = st.columns(5)
+                with col1:
+                    st.metric("Total Chunks", metrics.get('total_chunks', 0))
+                with col2:
+                    st.metric("Avg Characters", f"{metrics.get('avg_chars', 0):.0f}")
+                with col3:
+                    st.metric("Avg Words", f"{metrics.get('avg_words', 0):.0f}")
+                with col4:
+                    st.metric("Consistency", f"{metrics.get('size_consistency', 0):.2f}")
+                with col5:
+                    overlap_pct = metrics.get('overlap_ratio', 0) * 100
+                    st.metric("Overlap", f"{overlap_pct:.1f}%")
+                
+                visualizer.visualize_chunks_advanced(text, chunks)
+                
+                if len(chunks) > 1:
+                    sizes = [chunk['char_count'] for chunk in chunks]
+                    fig = px.histogram(
+                        x=sizes, nbins=min(20, len(chunks)),
+                        title=f"{method} - Chunk Size Distribution",
+                        labels={'x': 'Characters', 'y': 'Count'}
+                    )
+                    fig.update_layout(height=300)
+                    st.plotly_chart(fig, use_container_width=True)
+        
+        with tabs[-1]:
+            st.header("📈 Comprehensive Analysis")
+            
+            visualizer.create_comprehensive_charts(all_results)
+            
+            st.subheader("📊 Detailed Metrics Comparison")
+            
+            comparison_data = []
+            for method, chunks in all_results.items():
+                metrics = visualizer.calculate_advanced_metrics(chunks)
+                comparison_data.append({
+                    'Method': method,
+                    'Chunks': metrics.get('total_chunks', 0),
+                    'Avg Size': f"{metrics.get('avg_chars', 0):.0f}",
+                    'Size StdDev': f"{metrics.get('std_chars', 0):.0f}",
+                    'Consistency': f"{metrics.get('size_consistency', 0):.3f}",
+                    'Overlap %': f"{metrics.get('overlap_ratio', 0)*100:.1f}%"
+                })
+            
+            df_comparison = pd.DataFrame(comparison_data)
+            st.dataframe(df_comparison, use_container_width=True)
+            
+            st.subheader("🤖 Intelligent Recommendations")
+            
+            best_consistency = max(all_results.keys(), 
+                                 key=lambda m: visualizer.calculate_advanced_metrics(all_results[m]).get('size_consistency', 0))
+            
+            optimal_size_method = min(all_results.keys(),
+                                    key=lambda m: abs(visualizer.calculate_advanced_metrics(all_results[m]).get('avg_chars', 1000) - 600))
+            
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                st.success(f"🎯 **Most Consistent**: {best_consistency}")
+                consistency_score = visualizer.calculate_advanced_metrics(all_results[best_consistency]).get('size_consistency', 0)
+                st.write(f"Consistency score: {consistency_score:.3f}")
+            
+            with col2:
+                st.info(f"⚖️ **Optimal Size**: {optimal_size_method}")
+                avg_size = visualizer.calculate_advanced_metrics(all_results[optimal_size_method]).get('avg_chars', 0)
+                st.write(f"Average size: {avg_size:.0f} characters")
+            
+            st.markdown("### 💡 Use Case Recommendations")
+            
+            recommendations = {
+                "🔍 **Search & Retrieval**": "Use Fixed Size (600-800 chars) for consistent embedding",
+                "📚 **Document Processing**": "Use Paragraph-based to preserve structure", 
+                "🤖 **LLM Input**": "Use Fixed Size (800-1200 chars) for token management",
+                "📖 **Reading Comprehension**": "Use Sentence-based for natural flow",
+                "🔄 **Data Pipeline**": "Use Recursive for robust processing"
+            }
+            
+            for use_case, recommendation in recommendations.items():
+                st.markdown(f"- {use_case}: {recommendation}")
+            
+            if export_results:
+                st.subheader("📤 Export Results")
+                
+                report_data = {
+                    'text_length': len(text),
+                    'methods_used': list(all_results.keys()),
+                    'parameters': params,
+                    'results': {}
+                }
+                
+                for method, chunks in all_results.items():
+                    metrics = visualizer.calculate_advanced_metrics(chunks)
+                    report_data['results'][method] = {
+                        'chunks': len(chunks),
+                        'metrics': metrics,
+                        'chunk_details': chunks
+                    }
+                
+                import json
+                report_json = json.dumps(report_data, indent=2, default=str)
+                
+                col1, col2 = st.columns(2)
+                
+                with col1:
+                    st.download_button(
+                        "📋 Download Analysis Report (JSON)",
+                        data=report_json,
+                        file_name=f"chunk_analysis_{len(text)}_chars.json",
+                        mime="application/json"
+                    )
+                
+                with col2:
+                    markdown_report = f"""# Multi-Format Chunk Analysis Report
+                    
+## Text Analysis
+- **Length**: {len(text):,} characters
+- **Methods**: {', '.join(all_results.keys())}
+- **Date**: {pd.Timestamp.now().strftime('%Y-%m-%d %H:%M')}
 
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
+## Results Summary
+"""
+                    
+                    for method, chunks in all_results.items():
+                        metrics = visualizer.calculate_advanced_metrics(chunks)
+                        markdown_report += f"""
+### {method} Method
+- **Chunks**: {metrics.get('total_chunks', 0)}
+- **Average Size**: {metrics.get('avg_chars', 0):.0f} characters
+- **Consistency**: {metrics.get('size_consistency', 0):.3f}
+- **Overlap**: {metrics.get('overlap_ratio', 0)*100:.1f}%
+"""
+                    
+                    st.download_button(
+                        "📄 Download Summary (Markdown)",
+                        data=markdown_report,
+                        file_name=f"chunk_summary_{len(text)}_chars.md",
+                        mime="text/markdown"
+                    )
 
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
+    else:
+        st.markdown("""
+        ## 👋 Welcome to the Multi-Format RAG Chunk Visualizer
+        
+        This tool analyzes how different chunking strategies split your documents for RAG systems.
+        
+        ### 🚀 Supported File Formats
+        - **📄 PDF**: Research papers, reports, documentation
+        - **📊 Excel (XLSX/XLS)**: Spreadsheets, data tables, financial reports
+        - **📋 CSV**: Data exports, logs, structured datasets
+        - **📝 Word (DOCX)**: Business documents, proposals, manuscripts
+        - **📜 Text (TXT)**: Plain text files, code, notes
+        
+        ### 🎯 Key Features
+        - **4 chunking strategies** with real-time comparison
+        - **Advanced metrics** including consistency and overlap analysis
+        - **Interactive visualizations** with detailed chunk inspection
+        - **Export capabilities** for team collaboration
+        - **Professional recommendations** for different use cases
+        
+        ### 💡 Quick Start
+        1. **Upload your file** or use sample text
+        2. **Select chunking methods** to compare (2-3 recommended)
+        3. **Adjust parameters** for each method
+        4. **Analyze results** with comprehensive metrics
+        
+        ### 🔧 Chunking Methods Available
+        - **Fixed Size**: Consistent character-based chunks with word boundaries
+        - **Sentence-based**: Natural language flow with sentence grouping
+        - **Paragraph-based**: Document structure preservation
+        - **Recursive**: Hierarchical splitting with multiple separators
+        
+        **Note**: Semantic chunking temporarily disabled in this environment
+        
+        Select your settings in the sidebar to begin analysis! 👈
+        """)
+        
+        # Sample file format examples
+        st.subheader("📁 Example Use Cases")
+        
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            st.markdown("""
+            **📄 PDF Files**
+            - Research papers
+            - Technical manuals
+            - Legal documents
+            - Reports and presentations
+            """)
+        
+        with col2:
+            st.markdown("""
+            **📊 Excel/CSV Files**
+            - Data tables
+            - Survey results
+            - Financial reports
+            - Product catalogs
+            """)
+        
+        with col3:
+            st.markdown("""
+            **📝 Text/Word Files**
+            - Articles and blogs
+            - Meeting notes
+            - Technical documentation
+            - Business proposals
+            """)
 
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+if __name__ == "__main__":
+    main()