Comprehensive UI/UX and Architecture Improvements

UI Improvements:
Added a "Clear Chat" button in the sidebar that remains accessible regardless of scroll position
Styled the button to match the application's dark theme
Fixed button styling to ensure text appears on a single line
Fixed hover jolt issues by stabilizing collapse button position
Set sidebar to be collapsed by default for cleaner initial UI
Removed the "Deploy" button and other unnecessary Streamlit elements
Changed layout from "wide" to "centered" for better readability
Architecture Improvements:
Renamed and restructured files to better reflect their purposes (chatbot.py → backend.py, app.py → frontend.py)
Created a separate admin.py interface for administrative functions
Implemented proper authentication in the admin interface
Improved configuration management with centralized config handling
Enhanced error handling and logging throughout the application
Fixed URL parameter handling to use current Streamlit API (removing deprecated methods)
Functionality Enhancements:
Implemented document reindexing capabilities in the admin interface
Added proper session state management for chat history
Improved document loading and indexing processes
Added better documentation in code comments and markup
Optimized LlamaIndex integration for more efficient document retrieval
Enhanced error recovery mechanisms
Code Quality:
Refactored for better code organization and maintainability
Updated deprecated API calls to current versions
Improved exception handling across the application
Added proper logging for important events and user actions
Created cleaner separation between frontend and backend logic

.gitignore

@@ -4,7 +4,6 @@ __pycache__/
 *$py.class
 *.so
 .Python
-env/
 build/
 develop-eggs/
 dist/
@@ -21,22 +20,56 @@ wheels/
 .installed.cfg
 *.egg
 
-# Virtual Environment
+# Environment variables
+.env
+.venv
+env/
 venv/
 ENV/
-myenv/
 
-# IDE
+# Streamlit secrets
+.streamlit/secrets.toml
+
+# Data and indexes
+index/
+data/
+
+# Logs
+logs/
+*.log
+
+# IDE files
 .idea/
 .vscode/
 *.swp
 *.swo
-
-# Project specific
-.env
-index/
-cache/
 .DS_Store
 
-# Logs
-*.log 
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+.tox/
+.nox/
+.hypothesis/
+
+# Docker
+.docker/
+
+# Distribution / packaging
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+*.egg-info/
+.installed.cfg
+*.egg 

DEPLOYMENT.md

@@ -0,0 +1,298 @@
+# Deployment Guide for Document Chatbot
+
+This guide outlines the steps to deploy the Document Chatbot application to production using Docker and LlamaDeploy.
+
+## Deployment Options
+
+The Document Chatbot can be deployed in several ways:
+
+1. **Local Development**: Running directly with Streamlit (as described in the README)
+2. **Docker Containerization**: Packaging the application in Docker containers
+3. **LlamaDeploy**: Using LlamaIndex's deployment framework for production-grade hosting
+
+This guide focuses on options 2 and 3, which are most suitable for production environments.
+
+## Prerequisites
+
+- Docker and Docker Compose installed
+- GitHub account (for version control)
+- Anthropic API key
+- Basic familiarity with command line tools
+
+## Step 1: Setting Up Version Control with GitHub
+
+1. Initialize a Git repository and commit your code:
+   ```bash
+   git init
+   git add .
+   git commit -m "Initial commit"
+   ```
+
+2. Create a GitHub repository and push your code:
+   ```bash
+   git remote add origin <your-github-repo-url>
+   git push -u origin main
+   ```
+
+## Step 2: Dockerizing the Application
+
+### Create Dockerfile
+
+Create a `Dockerfile` in the project root:
+
+```dockerfile
+FROM python:3.9-slim
+
+WORKDIR /app
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the rest of the application
+COPY . .
+
+# Create directories if they don't exist
+RUN mkdir -p data index logs
+
+# Expose the port Streamlit will run on
+EXPOSE 8501
+
+# Set environment variables
+ENV PYTHONUNBUFFERED=1
+
+# Set up entry point
+ENTRYPOINT ["streamlit", "run"]
+CMD ["frontend.py"]
+```
+
+### Create Docker Compose File
+
+Create a `docker-compose.yml` file for managing multiple services:
+
+```yaml
+version: '3'
+
+services:
+  chatbot-frontend:
+    build: .
+    command: frontend.py
+    ports:
+      - "8501:8501"
+    volumes:
+      - ./data:/app/data
+      - ./index:/app/index
+      - ./logs:/app/logs
+    env_file:
+      - .env
+    restart: unless-stopped
+
+  chatbot-admin:
+    build: .
+    command: admin.py
+    ports:
+      - "8502:8501"
+    volumes:
+      - ./data:/app/data
+      - ./index:/app/index
+      - ./logs:/app/logs
+    env_file:
+      - .env
+    restart: unless-stopped
+```
+
+### Create .dockerignore File
+
+Create a `.dockerignore` file to exclude unnecessary files:
+
+```
+.git
+.gitignore
+.env
+__pycache__/
+*.py[cod]
+*$py.class
+.Python
+*.so
+.pytest_cache/
+.coverage
+htmlcov/
+.tox/
+.nox/
+.hypothesis/
+.idea/
+.vscode/
+```
+
+## Step 3: Setting Up Secrets Management
+
+1. Create a `.env.example` file with placeholders for required environment variables:
+   ```
+   ANTHROPIC_API_KEY=your_api_key_here
+   ```
+
+2. Ensure the actual `.env` file with real secrets is in `.gitignore`
+
+3. For Streamlit admin secrets, create a `.streamlit/secrets.toml.example`:
+   ```toml
+   admin_password = "example_password"
+   ```
+
+## Step 4: Deployment with Docker Compose
+
+1. Build and start the containers:
+   ```bash
+   docker-compose up -d
+   ```
+
+2. Access the applications:
+   - User interface: http://localhost:8501
+   - Admin interface: http://localhost:8502
+
+## Step 5: Production Deployment with LlamaDeploy
+
+For a production-grade deployment using LlamaDeploy, follow these steps:
+
+1. Install LlamaDeploy:
+   ```bash
+   pip install llama_deploy
+   ```
+
+2. Create a deployment script `deploy_llamadeploy.py`:
+
+```python
+from llama_deploy import LlamaDeploySDK
+from llama_deploy.types import WorkflowDefinition
+from llama_index.core import Settings
+from llama_index.llms.anthropic import Anthropic
+from backend import Chatbot
+import os
+
+# Get API key from environment
+api_key = os.environ.get("ANTHROPIC_API_KEY")
+if not api_key:
+    raise ValueError("ANTHROPIC_API_KEY environment variable is required")
+
+# Initialize the Chatbot
+chatbot = Chatbot()
+
+# Define a workflow for the query function
+def query_workflow(query_text: str) -> str:
+    """Execute a query against the chatbot backend."""
+    response = chatbot.query(query_text)
+    return response
+
+# Define a workflow for reindexing
+def reindex_workflow() -> str:
+    """Update the index with new documents."""
+    documents = chatbot.load_documents()
+    chatbot.update_index(documents)
+    return "Index updated successfully"
+
+# Initialize LlamaDeploy SDK
+sdk = LlamaDeploySDK()
+
+# Create workflow definitions
+query_definition = WorkflowDefinition(
+    name="document_query",
+    description="Query documents using the chatbot",
+    workflow_fn=query_workflow
+)
+
+reindex_definition = WorkflowDefinition(
+    name="reindex_documents",
+    description="Update the index with new documents",
+    workflow_fn=reindex_workflow
+)
+
+# Deploy workflows
+query_deployment = sdk.create_deployment(query_definition)
+reindex_deployment = sdk.create_deployment(reindex_definition)
+
+print(f"Query API endpoint: {query_deployment.endpoint}")
+print(f"Reindex API endpoint: {reindex_deployment.endpoint}")
+```
+
+3. Deploy your workflows:
+   ```bash
+   python deploy_llamadeploy.py
+   ```
+
+4. Create a production-ready frontend that connects to the LlamaDeploy endpoints.
+
+## Step 6: Continuous Integration and Deployment (CI/CD)
+
+Set up GitHub Actions for CI/CD by creating `.github/workflows/deploy.yml`:
+
+```yaml
+name: Deploy Document Chatbot
+
+on:
+  push:
+    branches: [ main ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Set up Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.9'
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -r requirements.txt
+      - name: Run tests
+        run: |
+          pytest
+
+  build-and-push:
+    needs: test
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v2
+      - name: Login to DockerHub
+        uses: docker/login-action@v2
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+      - name: Build and push
+        uses: docker/build-push-action@v4
+        with:
+          push: true
+          tags: yourusername/document-chatbot:latest
+```
+
+## Monitoring and Scaling
+
+1. **Monitoring**: Set up logging to a service like CloudWatch, DataDog, or Grafana
+2. **Scaling**: Consider using Kubernetes for production deployments with multiple replicas
+3. **Database-Backed Indexes**: For better persistence and scalability, consider switching to a database-backed vector store like PostgreSQL with pgvector
+
+## Security Considerations
+
+1. Use HTTPS for all production deployments
+2. Implement proper authentication using OAuth or similar
+3. Regularly update dependencies and scan for security vulnerabilities
+4. Restrict access to the admin interface through network controls
+
+## Cost Management
+
+1. Monitor API usage to control costs
+2. Consider caching common queries
+3. Use efficient embedding models to reduce computational costs
+4. Implement rate limiting to prevent abuse
+
+## Disaster Recovery
+
+1. Regularly backup your data directory and index
+2. Set up automatic failover where possible
+3. Document recovery procedures for various failure scenarios
+
+## Conclusion
+
+This deployment guide outlines the steps to move your Document Chatbot from local development to production. Each environment may require specific adaptations, so consider this a starting point for your deployment journey. 

Future_Improvements.md

@@ -0,0 +1,95 @@
+Future plans to help monitor bad responses so we can improve on replies.
+
+> **Note:** We've created an `architecture.md` file in the root directory that outlines our planned modular architecture and development practices. Please refer to that document for guidance on code organization as we implement these improvements.
+
+# LlamaIndex Capabilities to Leverage
+
+Looking at our current implementation and LlamaIndex's capabilities, here's what we're not using that could help with these issues:
+
+## Document Processing and Metadata:
+- We're using SimpleDirectoryReader but not extracting metadata
+- LlamaIndex has Document class with metadata support
+- We could add title, author, date, etc. during document loading
+
+## Response Quality:
+- We're using basic as_query_engine()
+- LlamaIndex has ResponseMode settings
+- We could use ResponseSynthesizer for better control
+- We could add SimilarityPostprocessor for filtering results
+
+## Feedback and Evaluation:
+- LlamaIndex has an Evaluation module
+- We could use ResponseEvaluator for measuring quality
+- We could implement FeedbackCallback for tracking user feedback
+
+## Document Structure:
+- We're using basic SentenceSplitter
+- LlamaIndex has more sophisticated parsers
+- We could use HierarchicalNodeParser for better structure
+
+# Feedback System Implementation Plan
+
+## Phase 1: Enhanced UI for Feedback Collection
+
+1. **Add Basic Feedback UI Components**
+   - Add thumbs up/down buttons after each answer
+   - Create a collapsible feedback form that appears on downvote
+   - Categories for feedback (incorrect, incomplete, irrelevant, other)
+   - Optional free-text field for detailed feedback
+
+2. **Modify Session Storage**
+   - Enhance `st.session_state.messages` to include feedback status
+   - Add temporary in-memory tracking of feedback during session
+
+## Phase 2: Persistent Storage Implementation
+
+1. **Create Database Schema**
+   - Design schema for Q&A pairs with feedback:
+     ```
+     conversations: id, timestamp, user_id(optional)
+     messages: id, conversation_id, role, content, timestamp
+     feedback: id, message_id, rating, category, comment, timestamp
+     ```
+
+2. **Add Database Integration**
+   - SQLite for local development (simple setup)
+   - Consider PostgreSQL for production
+   - Implement functions to save all conversations automatically
+
+3. **Implement Migration**
+   - Create a migration script to move existing session data to database
+   - Add proper indices for efficient queries
+
+## Phase 3: Feedback Analysis Tools
+
+1. **Create Admin Dashboard**
+   - Overview of feedback metrics
+   - Filter/sort capabilities (by date, rating, category)
+   - Export functionality
+
+2. **Implement LlamaIndex Evaluation Tools**
+   - Integrate `ResponseEvaluator` from LlamaIndex
+   - Compare ratings from users with automated scores
+   - Create quality metrics dashboard
+
+3. **Add Batch Analysis Tools**
+   - Identify patterns in negative feedback
+   - Group similar problematic questions
+   - Automated reporting for common issues
+
+## Phase 4: Continuous Improvement System
+
+1. **Implement Document Enhancement Process**
+   - Flag documents related to poor answers
+   - Create system for document refinement
+   - Track improvements over time
+
+2. **Add A/B Testing Capabilities**
+   - Test different retrieval strategies
+   - Compare different chunking strategies
+   - Evaluate response synthesis approaches
+
+3. **Implement Knowledge Gap Detection**
+   - Identify topics with consistent poor performance
+   - Suggest new documents needed to fill gaps
+   - Track coverage improvement over time

