Add core configuration files

.deployment

@@ -1,3 +0,0 @@
-[config]
-SCM_DO_BUILD_DURING_DEPLOYMENT=true
-PYTHON_ENABLE_GUNICORN=false

.devcontainer/devcontainer.json

@@ -1,33 +0,0 @@
-{
-  "name": "Python 3",
-  // Or use a Dockerfile or Docker Compose file. More info: https://containers.dev/guide/dockerfile
-  "image": "mcr.microsoft.com/devcontainers/python:1-3.11-bullseye",
-  "customizations": {
-    "codespaces": {
-      "openFiles": [
-        "README.md",
-        "streamlit_app.py"
-      ]
-    },
-    "vscode": {
-      "settings": {},
-      "extensions": [
-        "ms-python.python",
-        "ms-python.vscode-pylance"
-      ]
-    }
-  },
-  "updateContentCommand": "[ -f packages.txt ] && sudo apt update && sudo apt upgrade -y && sudo xargs apt install -y <packages.txt; [ -f requirements.txt ] && pip3 install --user -r requirements.txt; pip3 install --user streamlit; echo '✅ Packages installed and Requirements met'",
-  "postAttachCommand": {
-    "server": "streamlit run streamlit_app.py --server.enableCORS false --server.enableXsrfProtection false"
-  },
-  "portsAttributes": {
-    "8501": {
-      "label": "Application",
-      "onAutoForward": "openPreview"
-    }
-  },
-  "forwardPorts": [
-    8501
-  ]
-}

.dockerignore

@@ -1,9 +0,0 @@
-.git
-.gitignore
-.env
-__pycache__
-*.pyc
-vector_store/
-venv/
-.pytest_cache/
-logs/

.gitattributes

@@ -1 +0,0 @@
-*.pdf filter=lfs diff=lfs merge=lfs -text

.github/workflows/huggingface-spaces-sync.yml

@@ -1,30 +0,0 @@
-name: Sync to Hugging Face Spaces
-on:
-  push:
-    branches: [main]
-
-jobs:
-  sync:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-          lfs: true
-
-      - name: Setup Git LFS
-        run: |
-          curl -s https://packagecloud.io/install/repositories/github/git-lfs/script.deb.sh | sudo bash
-          sudo apt-get install git-lfs
-          git lfs install
-
-      - name: Push to Hugging Face Spaces
-        env:
-          HF_TOKEN: ${{ secrets.HF_TOKEN }}
-        run: |
-          git config --global user.email "[email protected]"
-          git config --global user.name "GitHub Actions"
-          git remote add hf https://tony-42069:[email protected]/spaces/tony-42069/cre-chatbot-rag
-          git fetch hf
-          git lfs push --all hf main
-          git push -f hf main

.gitignore

@@ -1,35 +0,0 @@
-# Next.js
-.next/
-node_modules/
-out/
-
-# Virtual environment
-venv/
-env/
-ENV/
-
-# Python
-__pycache__/
-*.py[cod]
-*$py.class
-
-# Distribution / packaging
-dist/
-build/
-*.egg-info/
-
-# Local development settings
-.env
-.env.local
-
-# IDE
-.vscode/
-.idea/
-
-# Operating System
-.DS_Store
-Thumbs.db
-
-# Misc
-*.pem
-.vercel

.streamlit/config.toml

@@ -1,9 +0,0 @@
-[theme]
-primaryColor = "#FF4B4B"
-backgroundColor = "#FFFFFF"
-secondaryBackgroundColor = "#F0F2F6"
-textColor = "#262730"
-font = "sans serif"
-
-[server]
-maxUploadSize = 200

Dataset/Commercial Lending 101.pdf

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:46f8deca30acd6c8b45ca371babf4bbcd1848916f09c088a33e2edcf46164746
-size 6879185

Dockerfile

@@ -1,16 +0,0 @@
-FROM python:3.11-slim
-
-WORKDIR /app
-
-COPY requirements.txt .
-RUN pip install -r requirements.txt
-
-COPY . .
-
-# Make port configurable via environment variable
-ENV PORT=8501
-
-EXPOSE ${PORT}
-
-# Use the correct path to app.py and make port configurable
-ENTRYPOINT ["streamlit", "run", "app.py", "--server.port=${PORT}", "--server.address=0.0.0.0"]

README.md

