back to original code

Dockerfile

@@ -1,68 +1,24 @@
-# Use Python 3.9 slim image for better compatibility
-FROM python:3.9-slim
+# Dockerfile
 
-# Set environment variables to prevent Python from buffering stdout/stderr
-ENV PYTHONDONTWRITEBYTECODE=1
-ENV PYTHONUNBUFFERED=1
+# Use the official Python image with the desired version
+FROM python:3.9-slim
 
-# Set the working directory
+# Set the working directory inside the container
 WORKDIR /app
 
-# Install system dependencies that might be needed
-RUN apt-get update && apt-get install -y \
-    gcc \
-    g++ \
-    curl \
-    && rm -rf /var/lib/apt/lists/*
-
-# Create NLTK data directory with proper permissions
-RUN mkdir -p /usr/local/nltk_data && chmod 755 /usr/local/nltk_data
-ENV NLTK_DATA=/usr/local/nltk_data
-
-# Copy requirements first for better Docker layer caching
-COPY requirements.txt .
+# Copy the requirements file to the working directory
+COPY requirements.txt /app
 
-# Install Python dependencies with specific flags for stability
-RUN pip install --no-cache-dir --upgrade pip && \
-    pip install --no-cache-dir -r requirements.txt
+# Install the dependencies
+RUN pip install --no-cache-dir -r requirements.txt
 
-# Download all potentially needed NLTK data during build
-# This ensures we have permissions and avoids runtime download issues
-RUN python -c "import nltk; \
-    nltk.download('punkt', download_dir='/usr/local/nltk_data', quiet=True); \
-    nltk.download('punkt_tab', download_dir='/usr/local/nltk_data', quiet=True); \
-    nltk.download('stopwords', download_dir='/usr/local/nltk_data', quiet=True); \
-    nltk.download('averaged_perceptron_tagger', download_dir='/usr/local/nltk_data', quiet=True); \
-    print('NLTK data download completed successfully')"
+# Copy the rest of the application code to the working directory
+COPY app.py /app
 
-# Verify NLTK data was downloaded correctly
-RUN python -c "import nltk; \
-    try: \
-        nltk.data.find('tokenizers/punkt'); \
-        print('NLTK punkt tokenizer found successfully'); \
-    except LookupError: \
-        print('Warning: NLTK punkt tokenizer not found'); \
-        exit(1)"
-
-# Copy application code
-COPY app.py .
-
-# Create a non-root user for security but ensure they can access NLTK data
-RUN useradd -m -u 1000 appuser && \
-    chown -R appuser:appuser /app && \
-    chmod -R 755 /usr/local/nltk_data
-USER appuser
-
-# Expose the port
+# Expose the port that Gradio will run on (default is 7860)
 EXPOSE 7860
 
-# Set Gradio environment variables
 ENV GRADIO_SERVER_NAME="0.0.0.0"
-ENV GRADIO_SERVER_PORT="7860"
-
-# Health check to ensure the service is running
-HEALTHCHECK --interval=30s --timeout=30s --start-period=60s --retries=3 \
-    CMD curl -f http://localhost:7860/ || exit 1
 
-# Run the application
+# Command to run your application
 CMD ["python", "app.py"]

app.py

@@ -1,63 +1,32 @@
 import os
 import gradio as gr
-
-# Handle NLTK setup early with proper error handling
-try:
-    import nltk
-    # Ensure NLTK data is available, try to download if missing
-    try:
-        nltk.data.find('tokenizers/punkt')
-    except LookupError:
-        print("NLTK punkt tokenizer not found, attempting to download...")
-        try:
-            nltk.download('punkt', quiet=True)
-            nltk.download('punkt_tab', quiet=True)
-        except Exception as e:
-            print(f"Warning: Could not download NLTK data: {e}")
-            print("This may cause issues with text processing")
-except ImportError:
-    print("NLTK not available, continuing without it")
-
-# Now import LlamaIndex components
+from dotenv import load_dotenv 
 from llama_index.core import SimpleDirectoryReader, VectorStoreIndex
 from llama_index.embeddings.cohere import CohereEmbedding
 from llama_index.llms.groq import Groq
 from llama_parse import LlamaParse
 
-# API keys validation with clearer error messages
+# Load variables from .env file
+load_dotenv()
+
+# API keys
 llama_cloud_key = os.environ.get("LLAMA_CLOUD_API_KEY")
 groq_key = os.environ.get("GROQ_API_KEY")
 cohere_key = os.environ.get("COHERE_API_KEY")
+if not (llama_cloud_key and groq_key and cohere_key):
+    raise ValueError(
+        "API Keys not found! Ensure they are passed to the Docker container."
+    )
 
-if not llama_cloud_key:
-    raise ValueError("LLAMA_CLOUD_API_KEY environment variable is required")
-if not groq_key:
-    raise ValueError("GROQ_API_KEY environment variable is required")
-if not cohere_key:
-    raise ValueError("COHERE_API_KEY environment variable is required")
-
-# Model configuration
+# models name
 llm_model_name = "llama3-70b-8192"
 embed_model_name = "embed-english-v3.0"
 
 # Global variable for the vector index
 vector_index = None
 
-# Initialize components with error handling
-try:
-    # Initialize the parser
-    parser = LlamaParse(api_key=llama_cloud_key, result_type="markdown")
-    
-    # Initialize the Cohere embedding model
-    embed_model = CohereEmbedding(api_key=cohere_key, model_name=embed_model_name)
-    
-    # Initialize the LLM
-    llm = Groq(model=llm_model_name, api_key=groq_key)
-    
-    print("All models initialized successfully")
-except Exception as e:
-    print(f"Error initializing models: {e}")
-    raise
+# Initialize the parser
+parser = LlamaParse(api_key=llama_cloud_key, result_type="markdown")
 
 # Define file extractor with various common extensions
 file_extractor = {
@@ -76,169 +45,108 @@ file_extractor = {
     ".svg": parser,
 }
 
+# Initialize the Cohere embedding model
+embed_model = CohereEmbedding(api_key=cohere_key, model_name=embed_model_name)
+
+# Initialize the LLM
+llm = Groq(model="llama3-70b-8192", api_key=groq_key)
+
+
+# File processing function
 def load_files(file_path: str):
-    """Process uploaded files and create vector index"""
     global vector_index
-    
     if not file_path:
         return "No file path provided. Please upload a file."
     
-    # Validate file extension
-    valid_extensions = list(file_extractor.keys())
-    if not any(file_path.lower().endswith(ext) for ext in valid_extensions):
-        valid_exts_str = ', '.join(valid_extensions)
-        return f"Unsupported file type. Supported types: {valid_exts_str}"
+    valid_extensions = ', '.join(file_extractor.keys())
+    if not any(file_path.endswith(ext) for ext in file_extractor):
+        return f"The parser can only parse the following file types: {valid_extensions}"
+
+    document = SimpleDirectoryReader(input_files=[file_path], file_extractor=file_extractor).load_data()
+    vector_index = VectorStoreIndex.from_documents(document, embed_model=embed_model)
+    
+    print(f"Parsing completed for: {file_path}")
+    filename = os.path.basename(file_path)
+    return f"Ready to provide responses based on: {filename}"
 
-    try:
-        # Load and process document
-        print(f"Processing file: {file_path}")
-        document = SimpleDirectoryReader(
-            input_files=[file_path], 
-            file_extractor=file_extractor
-        ).load_data()
-        
-        # Create vector index
-        vector_index = VectorStoreIndex.from_documents(
-            document, 
-            embed_model=embed_model
-        )
-        
-        filename = os.path.basename(file_path)
-        success_msg = f"✅ Successfully processed: {filename}"
-        print(success_msg)
-        return success_msg
-        
-    except Exception as e:
-        error_msg = f"❌ Error processing file: {str(e)}"
-        print(error_msg)
-        return error_msg
 
+# Respond function
 def respond(message, history):
-    """Generate responses based on the uploaded document"""
     global vector_index
-    
     if vector_index is None:
-        yield "⚠️ Please upload and process a document first."
-        return
-
-    if not message.strip():
-        yield "⚠️ Please enter a question."
+        yield "Please upload a file first to begin the chat."
         return
 
     try:
-        # Create query engine
+        # Create a stateless query engine for each response
         query_engine = vector_index.as_query_engine(streaming=True, llm=llm)
         streaming_response = query_engine.query(message)
         
-        # Stream the response
+        # Stream the text response
         partial_text = ""
         for token in streaming_response.response_gen:
             partial_text += token
+            # Yield an empty string to cleanup the message textbox and the updated conversation history 
             yield partial_text
-            
     except Exception as e:
-        error_msg = f"❌ Error generating response: {str(e)}"
-        print(error_msg)
-        yield error_msg
+        print(f"An error occurred during chat: {e}")
+        yield "An error occurred while processing your request. Please try again."
+
 
+# Clear function
 def clear_state():
-    """Clear all application state"""
     global vector_index
     vector_index = None
-    return [None, "State cleared. Ready for new document.", None]
-
-# Create the Gradio interface with better error handling
-def create_interface():
-    """Create and configure the Gradio interface"""
+    return [None, None, None]
+
+
+# UI Setup
+with gr.Blocks(
+    theme=gr.themes.Monochrome(
+        primary_hue="indigo",
+        secondary_hue="blue",
+        font=[gr.themes.GoogleFont("Inter"), "system-ui", "sans-serif"],
+    ),
+    css="footer {visibility: hidden}",
+) as demo:
+    gr.Markdown("# Document Q&A 🤖📃")
     
-    # Use a more conservative theme configuration
-    theme = gr.themes.Soft(
-        primary_hue="blue",
-        secondary_hue="slate",
-    )
+    with gr.Row():
+        with gr.Column(scale=1, min_width=300):
+            gr.Markdown("### Controls")
+            file_input = gr.File(
+                file_count="single", type="filepath", label="Upload Document"
+            )
+            output = gr.Textbox(label="Status", interactive=False)
+            with gr.Row():
+                btn = gr.Button("1. Process Document", variant="primary", scale=2)
+                clear = gr.Button("Clear All", scale=1)
+
+        with gr.Column(scale=3):
+            chatbot = gr.ChatInterface(
+                fn=respond,
+                chatbot=gr.Chatbot(
+                    height=500,
+                    label="Chat Window",
+                ),
+                textbox=gr.Textbox(
+                    placeholder="2. Ask questions about the document here...",
+                    container=False,
+                    scale=7,
+                ),
+                submit_btn="Ask",
+                show_progress="full",
+            )
+
+    # Set up Gradio interactions
+    btn.click(fn=load_files, inputs=file_input, outputs=output)
     
-    # Create the interface
-    with gr.Blocks(theme=theme, title="Document Q&A") as demo:
-        gr.Markdown("# 🤖📃 Document Q&A Assistant")
-        gr.Markdown("Upload a document and ask questions about its content!")
-        
-        with gr.Row():
-            with gr.Column(scale=1, min_width=300):
-                gr.Markdown("### 📁 Document Upload")
-                
-                file_input = gr.File(
-                    file_count="single", 
-                    type="filepath", 
-                    label="Choose Document",
-                    file_types=[".pdf", ".docx", ".doc", ".txt", ".csv", ".xlsx", ".pptx", ".html"]
-                )
-                
-                status_output = gr.Textbox(
-                    label="📊 Status", 
-                    interactive=False,
-                    value="Ready to process documents..."
-                )
-                
-                with gr.Row():
-                    process_btn = gr.Button(
-                        "🔄 Process Document", 
-                        variant="primary", 
-                        scale=2
-                    )
-                    clear_btn = gr.Button("🗑️ Clear All", scale=1)
-
-            with gr.Column(scale=3):
-                gr.Markdown("### 💬 Chat Interface")
-                
-                # Use the older ChatInterface syntax for better compatibility
-                chatbot_interface = gr.ChatInterface(
-                    fn=respond,
-                    chatbot=gr.Chatbot(
-                        height=500,
-                        label="Conversation",
-                        show_copy_button=True
-                    ),
-                    textbox=gr.Textbox(
-                        placeholder="Ask questions about your document...",
-                        container=False,
-                        scale=7
-                    ),
-                    submit_btn="Send",
-                    retry_btn="🔄 Retry",
-                    undo_btn="↶ Undo",
-                    clear_btn="🗑️ Clear Chat"
-                )
-
-        # Wire up the event handlers
-        process_btn.click(
-            fn=load_files, 
-            inputs=[file_input], 
-            outputs=[status_output]
-        )
-        
-        clear_btn.click(
-            fn=clear_state,
-            outputs=[file_input, status_output, chatbot_interface.chatbot],
-            queue=False
-        )
-
-        return demo
+    clear.click(
+        fn=clear_state,  # Use the clear_state function 
+        outputs=[file_input, output, chatbot],
+        queue=False 
+    )
 
-# Main execution
+# Launch the demo
 if __name__ == "__main__":
-    try:
-        demo = create_interface()
-        print("Starting Gradio interface...")
-        
-        # Launch with more conservative settings
-        demo.launch(
-            server_name="0.0.0.0",
-            server_port=7860,
-            share=True,
-            show_error=True,  # This helps with debugging
-            quiet=False  # Show startup messages
-        )
-        
-    except Exception as e:
-        print(f"Failed to start application: {e}")
-        raise
+    demo.launch()

requirements.txt

@@ -1,19 +1,8 @@
-# Pin Gradio to a stable version that works well with LlamaIndex
-gradio>=4.0.0,<5.0.0
-
-# Pin LlamaIndex core and related packages to compatible versions
-llama-index>=0.9.0,<0.11.0
-llama-parse>=0.4.0,<0.5.0
-llama-index-llms-groq>=0.1.0,<0.2.0
-llama-index-embeddings-cohere>=0.1.0,<0.2.0
-
-# Pin PyTorch to avoid potential conflicts
-torch>=2.0.0,<2.2.0
-transformers>=4.30.0,<5.0.0
-
-# Add explicit dependencies that might be causing issues
-pydantic>=2.0.0,<3.0.0
-fastapi>=0.100.0,<1.0.0
-
-# Explicitly include NLTK with a compatible version
-nltk>=3.8,<4.0
+gradio
+python-dotenv
+llama-index
+llama-parse
+llama-index-llms-groq
+llama-index-embeddings-cohere
+torch
+transformers