README.md

@@ -0,0 +1,112 @@
+# Document Chatbot
+
+A simple chatbot that can answer questions about your documents using LlamaIndex and Anthropic's Claude API.
+
+## Features
+
+- Document indexing and search using LlamaIndex
+- Natural language question answering using Claude API
+- Separate user and admin interfaces
+- Handles multiple document formats (PDF, TXT, etc.)
+- Dynamic document reindexing without restarting the application
+- Streamlined UI with persistent "Clear Chat" button 
+- Centered layout for improved readability
+
+## Setup
+
+1. Clone this repository:
+   ```
+   git clone <repository-url>
+   cd <repository-directory>
+   ```
+
+2. Install the required dependencies:
+   ```
+   pip install -r requirements.txt
+   ```
+
+3. Set up your Anthropic API key by creating a `.env` file with:
+   ```
+   ANTHROPIC_API_KEY=your-api-key
+   ```
+
+4. Place your documents in the `data` directory.
+
+5. (Optional) For the admin interface, create a `.streamlit/secrets.toml` file with:
+   ```
+   admin_password = "your-secure-password"
+   ```
+
+## Usage
+
+### User Interface
+
+1. Start the user interface:
+   ```
+   streamlit run frontend.py
+   ```
+
+2. Open your browser and navigate to `http://localhost:8501`
+
+3. Ask questions about your documents!
+
+### Admin Interface
+
+1. Start the admin interface:
+   ```
+   streamlit run admin.py
+   ```
+
+2. Enter the admin password (default is "admin" if not set in secrets)
+
+3. Use the admin interface to:
+   - Upload new documents
+   - Delete documents
+   - Update the index with new documents
+   - Rebuild the entire index
+   - View configuration settings
+
+## Interface Separation
+
+The application uses two separate interfaces:
+
+1. **User Interface (frontend.py)**: Simple chat interface for asking questions about documents. Users cannot modify documents or the index. Features include:
+   - Chat-based question answering
+   - Persistent "Clear Chat" button for easy history management
+   - Clean, distraction-free UI with hidden Streamlit elements
+   - Centered layout for improved readability
+
+2. **Admin Interface (admin.py)**: Protected interface for managing documents and the index. Features include:
+   - Document management (upload, delete)
+   - Index management (update, rebuild)
+   - Configuration settings
+   - System information
+
+This separation ensures that regular users can't accidentally modify documents or index settings.
+
+## Project Structure
+
+- `backend.py`: Core chatbot functionality and document processing
+- `frontend.py`: Streamlit web interface for users
+- `admin.py`: Streamlit admin interface for document management
+- `config.py`: Configuration settings
+- `utils/logging_config.py`: Logging configuration
+- `data/`: Directory for your documents
+- `index/`: Directory for the generated index (created automatically)
+- `architecture.md`: Detailed architecture documentation
+- `DEPLOYMENT.md`: Deployment instructions
+- `Future_Improvements.md`: Planned future enhancements
+
+## Configuration
+
+You can modify the chatbot settings in `config.py`, including:
+
+- LLM model settings (temperature, max tokens)
+- Embedding model settings
+- Chunking settings for document processing
+
+## Requirements
+
+- Python 3.7+
+- Anthropic API key
+- See `requirements.txt` for full dependencies

admin.py

@@ -0,0 +1,248 @@
+"""
+Admin interface for document management and reindexing.
+"""
+import streamlit as st
+import os
+import shutil
+from backend import Chatbot
+from utils.logging_config import setup_logging
+import config
+
+# Setup logging
+logger = setup_logging()
+
+# Set page config
+st.set_page_config(
+    page_title="Document Chatbot Admin",
+    page_icon="🔧",
+    layout="wide"
+)
+
+# Hide just the deploy button
+hide_deploy_button = """
+<style>
+button[kind="deploy"], 
+.stDeployButton {
+    display: none !important;
+}
+</style>
+"""
+st.markdown(hide_deploy_button, unsafe_allow_html=True)
+
+# Simple authentication
+def check_password():
+    """Returns `True` if the user had the correct password."""
+    def password_entered():
+        """Checks whether a password entered by the user is correct."""
+        try:
+            correct_password = st.secrets.get("admin_password", "admin")
+        except Exception:
+            # Fallback to default password if secrets are not available
+            correct_password = "admin"
+            
+        if st.session_state["password"] == correct_password:
+            st.session_state["password_correct"] = True
+            del st.session_state["password"]  # Don't store the password
+        else:
+            st.session_state["password_correct"] = False
+
+    if "password_correct" not in st.session_state:
+        # First run, show input for password
+        st.text_input(
+            "Password", type="password", on_change=password_entered, key="password"
+        )
+        return False
+    elif not st.session_state["password_correct"]:
+        # Password not correct, show input + error
+        st.text_input(
+            "Password", type="password", on_change=password_entered, key="password"
+        )
+        st.error("😕 Password incorrect")
+        return False
+    else:
+        # Password correct
+        return True
+
+# Initialize chatbot
+def initialize_chatbot():
+    if "chatbot" not in st.session_state:
+        with st.spinner("Initializing chatbot..."):
+            # Get configuration from config module
+            chatbot_config = config.get_chatbot_config()
+            
+            # Initialize chatbot
+            logger.info("Initializing chatbot...")
+            st.session_state.chatbot = Chatbot(chatbot_config)
+            
+            # Load documents and create index
+            documents = st.session_state.chatbot.load_documents()
+            st.session_state.chatbot.create_index(documents)
+            st.session_state.chatbot.initialize_query_engine()
+            logger.info("Chatbot initialized successfully")
+
+# Main admin interface
+if check_password():
+    # Initialize the chatbot
+    initialize_chatbot()
+    
+    # Admin header
+    st.title("🔧 Document Chatbot Admin")
+    st.markdown("""
+    This is the admin interface for managing documents and index settings.
+    """)
+    
+    # Tabs for different admin functions
+    tab1, tab2, tab3 = st.tabs(["Document Management", "Index Management", "Configuration"])
+    
+    # Document Management Tab
+    with tab1:
+        st.header("Document Management")
+        
+        # Show current documents
+        data_dir = "data"
+        col1, col2 = st.columns([3, 1])
+        
+        with col1:
+            st.subheader("Current Documents")
+            if os.path.exists(data_dir):
+                documents = [f for f in os.listdir(data_dir) if not f.startswith('.')]
+                if documents:
+                    for doc in documents:
+                        doc_col1, doc_col2 = st.columns([5, 1])
+                        doc_col1.write(f"📄 {doc}")
+                        if doc_col2.button("Delete", key=f"delete_{doc}"):
+                            try:
+                                os.remove(os.path.join(data_dir, doc))
+                                st.success(f"Deleted {doc}")
+                                st.rerun()
+                            except Exception as e:
+                                st.error(f"Error deleting {doc}: {str(e)}")
+                else:
+                    st.info("No documents found in data directory.")
+            else:
+                st.error("Data directory not found.")
+                if st.button("Create Data Directory"):
+                    os.makedirs(data_dir)
+                    st.success("Data directory created.")
+                    st.rerun()
+        
+        with col2:
+            st.subheader("Upload Document")
+            uploaded_file = st.file_uploader("Choose a file", type=["txt", "pdf", "docx", "md"])
+            
+            if uploaded_file is not None:
+                # Save the uploaded file
+                if not os.path.exists(data_dir):
+                    os.makedirs(data_dir)
+                
+                file_path = os.path.join(data_dir, uploaded_file.name)
+                with open(file_path, "wb") as f:
+                    f.write(uploaded_file.getbuffer())
+                
+                st.success(f"File {uploaded_file.name} saved successfully!")
+    
+    # Index Management Tab
+    with tab2:
+        st.header("Index Management")
+        
+        # Index Status
+        st.subheader("Index Status")
+        index_dir = "index"
+        if os.path.exists(index_dir):
+            index_files = os.listdir(index_dir)
+            if index_files:
+                st.write(f"Index exists with {len(index_files)} files")
+                total_size = sum(os.path.getsize(os.path.join(index_dir, f)) for f in index_files)
+                st.write(f"Total index size: {total_size/1024:.2f} KB")
+                
+                # Display index files
+                with st.expander("Index Files"):
+                    for file in index_files:
+                        st.write(f"- {file}: {os.path.getsize(os.path.join(index_dir, file))/1024:.2f} KB")
+            else:
+                st.warning("Index directory exists but is empty.")
+        else:
+            st.error("Index directory not found.")
+        
+        # Reindex Options
+        st.subheader("Reindex Options")
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            if st.button("Update Index", help="Add new documents to the existing index"):
+                with st.spinner("Updating index..."):
+                    try:
+                        # Load fresh documents
+                        documents = st.session_state.chatbot.load_documents()
+                        # Update the index with new documents
+                        st.session_state.chatbot.update_index(documents)
+                        st.success("Index updated successfully!")
+                        logger.info("Index updated successfully")
+                    except Exception as e:
+                        st.error(f"Error updating index: {str(e)}")
+                        logger.error(f"Error updating index: {e}")
+        
+        with col2:
+            if st.button("Rebuild Index", help="Delete and recreate the entire index"):
+                with st.spinner("Rebuilding index..."):
+                    try:
+                        # Delete index directory
+                        if os.path.exists(index_dir):
+                            shutil.rmtree(index_dir)
+                            os.makedirs(index_dir)
+                            logger.info("Index directory cleared")
+                        
+                        # Load documents and recreate index
+                        documents = st.session_state.chatbot.load_documents()
+                        st.session_state.chatbot.create_index(documents)
+                        st.session_state.chatbot.initialize_query_engine()
+                        
+                        st.success("Index rebuilt successfully!")
+                        logger.info("Index rebuilt successfully")
+                    except Exception as e:
+                        st.error(f"Error rebuilding index: {str(e)}")
+                        logger.error(f"Error rebuilding index: {e}")
+    
+    # Configuration Tab
+    with tab3:
+        st.header("Configuration")
+        
+        # Display current configuration
+        st.subheader("Current Configuration")
+        chatbot_config = config.get_chatbot_config()
+        
+        # LLM Settings
+        st.write("#### LLM Settings")
+        llm_col1, llm_col2 = st.columns(2)
+        
+        model = llm_col1.text_input("Model", value=chatbot_config.get("model", "claude-3-7-sonnet-20250219"))
+        temperature = llm_col2.slider("Temperature", min_value=0.0, max_value=1.0, value=chatbot_config.get("temperature", 0.1), step=0.1)
+        
+        # Embedding Settings
+        st.write("#### Embedding Settings")
+        emb_col1, emb_col2 = st.columns(2)
+        
+        embedding_model = emb_col1.text_input("Embedding Model", value=chatbot_config.get("embedding_model", "sentence-transformers/all-MiniLM-L6-v2"))
+        device = emb_col2.selectbox("Device", options=["cpu", "cuda"], index=0 if chatbot_config.get("device", "cpu") == "cpu" else 1)
+        
+        # Text Splitter Settings
+        st.write("#### Text Splitter Settings")
+        split_col1, split_col2 = st.columns(2)
+        
+        chunk_size = split_col1.number_input("Chunk Size", min_value=100, max_value=4096, value=chatbot_config.get("chunk_size", 1024), step=100)
+        chunk_overlap = split_col2.number_input("Chunk Overlap", min_value=0, max_value=1000, value=chatbot_config.get("chunk_overlap", 100), step=10)
+        
+        # Save Configuration Button
+        if st.button("Save Configuration"):
+            st.warning("Configuration saving is not implemented yet.")
+            # In a real implementation, you would update the config file or database
+
+    # Footer
+    st.markdown("---")
+    st.markdown("⚠️ **Note**: This admin interface should be protected and not accessible to regular users.")
+    
+else:
+    # Show login screen only
+    st.title("🔧 Document Chatbot Admin")
+    st.markdown("Please enter the password to access the admin interface.") 