@@ -1,122 +0,0 @@
-# Commercial Real Estate Knowledge Assistant
-
-![Commercial Lending 101](Dataset/commercial-lending-101.png)
-
-A sophisticated Retrieval-Augmented Generation (RAG) chatbot that transforms how professionals understand commercial real estate concepts. Built with Azure OpenAI and modern Python technologies, this assistant processes commercial real estate documentation and provides accurate, context-aware answers to your questions.
-
-## 🚀 Deployments
-- **Live Demo**: [Try it on Hugging Face Spaces](https://huggingface.co/spaces/tony-42069/cre-chatbot-rag)
-
-## 🌟 Key Features
-- **Multi-Document Support**: Process and analyze multiple PDF documents simultaneously
-- **Intelligent PDF Processing**: Advanced document analysis and text extraction
-- **Azure OpenAI Integration**: Leveraging GPT-3.5 Turbo for accurate, contextual responses
-- **Semantic Search**: Using Azure OpenAI embeddings for precise context retrieval
-- **Vector Storage**: Efficient document indexing with ChromaDB
-- **Modern UI**: Beautiful chat interface with message history and source tracking
-- **Enterprise-Ready**: Comprehensive logging and error handling
-
-## 🎯 Use Cases
-- **Training & Education**: Help new CRE professionals understand industry concepts
-- **Quick Reference**: Instant access to definitions and explanations
-- **Document Analysis**: Extract insights from CRE documentation
-- **Knowledge Base**: Build and query your own CRE knowledge repository
-
-## 🚀 Quick Start
-
-### Prerequisites
-- Python 3.8+
-- Azure OpenAI Service access with:
-  - `gpt-35-turbo` model deployment
-  - `text-embedding-ada-002` model deployment
-
-### Installation
-1. Clone the repository:
-```bash
-git clone https://github.com/tony-42069/cre-chatbot-rag.git
-cd cre-chatbot-rag
-```
-
-2. Create and activate virtual environment:
-```bash
-python -m venv venv
-venv\Scripts\activate
-```
-
-3. Install dependencies:
-```bash
-pip install -r requirements.txt
-```
-
-4. Create `.env` file with Azure OpenAI credentials:
-```env
-AZURE_OPENAI_ENDPOINT=your_endpoint_here
-AZURE_OPENAI_KEY=your_key_here
-AZURE_OPENAI_DEPLOYMENT_NAME=your_gpt_deployment_name
-AZURE_OPENAI_EMBEDDING_DEPLOYMENT_NAME=text-embedding-ada-002
-```
-
-5. Run the application:
-```bash
-streamlit run app/main.py
-```
-
-## 🔌 Embedding
-To embed this chatbot in your website, use the following HTML code:
-
-```html
-<iframe
-    src="https://tony-42069-cre-chatbot-rag.hf.space"
-    frameborder="0"
-    width="850px"
-    height="450px"
-></iframe>
-```
-
-## 💡 Features
-
-### Modern Chat Interface
-- Clean, professional design
-- Persistent chat history
-- Source context tracking
-- Multiple document management
-- Real-time processing feedback
-
-### Advanced RAG Implementation
-- Semantic chunking of documents
-- Azure OpenAI embeddings for accurate retrieval
-- Context-aware answer generation
-- Multi-document knowledge base
-- Source attribution for answers
-
-### Enterprise Security
-- Secure credential management
-- Azure OpenAI integration
-- Local vector storage with ChromaDB
-- Comprehensive error handling
-- Detailed logging system
-
-## 🛠️ Technical Stack
-- **Frontend**: Streamlit
-- **Language Models**: Azure OpenAI (GPT-3.5 Turbo)
-- **Embeddings**: Azure OpenAI (text-embedding-ada-002)
-- **Vector Store**: ChromaDB
-- **PDF Processing**: PyPDF2
-- **Framework**: LangChain
-
-## 📚 Documentation
-- [Azure OpenAI Service](https://azure.microsoft.com/en-us/products/cognitive-services/openai-service/)
-- [Streamlit](https://streamlit.io/)
-- [LangChain](https://python.langchain.com/)
-- [ChromaDB](https://www.trychroma.com/)
-
-## 🤝 Contributing
-Contributions are welcome! Please feel free to submit a Pull Request.
-
-## 📄 License
-This project is licensed under the MIT License - see the LICENSE file for details.
-
-## 🙏 Acknowledgments
-- Azure OpenAI team for providing the powerful language models
-- LangChain community for the excellent RAG framework
-- Streamlit team for the amazing web framework

api/__init__.py

@@ -1,8 +0,0 @@
-import azure.functions as func
-import streamlit as st
-
-def main(req: func.HttpRequest) -> func.HttpResponse:
-    return func.HttpResponse(
-        "This is the API endpoint for the CRE Knowledge Assistant",
-        status_code=200
-    )

api/function_app.py

@@ -1,71 +0,0 @@
-import azure.functions as func
-import logging
-import json
-from io import BytesIO
-
-# Add the project root to Python path
-import sys
-import os
-sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-from app.config import validate_config
-from app.logging import setup_logging
-from src.pdf_processor import PDFProcessor
-from src.rag_engine import RAGEngine
-
-# Initialize components
-setup_logging()
-logger = logging.getLogger('app')
-pdf_processor = PDFProcessor()
-rag_engine = RAGEngine()
-
-def process_pdf(req: func.HttpRequest) -> func.HttpResponse:
-    try:
-        # Get the PDF file from the request
-        pdf_file = req.files['file']
-        pdf_bytes = pdf_file.read()
-        
-        # Process the PDF
-        pdf_processor.process(BytesIO(pdf_bytes))
-        
-        return func.HttpResponse(
-            json.dumps({"message": "PDF processed successfully"}),
-            mimetype="application/json",
-            status_code=200
-        )
-    except Exception as e:
-        logger.error(f"Error processing PDF: {str(e)}")
-        return func.HttpResponse(
-            json.dumps({"error": str(e)}),
-            mimetype="application/json",
-            status_code=500
-        )
-
-def query(req: func.HttpRequest) -> func.HttpResponse:
-    try:
-        # Get the query from request body
-        req_body = req.get_json()
-        user_query = req_body.get('query')
-        
-        if not user_query:
-            return func.HttpResponse(
-                json.dumps({"error": "No query provided"}),
-                mimetype="application/json",
-                status_code=400
-            )
-        
-        # Process query through RAG engine
-        answer = rag_engine.process_query(user_query)
-        
-        return func.HttpResponse(
-            json.dumps({"answer": answer}),
-            mimetype="application/json",
-            status_code=200
-        )
-    except Exception as e:
-        logger.error(f"Error processing query: {str(e)}")
-        return func.HttpResponse(
-            json.dumps({"error": str(e)}),
-            mimetype="application/json",
-            status_code=500
-        )

api/requirements.txt

@@ -1,7 +0,0 @@
-azure-functions==1.15.0
-openai==1.6.1
-python-dotenv==1.0.0
-azure-cognitiveservices-language-textanalytics==0.2.0
-PyPDF2==3.0.1
-langchain==0.0.352
-azure-storage-blob==12.19.0

app.py

@@ -1,116 +0,0 @@
-import streamlit as st
-import tempfile
-import os
-from pdf_processor import PDFProcessor
-from rag_engine import RAGEngine
-
-# Initialize session state
-if 'rag_engine' not in st.session_state:
-    try:
-        st.session_state.rag_engine = RAGEngine()
-    except ValueError as e:
-        st.error(f"Configuration Error: {str(e)}")
-        st.stop()
-    except ConnectionError as e:
-        st.error(f"Connection Error: {str(e)}")
-        st.stop()
-    except Exception as e:
-        st.error(f"Unexpected Error: {str(e)}")
-        st.stop()
-
-if 'processed_file' not in st.session_state:
-    st.session_state.processed_file = False
-
-# Page config
-st.set_page_config(page_title="Concept Definition Chatbot", layout="wide")
-st.title("Concept Definition Chatbot")
-
-# Sidebar for PDF upload
-with st.sidebar:
-    st.header("Upload PDF")
-    uploaded_file = st.file_uploader("Choose a PDF file", type="pdf")
-    
-    if uploaded_file is not None and not st.session_state.processed_file:
-        with st.spinner("Processing PDF..."):
-            try:
-                # Save uploaded file temporarily
-                with tempfile.NamedTemporaryFile(delete=False, suffix='.pdf') as tmp_file:
-                    tmp_file.write(uploaded_file.getvalue())
-                    tmp_path = tmp_file.name
-                
-                # Process PDF
-                processor = PDFProcessor()
-                chunks = processor.process_pdf(tmp_path)
-                
-                # Initialize RAG engine
-                st.session_state.rag_engine.initialize_vector_store(chunks)
-                st.session_state.processed_file = True
-                
-                # Clean up
-                os.unlink(tmp_path)
-            except ValueError as e:
-                st.error(f"Configuration Error: {str(e)}")
-                st.stop()
-            except ConnectionError as e:
-                st.error(f"Connection Error: {str(e)}")
-                st.stop()
-            except Exception as e:
-                st.error(f"Unexpected Error: {str(e)}")
-                st.stop()
-        st.success("PDF processed successfully!")
-
-# Main chat interface
-if st.session_state.processed_file:
-    # Initialize chat history
-    if "messages" not in st.session_state:
-        st.session_state.messages = []
-
-    # Display chat messages
-    for message in st.session_state.messages:
-        with st.chat_message(message["role"]):
-            st.markdown(message["content"])
-            if "sources" in message:
-                with st.expander("View Sources"):
-                    for source in message["sources"]:
-                        st.markdown(f"**Page {source['page']}:**\n{source['text']}")
-
-    # Chat input
-    if prompt := st.chat_input("Ask a question about the concepts in your PDF"):
-        # Add user message to chat history
-        st.session_state.messages.append({"role": "user", "content": prompt})
-        
-        # Display user message
-        with st.chat_message("user"):
-            st.markdown(prompt)
-
-        # Get bot response
-        with st.chat_message("assistant"):
-            with st.spinner("Thinking..."):
-                try:
-                    response = st.session_state.rag_engine.answer_question(prompt)
-                    
-                    # Display response
-                    st.markdown(response["answer"])
-                    
-                    # Display sources in expander
-                    with st.expander("View Sources"):
-                        for source in response["sources"]:
-                            st.markdown(f"**Page {source['page']}:**\n{source['text']}")
-                    
-                    # Add assistant response to chat history
-                    st.session_state.messages.append({
-                        "role": "assistant",
-                        "content": response["answer"],
-                        "sources": response["sources"]
-                    })
-                except ValueError as e:
-                    st.error(f"Configuration Error: {str(e)}")
-                    st.stop()
-                except ConnectionError as e:
-                    st.error(f"Connection Error: {str(e)}")
-                    st.stop()
-                except Exception as e:
-                    st.error(f"Unexpected Error: {str(e)}")
-                    st.stop()
-else:
-    st.info("Please upload a PDF file to start chatting.")

app/__init__.py

@@ -1 +0,0 @@
-

app/config.py

@@ -1,45 +0,0 @@
-"""
-Configuration management for the CRE Chatbot application.
-"""
-import os
-from dotenv import load_dotenv
-
-# Load environment variables
-load_dotenv()
-
-# Azure OpenAI Configuration
-AZURE_OPENAI_ENDPOINT = os.getenv('AZURE_OPENAI_ENDPOINT')
-AZURE_OPENAI_API_KEY = os.getenv('AZURE_OPENAI_KEY')
-AZURE_OPENAI_DEPLOYMENT_NAME = os.getenv('AZURE_OPENAI_DEPLOYMENT_NAME')
-AZURE_OPENAI_EMBEDDING_DEPLOYMENT_NAME = os.getenv('AZURE_OPENAI_EMBEDDING_DEPLOYMENT_NAME')
-
-# Application Configuration
-MAX_CHUNK_SIZE = 1000
-OVERLAP_SIZE = 200
-TEMPERATURE = 0.7
-MAX_TOKENS = 500
-
-# Logging Configuration
-LOG_LEVEL = "INFO"
-LOG_FORMAT = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
-LOG_FILE = "logs/app.log"
-
-# Vector Store Configuration
-VECTOR_STORE_PATH = "vector_store"
-
-def validate_config():
-    """Validate that all required configuration variables are set."""
-    required_vars = [
-        'AZURE_OPENAI_ENDPOINT',
-        'AZURE_OPENAI_API_KEY',
-        'AZURE_OPENAI_DEPLOYMENT_NAME',
-        'AZURE_OPENAI_EMBEDDING_DEPLOYMENT_NAME'
-    ]
-    
-    missing_vars = [var for var in required_vars if not os.getenv(var)]
-    
-    if missing_vars:
-        raise ValueError(f"Missing required environment variables: {', '.join(missing_vars)}")
-
-# Validate that all required configuration variables are set.
-validate_config()

app/logging.py

@@ -1,59 +0,0 @@
-"""
-Logging configuration for the CRE Chatbot application.
-"""
-import logging
-import os
-from logging.handlers import RotatingFileHandler
-from .config import LOG_LEVEL, LOG_FORMAT, LOG_FILE
-
-def setup_logging():
-    """Set up logging configuration for the application."""
-    # Create logs directory if it doesn't exist
-    os.makedirs('logs', exist_ok=True)
-    
-    # Set up root logger
-    logger = logging.getLogger()
-    logger.setLevel(LOG_LEVEL)
-    
-    # Create formatters and handlers
-    formatter = logging.Formatter(LOG_FORMAT)
-    
-    # Console Handler
-    console_handler = logging.StreamHandler()
-    console_handler.setFormatter(formatter)
-    logger.addHandler(console_handler)
-    
-    # File Handler
-    file_handler = RotatingFileHandler(
-        LOG_FILE,
-        maxBytes=10485760,  # 10MB
-        backupCount=5
-    )
-    file_handler.setFormatter(formatter)
-    logger.addHandler(file_handler)
-    
-    # Create separate loggers for different components
-    loggers = {
-        'api': setup_component_logger('api'),
-        'pdf': setup_component_logger('pdf'),
-        'rag': setup_component_logger('rag'),
-        'app': setup_component_logger('app')
-    }
-    
-    return loggers
-
-def setup_component_logger(name):
-    """Set up a logger for a specific component."""
-    logger = logging.getLogger(name)
-    logger.setLevel(LOG_LEVEL)
-    
-    # Create component-specific log file
-    handler = RotatingFileHandler(
-        f'logs/{name}.log',
-        maxBytes=10485760,  # 10MB
-        backupCount=3
-    )
-    handler.setFormatter(logging.Formatter(LOG_FORMAT))
-    logger.addHandler(handler)
-    
-    return logger

app/main.py

@@ -1,209 +0,0 @@
-"""
-Main Streamlit application for the CRE Chatbot.
-"""
-import logging
-import streamlit as st
-from io import BytesIO
-import sys
-import os
-
-# Add the project root to Python path
-sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-from app.config import validate_config, AZURE_OPENAI_DEPLOYMENT_NAME
-from app.logging import setup_logging
-from src.pdf_processor import PDFProcessor
-from src.rag_engine import RAGEngine
-
-# Setup logging
-loggers = setup_logging()
-logger = logging.getLogger('app')
-
-# Page configuration
-st.set_page_config(
-    page_title="CRE Knowledge Assistant",
-    page_icon="🏢",
-    layout="wide",
-    initial_sidebar_state="expanded"
-)
-
-# Custom CSS
-st.markdown("""
-    <style>
-    .main {
-        background-color: #f5f5f5;
-    }
-    .stApp {
-        max-width: 1200px;
-        margin: 0 auto;
-    }
-    .chat-message {
-        padding: 1.5rem;
-        border-radius: 0.5rem;
-        margin-bottom: 1rem;
-        display: flex;
-        flex-direction: column;
-    }
-    .chat-message.user {
-        background-color: #e3f2fd;
-    }
-    .chat-message.assistant {
-        background-color: #f3e5f5;
-    }
-    .chat-message .message {
-        margin-top: 0.5rem;
-    }
-    </style>
-    """, unsafe_allow_html=True)
-
-# Initialize session state
-if 'rag_engine' not in st.session_state:
-    st.session_state.rag_engine = None
-if 'pdf_processor' not in st.session_state:
-    st.session_state.pdf_processor = PDFProcessor()
-if 'chat_history' not in st.session_state:
-    st.session_state.chat_history = []
-if 'uploaded_pdfs' not in st.session_state:
-    st.session_state.uploaded_pdfs = set()
-
-def initialize_rag_engine(deployment_name: str):
-    """Initialize the RAG engine with error handling."""
-    try:
-        st.session_state.rag_engine = RAGEngine(deployment_name)
-        logger.info("RAG Engine initialized successfully")
-    except Exception as e:
-        logger.error(f"Error initializing the application: {str(e)}")
-        st.error(f"Error initializing the application: {str(e)}")
-
-def process_pdf(pdf_file):
-    """Process uploaded PDF file."""
-    try:
-        # Check if PDF was already processed
-        if pdf_file.name in st.session_state.uploaded_pdfs:
-            st.warning(f"'{pdf_file.name}' has already been processed!")
-            return
-
-        with st.spinner(f"Processing {pdf_file.name}..."):
-            # Read PDF content
-            pdf_content = pdf_file.read()
-            
-            # Process PDF and get chunks
-            chunks = st.session_state.pdf_processor.process_pdf(
-                BytesIO(pdf_content)
-            )
-            
-            # Add chunks to vector store
-            texts = [chunk[0] for chunk in chunks]
-            metadata = [{"source": pdf_file.name, **chunk[1]} for chunk in chunks]
-            st.session_state.rag_engine.add_documents(texts, metadata)
-            
-            # Mark PDF as processed
-            st.session_state.uploaded_pdfs.add(pdf_file.name)
-            
-        st.success(f"Successfully processed '{pdf_file.name}'!")
-        logger.info(f"PDF '{pdf_file.name}' processed and added to vector store")
-        
-    except Exception as e:
-        logger.error(f"Error processing PDF: {str(e)}")
-        st.error(f"Error processing PDF: {str(e)}")
-
-def display_chat_message(role: str, content: str):
-    """Display a chat message with proper styling."""
-    with st.container():
-        st.markdown(f"""
-            <div class="chat-message {role}">
-                <div class="role"><strong>{'You' if role == 'user' else 'Assistant'}:</strong></div>
-                <div class="message">{content}</div>
-            </div>
-        """, unsafe_allow_html=True)
-
-def main():
-    """Main application function."""
-    # Header
-    col1, col2 = st.columns([2, 1])
-    with col1:
-        st.title("🏢 CRE Knowledge Assistant")
-        st.markdown("*Your AI guide for commercial real estate concepts*")
-    
-    # Sidebar
-    with st.sidebar:
-        st.header("📚 Knowledge Base")
-        st.markdown("Upload your CRE documents to enhance the assistant's knowledge.")
-        
-        # Model configuration (collapsible)
-        with st.expander("⚙️ Model Configuration"):
-            deployment_name = st.text_input(
-                "Model Deployment Name",
-                value=AZURE_OPENAI_DEPLOYMENT_NAME,
-                help="Enter your Azure OpenAI model deployment name"
-            )
-        
-        # Initialize RAG engine if not already done
-        if not st.session_state.rag_engine:
-            initialize_rag_engine(deployment_name)
-        
-        # PDF upload section
-        st.subheader("📄 Upload Documents")
-        uploaded_files = st.file_uploader(
-            "Choose PDF files",
-            type="pdf",
-            accept_multiple_files=True,
-            help="Upload one or more PDF files to add to the knowledge base"
-        )
-        
-        if uploaded_files:
-            for pdf_file in uploaded_files:
-                process_pdf(pdf_file)
-        
-        # Show processed documents
-        if st.session_state.uploaded_pdfs:
-            st.subheader("📚 Processed Documents")
-            for pdf_name in st.session_state.uploaded_pdfs:
-                st.markdown(f"✓ {pdf_name}")
-    
-    # Main chat interface
-    if st.session_state.rag_engine:
-        # Display chat history
-        for message in st.session_state.chat_history:
-            display_chat_message(
-                role=message["role"],
-                content=message["content"]
-            )
-        
-        # Chat input
-        user_question = st.text_input(
-            "Ask a question about commercial real estate:",
-            placeholder="e.g., What is LTV? How is DSCR calculated?",
-            key="user_question"
-        )
-        
-        if user_question:
-            try:
-                # Add user message to chat
-                st.session_state.chat_history.append({
-                    "role": "user",
-                    "content": user_question
-                })
-                
-                with st.spinner("Generating answer..."):
-                    response = st.session_state.rag_engine.query(user_question)
-                
-                # Add assistant response to chat
-                st.session_state.chat_history.append({
-                    "role": "assistant",
-                    "content": response["answer"]
-                })
-                
-                # Display latest messages immediately
-                display_chat_message("user", user_question)
-                display_chat_message("assistant", response["answer"])
-                
-            except Exception as e:
-                logger.error(f"Error generating answer: {str(e)}")
-                st.error(f"Error generating answer: {str(e)}")
-    
-    else:
-        st.info("👆 Please upload PDF documents in the sidebar to start asking questions!")
-
-if __name__ == "__main__":
-    main()

docker-compose.yml

@@ -1,15 +0,0 @@
-version: '3.8'
-
-services:
-  chatbot:
-    build: .
-    ports:
-      - "8501:8501"
-    environment:
-      - AZURE_OPENAI_ENDPOINT=${AZURE_OPENAI_ENDPOINT}
-      - AZURE_OPENAI_KEY=${AZURE_OPENAI_KEY}
-      - AZURE_OPENAI_DEPLOYMENT_NAME=${AZURE_OPENAI_DEPLOYMENT_NAME}
-      - AZURE_OPENAI_EMBEDDING_DEPLOYMENT_NAME=${AZURE_OPENAI_EMBEDDING_DEPLOYMENT_NAME}
-    volumes:
-      - ./vector_store:/app/vector_store
-      - ./logs:/app/logs

frontend/main.py

@@ -1,59 +0,0 @@
-import streamlit as st
-import requests
-import sys
-import os
-
-# Add the project root to Python path
-sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-from app.config import validate_config
-from app.logging import setup_logging
-
-def main():
-    # Setup logging
-    setup_logging()
-    
-    st.set_page_config(
-        page_title="CRE Knowledge Assistant",
-        page_icon="🤖",
-        layout="wide"
-    )
-
-    st.title("CRE Knowledge Assistant")
-    
-    # File uploader
-    uploaded_file = st.file_uploader("Upload a PDF document", type="pdf")
-    
-    if uploaded_file:
-        # Convert file to bytes
-        file_bytes = uploaded_file.getvalue()
-        
-        # Send to API endpoint
-        response = requests.post(
-            "api/process_pdf",
-            files={"file": (uploaded_file.name, file_bytes, "application/pdf")}
-        )
-        
-        if response.status_code == 200:
-            st.success("PDF processed successfully!")
-        else:
-            st.error("Error processing PDF")
-    
-    # Query input
-    query = st.text_input("Ask a question about your documents:")
-    
-    if query:
-        # Send query to API endpoint
-        response = requests.post(
-            "api/query",
-            json={"query": query}
-        )
-        
-        if response.status_code == 200:
-            result = response.json()
-            st.write("Answer:", result["answer"])
-        else:
-            st.error("Error processing query")
-
-if __name__ == "__main__":
-    main()

frontend/requirements.txt

@@ -1,3 +0,0 @@
-streamlit==1.29.0
-requests==2.31.0
-python-dotenv==1.0.0

index.html

@@ -1,30 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-    <title>CRE Knowledge Assistant</title>
-    <style>
-        body, html {
-            margin: 0;
-            padding: 0;
-            height: 100%;
-            overflow: hidden;
-        }
-        iframe {
-            width: 100%;
-            height: 100vh;
-            border: none;
-        }
-    </style>
-</head>
-<body>
-    <iframe src="/api" allow="camera;microphone"></iframe>
-    <script>
-        window.addEventListener('message', function(e) {
-            // Handle any messages from the Streamlit app
-            if (e.data.type === 'streamlit') {
-                console.log('Received message from Streamlit:', e.data);
-            }
-        });
-    </script>
-</body>
-</html>

package.json

@@ -1,21 +0,0 @@
-{
-  "name": "cre-chatbot-rag",
-  "version": "1.0.0",
-  "private": true,
-  "scripts": {
-    "dev": "next dev",
-    "build": "next build",
-    "start": "next start"
-  },
-  "dependencies": {
-    "@chakra-ui/react": "^2.8.2",
-    "@emotion/react": "^11.11.1",
-    "@emotion/styled": "^11.11.0",
-    "axios": "^1.6.2",
-    "framer-motion": "^10.16.16",
-    "next": "^14.0.4",
-    "react": "^18.2.0",
-    "react-dom": "^18.2.0",
-    "vercel": "^39.1.1"
-  }
-}

pdf_processor.py

@@ -1,42 +0,0 @@
-from typing import List, Dict
-from langchain.document_loaders import PyPDFLoader
-from langchain.text_splitter import RecursiveCharacterTextSplitter
-
-class PDFProcessor:
-    def __init__(self):
-        self.text_splitter = RecursiveCharacterTextSplitter(
-            chunk_size=1000,
-            chunk_overlap=200,
-            length_function=len,
-            separators=["\n\n", "\n", " ", ""]
-        )
-    
-    def process_pdf(self, pdf_path: str) -> List[Dict]:
-        """
-        Process a PDF file and return chunks of text with metadata.
-        
-        Args:
-            pdf_path (str): Path to the PDF file
-            
-        Returns:
-            List[Dict]: List of dictionaries containing text chunks and metadata
-        """
-        # Load PDF
-        loader = PyPDFLoader(pdf_path)
-        pages = loader.load()
-        
-        # Split text into chunks
-        chunks = self.text_splitter.split_documents(pages)
-        
-        # Format chunks with metadata
-        processed_chunks = []
-        for chunk in chunks:
-            processed_chunks.append({
-                'text': chunk.page_content,
-                'metadata': {
-                    'page': chunk.metadata.get('page', 0) + 1,
-                    'source': pdf_path
-                }
-            })
-        
-        return processed_chunks

rag_engine.py

@@ -1,112 +0,0 @@
-import os
-from typing import List, Dict
-from dotenv import load_dotenv
-import chromadb
-from langchain.embeddings import AzureOpenAIEmbeddings
-from langchain.vectorstores import Chroma
-from langchain.chat_models import AzureChatOpenAI
-from langchain.chains import RetrievalQA
-import time
-
-# Load environment variables
-load_dotenv()
-
-class RAGEngine:
-    def __init__(self):
-        # Verify Azure OpenAI settings are set
-        required_vars = [
-            'AZURE_OPENAI_ENDPOINT',
-            'AZURE_OPENAI_KEY',
-            'AZURE_OPENAI_DEPLOYMENT_NAME',
-            'AZURE_OPENAI_EMBEDDING_DEPLOYMENT_NAME'
-        ]
-        
-        missing_vars = [var for var in required_vars if not os.getenv(var)]
-        if missing_vars:
-            raise ValueError(f"Missing required Azure OpenAI settings: {', '.join(missing_vars)}")
-        
-        # Initialize with retry mechanism
-        max_retries = 3
-        for attempt in range(max_retries):
-            try:
-                self.embeddings = AzureOpenAIEmbeddings(
-                    azure_endpoint=os.getenv('AZURE_OPENAI_ENDPOINT'),
-                    azure_deployment=os.getenv('AZURE_OPENAI_EMBEDDING_DEPLOYMENT_NAME'),
-                    api_key=os.getenv('AZURE_OPENAI_KEY')
-                )
-                self.vector_store = None
-                self.qa_chain = None
-                # Test connection
-                self.embeddings.embed_query("test")
-                break
-            except Exception as e:
-                if attempt == max_retries - 1:
-                    raise ConnectionError(f"Failed to connect to Azure OpenAI API after {max_retries} attempts. Error: {str(e)}")
-                time.sleep(2)  # Wait before retrying
-        
-    def initialize_vector_store(self, chunks: List[Dict]):
-        """
-        Initialize the vector store with document chunks.
-        
-        Args:
-            chunks (List[Dict]): List of dictionaries containing text and metadata
-        """
-        texts = [chunk['text'] for chunk in chunks]
-        metadatas = [chunk['metadata'] for chunk in chunks]
-        
-        # Create vector store
-        self.vector_store = Chroma.from_texts(
-            texts=texts,
-            embedding=self.embeddings,
-            metadatas=metadatas
-        )
-        
-        # Initialize QA chain
-        llm = AzureChatOpenAI(temperature=0, model_name="gpt-3.5-turbo", azure_deployment_name=os.getenv('AZURE_OPENAI_DEPLOYMENT_NAME'), azure_endpoint=os.getenv('AZURE_OPENAI_ENDPOINT'), api_key=os.getenv('AZURE_OPENAI_KEY'))
-        self.qa_chain = RetrievalQA.from_chain_type(
-            llm=llm,
-            chain_type="stuff",
-            retriever=self.vector_store.as_retriever(
-                search_kwargs={"k": 3}
-            )
-        )
-    
-    def answer_question(self, question: str) -> Dict:
-        """
-        Answer a question using the RAG system.
-        
-        Args:
-            question (str): User's question
-            
-        Returns:
-            Dict: Answer and source information
-        """
-        if not self.qa_chain:
-            raise ValueError("Vector store not initialized. Please process documents first.")
-        
-        # Create a prompt that emphasizes definition extraction
-        prompt = f"""
-        Question: {question}
-        Please provide a clear and concise answer based on the provided context. 
-        If the question asks for a definition or explanation of a concept, 
-        make sure to provide that specifically. Include relevant examples or 
-        additional context only if they help clarify the concept.
-        """
-        
-        # Get answer from QA chain
-        result = self.qa_chain({"query": prompt})
-        
-        # Get source documents
-        source_docs = self.vector_store.similarity_search(question, k=2)
-        sources = [
-            {
-                'page': doc.metadata['page'],
-                'text': doc.page_content[:200] + "..."  # Preview of source text
-            }
-            for doc in source_docs
-        ]
-        
-        return {
-            'answer': result['result'],
-            'sources': sources
-        }

railway.toml

@@ -1,8 +0,0 @@
-[build]
-builder = "NIXPACKS"
-buildCommand = "apt-get update && apt-get install -y build-essential && pip install --upgrade pip && pip install -r requirements.txt"
-
-[deploy]
-startCommand = "streamlit run streamlit_app.py --server.address=0.0.0.0 --server.port=$PORT"
-restartPolicyType = "ON_FAILURE"
-restartPolicyMaxRetries = 10

requirements-dev.txt

@@ -1,20 +0,0 @@
--r requirements.txt
-
-# Testing
-pytest==7.4.3
-pytest-cov==4.1.0
-
-# Linting
-flake8==6.1.0
-black==23.11.0
-
-# Type checking
-mypy==1.7.1
-
-# Documentation
-sphinx==7.2.6
-sphinx-rtd-theme==1.3.0
-
-# Development tools
-pre-commit==3.5.0
-python-dotenv==1.0.0

requirements.txt

@@ -1,13 +0,0 @@
-streamlit==1.29.0
-openai==1.6.1
-python-dotenv==1.0.0
-PyPDF2==3.0.1
-langchain==0.0.352
-chromadb==0.3.26
-pydantic==1.10.13
-azure-storage-blob==12.19.0
-numpy==1.22.4
-duckdb==0.9.2
-typing-inspect==0.8.0
-overrides==7.3.1
-SQLAlchemy==2.0.19

requirements_api.txt

@@ -1,4 +0,0 @@
-openai==1.6.1
-python-dotenv==1.0.0
-PyPDF2==3.0.1
-langchain==0.0.352

src/__init__.py

@@ -1 +0,0 @@
-

src/pdf_processor.py

@@ -1,112 +0,0 @@
-"""
-PDF processing module for extracting and chunking text from PDF documents.
-"""
-import logging
-from typing import List, Tuple
-import PyPDF2
-from io import BytesIO
-
-from app.config import MAX_CHUNK_SIZE, OVERLAP_SIZE
-
-logger = logging.getLogger('pdf')
-
-class PDFProcessor:
-    """Handles PDF document processing and text chunking."""
-    
-    @staticmethod
-    def extract_text(pdf_file: BytesIO) -> str:
-        """Extract text content from a PDF file."""
-        try:
-            pdf_reader = PyPDF2.PdfReader(pdf_file)
-            text = ""
-            
-            for page in pdf_reader.pages:
-                text += page.extract_text() + "\n"
-            
-            logger.info(f"Successfully extracted text from PDF ({len(text)} characters)")
-            return text
-            
-        except Exception as e:
-            logger.error(f"Error extracting text from PDF: {str(e)}")
-            raise
-    
-    @staticmethod
-    def create_chunks(text: str, chunk_size: int = MAX_CHUNK_SIZE, 
-                     overlap: int = OVERLAP_SIZE) -> List[Tuple[str, dict]]:
-        """Split text into overlapping chunks with metadata."""
-        try:
-            chunks = []
-            start = 0
-            
-            while start < len(text):
-                # Find the end of the chunk
-                end = start + chunk_size
-                
-                # If we're not at the end of the text, try to find a good break point
-                if end < len(text):
-                    # Try to find the last period or newline in the chunk
-                    last_period = text.rfind('.', start, end)
-                    last_newline = text.rfind('\n', start, end)
-                    break_point = max(last_period, last_newline)
-                    
-                    if break_point > start:
-                        end = break_point + 1
-                
-                # Create chunk with metadata
-                chunk_text = text[start:end].strip()
-                if chunk_text:  # Only add non-empty chunks
-                    metadata = {
-                        "start_char": start,
-                        "end_char": end,
-                        "chunk_size": len(chunk_text)
-                    }
-                    chunks.append((chunk_text, metadata))
-                
-                # Move the start position, accounting for overlap
-                start = end - overlap if end < len(text) else len(text)
-            
-            logger.info(f"Created {len(chunks)} chunks from text")
-            return chunks
-            
-        except Exception as e:
-            logger.error(f"Error creating chunks: {str(e)}")
-            raise
-    
-    @staticmethod
-    def clean_text(text: str) -> str:
-        """Clean and normalize extracted text."""
-        try:
-            # Remove extra whitespace
-            text = ' '.join(text.split())
-            
-            # Remove special characters that might cause issues
-            text = text.replace('\x00', '')
-            
-            # Normalize newlines
-            text = text.replace('\r\n', '\n')
-            
-            logger.info("Text cleaned successfully")
-            return text
-            
-        except Exception as e:
-            logger.error(f"Error cleaning text: {str(e)}")
-            raise
-    
-    def process_pdf(self, pdf_file: BytesIO) -> List[Tuple[str, dict]]:
-        """Process PDF file and return chunks with metadata."""
-        try:
-            # Extract text from PDF
-            raw_text = self.extract_text(pdf_file)
-            
-            # Clean the extracted text
-            cleaned_text = self.clean_text(raw_text)
-            
-            # Create chunks
-            chunks = self.create_chunks(cleaned_text)
-            
-            logger.info(f"PDF processed successfully: {len(chunks)} chunks created")
-            return chunks
-            
-        except Exception as e:
-            logger.error(f"Error processing PDF: {str(e)}")
-            raise

src/rag_engine.py

@@ -1,131 +0,0 @@
-"""
-RAG (Retrieval Augmented Generation) engine for the CRE Chatbot.
-"""
-import logging
-import os
-from typing import List, Dict, Any, Optional
-
-import chromadb
-from chromadb.config import Settings
-from openai import AzureOpenAI
-from app.config import (
-    AZURE_OPENAI_ENDPOINT,
-    AZURE_OPENAI_API_KEY,  # Added this line
-    TEMPERATURE,
-    MAX_TOKENS,
-    AZURE_OPENAI_EMBEDDING_DEPLOYMENT_NAME
-)
-
-logger = logging.getLogger('rag')
-
-class RAGEngine:
-    """Handles document retrieval and question answering using Azure OpenAI."""
-    
-    def __init__(self, deployment_name: str):
-        """Initialize the RAG engine with Azure OpenAI client."""
-        self.client = AzureOpenAI(
-            api_key=AZURE_OPENAI_API_KEY,
-            api_version="2023-12-01-preview",
-            azure_endpoint=AZURE_OPENAI_ENDPOINT
-        )
-        self.deployment_name = deployment_name
-        self.embedding_deployment_name = AZURE_OPENAI_EMBEDDING_DEPLOYMENT_NAME
-        
-        # Initialize ChromaDB with simple in-memory settings
-        self.chroma_client = chromadb.Client(Settings(anonymized_telemetry=False))
-        self.collection = None
-        self.initialize_vector_store("cre_docs")
-        logger.info("RAG Engine initialized with Azure OpenAI")
-    
-    def create_embeddings(self, texts: List[str]) -> List[List[float]]:
-        """Create embeddings for the given texts using Azure OpenAI."""
-        try:
-            response = self.client.embeddings.create(
-                input=texts,
-                model=self.embedding_deployment_name
-            )
-            return [item.embedding for item in response.data]
-        except Exception as e:
-            logger.error(f"Error creating embeddings: {str(e)}")
-            raise
-    
-    def initialize_vector_store(self, collection_name: str):
-        """Initialize or get the vector store collection."""
-        try:
-            self.collection = self.chroma_client.get_or_create_collection(
-                name=collection_name,
-                metadata={"hnsw:space": "cosine"}
-            )
-            logger.info(f"Vector store initialized with collection: {collection_name}")
-        except Exception as e:
-            logger.error(f"Error initializing vector store: {str(e)}")
-            raise
-    
-    def add_documents(self, texts: List[str], metadata: Optional[List[Dict[str, Any]]] = None):
-        """Add documents to the vector store."""
-        try:
-            if not self.collection:
-                raise ValueError("Vector store collection not initialized")
-                
-            embeddings = self.create_embeddings(texts)
-            # Use timestamp + index as ID to ensure uniqueness
-            import time
-            timestamp = int(time.time())
-            ids = [f"{timestamp}_{i}" for i in range(len(texts))]
-            
-            self.collection.add(
-                embeddings=embeddings,
-                documents=texts,
-                ids=ids,
-                metadatas=metadata if metadata else [{}] * len(texts)
-            )
-            logger.info(f"Added {len(texts)} documents to vector store")
-        except Exception as e:
-            logger.error(f"Error adding documents: {str(e)}")
-            raise
-    
-    def query(self, question: str, k: int = 3) -> Dict[str, Any]:
-        """Query the vector store and generate an answer."""
-        try:
-            # Create embedding for the question
-            question_embedding = self.create_embeddings([question])[0]
-            
-            # Query vector store
-            results = self.collection.query(
-                query_embeddings=[question_embedding],
-                n_results=k
-            )
-            
-            # Prepare context from retrieved documents
-            context = "\n".join(results['documents'][0])
-            
-            # Generate answer using Azure OpenAI
-            messages = [
-                {"role": "system", "content": "You are a helpful assistant that answers questions about commercial real estate concepts. Use the provided context to answer questions accurately and concisely."},
-                {"role": "user", "content": f"Context: {context}\n\nQuestion: {question}"}
-            ]
-            
-            response = self.client.chat.completions.create(
-                model=self.deployment_name,
-                messages=messages,
-                temperature=TEMPERATURE,
-                max_tokens=MAX_TOKENS
-            )
-            
-            answer = response.choices[0].message.content
-            
-            return {
-                "answer": answer,
-                "context": context,
-                "source_documents": results['documents'][0]
-            }
-            
-        except Exception as e:
-            logger.error(f"Error querying RAG engine: {str(e)}")
-            raise
-    
-    def clear(self):
-        """Clear the vector store collection."""
-        if self.collection:
-            self.collection.delete()
-            logger.info("Vector store collection cleared")

startup.sh

@@ -1,2 +0,0 @@
-#!/bin/sh
-streamlit run app/main.py --server.port 8000 --server.address 0.0.0.0

staticwebapp.config.json

@@ -1,31 +0,0 @@
-{
-    "routes": [
-        {
-            "route": "/api/*",
-            "serve": "/api",
-            "methods": ["GET", "POST"]
-        },
-        {
-            "route": "/*",
-            "serve": "/",
-            "statusCode": 200
-        }
-    ],
-    "navigationFallback": {
-        "rewrite": "/index.html"
-    },
-    "platform": {
-        "apiRuntime": "python:3.11"
-    },
-    "globalHeaders": {
-        "Content-Security-Policy": "default-src * 'unsafe-inline' 'unsafe-eval' data: blob:;",
-        "Access-Control-Allow-Origin": "*"
-    },
-    "buildProperties": {
-        "appLocation": "/frontend",
-        "apiLocation": "/api",
-        "outputLocation": "",
-        "apiBuildCommand": "pip install -r requirements.txt",
-        "appBuildCommand": "pip install -r requirements.txt"
-    }
-}

streamlit_app.py

@@ -1,43 +0,0 @@
-import streamlit as st
-import os
-from dotenv import load_dotenv
-from pdf_processor import PDFProcessor
-from rag_engine import RAGEngine
-from app.config import AZURE_OPENAI_DEPLOYMENT_NAME
-
-# Load environment variables
-load_dotenv()
-
-# Initialize components
-pdf_processor = PDFProcessor()
-rag_engine = RAGEngine(deployment_name=AZURE_OPENAI_DEPLOYMENT_NAME)
-
-def main():
-    st.set_page_config(
-        page_title="CRE Knowledge Assistant",
-        page_icon="🤖",
-        layout="wide"
-    )
-
-    st.title("CRE Knowledge Assistant 🏢")
-    
-    # File uploader
-    uploaded_file = st.file_uploader("Upload a PDF document", type="pdf")
-    
-    if uploaded_file:
-        try:
-            # Process the PDF
-            pdf_processor.process(uploaded_file)
-            st.success("PDF processed successfully! You can now ask questions about it.")
-            
-            # Show chat interface
-            user_question = st.text_input("Ask a question about the document:")
-            if user_question:
-                response = rag_engine.get_response(user_question)
-                st.write("Answer:", response)
-                
-        except Exception as e:
-            st.error(f"Error processing PDF: {str(e)}")
-
-if __name__ == "__main__":
-    main()

tests/__init__.py

@@ -1 +0,0 @@
-

tests/test_pdf_processor.py

@@ -1,73 +0,0 @@
-"""
-Tests for the PDF processor module.
-"""
-import pytest
-from io import BytesIO
-from src.pdf_processor import PDFProcessor
-
-def test_clean_text():
-    """Test text cleaning functionality."""
-    processor = PDFProcessor()
-    
-    # Test removing extra whitespace
-    text = "This   has    extra   spaces"
-    assert processor.clean_text(text) == "This has extra spaces"
-    
-    # Test normalizing newlines
-    text = "Line1\r\nLine2\r\nLine3"
-    assert processor.clean_text(text) == "Line1 Line2 Line3"
-    
-    # Test removing null characters
-    text = "Text with\x00null\x00chars"
-    assert processor.clean_text(text) == "Text with null chars"
-
-def test_create_chunks():
-    """Test text chunking functionality."""
-    processor = PDFProcessor()
-    
-    # Test basic chunking
-    text = "This is a test. This is another test. And a final test."
-    chunks = processor.create_chunks(text, chunk_size=20, overlap=5)
-    
-    assert len(chunks) > 0
-    assert all(isinstance(chunk, tuple) for chunk in chunks)
-    assert all(len(chunk) == 2 for chunk in chunks)  # (text, metadata)
-    assert all(isinstance(chunk[1], dict) for chunk in chunks)  # metadata is dict
-
-def test_chunk_metadata():
-    """Test chunk metadata creation."""
-    processor = PDFProcessor()
-    
-    text = "Short test text."
-    chunks = processor.create_chunks(text, chunk_size=20, overlap=5)
-    
-    assert len(chunks) == 1
-    chunk_text, metadata = chunks[0]
-    
-    assert "start_char" in metadata
-    assert "end_char" in metadata
-    assert "chunk_size" in metadata
-    assert metadata["chunk_size"] == len(chunk_text)
-
-def test_empty_text():
-    """Test handling of empty text."""
-    processor = PDFProcessor()
-    
-    chunks = processor.create_chunks("")
-    assert len(chunks) == 0
-
-def test_chunk_overlap():
-    """Test chunk overlap functionality."""
-    processor = PDFProcessor()
-    
-    text = "This is a long text that should be split into multiple chunks with overlap."
-    chunks = processor.create_chunks(text, chunk_size=20, overlap=5)
-    
-    # Check that chunks overlap
-    if len(chunks) > 1:
-        for i in range(len(chunks) - 1):
-            current_chunk = chunks[i][0]
-            next_chunk = chunks[i + 1][0]
-            
-            # There should be some overlap between consecutive chunks
-            assert any(word in next_chunk for word in current_chunk.split()[-3:])

tests/test_rag_engine.py

@@ -1,112 +0,0 @@
-"""
-Tests for the RAG engine module.
-"""
-import pytest
-from unittest.mock import Mock, patch
-from src.rag_engine import RAGEngine
-
-@pytest.fixture
-def mock_azure_client():
-    """Create a mock Azure OpenAI client."""
-    with patch('openai.AzureOpenAI') as mock_client:
-        yield mock_client
-
-@pytest.fixture
-def mock_chroma_client():
-    """Create a mock Chroma client."""
-    with patch('chromadb.Client') as mock_client:
-        yield mock_client
-
-@pytest.fixture
-def rag_engine(mock_azure_client, mock_chroma_client):
-    """Create a RAG engine instance with mocked dependencies."""
-    return RAGEngine("test-deployment")
-
-def test_create_embeddings(rag_engine, mock_azure_client):
-    """Test embedding creation."""
-    # Setup mock response
-    mock_response = Mock()
-    mock_response.data = [
-        Mock(embedding=[0.1, 0.2, 0.3]),
-        Mock(embedding=[0.4, 0.5, 0.6])
-    ]
-    rag_engine.client.embeddings.create.return_value = mock_response
-    
-    # Test
-    texts = ["Text 1", "Text 2"]
-    embeddings = rag_engine.create_embeddings(texts)
-    
-    # Verify
-    assert len(embeddings) == 2
-    assert all(isinstance(emb, list) for emb in embeddings)
-    assert len(embeddings[0]) == 3  # Embedding dimension
-
-def test_initialize_vector_store(rag_engine):
-    """Test vector store initialization."""
-    rag_engine.initialize_vector_store("test_collection")
-    
-    # Verify the collection was created
-    assert rag_engine.collection is not None
-
-def test_add_documents(rag_engine):
-    """Test adding documents to vector store."""
-    # Setup
-    rag_engine.initialize_vector_store("test_collection")
-    texts = ["Document 1", "Document 2"]
-    metadata = [{"source": "test1"}, {"source": "test2"}]
-    
-    # Create mock embeddings
-    with patch.object(rag_engine, 'create_embeddings') as mock_create_embeddings:
-        mock_create_embeddings.return_value = [[0.1, 0.2], [0.3, 0.4]]
-        
-        # Test
-        rag_engine.add_documents(texts, metadata)
-        
-        # Verify
-        mock_create_embeddings.assert_called_once_with(texts)
-        assert rag_engine.collection.add.called
-
-def test_query(rag_engine):
-    """Test querying the RAG engine."""
-    # Setup
-    rag_engine.initialize_vector_store("test_collection")
-    
-    # Mock embeddings creation
-    with patch.object(rag_engine, 'create_embeddings') as mock_create_embeddings:
-        mock_create_embeddings.return_value = [[0.1, 0.2]]
-        
-        # Mock vector store query
-        mock_results = {
-            'documents': [["Relevant document 1", "Relevant document 2"]],
-            'distances': [[0.1, 0.2]]
-        }
-        rag_engine.collection.query.return_value = mock_results
-        
-        # Mock chat completion
-        mock_response = Mock()
-        mock_response.choices = [Mock(message=Mock(content="Test answer"))]
-        rag_engine.client.chat.completions.create.return_value = mock_response
-        
-        # Test
-        result = rag_engine.query("Test question")
-        
-        # Verify
-        assert isinstance(result, dict)
-        assert "answer" in result
-        assert "context" in result
-        assert "source_documents" in result
-        assert result["answer"] == "Test answer"
-
-def test_error_handling(rag_engine):
-    """Test error handling in RAG engine."""
-    # Test error in embeddings creation
-    rag_engine.client.embeddings.create.side_effect = Exception("API Error")
-    
-    with pytest.raises(Exception):
-        rag_engine.create_embeddings(["Test"])
-    
-    # Test error in vector store initialization
-    rag_engine.chroma_client.get_or_create_collection.side_effect = Exception("DB Error")
-    
-    with pytest.raises(Exception):
-        rag_engine.initialize_vector_store("test")

vercel.json

@@ -1,14 +0,0 @@
-{
-  "builds": [
-    {
-      "src": "app.py",
-      "use": "@vercel/python"
-    }
-  ],
-  "routes": [
-    {
-      "src": "/(.*)",
-      "dest": "app.py"
-    }
-  ]
-}

vercel.txt

@@ -1,7 +0,0 @@
-streamlit==1.29.0
-openai==1.6.1
-python-dotenv==1.0.0
-PyPDF2==3.0.1
-langchain==0.0.352
-chromadb==0.3.26
-pydantic==1.10.13