app.py

@@ -1,6 +1,13 @@
+"""
+Streamlit web interface for the chatbot application.
+"""
 import streamlit as st
 from chatbot import Chatbot
-import time
+from utils.logging_config import setup_logging
+import config
+
+# Setup logging
+logger = setup_logging()
 
 # Set page config
 st.set_page_config(
@@ -16,20 +23,18 @@ if "messages" not in st.session_state:
 # Initialize chatbot
 if "chatbot" not in st.session_state:
     with st.spinner("Initializing chatbot..."):
-        config = {
-            "model": "claude-3-7-sonnet-20250219",
-            "temperature": 0.1,
-            "max_tokens": 2048,
-            "embedding_model": "sentence-transformers/all-MiniLM-L6-v2",
-            "device": "cpu",
-            "embed_batch_size": 8,
-            "chunk_size": 1024,
-            "chunk_overlap": 100
-        }
-        st.session_state.chatbot = Chatbot(config)
-        st.session_state.chatbot.load_documents()
-        st.session_state.chatbot.create_index(st.session_state.chatbot.load_documents())
+        # Get configuration from config module
+        chatbot_config = config.get_chatbot_config()
+        
+        # Initialize chatbot
+        logger.info("Initializing chatbot...")
+        st.session_state.chatbot = Chatbot(chatbot_config)
+        
+        # Load documents and create index
+        documents = st.session_state.chatbot.load_documents()
+        st.session_state.chatbot.create_index(documents)
         st.session_state.chatbot.initialize_query_engine()
+        logger.info("Chatbot initialized successfully")
 
 # Title and description
 st.title("📚 Document Chatbot")
@@ -53,9 +58,11 @@ if prompt := st.chat_input("What would you like to know?"):
     # Get chatbot response
     with st.chat_message("assistant"):
         with st.spinner("Thinking..."):
+            logger.info(f"User query: {prompt}")
             response = st.session_state.chatbot.query(prompt)
             st.markdown(response)
             st.session_state.messages.append({"role": "assistant", "content": response})
+            logger.info("Response provided to user")
 
 # Sidebar with information
 with st.sidebar:
@@ -72,4 +79,5 @@ with st.sidebar:
     # Add a clear chat button
     if st.button("Clear Chat History"):
         st.session_state.messages = []
+        logger.info("Chat history cleared")
         st.rerun() 

architecture.md

@@ -0,0 +1,305 @@
+# Document Chatbot Architecture
+
+This document describes the architecture of the Document Chatbot application, its key components, and design decisions.
+
+## Application Components
+
+The application follows a clear separation of concerns with separate frontend and admin interfaces:
+
+### User Interface (`frontend.py`)
+
+- Built with Streamlit
+- Provides a chat-like interface for user interaction
+- Focused solely on the chat experience
+- Streamlined UI with hidden Streamlit elements
+- Centered layout for improved readability
+- Persistent "Clear Chat" button in collapsible sidebar
+- Maintains session state for consistent user experience
+
+### Admin Interface (`admin.py`)
+
+- Separate Streamlit application with password protection
+- Provides administrative functionality:
+  - Document management (upload, delete)
+  - Index management (update, rebuild)
+  - Configuration settings
+  - System information
+- Organized into tabs for different functionality
+- Protected with a simple password authentication system
+
+### Backend (`backend.py`)
+
+- Core chatbot functionality
+- Handles document loading, indexing, and querying
+- Manages the LlamaIndex and Claude API interactions
+- Implements error handling and retry logic
+- Provides document reindexing capabilities
+- Shared by both the user and admin interfaces
+
+### Configuration (`config.py`)
+
+- Centralizes application settings
+- Manages API keys and model parameters
+- Configures embedding and chunking settings
+
+### Utilities
+
+- Logging configuration
+- Helper functions
+
+## Data Flow
+
+### User Interface Flow
+
+1. User submits a question through the Streamlit UI
+2. The frontend passes the question to the backend
+3. The backend:
+   - Processes the question
+   - Retrieves relevant documents from the index
+   - Generates a response using the Claude API
+4. The response is displayed to the user in the UI
+
+### Admin Interface Flow
+
+1. Admin enters password to access the interface
+2. Admin manages documents and index:
+   - Uploads new documents to the data directory
+   - Deletes existing documents 
+   - Updates the index with new documents
+   - Rebuilds the index completely if needed
+3. Admin views system information and configuration settings
+
+## Document Indexing System
+
+The application includes a dynamic document indexing system that allows adding new documents without disrupting the service.
+
+### How Document Indexing Works
+
+1. **Document Loading**: The `load_documents()` method in `backend.py` uses LlamaIndex's `SimpleDirectoryReader` to read all documents from the `data` directory.
+
+2. **Index Management**: 
+   - If no index exists, `create_index()` creates a new one
+   - For adding new documents, `update_index()` adds them to the existing index
+
+3. **Efficient Updates**: 
+   - The `update_index()` method inserts each new document into the existing index
+   - Only new documents are processed, avoiding rebuilding the entire index
+   - The updated index is persisted to disk
+
+4. **Admin Interface**: 
+   - The admin interface provides buttons for updating or rebuilding the index
+   - Document uploading and deletion happens in the admin interface
+   - Success/failure feedback is displayed to the admin
+
+### Benefits of the Approach
+
+- **Role Separation**: Users interact with content while admins manage it
+- **Zero Downtime**: Users can continue using the application during reindexing
+- **Efficiency**: Only processes new documents instead of rebuilding the entire index
+- **Security**: Administrative functions are protected by authentication
+
+## Authentication
+
+The admin interface uses a simple password-based authentication system:
+
+1. Password is stored in `.streamlit/secrets.toml`
+2. Default password is "admin" if not set in secrets
+3. Session state is used to track authentication status
+
+This provides basic security to prevent unauthorized access to administrative functions.
+
+## Future Considerations
+
+For larger-scale deployments:
+
+1. **Database-Backed Indices**: Switch to PostgreSQL-backed vector store for better concurrency
+2. **Background Processing**: Move reindexing to background tasks for larger document sets
+3. **API-Based Architecture**: Separate frontend and backend completely with REST API
+4. **Enhanced Authentication**: Implement more robust authentication using OAuth or SAML
+5. **Document Change Detection**: Implement file system watchers for automatic reindexing
+
+## Design Decisions
+
+1. **Separate Interfaces**: Creating distinct interfaces for users and admins ensures clean separation of concerns
+
+2. **LlamaIndex for Document Processing**: Chosen for its powerful document handling capabilities and simple API
+
+3. **Claude API for Question Answering**: Selected for high-quality responses and good context handling
+
+4. **Streamlit for UI**: Allows for rapid development of interactive interfaces with minimal code
+
+5. **Simple Folder-Based Document Storage**: Prioritizes ease of use over complex document management
+
+6. **UI Optimization**: 
+   - Centered layout for improved readability
+   - Hidden deployment buttons and unnecessary Streamlit elements
+   - Persistent "Clear Chat" button in collapsible sidebar
+   - Consistent styling and color scheme
+
+## Ideal File Organization & Structure
+
+We aim to maintain a modular, well-organized codebase with these principles:
+
+### File Size Guidelines
+- **Python files**: 300-500 lines maximum
+- **Single modules/classes**: 100-200 lines
+- **Functions**: Under 50 lines each
+
+Keeping files within these limits improves:
+- Code navigation and readability
+- Mental model of component relationships
+- Ability to make targeted changes
+- Testing and maintenance
+
+### Recommended Directory Structure
+
+```
+llamaindex-app/
+├── frontend.py             # Streamlit frontend interface
+├── backend.py              # Runnable backend with CLI interface
+├── config.py               # Configuration settings
+├── requirements.txt        # Dependencies
+├── .env                    # Environment variables (not in git)
+├── architecture.md         # This document
+├── Future_Improvements.md  # Planned improvements
+├── chatbot/                # Additional chatbot modules (future)
+│   ├── __init__.py
+│   ├── document_loader.py  # Document processing (future)
+│   └── llm.py              # LLM configuration (future)
+├── database/               # Database functionality
+│   ├── __init__.py
+│   ├── models.py           # Database schema models (future)
+│   ├── repository.py       # Data access layer (future)
+│   └── migrations/         # Database migrations (future)
+├── feedback/               # Feedback system
+│   ├── __init__.py
+│   ├── collector.py        # UI and gathering functions (future)
+│   ├── storage.py          # Saving feedback data (future)
+│   └── analysis.py         # Feedback analysis tools (future)
+├── admin/                  # Admin dashboard
+│   ├── __init__.py
+│   ├── dashboard.py        # Main admin interface (future)
+│   └── reports.py          # Reporting functionality (future)
+├── utils/                  # Shared utilities
+│   ├── __init__.py
+│   ├── logging_config.py   # Logging configuration
+│   └── helpers.py          # Common helper functions (future)
+├── data/                   # Your document data
+├── index/                  # Vector index storage
+└── tests/                  # Test suite
+    ├── test_config.py      # Config module tests
+    ├── test_chatbot.py     # Chatbot tests (future)
+    └── test_feedback.py    # Feedback tests (future)
+```
+
+## Architecture Principles
+
+### 1. Frontend/Backend Separation
+- `frontend.py` provides a web interface using Streamlit
+- `backend.py` contains the core chatbot logic and a CLI interface
+- Both can be run independently depending on user needs
+
+### 2. Dependency Injection
+- Components receive dependencies rather than creating them
+- Makes testing and switching implementations easier
+- Facilitates mocking for unit tests
+
+### 3. Deployment Options
+- Run just the backend for command-line interaction
+- Run the frontend for a web-based interface
+- Both use the same underlying chatbot functionality
+
+### 4. Configuration Management
+- External configuration for environment-specific settings
+- Environment variables for sensitive data
+- Config files for application settings
+
+### 5. Database Abstraction
+- Repository pattern to abstract database operations
+- Migration system for schema changes
+- ORM for database portability
+
+## Cloud-Ready Development Practices
+
+To ensure smooth transition to cloud hosting:
+
+### 1. Environment Configuration
+- Use `.env` files locally
+- Design for environment variables in production
+- Create a `config.py` that handles both scenarios
+
+```python
+# Example config.py approach
+import os
+from dotenv import load_dotenv
+
+# Load .env file if it exists
+load_dotenv()
+
+# Configuration with fallbacks
+DATABASE_URL = os.getenv("DATABASE_URL", "sqlite:///local.db")
+API_KEY = os.getenv("ANTHROPIC_API_KEY")
+DEBUG = os.getenv("DEBUG", "False").lower() == "true"
+```
+
+### 2. Database Strategy
+- Use SQLite locally but design for PostgreSQL/MySQL
+- Use SQLAlchemy as ORM for database portability
+- Implement connection pooling for production
+
+### 3. File Storage
+- Design with cloud storage in mind (S3-compatible interface)
+- Abstract file operations behind a service interface
+- Plan for distributed storage in production
+
+### 4. Stateless Design
+- Don't rely on local file system for temporary storage
+- Use database or distributed cache for shared state
+- Design components to be horizontally scalable
+
+### 5. Containerization
+- Use Docker during development
+- Create a Dockerfile and docker-compose.yml early
+- Plan for orchestration (Kubernetes, ECS) in production
+
+## Implementation Roadmap
+
+1. **Refactoring (Current Phase)**
+   - Move `chatbot.py` functionality into organized modules
+   - Implement basic dependency injection
+   - Setup configuration management
+
+2. **Database Integration**
+   - Implement SQLAlchemy models for feedback
+   - Create repository classes for data access
+   - Add migration system (Alembic)
+
+3. **Feedback System**
+   - Add UI components for feedback
+   - Connect to database layer
+   - Implement storage and retrieval
+
+4. **Analysis Tools**
+   - Build admin dashboard
+   - Implement feedback analysis functions
+   - Create reporting capabilities
+
+## Deployment Considerations
+
+### Development Environment
+- Local development with SQLite
+- Environment variables for secrets
+- Local vector index storage
+
+### Production Environment
+- Cloud hosting (AWS, Azure, GCP)
+- Managed database service
+- Vector database service or optimized self-hosted
+- Container orchestration for scaling
+
+## Monitoring and Maintenance
+
+- Implement logging throughout the application
+- Track key metrics (response times, user feedback)
+- Regular database backups
+- Version control for document corpus and vector indices 

backend.py

@@ -0,0 +1,270 @@
+from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, Settings
+from llama_index.llms.anthropic import Anthropic
+from llama_index.embeddings.huggingface import HuggingFaceEmbedding
+from llama_index.core.node_parser import SentenceSplitter
+from llama_index.core.callbacks import CallbackManager, LlamaDebugHandler
+from llama_index.core import StorageContext, load_index_from_storage
+import logging
+import os
+from dotenv import load_dotenv
+import time
+from typing import Optional, Dict, Any, List
+from tqdm import tqdm
+
+# Set up logging to track what the chatbot is doing
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+# Disable tokenizer parallelism warnings
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+
+# Create a directory for storing the index
+INDEX_DIR = "index"
+if not os.path.exists(INDEX_DIR):
+    os.makedirs(INDEX_DIR)
+
+class Chatbot:
+    def __init__(self, config: Optional[Dict[str, Any]] = None):
+        """Initialize the chatbot with configuration."""
+        # Set up basic variables and load configuration
+        self.config = config or {}
+        self.api_key = self._get_api_key()
+        self.index = None
+        self.query_engine = None
+        self.llm = None
+        self.embed_model = None
+        
+        # Set up debugging tools to help track any issues
+        self.debug_handler = LlamaDebugHandler(print_trace_on_end=True)
+        self.callback_manager = CallbackManager([self.debug_handler])
+        
+        # Set up all the components needed for the chatbot
+        self._initialize_components()
+        
+    def _get_api_key(self) -> str:
+        """Get API key from environment or config."""
+        # Load the API key from environment variables or config file
+        load_dotenv()
+        api_key = os.getenv("ANTHROPIC_API_KEY") or self.config.get("api_key")
+        if not api_key:
+            raise ValueError("API key not found in environment or config")
+        return api_key
+    
+    def _initialize_components(self):
+        """Initialize all components with proper error handling."""
+        try:
+            # Set up the language model (Claude) with our settings
+            logger.info("Setting up Claude language model...")
+            self.llm = Anthropic(
+                api_key=self.api_key,
+                model=self.config.get("model", "claude-3-7-sonnet-20250219"),
+                temperature=self.config.get("temperature", 0.1),
+                max_tokens=self.config.get("max_tokens", 2048)  # Allow for longer responses
+            )
+            
+            # Set up the model that converts text into numbers (embeddings)
+            logger.info("Setting up text embedding model...")
+            self.embed_model = HuggingFaceEmbedding(
+                model_name=self.config.get("embedding_model", "sentence-transformers/all-MiniLM-L6-v2"),
+                device=self.config.get("device", "cpu"),
+                embed_batch_size=self.config.get("embed_batch_size", 8)
+            )
+            
+            # Configure all the settings for the chatbot
+            logger.info("Configuring chatbot settings...")
+            Settings.embed_model = self.embed_model
+            Settings.text_splitter = SentenceSplitter(
+                chunk_size=self.config.get("chunk_size", 1024),
+                chunk_overlap=self.config.get("chunk_overlap", 100),
+                paragraph_separator="\n\n"
+            )
+            Settings.llm = self.llm
+            Settings.callback_manager = self.callback_manager
+            
+            logger.info("Components initialized successfully")
+            
+        except Exception as e:
+            logger.error(f"Error initializing components: {e}")
+            raise
+    
+    def load_documents(self, data_dir: str = "data"):
+        """Load documents with retry logic."""
+        # Try to load documents up to 3 times if there's an error
+        max_retries = 3
+        retry_delay = 1
+        
+        for attempt in range(max_retries):
+            try:
+                logger.info(f"Loading documents from {data_dir}...")
+                documents = SimpleDirectoryReader(data_dir).load_data()
+                logger.info(f"Loaded {len(documents)} documents")
+                return documents
+            except Exception as e:
+                if attempt < max_retries - 1:
+                    logger.warning(f"Attempt {attempt + 1} failed: {e}. Retrying in {retry_delay} seconds...")
+                    time.sleep(retry_delay)
+                else:
+                    logger.error(f"Failed to load documents after {max_retries} attempts: {e}")
+                    raise
+    
+    def create_index(self, documents):
+        """Create index with error handling."""
+        try:
+            # Check if index already exists
+            if os.path.exists(os.path.join(INDEX_DIR, "index.json")):
+                logger.info("Loading existing index...")
+                storage_context = StorageContext.from_defaults(persist_dir=INDEX_DIR)
+                self.index = load_index_from_storage(storage_context)
+                logger.info("Index loaded successfully")
+                return
+            
+            # Create a new index if none exists
+            logger.info("Creating new index...")
+            with tqdm(total=1, desc="Creating searchable index") as pbar:
+                self.index = VectorStoreIndex.from_documents(documents)
+                # Save the index
+                self.index.storage_context.persist(persist_dir=INDEX_DIR)
+                pbar.update(1)
+            logger.info("Index created and saved successfully")
+        except Exception as e:
+            logger.error(f"Error creating/loading index: {e}")
+            raise
+    
+    def update_index(self, new_documents: List):
+        """Update existing index with new documents without rebuilding.
+        
+        Args:
+            new_documents: List of new documents to add to the index
+            
+        Returns:
+            None, updates self.index in place
+        """
+        try:
+            if self.index is None:
+                logger.warning("No existing index found. Creating new index instead.")
+                self.create_index(new_documents)
+                return
+                
+            logger.info(f"Updating index with {len(new_documents)} new documents...")
+            with tqdm(total=1, desc="Updating searchable index") as pbar:
+                # Insert the new documents into the existing index
+                for doc in new_documents:
+                    self.index.insert(doc)
+                
+                # Persist the updated index
+                self.index.storage_context.persist(persist_dir=INDEX_DIR)
+                pbar.update(1)
+                
+            logger.info("Index updated and saved successfully")
+            
+            # Reinitialize query engine with updated index
+            self.initialize_query_engine()
+            
+        except Exception as e:
+            logger.error(f"Error updating index: {e}")
+            raise
+    
+    def initialize_query_engine(self):
+        """Initialize query engine with error handling."""
+        try:
+            # Set up the system that will handle questions
+            logger.info("Initializing query engine...")
+            self.query_engine = self.index.as_query_engine()
+            logger.info("Query engine initialized successfully")
+        except Exception as e:
+            logger.error(f"Error initializing query engine: {e}")
+            raise
+    
+    def query(self, query_text: str) -> str:
+        """Execute a query with error handling and retries."""
+        # Try to answer questions up to 3 times if there's an error
+        max_retries = 3
+        retry_delay = 1
+        
+        for attempt in range(max_retries):
+            try:
+                logger.info(f"Executing query: {query_text}")
+                print("\nThinking...", end="", flush=True)
+                response = self.query_engine.query(query_text)
+                print(" Done!")
+                logger.info("Query executed successfully")
+                return str(response)
+            except Exception as e:
+                if attempt < max_retries - 1:
+                    logger.warning(f"Attempt {attempt + 1} failed: {e}. Retrying in {retry_delay} seconds...")
+                    time.sleep(retry_delay)
+                else:
+                    logger.error(f"Failed to execute query after {max_retries} attempts: {e}")
+                    raise
+    
+    def cleanup(self):
+        """Clean up resources."""
+        try:
+            # Clean up any resources we used
+            logger.info("Cleaning up resources...")
+            logger.info("Cleanup completed successfully")
+        except Exception as e:
+            logger.error(f"Error during cleanup: {e}")
+
+def main():
+    # Set up all the configuration settings for the chatbot
+    config = {
+        "model": "claude-3-7-sonnet-20250219",
+        "temperature": 0.1,
+        "max_tokens": 2048,  # Allow for longer responses
+        "embedding_model": "sentence-transformers/all-MiniLM-L6-v2",
+        "device": "cpu",
+        "embed_batch_size": 8,
+        "chunk_size": 1024,
+        "chunk_overlap": 100
+    }
+    
+    chatbot = None
+    try:
+        # Create and set up the chatbot
+        print("\nInitializing chatbot...")
+        chatbot = Chatbot(config)
+        
+        # Load the documents we want to analyze
+        documents = chatbot.load_documents()
+        
+        # Create a searchable index from the documents
+        chatbot.create_index(documents)
+        
+        # Set up the system that will handle questions
+        chatbot.initialize_query_engine()
+        
+        print("\nChatbot is ready! You can ask questions about your documents.")
+        print("Type 'exit' to quit.")
+        print("-" * 50)
+        
+        while True:
+            # Get user input
+            question = input("\nYour question: ").strip()
+            
+            # Check if user wants to exit
+            if question.lower() in ['exit', 'quit', 'bye']:
+                print("\nGoodbye!")
+                break
+            
+            # Skip empty questions
+            if not question:
+                continue
+            
+            # Get and print the response
+            response = chatbot.query(question)
+            print("\nAnswer:", response)
+            print("-" * 50)
+        
+    except Exception as e:
+        logger.error(f"Error in main: {e}")
+    finally:
+        # Clean up when we're done
+        if chatbot:
+            chatbot.cleanup()
+
+if __name__ == "__main__":
+    main()

chatbot/__init__.py

@@ -0,0 +1,6 @@
+"""
+Chatbot module for document question answering using LlamaIndex.
+"""
+from chatbot.core import Chatbot
+
+__all__ = ["Chatbot"] 

chatbot/core.py

@@ -0,0 +1,223 @@
+"""
+Core chatbot implementation for document question answering.
+"""
+import logging
+import os
+import time
+from typing import Optional, Dict, Any, List
+
+from tqdm import tqdm
+from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, Settings, StorageContext, load_index_from_storage
+from llama_index.llms.anthropic import Anthropic
+from llama_index.embeddings.huggingface import HuggingFaceEmbedding
+from llama_index.core.node_parser import SentenceSplitter
+from llama_index.core.callbacks import CallbackManager, LlamaDebugHandler
+
+import config
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+class Chatbot:
+    """Chatbot for document question answering using LlamaIndex."""
+    
+    def __init__(self, config_dict: Optional[Dict[str, Any]] = None):
+        """Initialize the chatbot with configuration.
+        
+        Args:
+            config_dict: Optional configuration dictionary. If not provided,
+                         configuration is loaded from environment variables.
+        """
+        # Set up basic variables and load configuration
+        self.config = config_dict or config.get_chatbot_config()
+        self.api_key = self._get_api_key()
+        self.index = None
+        self.query_engine = None
+        self.llm = None
+        self.embed_model = None
+        
+        # Set up debugging tools to help track any issues
+        self.debug_handler = LlamaDebugHandler(print_trace_on_end=True)
+        self.callback_manager = CallbackManager([self.debug_handler])
+        
+        # Set up all the components needed for the chatbot
+        self._initialize_components()
+        
+    def _get_api_key(self) -> str:
+        """Get API key from environment or config.
+        
+        Returns:
+            API key as string
+            
+        Raises:
+            ValueError: If API key is not found
+        """
+        api_key = config.ANTHROPIC_API_KEY or self.config.get("api_key")
+        if not api_key:
+            raise ValueError("API key not found in environment or config")
+        return api_key
+    
+    def _initialize_components(self):
+        """Initialize all components with proper error handling.
+        
+        Sets up the LLM, embedding model, and other settings.
+        
+        Raises:
+            Exception: If component initialization fails
+        """
+        try:
+            # Set up the language model (Claude) with our settings
+            logger.info("Setting up Claude language model...")
+            self.llm = Anthropic(
+                api_key=self.api_key,
+                model=self.config.get("model", config.LLM_MODEL),
+                temperature=self.config.get("temperature", config.LLM_TEMPERATURE),
+                max_tokens=self.config.get("max_tokens", config.LLM_MAX_TOKENS)
+            )
+            
+            # Set up the model that converts text into numbers (embeddings)
+            logger.info("Setting up text embedding model...")
+            self.embed_model = HuggingFaceEmbedding(
+                model_name=self.config.get("embedding_model", config.EMBEDDING_MODEL),
+                device=self.config.get("device", config.EMBEDDING_DEVICE),
+                embed_batch_size=self.config.get("embed_batch_size", config.EMBEDDING_BATCH_SIZE)
+            )
+            
+            # Configure all the settings for the chatbot
+            logger.info("Configuring chatbot settings...")
+            Settings.embed_model = self.embed_model
+            Settings.text_splitter = SentenceSplitter(
+                chunk_size=self.config.get("chunk_size", config.CHUNK_SIZE),
+                chunk_overlap=self.config.get("chunk_overlap", config.CHUNK_OVERLAP),
+                paragraph_separator="\n\n"
+            )
+            Settings.llm = self.llm
+            Settings.callback_manager = self.callback_manager
+            
+            logger.info("Components initialized successfully")
+            
+        except Exception as e:
+            logger.error(f"Error initializing components: {e}")
+            raise
+    
+    def load_documents(self, data_dir: str = None) -> List:
+        """Load documents with retry logic.
+        
+        Args:
+            data_dir: Directory containing documents to load. If None, uses default.
+            
+        Returns:
+            List of loaded documents
+            
+        Raises:
+            Exception: If document loading fails after retries
+        """
+        # Try to load documents up to 3 times if there's an error
+        max_retries = 3
+        retry_delay = 1
+        data_dir = data_dir or config.DATA_DIR
+        
+        for attempt in range(max_retries):
+            try:
+                logger.info(f"Loading documents from {data_dir}...")
+                documents = SimpleDirectoryReader(data_dir).load_data()
+                logger.info(f"Loaded {len(documents)} documents")
+                return documents
+            except Exception as e:
+                if attempt < max_retries - 1:
+                    logger.warning(f"Attempt {attempt + 1} failed: {e}. Retrying in {retry_delay} seconds...")
+                    time.sleep(retry_delay)
+                else:
+                    logger.error(f"Failed to load documents after {max_retries} attempts: {e}")
+                    raise
+    
+    def create_index(self, documents, index_dir: str = None):
+        """Create index with error handling.
+        
+        Args:
+            documents: Documents to index
+            index_dir: Directory to store the index. If None, uses default.
+            
+        Raises:
+            Exception: If index creation fails
+        """
+        index_dir = index_dir or config.INDEX_DIR
+        try:
+            # Check if index already exists
+            if os.path.exists(os.path.join(index_dir, "index_store.json")):
+                logger.info("Loading existing index...")
+                storage_context = StorageContext.from_defaults(persist_dir=index_dir)
+                self.index = load_index_from_storage(storage_context)
+                logger.info("Index loaded successfully")
+                return
+            
+            # Create a new index if none exists
+            logger.info("Creating new index...")
+            with tqdm(total=1, desc="Creating searchable index") as pbar:
+                self.index = VectorStoreIndex.from_documents(documents)
+                # Save the index
+                self.index.storage_context.persist(persist_dir=index_dir)
+                pbar.update(1)
+            logger.info("Index created and saved successfully")
+        except Exception as e:
+            logger.error(f"Error creating/loading index: {e}")
+            raise
+    
+    def initialize_query_engine(self):
+        """Initialize query engine with error handling.
+        
+        Sets up the query engine from the index.
+        
+        Raises:
+            Exception: If query engine initialization fails
+        """
+        try:
+            # Set up the system that will handle questions
+            logger.info("Initializing query engine...")
+            self.query_engine = self.index.as_query_engine()
+            logger.info("Query engine initialized successfully")
+        except Exception as e:
+            logger.error(f"Error initializing query engine: {e}")
+            raise
+    
+    def query(self, query_text: str) -> str:
+        """Execute a query with error handling and retries.
+        
+        Args:
+            query_text: The question to answer
+            
+        Returns:
+            Response as string
+            
+        Raises:
+            Exception: If query fails after retries
+        """
+        # Try to answer questions up to 3 times if there's an error
+        max_retries = 3
+        retry_delay = 1
+        
+        for attempt in range(max_retries):
+            try:
+                logger.info(f"Executing query: {query_text}")
+                response = self.query_engine.query(query_text)
+                logger.info("Query executed successfully")
+                return str(response)
+            except Exception as e:
+                if attempt < max_retries - 1:
+                    logger.warning(f"Attempt {attempt + 1} failed: {e}. Retrying in {retry_delay} seconds...")
+                    time.sleep(retry_delay)
+                else:
+                    logger.error(f"Failed to execute query after {max_retries} attempts: {e}")
+                    raise
+    
+    def cleanup(self):
+        """Clean up resources.
+        
+        Performs any necessary cleanup operations.
+        """
+        try:
+            # Clean up any resources we used
+            logger.info("Cleaning up resources...")
+            logger.info("Cleanup completed successfully")
+        except Exception as e:
+            logger.error(f"Error during cleanup: {e}") 

config.py

@@ -0,0 +1,49 @@
+"""
+Configuration settings for the chatbot application.
+Loads from environment variables with sensible defaults.
+"""
+import os
+from dotenv import load_dotenv
+
+# Load environment variables from .env file if it exists
+load_dotenv()
+
+# Paths
+DATA_DIR = os.getenv("DATA_DIR", "data")
+INDEX_DIR = os.getenv("INDEX_DIR", "index")
+
+# LLM Configuration
+ANTHROPIC_API_KEY = os.getenv("ANTHROPIC_API_KEY")
+LLM_MODEL = os.getenv("LLM_MODEL", "claude-3-7-sonnet-20250219")
+LLM_TEMPERATURE = float(os.getenv("LLM_TEMPERATURE", "0.1"))
+LLM_MAX_TOKENS = int(os.getenv("LLM_MAX_TOKENS", "2048"))
+
+# Embedding Configuration
+EMBEDDING_MODEL = os.getenv("EMBEDDING_MODEL", "sentence-transformers/all-MiniLM-L6-v2")
+EMBEDDING_DEVICE = os.getenv("EMBEDDING_DEVICE", "cpu")
+EMBEDDING_BATCH_SIZE = int(os.getenv("EMBEDDING_BATCH_SIZE", "8"))
+
+# Document Processing Configuration
+CHUNK_SIZE = int(os.getenv("CHUNK_SIZE", "1024"))
+CHUNK_OVERLAP = int(os.getenv("CHUNK_OVERLAP", "100"))
+
+# Database Configuration (for future use)
+DATABASE_URL = os.getenv("DATABASE_URL", "sqlite:///chatbot.db")
+
+# Debug and logging
+DEBUG = os.getenv("DEBUG", "False").lower() == "true"
+LOG_LEVEL = os.getenv("LOG_LEVEL", "INFO")
+
+# Function to get configuration as a dictionary
+def get_chatbot_config():
+    """Return chatbot configuration as a dictionary"""
+    return {
+        "model": LLM_MODEL,
+        "temperature": LLM_TEMPERATURE,
+        "max_tokens": LLM_MAX_TOKENS,
+        "embedding_model": EMBEDDING_MODEL,
+        "device": EMBEDDING_DEVICE,
+        "embed_batch_size": EMBEDDING_BATCH_SIZE,
+        "chunk_size": CHUNK_SIZE,
+        "chunk_overlap": CHUNK_OVERLAP,
+    } 

database/__init__.py

@@ -0,0 +1,3 @@
+"""
+Database models and operations for the chatbot application.
+""" 

feedback/__init__.py

@@ -0,0 +1,3 @@
+"""
+Feedback collection and analysis module for the chatbot.
+""" 

frontend.py

@@ -0,0 +1,132 @@
+"""
+Frontend Streamlit application for the chatbot.
+"""
+import streamlit as st
+# Import directly from backend.py instead of the chatbot module
+from backend import Chatbot
+from utils.logging_config import setup_logging
+import config
+
+# Setup logging
+logger = setup_logging()
+
+# Set page config
+st.set_page_config(
+    page_title="Document Chatbot",
+    page_icon="📚",
+    layout="centered",
+    initial_sidebar_state="collapsed"
+)
+
+# Hide Streamlit's default elements and style sidebar
+st.markdown("""
+<style>
+/* Hide default elements */
+button[kind="deploy"], 
+[data-testid="stToolbar"],
+.stDeployButton,
+#MainMenu,
+footer {
+    display: none !important;
+}
+
+/* Style the sidebar */
+[data-testid="stSidebar"] {
+    width: 120px !important;
+    background-color: #0e1117 !important;
+    border-right: 1px solid #1e1e1e !important;
+}
+
+/* Style the collapse button to prevent movement and maintain size */
+button[kind="menuButton"] {
+    left: 120px !important;
+    margin-left: 0 !important;
+    position: fixed !important;
+    transform: translateX(0) !important;
+    transition: none !important;
+    background-color: #0e1117 !important;
+    color: #fff !important;
+    z-index: 999 !important;
+}
+
+/* Button styling */
+[data-testid="stSidebar"] [data-testid="stButton"] button {
+    background-color: #262730 !important;
+    color: white !important;
+    padding: 8px 10px !important;
+    width: 100px !important;
+    font-size: 0.9rem !important;
+    margin: 1rem auto !important;
+    display: block !important;
+    border-radius: 4px !important;
+    white-space: nowrap !important;
+}
+
+[data-testid="stSidebar"] [data-testid="stButton"] button p {
+    text-align: center !important;
+    white-space: nowrap !important;
+    overflow: visible !important;
+}
+
+[data-testid="stSidebar"] [data-testid="stButton"] button:hover {
+    background-color: #1E2130 !important;
+}
+</style>
+""", unsafe_allow_html=True)
+
+# Create a sidebar with just the button
+with st.sidebar:
+    def clear_chat():
+        st.session_state.messages = []
+        logger.info("Chat history cleared via sidebar button")
+        st.rerun()
+        
+    st.button("Clear Chat", on_click=clear_chat)
+
+# Initialize session state for chat history
+if "messages" not in st.session_state:
+    st.session_state.messages = []
+
+# Initialize chatbot
+if "chatbot" not in st.session_state:
+    with st.spinner("Initializing chatbot..."):
+        # Get configuration from config module
+        chatbot_config = config.get_chatbot_config()
+        
+        # Initialize chatbot
+        logger.info("Initializing chatbot...")
+        st.session_state.chatbot = Chatbot(chatbot_config)
+        
+        # Load documents and create index
+        documents = st.session_state.chatbot.load_documents()
+        st.session_state.chatbot.create_index(documents)
+        st.session_state.chatbot.initialize_query_engine()
+        logger.info("Chatbot initialized successfully")
+
+# Title and description
+st.title("📚 Document Chatbot")
+st.markdown("""
+This chatbot can answer questions about your documents. 
+Ask any question about the content in your documents!
+""")
+
+# Display chat messages
+for message in st.session_state.messages:
+    with st.chat_message(message["role"]):
+        st.markdown(message["content"])
+
+# Chat input
+if prompt := st.chat_input("What would you like to know?"):
+    # Add user message to chat history
+    st.session_state.messages.append({"role": "user", "content": prompt})
+    with st.chat_message("user"):
+        st.markdown(prompt)
+
+    # Get chatbot response
+    with st.chat_message("assistant"):
+        with st.spinner("Thinking..."):
+            logger.info(f"User query: {prompt}")
+            response = st.session_state.chatbot.query(prompt)
+            st.markdown(response)
+            st.session_state.messages.append({"role": "assistant", "content": response})
+            logger.info("Response provided to user") 

myenv/bin/Activate.ps1

@@ -0,0 +1,247 @@
+<#
+.Synopsis
+Activate a Python virtual environment for the current PowerShell session.
+
+.Description
+Pushes the python executable for a virtual environment to the front of the
+$Env:PATH environment variable and sets the prompt to signify that you are
+in a Python virtual environment. Makes use of the command line switches as
+well as the `pyvenv.cfg` file values present in the virtual environment.
+
+.Parameter VenvDir
+Path to the directory that contains the virtual environment to activate. The
+default value for this is the parent of the directory that the Activate.ps1
+script is located within.
+
+.Parameter Prompt
+The prompt prefix to display when this virtual environment is activated. By
+default, this prompt is the name of the virtual environment folder (VenvDir)
+surrounded by parentheses and followed by a single space (ie. '(.venv) ').
+
+.Example
+Activate.ps1
+Activates the Python virtual environment that contains the Activate.ps1 script.
+
+.Example
+Activate.ps1 -Verbose
+Activates the Python virtual environment that contains the Activate.ps1 script,
+and shows extra information about the activation as it executes.
+
+.Example
+Activate.ps1 -VenvDir C:\Users\MyUser\Common\.venv
+Activates the Python virtual environment located in the specified location.
+
+.Example
+Activate.ps1 -Prompt "MyPython"
+Activates the Python virtual environment that contains the Activate.ps1 script,
+and prefixes the current prompt with the specified string (surrounded in
+parentheses) while the virtual environment is active.
+
+.Notes
+On Windows, it may be required to enable this Activate.ps1 script by setting the
+execution policy for the user. You can do this by issuing the following PowerShell
+command:
+
+PS C:\> Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
+
+For more information on Execution Policies: 
+https://go.microsoft.com/fwlink/?LinkID=135170
+
+#>
+Param(
+    [Parameter(Mandatory = $false)]
+    [String]
+    $VenvDir,
+    [Parameter(Mandatory = $false)]
+    [String]
+    $Prompt
+)
+
+<# Function declarations --------------------------------------------------- #>
+
+<#
+.Synopsis
+Remove all shell session elements added by the Activate script, including the
+addition of the virtual environment's Python executable from the beginning of
+the PATH variable.
+
+.Parameter NonDestructive
+If present, do not remove this function from the global namespace for the
+session.
+
+#>
+function global:deactivate ([switch]$NonDestructive) {
+    # Revert to original values
+
+    # The prior prompt:
+    if (Test-Path -Path Function:_OLD_VIRTUAL_PROMPT) {
+        Copy-Item -Path Function:_OLD_VIRTUAL_PROMPT -Destination Function:prompt
+        Remove-Item -Path Function:_OLD_VIRTUAL_PROMPT
+    }
+
+    # The prior PYTHONHOME:
+    if (Test-Path -Path Env:_OLD_VIRTUAL_PYTHONHOME) {
+        Copy-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME -Destination Env:PYTHONHOME
+        Remove-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME
+    }
+
+    # The prior PATH:
+    if (Test-Path -Path Env:_OLD_VIRTUAL_PATH) {
+        Copy-Item -Path Env:_OLD_VIRTUAL_PATH -Destination Env:PATH
+        Remove-Item -Path Env:_OLD_VIRTUAL_PATH
+    }
+
+    # Just remove the VIRTUAL_ENV altogether:
+    if (Test-Path -Path Env:VIRTUAL_ENV) {
+        Remove-Item -Path env:VIRTUAL_ENV
+    }
+
+    # Just remove VIRTUAL_ENV_PROMPT altogether.
+    if (Test-Path -Path Env:VIRTUAL_ENV_PROMPT) {
+        Remove-Item -Path env:VIRTUAL_ENV_PROMPT
+    }
+
+    # Just remove the _PYTHON_VENV_PROMPT_PREFIX altogether:
+    if (Get-Variable -Name "_PYTHON_VENV_PROMPT_PREFIX" -ErrorAction SilentlyContinue) {
+        Remove-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Scope Global -Force
+    }
+
+    # Leave deactivate function in the global namespace if requested:
+    if (-not $NonDestructive) {
+        Remove-Item -Path function:deactivate
+    }
+}
+
+<#
+.Description
+Get-PyVenvConfig parses the values from the pyvenv.cfg file located in the
+given folder, and returns them in a map.
+
+For each line in the pyvenv.cfg file, if that line can be parsed into exactly
+two strings separated by `=` (with any amount of whitespace surrounding the =)
+then it is considered a `key = value` line. The left hand string is the key,
+the right hand is the value.
+
+If the value starts with a `'` or a `"` then the first and last character is
+stripped from the value before being captured.
+
+.Parameter ConfigDir
+Path to the directory that contains the `pyvenv.cfg` file.
+#>
+function Get-PyVenvConfig(
+    [String]
+    $ConfigDir
+) {
+    Write-Verbose "Given ConfigDir=$ConfigDir, obtain values in pyvenv.cfg"
+
+    # Ensure the file exists, and issue a warning if it doesn't (but still allow the function to continue).
+    $pyvenvConfigPath = Join-Path -Resolve -Path $ConfigDir -ChildPath 'pyvenv.cfg' -ErrorAction Continue
+
+    # An empty map will be returned if no config file is found.
+    $pyvenvConfig = @{ }
+
+    if ($pyvenvConfigPath) {
+
+        Write-Verbose "File exists, parse `key = value` lines"
+        $pyvenvConfigContent = Get-Content -Path $pyvenvConfigPath
+
+        $pyvenvConfigContent | ForEach-Object {
+            $keyval = $PSItem -split "\s*=\s*", 2
+            if ($keyval[0] -and $keyval[1]) {
+                $val = $keyval[1]
+
+                # Remove extraneous quotations around a string value.
+                if ("'""".Contains($val.Substring(0, 1))) {
+                    $val = $val.Substring(1, $val.Length - 2)
+                }
+
+                $pyvenvConfig[$keyval[0]] = $val
+                Write-Verbose "Adding Key: '$($keyval[0])'='$val'"
+            }
+        }
+    }
+    return $pyvenvConfig
+}
+
+
+<# Begin Activate script --------------------------------------------------- #>
+
+# Determine the containing directory of this script
+$VenvExecPath = Split-Path -Parent $MyInvocation.MyCommand.Definition
+$VenvExecDir = Get-Item -Path $VenvExecPath
+
+Write-Verbose "Activation script is located in path: '$VenvExecPath'"
+Write-Verbose "VenvExecDir Fullname: '$($VenvExecDir.FullName)"
+Write-Verbose "VenvExecDir Name: '$($VenvExecDir.Name)"
+
+# Set values required in priority: CmdLine, ConfigFile, Default
+# First, get the location of the virtual environment, it might not be
+# VenvExecDir if specified on the command line.
+if ($VenvDir) {
+    Write-Verbose "VenvDir given as parameter, using '$VenvDir' to determine values"
+}
+else {
+    Write-Verbose "VenvDir not given as a parameter, using parent directory name as VenvDir."
+    $VenvDir = $VenvExecDir.Parent.FullName.TrimEnd("\\/")
+    Write-Verbose "VenvDir=$VenvDir"
+}
+
+# Next, read the `pyvenv.cfg` file to determine any required value such
+# as `prompt`.
+$pyvenvCfg = Get-PyVenvConfig -ConfigDir $VenvDir
+
+# Next, set the prompt from the command line, or the config file, or
+# just use the name of the virtual environment folder.
+if ($Prompt) {
+    Write-Verbose "Prompt specified as argument, using '$Prompt'"
+}
+else {
+    Write-Verbose "Prompt not specified as argument to script, checking pyvenv.cfg value"
+    if ($pyvenvCfg -and $pyvenvCfg['prompt']) {
+        Write-Verbose "  Setting based on value in pyvenv.cfg='$($pyvenvCfg['prompt'])'"
+        $Prompt = $pyvenvCfg['prompt'];
+    }
+    else {
+        Write-Verbose "  Setting prompt based on parent's directory's name. (Is the directory name passed to venv module when creating the virtual environment)"
+        Write-Verbose "  Got leaf-name of $VenvDir='$(Split-Path -Path $venvDir -Leaf)'"
+        $Prompt = Split-Path -Path $venvDir -Leaf
+    }
+}
+
+Write-Verbose "Prompt = '$Prompt'"
+Write-Verbose "VenvDir='$VenvDir'"
+
+# Deactivate any currently active virtual environment, but leave the
+# deactivate function in place.
+deactivate -nondestructive
+
+# Now set the environment variable VIRTUAL_ENV, used by many tools to determine
+# that there is an activated venv.
+$env:VIRTUAL_ENV = $VenvDir
+
+if (-not $Env:VIRTUAL_ENV_DISABLE_PROMPT) {
+
+    Write-Verbose "Setting prompt to '$Prompt'"
+
+    # Set the prompt to include the env name
+    # Make sure _OLD_VIRTUAL_PROMPT is global
+    function global:_OLD_VIRTUAL_PROMPT { "" }
+    Copy-Item -Path function:prompt -Destination function:_OLD_VIRTUAL_PROMPT
+    New-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Description "Python virtual environment prompt prefix" -Scope Global -Option ReadOnly -Visibility Public -Value $Prompt
+
+    function global:prompt {
+        Write-Host -NoNewline -ForegroundColor Green "($_PYTHON_VENV_PROMPT_PREFIX) "
+        _OLD_VIRTUAL_PROMPT
+    }
+    $env:VIRTUAL_ENV_PROMPT = $Prompt
+}
+
+# Clear PYTHONHOME
+if (Test-Path -Path Env:PYTHONHOME) {
+    Copy-Item -Path Env:PYTHONHOME -Destination Env:_OLD_VIRTUAL_PYTHONHOME
+    Remove-Item -Path Env:PYTHONHOME
+}
+
+# Add the venv to the PATH
+Copy-Item -Path Env:PATH -Destination Env:_OLD_VIRTUAL_PATH
+$Env:PATH = "$VenvExecDir$([System.IO.Path]::PathSeparator)$Env:PATH"

myenv/bin/activate

@@ -0,0 +1,63 @@
+# This file must be used with "source bin/activate" *from bash*
+# you cannot run it directly
+
+deactivate () {
+    # reset old environment variables
+    if [ -n "${_OLD_VIRTUAL_PATH:-}" ] ; then
+        PATH="${_OLD_VIRTUAL_PATH:-}"
+        export PATH
+        unset _OLD_VIRTUAL_PATH
+    fi
+    if [ -n "${_OLD_VIRTUAL_PYTHONHOME:-}" ] ; then
+        PYTHONHOME="${_OLD_VIRTUAL_PYTHONHOME:-}"
+        export PYTHONHOME
+        unset _OLD_VIRTUAL_PYTHONHOME
+    fi
+
+    # Call hash to forget past commands. Without forgetting
+    # past commands the $PATH changes we made may not be respected
+    hash -r 2> /dev/null
+
+    if [ -n "${_OLD_VIRTUAL_PS1:-}" ] ; then
+        PS1="${_OLD_VIRTUAL_PS1:-}"
+        export PS1
+        unset _OLD_VIRTUAL_PS1
+    fi
+
+    unset VIRTUAL_ENV
+    unset VIRTUAL_ENV_PROMPT
+    if [ ! "${1:-}" = "nondestructive" ] ; then
+    # Self destruct!
+        unset -f deactivate
+    fi
+}
+
+# unset irrelevant variables
+deactivate nondestructive
+
+VIRTUAL_ENV="/Users/paulmagee/llamaindex-demo-1/myenv"
+export VIRTUAL_ENV
+
+_OLD_VIRTUAL_PATH="$PATH"
+PATH="$VIRTUAL_ENV/bin:$PATH"
+export PATH
+
+# unset PYTHONHOME if set
+# this will fail if PYTHONHOME is set to the empty string (which is bad anyway)
+# could use `if (set -u; : $PYTHONHOME) ;` in bash
+if [ -n "${PYTHONHOME:-}" ] ; then
+    _OLD_VIRTUAL_PYTHONHOME="${PYTHONHOME:-}"
+    unset PYTHONHOME
+fi
+
+if [ -z "${VIRTUAL_ENV_DISABLE_PROMPT:-}" ] ; then
+    _OLD_VIRTUAL_PS1="${PS1:-}"
+    PS1="(myenv) ${PS1:-}"
+    export PS1
+    VIRTUAL_ENV_PROMPT="(myenv) "
+    export VIRTUAL_ENV_PROMPT
+fi
+
+# Call hash to forget past commands. Without forgetting
+# past commands the $PATH changes we made may not be respected
+hash -r 2> /dev/null

myenv/bin/activate.csh

@@ -0,0 +1,26 @@
+# This file must be used with "source bin/activate.csh" *from csh*.
+# You cannot run it directly.
+# Created by Davide Di Blasi <davidedb@gmail.com>.
+# Ported to Python 3.3 venv by Andrew Svetlov <andrew.svetlov@gmail.com>
+
+alias deactivate 'test $?_OLD_VIRTUAL_PATH != 0 && setenv PATH "$_OLD_VIRTUAL_PATH" && unset _OLD_VIRTUAL_PATH; rehash; test $?_OLD_VIRTUAL_PROMPT != 0 && set prompt="$_OLD_VIRTUAL_PROMPT" && unset _OLD_VIRTUAL_PROMPT; unsetenv VIRTUAL_ENV; unsetenv VIRTUAL_ENV_PROMPT; test "\!:*" != "nondestructive" && unalias deactivate'
+
+# Unset irrelevant variables.
+deactivate nondestructive
+
+setenv VIRTUAL_ENV "/Users/paulmagee/llamaindex-demo-1/myenv"
+
+set _OLD_VIRTUAL_PATH="$PATH"
+setenv PATH "$VIRTUAL_ENV/bin:$PATH"
+
+
+set _OLD_VIRTUAL_PROMPT="$prompt"
+
+if (! "$?VIRTUAL_ENV_DISABLE_PROMPT") then
+    set prompt = "(myenv) $prompt"
+    setenv VIRTUAL_ENV_PROMPT "(myenv) "
+endif
+
+alias pydoc python -m pydoc
+
+rehash

myenv/bin/activate.fish

@@ -0,0 +1,69 @@
+# This file must be used with "source <venv>/bin/activate.fish" *from fish*
+# (https://fishshell.com/); you cannot run it directly.
+
+function deactivate  -d "Exit virtual environment and return to normal shell environment"
+    # reset old environment variables
+    if test -n "$_OLD_VIRTUAL_PATH"
+        set -gx PATH $_OLD_VIRTUAL_PATH
+        set -e _OLD_VIRTUAL_PATH
+    end
+    if test -n "$_OLD_VIRTUAL_PYTHONHOME"
+        set -gx PYTHONHOME $_OLD_VIRTUAL_PYTHONHOME
+        set -e _OLD_VIRTUAL_PYTHONHOME
+    end
+
+    if test -n "$_OLD_FISH_PROMPT_OVERRIDE"
+        set -e _OLD_FISH_PROMPT_OVERRIDE
+        # prevents error when using nested fish instances (Issue #93858)
+        if functions -q _old_fish_prompt
+            functions -e fish_prompt
+            functions -c _old_fish_prompt fish_prompt
+            functions -e _old_fish_prompt
+        end
+    end
+
+    set -e VIRTUAL_ENV
+    set -e VIRTUAL_ENV_PROMPT
+    if test "$argv[1]" != "nondestructive"
+        # Self-destruct!
+        functions -e deactivate
+    end
+end
+
+# Unset irrelevant variables.
+deactivate nondestructive
+
+set -gx VIRTUAL_ENV "/Users/paulmagee/llamaindex-demo-1/myenv"
+
+set -gx _OLD_VIRTUAL_PATH $PATH
+set -gx PATH "$VIRTUAL_ENV/bin" $PATH
+
+# Unset PYTHONHOME if set.
+if set -q PYTHONHOME
+    set -gx _OLD_VIRTUAL_PYTHONHOME $PYTHONHOME
+    set -e PYTHONHOME
+end
+
+if test -z "$VIRTUAL_ENV_DISABLE_PROMPT"
+    # fish uses a function instead of an env var to generate the prompt.
+
+    # Save the current fish_prompt function as the function _old_fish_prompt.
+    functions -c fish_prompt _old_fish_prompt
+
+    # With the original prompt function renamed, we can override with our own.
+    function fish_prompt
+        # Save the return status of the last command.
+        set -l old_status $status
+
+        # Output the venv prompt; color taken from the blue of the Python logo.
+        printf "%s%s%s" (set_color 4B8BBE) "(myenv) " (set_color normal)
+
+        # Restore the return status of the previous command.
+        echo "exit $old_status" | .
+        # Output the original/"old" prompt.
+        _old_fish_prompt
+    end
+
+    set -gx _OLD_FISH_PROMPT_OVERRIDE "$VIRTUAL_ENV"
+    set -gx VIRTUAL_ENV_PROMPT "(myenv) "
+end

myenv/bin/convert-caffe2-to-onnx

@@ -0,0 +1,8 @@
+#!/Users/paulmagee/llamaindex-demo-1/myenv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from caffe2.python.onnx.bin.conversion import caffe2_to_onnx
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(caffe2_to_onnx())

myenv/bin/convert-onnx-to-caffe2

@@ -0,0 +1,8 @@
+#!/Users/paulmagee/llamaindex-demo-1/myenv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from caffe2.python.onnx.bin.conversion import onnx_to_caffe2
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(onnx_to_caffe2())

myenv/bin/distro

@@ -0,0 +1,8 @@
+#!/Users/paulmagee/llamaindex-demo-1/myenv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from distro.distro import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

myenv/bin/dotenv

@@ -0,0 +1,8 @@
+#!/Users/paulmagee/llamaindex-demo-1/myenv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from dotenv.__main__ import cli
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(cli())

myenv/bin/f2py

@@ -0,0 +1,8 @@
+#!/Users/paulmagee/llamaindex-demo-1/myenv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from numpy.f2py.f2py2e import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

myenv/bin/filetype

@@ -0,0 +1,8 @@
+#!/Users/paulmagee/llamaindex-demo-1/myenv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from filetype.__main__ import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

myenv/bin/griffe

@@ -0,0 +1,8 @@
+#!/Users/paulmagee/llamaindex-demo-1/myenv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from griffe import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

myenv/bin/httpx

@@ -0,0 +1,8 @@
+#!/Users/paulmagee/llamaindex-demo-1/myenv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from httpx import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

myenv/bin/huggingface-cli

@@ -0,0 +1,8 @@
+#!/Users/paulmagee/llamaindex-demo-1/myenv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from huggingface_hub.commands.huggingface_cli import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

myenv/bin/isympy

@@ -0,0 +1,8 @@
+#!/Users/paulmagee/llamaindex-demo-1/myenv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from isympy import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

myenv/bin/jp.py

@@ -0,0 +1,54 @@
+#!/Users/paulmagee/llamaindex-demo-1/myenv/bin/python
+
+import sys
+import json
+import argparse
+from pprint import pformat
+
+import jmespath
+from jmespath import exceptions
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('expression')
+    parser.add_argument('-f', '--filename',
+                        help=('The filename containing the input data.  '
+                              'If a filename is not given then data is '
+                              'read from stdin.'))
+    parser.add_argument('--ast', action='store_true',
+                        help=('Pretty print the AST, do not search the data.'))
+    args = parser.parse_args()
+    expression = args.expression
+    if args.ast:
+        # Only print the AST
+        expression = jmespath.compile(args.expression)
+        sys.stdout.write(pformat(expression.parsed))
+        sys.stdout.write('\n')
+        return 0
+    if args.filename:
+        with open(args.filename, 'r') as f:
+            data = json.load(f)
+    else:
+        data = sys.stdin.read()
+        data = json.loads(data)
+    try:
+        sys.stdout.write(json.dumps(
+            jmespath.search(expression, data), indent=4, ensure_ascii=False))
+        sys.stdout.write('\n')
+    except exceptions.ArityError as e:
+        sys.stderr.write("invalid-arity: %s\n" % e)
+        return 1
+    except exceptions.JMESPathTypeError as e:
+        sys.stderr.write("invalid-type: %s\n" % e)
+        return 1
+    except exceptions.UnknownFunctionError as e:
+        sys.stderr.write("unknown-function: %s\n" % e)
+        return 1
+    except exceptions.ParseError as e:
+        sys.stderr.write("syntax-error: %s\n" % e)
+        return 1
+
+
+if __name__ == '__main__':
+    sys.exit(main())

myenv/bin/nltk

@@ -0,0 +1,8 @@
+#!/Users/paulmagee/llamaindex-demo-1/myenv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from nltk.cli import cli
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(cli())

myenv/bin/normalizer

@@ -0,0 +1,8 @@
+#!/Users/paulmagee/llamaindex-demo-1/myenv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from charset_normalizer import cli
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(cli.cli_detect())

myenv/bin/pip

@@ -0,0 +1,8 @@
+#!/Users/paulmagee/llamaindex-demo-1/myenv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from pip._internal.cli.main import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

myenv/bin/pip3

@@ -0,0 +1,8 @@
+#!/Users/paulmagee/llamaindex-demo-1/myenv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from pip._internal.cli.main import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

myenv/bin/pip3.11

@@ -0,0 +1,8 @@
+#!/Users/paulmagee/llamaindex-demo-1/myenv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from pip._internal.cli.main import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

myenv/bin/pyrsa-decrypt

@@ -0,0 +1,8 @@
+#!/Users/paulmagee/llamaindex-demo-1/myenv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from rsa.cli import decrypt
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(decrypt())

myenv/bin/pyrsa-encrypt

@@ -0,0 +1,8 @@
+#!/Users/paulmagee/llamaindex-demo-1/myenv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from rsa.cli import encrypt
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(encrypt())

myenv/bin/pyrsa-keygen

@@ -0,0 +1,8 @@
+#!/Users/paulmagee/llamaindex-demo-1/myenv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from rsa.cli import keygen
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(keygen())

myenv/bin/pyrsa-priv2pub

@@ -0,0 +1,8 @@
+#!/Users/paulmagee/llamaindex-demo-1/myenv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from rsa.util import private_to_public
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(private_to_public())

myenv/bin/pyrsa-sign

@@ -0,0 +1,8 @@
+#!/Users/paulmagee/llamaindex-demo-1/myenv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from rsa.cli import sign
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(sign())

myenv/bin/pyrsa-verify

@@ -0,0 +1,8 @@
+#!/Users/paulmagee/llamaindex-demo-1/myenv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from rsa.cli import verify
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(verify())

myenv/bin/python

@@ -0,0 +1 @@
+/Users/paulmagee/.pyenv/versions/3.11.9/bin/python

myenv/bin/python3

@@ -0,0 +1 @@
+python

myenv/bin/python3.11

@@ -0,0 +1 @@
+python

myenv/bin/torchrun

@@ -0,0 +1,8 @@
+#!/Users/paulmagee/llamaindex-demo-1/myenv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from torch.distributed.run import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

myenv/bin/tqdm

@@ -0,0 +1,8 @@
+#!/Users/paulmagee/llamaindex-demo-1/myenv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from tqdm.cli import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

myenv/bin/transformers-cli

@@ -0,0 +1,8 @@
+#!/Users/paulmagee/llamaindex-demo-1/myenv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from transformers.commands.transformers_cli import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

myenv/include/site/python3.11/greenlet/greenlet.h

@@ -0,0 +1,164 @@
+/* -*- indent-tabs-mode: nil; tab-width: 4; -*- */
+
+/* Greenlet object interface */
+
+#ifndef Py_GREENLETOBJECT_H
+#define Py_GREENLETOBJECT_H
+
+
+#include <Python.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* This is deprecated and undocumented. It does not change. */
+#define GREENLET_VERSION "1.0.0"
+
+#ifndef GREENLET_MODULE
+#define implementation_ptr_t void*
+#endif
+
+typedef struct _greenlet {
+    PyObject_HEAD
+    PyObject* weakreflist;
+    PyObject* dict;
+    implementation_ptr_t pimpl;
+} PyGreenlet;
+
+#define PyGreenlet_Check(op) (op && PyObject_TypeCheck(op, &PyGreenlet_Type))
+
+
+/* C API functions */
+
+/* Total number of symbols that are exported */
+#define PyGreenlet_API_pointers 12
+
+#define PyGreenlet_Type_NUM 0
+#define PyExc_GreenletError_NUM 1
+#define PyExc_GreenletExit_NUM 2
+
+#define PyGreenlet_New_NUM 3
+#define PyGreenlet_GetCurrent_NUM 4
+#define PyGreenlet_Throw_NUM 5
+#define PyGreenlet_Switch_NUM 6
+#define PyGreenlet_SetParent_NUM 7
+
+#define PyGreenlet_MAIN_NUM 8
+#define PyGreenlet_STARTED_NUM 9
+#define PyGreenlet_ACTIVE_NUM 10
+#define PyGreenlet_GET_PARENT_NUM 11
+
+#ifndef GREENLET_MODULE
+/* This section is used by modules that uses the greenlet C API */
+static void** _PyGreenlet_API = NULL;
+
+#    define PyGreenlet_Type \
+        (*(PyTypeObject*)_PyGreenlet_API[PyGreenlet_Type_NUM])
+
+#    define PyExc_GreenletError \
+        ((PyObject*)_PyGreenlet_API[PyExc_GreenletError_NUM])
+
+#    define PyExc_GreenletExit \
+        ((PyObject*)_PyGreenlet_API[PyExc_GreenletExit_NUM])
+
+/*
+ * PyGreenlet_New(PyObject *args)
+ *
+ * greenlet.greenlet(run, parent=None)
+ */
+#    define PyGreenlet_New                                        \
+        (*(PyGreenlet * (*)(PyObject * run, PyGreenlet * parent)) \
+             _PyGreenlet_API[PyGreenlet_New_NUM])
+
+/*
+ * PyGreenlet_GetCurrent(void)
+ *
+ * greenlet.getcurrent()
+ */
+#    define PyGreenlet_GetCurrent \
+        (*(PyGreenlet * (*)(void)) _PyGreenlet_API[PyGreenlet_GetCurrent_NUM])
+
+/*
+ * PyGreenlet_Throw(
+ *         PyGreenlet *greenlet,
+ *         PyObject *typ,
+ *         PyObject *val,
+ *         PyObject *tb)
+ *
+ * g.throw(...)
+ */
+#    define PyGreenlet_Throw                 \
+        (*(PyObject * (*)(PyGreenlet * self, \
+                          PyObject * typ,    \
+                          PyObject * val,    \
+                          PyObject * tb))    \
+             _PyGreenlet_API[PyGreenlet_Throw_NUM])
+
+/*
+ * PyGreenlet_Switch(PyGreenlet *greenlet, PyObject *args)
+ *
+ * g.switch(*args, **kwargs)
+ */
+#    define PyGreenlet_Switch                                              \
+        (*(PyObject *                                                      \
+           (*)(PyGreenlet * greenlet, PyObject * args, PyObject * kwargs)) \
+             _PyGreenlet_API[PyGreenlet_Switch_NUM])
+
+/*
+ * PyGreenlet_SetParent(PyObject *greenlet, PyObject *new_parent)
+ *
+ * g.parent = new_parent
+ */
+#    define PyGreenlet_SetParent                                 \
+        (*(int (*)(PyGreenlet * greenlet, PyGreenlet * nparent)) \
+             _PyGreenlet_API[PyGreenlet_SetParent_NUM])
+
+/*
+ * PyGreenlet_GetParent(PyObject* greenlet)
+ *
+ * return greenlet.parent;
+ *
+ * This could return NULL even if there is no exception active.
+ * If it does not return NULL, you are responsible for decrementing the
+ * reference count.
+ */
+#     define PyGreenlet_GetParent                                    \
+    (*(PyGreenlet* (*)(PyGreenlet*))                                 \
+     _PyGreenlet_API[PyGreenlet_GET_PARENT_NUM])
+
+/*
+ * deprecated, undocumented alias.
+ */
+#     define PyGreenlet_GET_PARENT PyGreenlet_GetParent
+
+#     define PyGreenlet_MAIN                                         \
+    (*(int (*)(PyGreenlet*))                                         \
+     _PyGreenlet_API[PyGreenlet_MAIN_NUM])
+
+#     define PyGreenlet_STARTED                                      \
+    (*(int (*)(PyGreenlet*))                                         \
+     _PyGreenlet_API[PyGreenlet_STARTED_NUM])
+
+#     define PyGreenlet_ACTIVE                                       \
+    (*(int (*)(PyGreenlet*))                                         \
+     _PyGreenlet_API[PyGreenlet_ACTIVE_NUM])
+
+
+
+
+/* Macro that imports greenlet and initializes C API */
+/* NOTE: This has actually moved to ``greenlet._greenlet._C_API``, but we
+   keep the older definition to be sure older code that might have a copy of
+   the header still works. */
+#    define PyGreenlet_Import()                                               \
+        {                                                                     \
+            _PyGreenlet_API = (void**)PyCapsule_Import("greenlet._C_API", 0); \
+        }
+
+#endif /* GREENLET_MODULE */
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_GREENLETOBJECT_H */

myenv/pyvenv.cfg

@@ -0,0 +1,5 @@
+home = /Users/paulmagee/.pyenv/versions/3.11.9/bin
+include-system-site-packages = false
+version = 3.11.9
+executable = /Users/paulmagee/.pyenv/versions/3.11.9/bin/python3.11
+command = /Users/paulmagee/.pyenv/versions/3.11.9/bin/python -m venv /Users/paulmagee/llamaindex-demo-1/myenv

myenv/share/man/man1/isympy.1

@@ -0,0 +1,188 @@
+'\" -*- coding: us-ascii -*-
+.if \n(.g .ds T< \\FC
+.if \n(.g .ds T> \\F[\n[.fam]]
+.de URL
+\\$2 \(la\\$1\(ra\\$3
+..
+.if \n(.g .mso www.tmac
+.TH isympy 1 2007-10-8 "" ""
+.SH NAME
+isympy \- interactive shell for SymPy
+.SH SYNOPSIS
+'nh
+.fi
+.ad l
+\fBisympy\fR \kx
+.if (\nx>(\n(.l/2)) .nr x (\n(.l/5)
+'in \n(.iu+\nxu
+[\fB-c\fR | \fB--console\fR] [\fB-p\fR ENCODING | \fB--pretty\fR ENCODING] [\fB-t\fR TYPE | \fB--types\fR TYPE] [\fB-o\fR ORDER | \fB--order\fR ORDER] [\fB-q\fR | \fB--quiet\fR] [\fB-d\fR | \fB--doctest\fR] [\fB-C\fR | \fB--no-cache\fR] [\fB-a\fR | \fB--auto\fR] [\fB-D\fR | \fB--debug\fR] [
+-- | PYTHONOPTIONS]
+'in \n(.iu-\nxu
+.ad b
+'hy
+'nh
+.fi
+.ad l
+\fBisympy\fR \kx
+.if (\nx>(\n(.l/2)) .nr x (\n(.l/5)
+'in \n(.iu+\nxu
+[
+{\fB-h\fR | \fB--help\fR}
+|
+{\fB-v\fR | \fB--version\fR}
+]
+'in \n(.iu-\nxu
+.ad b
+'hy
+.SH DESCRIPTION
+isympy is a Python shell for SymPy. It is just a normal python shell
+(ipython shell if you have the ipython package installed) that executes
+the following commands so that you don't have to:
+.PP
+.nf
+\*(T<
+>>> from __future__ import division
+>>> from sympy import *
+>>> x, y, z = symbols("x,y,z")
+>>> k, m, n = symbols("k,m,n", integer=True)
+    \*(T>
+.fi
+.PP
+So starting isympy is equivalent to starting python (or ipython) and
+executing the above commands by hand. It is intended for easy and quick
+experimentation with SymPy. For more complicated programs, it is recommended
+to write a script and import things explicitly (using the "from sympy
+import sin, log, Symbol, ..." idiom).
+.SH OPTIONS
+.TP
+\*(T<\fB\-c \fR\*(T>\fISHELL\fR, \*(T<\fB\-\-console=\fR\*(T>\fISHELL\fR
+Use the specified shell (python or ipython) as
+console backend instead of the default one (ipython
+if present or python otherwise).
+
+Example: isympy -c python
+
+\fISHELL\fR could be either
+\&'ipython' or 'python'
+.TP
+\*(T<\fB\-p \fR\*(T>\fIENCODING\fR, \*(T<\fB\-\-pretty=\fR\*(T>\fIENCODING\fR
+Setup pretty printing in SymPy. By default, the most pretty, unicode
+printing is enabled (if the terminal supports it). You can use less
+pretty ASCII printing instead or no pretty printing at all.
+
+Example: isympy -p no
+
+\fIENCODING\fR must be one of 'unicode',
+\&'ascii' or 'no'.
+.TP
+\*(T<\fB\-t \fR\*(T>\fITYPE\fR, \*(T<\fB\-\-types=\fR\*(T>\fITYPE\fR
+Setup the ground types for the polys. By default, gmpy ground types
+are used if gmpy2 or gmpy is installed, otherwise it falls back to python
+ground types, which are a little bit slower. You can manually
+choose python ground types even if gmpy is installed (e.g., for testing purposes).
+
+Note that sympy ground types are not supported, and should be used
+only for experimental purposes.
+
+Note that the gmpy1 ground type is primarily intended for testing; it the
+use of gmpy even if gmpy2 is available.
+
+This is the same as setting the environment variable
+SYMPY_GROUND_TYPES to the given ground type (e.g.,
+SYMPY_GROUND_TYPES='gmpy')
+
+The ground types can be determined interactively from the variable
+sympy.polys.domains.GROUND_TYPES inside the isympy shell itself.
+
+Example: isympy -t python
+
+\fITYPE\fR must be one of 'gmpy',
+\&'gmpy1' or 'python'.
+.TP
+\*(T<\fB\-o \fR\*(T>\fIORDER\fR, \*(T<\fB\-\-order=\fR\*(T>\fIORDER\fR
+Setup the ordering of terms for printing. The default is lex, which
+orders terms lexicographically (e.g., x**2 + x + 1). You can choose
+other orderings, such as rev-lex, which will use reverse
+lexicographic ordering (e.g., 1 + x + x**2).
+
+Note that for very large expressions, ORDER='none' may speed up
+printing considerably, with the tradeoff that the order of the terms
+in the printed expression will have no canonical order
+
+Example: isympy -o rev-lax
+
+\fIORDER\fR must be one of 'lex', 'rev-lex', 'grlex',
+\&'rev-grlex', 'grevlex', 'rev-grevlex', 'old', or 'none'.
+.TP
+\*(T<\fB\-q\fR\*(T>, \*(T<\fB\-\-quiet\fR\*(T>
+Print only Python's and SymPy's versions to stdout at startup, and nothing else.
+.TP
+\*(T<\fB\-d\fR\*(T>, \*(T<\fB\-\-doctest\fR\*(T>
+Use the same format that should be used for doctests. This is
+equivalent to '\fIisympy -c python -p no\fR'.
+.TP
+\*(T<\fB\-C\fR\*(T>, \*(T<\fB\-\-no\-cache\fR\*(T>
+Disable the caching mechanism. Disabling the cache may slow certain
+operations down considerably. This is useful for testing the cache,
+or for benchmarking, as the cache can result in deceptive benchmark timings.
+
+This is the same as setting the environment variable SYMPY_USE_CACHE
+to 'no'.
+.TP
+\*(T<\fB\-a\fR\*(T>, \*(T<\fB\-\-auto\fR\*(T>
+Automatically create missing symbols. Normally, typing a name of a
+Symbol that has not been instantiated first would raise NameError,
+but with this option enabled, any undefined name will be
+automatically created as a Symbol. This only works in IPython 0.11.
+
+Note that this is intended only for interactive, calculator style
+usage. In a script that uses SymPy, Symbols should be instantiated
+at the top, so that it's clear what they are.
+
+This will not override any names that are already defined, which
+includes the single character letters represented by the mnemonic
+QCOSINE (see the "Gotchas and Pitfalls" document in the
+documentation). You can delete existing names by executing "del
+name" in the shell itself. You can see if a name is defined by typing
+"'name' in globals()".
+
+The Symbols that are created using this have default assumptions.
+If you want to place assumptions on symbols, you should create them
+using symbols() or var().
+
+Finally, this only works in the top level namespace. So, for
+example, if you define a function in isympy with an undefined
+Symbol, it will not work.
+.TP
+\*(T<\fB\-D\fR\*(T>, \*(T<\fB\-\-debug\fR\*(T>
+Enable debugging output. This is the same as setting the
+environment variable SYMPY_DEBUG to 'True'. The debug status is set
+in the variable SYMPY_DEBUG within isympy.
+.TP
+-- \fIPYTHONOPTIONS\fR
+These options will be passed on to \fIipython (1)\fR shell.
+Only supported when ipython is being used (standard python shell not supported).
+
+Two dashes (--) are required to separate \fIPYTHONOPTIONS\fR
+from the other isympy options.
+
+For example, to run iSymPy without startup banner and colors:
+
+isympy -q -c ipython -- --colors=NoColor
+.TP
+\*(T<\fB\-h\fR\*(T>, \*(T<\fB\-\-help\fR\*(T>
+Print help output and exit.
+.TP
+\*(T<\fB\-v\fR\*(T>, \*(T<\fB\-\-version\fR\*(T>
+Print isympy version information and exit.
+.SH FILES
+.TP
+\*(T<\fI${HOME}/.sympy\-history\fR\*(T>
+Saves the history of commands when using the python
+shell as backend.
+.SH BUGS
+The upstreams BTS can be found at \(lahttps://github.com/sympy/sympy/issues\(ra
+Please report all bugs that you find in there, this will help improve
+the overall quality of SymPy.
+.SH "SEE ALSO"
+\fBipython\fR(1), \fBpython\fR(1)

requirements.txt

@@ -0,0 +1,10 @@
+llama-index-core>=0.10.0
+llama-index-llms-anthropic>=0.1.0
+llama-index-embeddings-huggingface>=0.1.0
+streamlit>=1.29.0
+anthropic>=0.49.0
+python-dotenv>=1.0.0
+tqdm>=4.66.0
+sqlalchemy>=2.0.0
+sentence-transformers>=2.3.0
+pytest>=7.4.0