Update for Hugging Face Space deployment

README.md

@@ -1,5 +1,5 @@
 ---
-title: Personal AI Assistant with RAG
+title: 🧠 Personal AI Second Brain
 emoji: 🤗
 colorFrom: indigo
 colorTo: purple
@@ -9,66 +9,152 @@ pinned: true
 license: mit
 ---
 
-# Personal AI Assistant with RAG
+# 🧠 Personal AI Second Brain
 
-A powerful personal AI assistant that uses Retrieval-Augmented Generation (RAG) to provide responses based on your documents and notes.
+A personalized AI assistant that serves as your second brain, built with Hugging Face, Streamlit, and Telegram integration. This system helps you store and retrieve information from your documents, conversations, and notes through a powerful Retrieval-Augmented Generation (RAG) system.
 
 ## Features
 
-- Uses free Hugging Face models for language processing and embeddings
-- Stores and retrieves information in a vector database 
-- Upload PDF, TXT, and CSV files to expand the knowledge base
-- Add direct text input to your knowledge base
-- View sources for AI responses
-- Conversation history tracking
+- **Chat Interface**: Ask questions and get answers based on your personal knowledge base
+- **Document Management**: Upload and process documents (PDF, TXT, DOC, etc.)
+- **RAG System**: Retrieve relevant information from your knowledge base
+- **Telegram Integration**: Access your second brain through Telegram
+- **Persistent Chat History**: Store conversations in Hugging Face Datasets
+- **Expandable**: Easy to add new data sources and functionalities
+
+## Architecture
+
+The system is built with the following components:
+
+1. **LLM Layer**: Uses Hugging Face models for text generation and embeddings
+2. **Memory Layer**: Vector database (Qdrant) for storing and retrieving information
+3. **RAG System**: Retrieval-Augmented Generation to ground answers in your data
+4. **Ingestion Pipeline**: Process documents and chat history
+5. **Telegram Bot**: Integration with Telegram for chat-based access
+6. **Hugging Face Dataset**: Persistent storage for chat history
+
+## Setup
+
+### Requirements
+
+- Python 3.8+
+- Hugging Face account (for model access and hosting)
+- Telegram account (for bot integration, optional)
+
+### Installation
+
+1. Clone the repository:
+   ```
+   git clone <repository-url>
+   cd personal-ai-second-brain
+   ```
+
+2. Install dependencies:
+   ```
+   pip install -r requirements.txt
+   ```
+
+3. Create a `.env` file with your configuration:
+   ```
+   # API Keys
+   HF_API_KEY=your_huggingface_api_key_here
+   TELEGRAM_BOT_TOKEN=your_telegram_bot_token_here
+   
+   # LLM Configuration
+   LLM_MODEL=gpt2  # Use small model for Hugging Face Spaces
+   EMBEDDING_MODEL=sentence-transformers/all-MiniLM-L6-v2
+   
+   # Vector Database
+   VECTOR_DB_PATH=./data/vector_db
+   COLLECTION_NAME=personal_assistant
+   
+   # Application Settings
+   DEFAULT_TEMPERATURE=0.7
+   CHUNK_SIZE=512
+   CHUNK_OVERLAP=128
+   MAX_TOKENS=256
+   
+   # Telegram Bot Settings
+   TELEGRAM_ENABLED=false
+   TELEGRAM_ALLOWED_USERS=  # Comma-separated list of Telegram user IDs
+   
+   # Hugging Face Dataset Settings
+   HF_DATASET_NAME=username/second-brain-history  # Your username/dataset-name
+   CHAT_HISTORY_DIR=./data/chat_history
+   SYNC_INTERVAL=60  # How often to sync history to HF (minutes)
+   ```
+
+4. Create necessary directories:
+   ```
+   mkdir -p data/documents data/vector_db data/chat_history
+   ```
+
+### Running Locally
+
+Start the application:
+```
+streamlit run app/ui/streamlit_app.py
+```
 
-## How to Use
+### Deploying to Hugging Face Spaces
 
-1. **Upload Documents**: Use the sidebar to upload files (PDF, TXT, CSV)
-2. **Add Text**: Enter text directly into the knowledge base
-3. **Ask Questions**: Chat with the assistant about your documents
-4. **View Sources**: See where information is coming from
+1. Create a new Space on Hugging Face
+2. Upload the code to the Space
+3. Set the environment variables in the Space settings
+4. The application will automatically start
 
-## Deployment
+## Telegram Bot Setup
 
-### Local Deployment
+1. Talk to [@BotFather](https://t.me/botfather) on Telegram
+2. Use the `/newbot` command to create a new bot
+3. Get your bot token and add it to your `.env` file
+4. Set `TELEGRAM_ENABLED=true` in your `.env` file
+5. To find your Telegram user ID (for restricting access), talk to [@userinfobot](https://t.me/userinfobot)
 
-To run the app locally:
+### Telegram Commands
 
-1. Clone this repository
-2. Install requirements: `pip install -r requirements.txt`
-3. Run the Streamlit UI: `python run.py --ui`
-4. Or run the API server: `python run.py --api`
+- **/start**: Start a conversation with the bot
+- **/help**: Shows available commands
+- **/search**: Use `/search your query` to search your knowledge base
+- **Direct messages**: Send any message to chat with your second brain
 
-### Deploying to Hugging Face Spaces
+## Hugging Face Dataset Integration
+
+To enable persistent chat history across deployments:
+
+1. Create a private dataset repository on Hugging Face Hub
+2. Set your API token in the `.env` file as `HF_API_KEY`
+3. Set your dataset name as `HF_DATASET_NAME` (format: username/repo-name)
 
-This application can be easily deployed to Hugging Face Spaces for free hosting:
+## Customization
 
-1. Make sure you have a Hugging Face account
-2. Create a Hugging Face API token at https://huggingface.co/settings/tokens
-3. Run the deployment script: `python deploy_to_hf.py`
-4. Follow the prompts to enter your username, token, and space name
-5. Wait for the deployment to complete
+### Using Different Models
 
-If you encounter any issues during deployment, run `python check_git_status.py` to diagnose and fix common problems.
+You can change the models by updating the `.env` file:
 
-The deployment process:
-- Creates a Hugging Face Space using the Spaces SDK
-- Configures git for pushing to Hugging Face
-- Pushes your code to the Space
-- Builds and deploys the Docker container automatically
+```
+LLM_MODEL=mistralai/Mistral-7B-Instruct-v0.2
+EMBEDDING_MODEL=sentence-transformers/all-mpnet-base-v2
+```
 
-## Built With
+### Adding Custom Tools
 
-- Hugging Face Models
-  - LLM: google/flan-t5-large
-  - Embeddings: sentence-transformers/all-MiniLM-L6-v2
-- LangChain for orchestration
-- Qdrant for vector storage
-- Streamlit for UI
+To add custom tools to your agent, modify the `app/core/agent.py` file to include additional functionality.
 
-Created by [p3rc03](https://huggingface.co/p3rc03) 
+## Roadmap
+
+- [ ] Web search tool integration
+- [ ] Calendar and email integration
+- [ ] Voice interface
+- [ ] Mobile app integration
+- [ ] Fine-tuning for personalized responses
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
 
 ## License
 
-MIT License - See LICENSE file for details 
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+Created by [p3rc03](https://huggingface.co/p3rc03) 

app/config.py

@@ -9,6 +9,7 @@ load_dotenv(dotenv_path=env_path)
 
 # API Keys
 HF_API_KEY = os.getenv('HF_API_KEY', '')
+TELEGRAM_BOT_TOKEN = os.getenv('TELEGRAM_BOT_TOKEN', '')
 
 # LLM Configuration
 # Use models that are freely accessible and don't require authentication
@@ -38,12 +39,27 @@ CHUNK_SIZE = int(os.getenv('CHUNK_SIZE', 512))
 CHUNK_OVERLAP = int(os.getenv('CHUNK_OVERLAP', 128))
 MAX_TOKENS = int(os.getenv('MAX_TOKENS', 256))
 
+# Telegram Bot Settings
+TELEGRAM_ENABLED = os.getenv('TELEGRAM_ENABLED', 'false').lower() == 'true'
+TELEGRAM_ALLOWED_USERS = os.getenv('TELEGRAM_ALLOWED_USERS', '')
+if TELEGRAM_ALLOWED_USERS:
+    TELEGRAM_ALLOWED_USERS = [int(user_id.strip()) for user_id in TELEGRAM_ALLOWED_USERS.split(',')]
+else:
+    TELEGRAM_ALLOWED_USERS = []
+
+# Hugging Face Dataset Settings for Chat History
+HF_DATASET_NAME = os.getenv('HF_DATASET_NAME', '')  # Format: username/repo-name
+CHAT_HISTORY_DIR = os.getenv('CHAT_HISTORY_DIR', './data/chat_history')
+# How often to sync chat history to HF Hub (in minutes)
+SYNC_INTERVAL = int(os.getenv('SYNC_INTERVAL', 60))
+
 # Create a template .env file if it doesn't exist
 def create_env_example():
     if not os.path.exists('.env.example'):
         with open('.env.example', 'w') as f:
             f.write("""# API Keys
 HF_API_KEY=your_huggingface_api_key_here
+TELEGRAM_BOT_TOKEN=your_telegram_bot_token_here
 
 # LLM Configuration
 LLM_MODEL=gpt2  # Use small model for Hugging Face Spaces
@@ -58,4 +74,13 @@ DEFAULT_TEMPERATURE=0.7
 CHUNK_SIZE=512
 CHUNK_OVERLAP=128
 MAX_TOKENS=256
+
+# Telegram Bot Settings
+TELEGRAM_ENABLED=false
+TELEGRAM_ALLOWED_USERS=  # Comma-separated list of Telegram user IDs
+
+# Hugging Face Dataset Settings
+HF_DATASET_NAME=username/second-brain-history  # Your username/dataset-name
+CHAT_HISTORY_DIR=./data/chat_history
+SYNC_INTERVAL=60  # How often to sync history to HF (minutes)
 """) 

app/core/chat_history.py

@@ -0,0 +1,192 @@
+import os
+import logging
+import uuid
+import json
+import pandas as pd
+from datetime import datetime
+from typing import List, Dict, Any, Optional
+from datasets import Dataset, load_dataset
+from huggingface_hub import HfApi, HfFolder, CommitOperationAdd
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class ChatHistoryManager:
+    """
+    Manages chat history persistence using Hugging Face Datasets.
+    Supports both local storage and syncing to Hugging Face Hub.
+    """
+    
+    def __init__(self, dataset_name=None, local_dir="./data/chat_history"):
+        """
+        Initialize the chat history manager.
+        
+        Args:
+            dataset_name: Hugging Face dataset name (username/repo)
+            local_dir: Local directory to store chat history
+        """
+        self.dataset_name = dataset_name or os.getenv("HF_DATASET_NAME")
+        self.local_dir = local_dir
+        self.hf_api = HfApi()
+        self.token = os.getenv("HF_API_KEY")
+        
+        # Create local directory if it doesn't exist
+        os.makedirs(self.local_dir, exist_ok=True)
+        
+        # Local path for the jsonl file
+        self.local_file = os.path.join(self.local_dir, "chat_history.jsonl")
+        
+        # Ensure the file exists
+        if not os.path.exists(self.local_file):
+            with open(self.local_file, "w") as f:
+                f.write("")
+                
+        logger.info(f"Chat history manager initialized with local file: {self.local_file}")
+        if self.dataset_name:
+            logger.info(f"Will sync to HF dataset: {self.dataset_name}")
+    
+    def load_history(self) -> List[Dict[str, Any]]:
+        """Load chat history from local file or Hugging Face dataset."""
+        try:
+            # First try to load from local file
+            if os.path.exists(self.local_file) and os.path.getsize(self.local_file) > 0:
+                with open(self.local_file, "r") as f:
+                    lines = f.readlines()
+                    history = [json.loads(line) for line in lines if line.strip()]
+                    logger.info(f"Loaded {len(history)} conversations from local file")
+                    return history
+            
+            # If local file is empty or doesn't exist, try to load from HF
+            if self.dataset_name and self.token:
+                try:
+                    dataset = load_dataset(self.dataset_name, token=self.token)
+                    history = dataset["train"].to_pandas().to_dict("records")
+                    logger.info(f"Loaded {len(history)} conversations from Hugging Face")
+                    
+                    # Write back to local file
+                    self._write_history_to_local(history)
+                    return history
+                except Exception as e:
+                    logger.warning(f"Error loading from Hugging Face: {e}")
+            
+            # If we get here, return empty history
+            return []
+        except Exception as e:
+            logger.error(f"Error loading chat history: {e}")
+            return []
+    
+    def save_conversation(self, conversation: Dict[str, Any]) -> bool:
+        """
+        Save a conversation to history.
+        
+        Args:
+            conversation: Dict with keys: user_query, assistant_response, 
+                          timestamp, sources (optional)
+        
+        Returns:
+            bool: True if successful
+        """
+        try:
+            # Add ID and timestamp if not present
+            if "id" not in conversation:
+                conversation["id"] = str(uuid.uuid4())
+            if "timestamp" not in conversation:
+                conversation["timestamp"] = datetime.now().isoformat()
+            
+            # Append to local file
+            with open(self.local_file, "a") as f:
+                f.write(json.dumps(conversation) + "\n")
+            
+            logger.info(f"Saved conversation to local file: {conversation['id']}")
+            return True
+        except Exception as e:
+            logger.error(f"Error saving conversation: {e}")
+            return False
+    
+    def sync_to_hub(self) -> bool:
+        """Sync local chat history to Hugging Face Hub."""
+        if not self.dataset_name or not self.token:
+            logger.warning("Cannot sync to Hub: missing dataset name or token")
+            return False
+            
+        try:
+            # Read the local file
+            history = self.load_history()
+            if not history:
+                logger.warning("No history to sync")
+                return False
+                
+            # Create a Dataset object
+            ds = Dataset.from_pandas(
+                pd.DataFrame(history)
+            )
+            
+            # Push to Hub
+            ds.push_to_hub(
+                self.dataset_name,
+                token=self.token,
+                private=True
+            )
+            
+            logger.info(f"Successfully synced {len(history)} conversations to Hugging Face Hub")
+            return True
+        except Exception as e:
+            logger.error(f"Error syncing to Hub: {e}")
+            return False
+    
+    def _write_history_to_local(self, history: List[Dict[str, Any]]) -> bool:
+        """Write history list to local file."""
+        try:
+            with open(self.local_file, "w") as f:
+                for conversation in history:
+                    f.write(json.dumps(conversation) + "\n")
+            return True
+        except Exception as e:
+            logger.error(f"Error writing history to local file: {e}")
+            return False
+    
+    def get_conversations_by_date(self, start_date=None, end_date=None) -> List[Dict[str, Any]]:
+        """Get conversations filtered by date range."""
+        history = self.load_history()
+        
+        if not start_date and not end_date:
+            return history
+            
+        filtered = []
+        for conv in history:
+            timestamp = conv.get("timestamp", "")
+            if not timestamp:
+                continue
+                
+            try:
+                conv_date = datetime.fromisoformat(timestamp)
+                
+                if start_date and end_date:
+                    if start_date <= conv_date <= end_date:
+                        filtered.append(conv)
+                elif start_date:
+                    if start_date <= conv_date:
+                        filtered.append(conv)
+                elif end_date:
+                    if conv_date <= end_date:
+                        filtered.append(conv)
+            except ValueError:
+                continue
+                
+        return filtered
+    
+    def search_conversations(self, query: str) -> List[Dict[str, Any]]:
+        """Search conversations by keyword (simple text match)."""
+        history = self.load_history()
+        query = query.lower()
+        
+        results = []
+        for conv in history:
+            user_query = conv.get("user_query", "").lower()
+            assistant_response = conv.get("assistant_response", "").lower()
+            
+            if query in user_query or query in assistant_response:
+                results.append(conv)
+                
+        return results 

app/core/discord_bot.py

@@ -0,0 +1,177 @@
+import discord
+import asyncio
+import logging
+import os
+from typing import Dict, List, Any
+import threading
+from discord.ext import commands
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class DiscordBot:
+    """
+    Discord bot integration for the AI second brain.
+    Handles message ingestion, responses, and synchronization with the main app.
+    """
+    
+    def __init__(self, agent, token=None, channel_whitelist=None):
+        """
+        Initialize the Discord bot.
+        
+        Args:
+            agent: The AssistantAgent instance to use for processing queries
+            token: Discord bot token (defaults to environment variable)
+            channel_whitelist: List of channel IDs to listen to (None for all)
+        """
+        self.agent = agent
+        self.token = token or os.getenv("DISCORD_BOT_TOKEN")
+        self.channel_whitelist = channel_whitelist or []
+        self.message_history = []
+        
+        # Set up Discord client with intents
+        intents = discord.Intents.default()
+        intents.message_content = True  # Required to read message content
+        self.client = commands.Bot(command_prefix="!", intents=intents)
+        
+        # Register event handlers
+        self.setup_event_handlers()
+        
+        # Thread for bot
+        self.bot_thread = None
+        
+        logger.info("Discord bot initialized")
+    
+    def setup_event_handlers(self):
+        """Register event handlers for the Discord client."""
+        
+        @self.client.event
+        async def on_ready():
+            logger.info(f"Discord bot logged in as {self.client.user}")
+        
+        @self.client.event
+        async def on_message(message):
+            # Don't respond to self
+            if message.author == self.client.user:
+                return
+                
+            # Check if this is a command
+            await self.client.process_commands(message)
+            
+            # Only process messages in whitelisted channels if whitelist exists
+            if self.channel_whitelist and message.channel.id not in self.channel_whitelist:
+                return
+                
+            # Only respond to messages that mention the bot or are DMs
+            is_dm = isinstance(message.channel, discord.DMChannel)
+            is_mentioned = self.client.user in message.mentions
+            
+            if is_dm or is_mentioned:
+                await self.process_message(message)
+        
+        # Add a !help command
+        @self.client.command(name="help")
+        async def help_command(ctx):
+            help_text = """
+**AI Assistant Commands**
+- Mention me with a question to get an answer
+- Send me a DM with your query
+- Use `!search <query>` to search your knowledge base
+- Use `!upload` with an attachment to add to your knowledge base
+            """
+            await ctx.send(help_text)
+            
+        # Add a search command
+        @self.client.command(name="search")
+        async def search_command(ctx, *, query):
+            async with ctx.typing():
+                response = await self.process_query(query)
+                await ctx.send(response["answer"])
+                
+                # If there are sources, show them in a followup message
+                if response["sources"]:
+                    sources_text = "**Sources:**\n" + "\n".join([
+                        f"- {s['file_name']} ({s['source']})"
+                        for s in response["sources"]
+                    ])
+                    await ctx.send(sources_text)
+    
+    async def process_message(self, message):
+        """Process a Discord message and send a response."""
+        # Clean up mention and extract query
+        content = message.content
+        for mention in message.mentions:
+            content = content.replace(f'<@{mention.id}>', '').replace(f'<@!{mention.id}>', '')
+        
+        query = content.strip()
+        if not query:
+            await message.channel.send("How can I help you?")
+            return
+            
+        # Show typing indicator
+        async with message.channel.typing():
+            # Process the query and get a response
+            response = await self.process_query(query)
+            
+            # Store in message history
+            self.message_history.append({
+                "user": str(message.author),
+                "query": query,
+                "response": response["answer"],
+                "timestamp": message.created_at.isoformat(),
+                "channel": str(message.channel)
+            })
+            
+            # Send the response
+            await message.channel.send(response["answer"])
+            
+            # If there are sources, send them in a followup message
+            if response["sources"]:
+                sources_text = "**Sources:**\n" + "\n".join([
+                    f"- {s['file_name']} ({s['source']})"
+                    for s in response["sources"]
+                ])
+                await message.channel.send(sources_text)
+    
+    async def process_query(self, query):
+        """Process a query using the agent and return a response."""
+        # Run the query in a thread to avoid blocking the event loop
+        loop = asyncio.get_event_loop()
+        response = await loop.run_in_executor(None, self.agent.query, query)
+        
+        # Add the conversation to the agent's memory
+        if "answer" in response:
+            await loop.run_in_executor(
+                None, 
+                self.agent.add_conversation_to_memory,
+                query, 
+                response["answer"]
+            )
+            
+        return response
+    
+    def start(self):
+        """Start the Discord bot in a separate thread."""
+        if not self.token:
+            logger.error("Discord bot token not found")
+            return False
+            
+        def run_bot():
+            asyncio.set_event_loop(asyncio.new_event_loop())
+            self.client.run(self.token)
+            
+        self.bot_thread = threading.Thread(target=run_bot, daemon=True)
+        self.bot_thread.start()
+        logger.info("Discord bot started in background thread")
+        return True
+        
+    def stop(self):
+        """Stop the Discord bot."""
+        if self.client and self.client.is_ready():
+            asyncio.run_coroutine_threadsafe(self.client.close(), self.client.loop)
+            logger.info("Discord bot stopped")
+            
+    def get_message_history(self):
+        """Get the message history."""
+        return self.message_history 

app/core/ingestion.py

@@ -5,7 +5,7 @@ import time
 import random
 import traceback
 from typing import List, Dict, Any
-from langchain.document_loaders import (
+from langchain_community.document_loaders import (
     PyPDFLoader,
     TextLoader,
     CSVLoader,

app/core/llm.py

@@ -1,4 +1,4 @@
-from langchain.llms import HuggingFaceHub
+from langchain_community.llms import HuggingFaceHub
 from langchain_community.llms import HuggingFaceEndpoint, HuggingFacePipeline
 from langchain_community.embeddings import HuggingFaceEmbeddings
 from langchain.chains import LLMChain

app/core/memory.py

@@ -3,7 +3,7 @@ import sys
 import time
 import random
 import logging
-from langchain.vectorstores import Qdrant
+from langchain_community.vectorstores import Qdrant
 from langchain.chains import ConversationalRetrievalChain
 from langchain.memory import ConversationBufferMemory
 from qdrant_client import QdrantClient

app/core/telegram_bot.py

@@ -0,0 +1,233 @@
+import os
+import logging
+import threading
+import asyncio
+from typing import Dict, List, Any
+import time
+from datetime import datetime
+from telegram import Update, Bot
+from telegram.ext import Application, CommandHandler, MessageHandler, ContextTypes, filters
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class TelegramBot:
+    """
+    Telegram bot integration for the AI second brain.
+    Handles message ingestion, responses, and synchronization with the main app.
+    """
+    
+    def __init__(self, agent, token=None, allowed_user_ids=None):
+        """
+        Initialize the Telegram bot.
+        
+        Args:
+            agent: The AssistantAgent instance to use for processing queries
+            token: Telegram bot token (defaults to environment variable)
+            allowed_user_ids: List of Telegram user IDs that can use the bot (None for all)
+        """
+        self.agent = agent
+        self.token = token or os.getenv("TELEGRAM_BOT_TOKEN")
+        self.allowed_user_ids = allowed_user_ids or []
+        if isinstance(self.allowed_user_ids, str):
+            # Convert comma-separated string to list of integers
+            self.allowed_user_ids = [int(uid.strip()) for uid in self.allowed_user_ids.split(',') if uid.strip()]
+        self.message_history = []
+        
+        # Initialize bot application
+        self.application = None
+        self.bot_thread = None
+        
+        logger.info("Telegram bot initialized")
+    
+    async def start_command(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
+        """Handle the /start command."""
+        user_name = update.message.from_user.first_name
+        await update.message.reply_text(
+            f"Hello {user_name}! I'm your AI Second Brain assistant. Ask me anything or use /help to see available commands."
+        )
+    
+    async def help_command(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
+        """Handle the /help command."""
+        help_text = """
+*AI Second Brain Commands*
+- Just send me a message with your question
+- /search query - Search your knowledge base
+- /help - Show this help message
+        """
+        await update.message.reply_text(help_text, parse_mode='Markdown')
+    
+    async def search_command(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
+        """Handle the /search command."""
+        # Check if user is allowed
+        if self.allowed_user_ids and update.message.from_user.id not in self.allowed_user_ids:
+            await update.message.reply_text("You're not authorized to use this bot.")
+            return
+            
+        query = ' '.join(context.args)
+        if not query:
+            await update.message.reply_text("Please provide a search query: /search your query here")
+            return
+            
+        # Show typing status
+        await context.bot.send_chat_action(chat_id=update.effective_chat.id, action="typing")
+        
+        # Process the query
+        try:
+            response = await self.process_query(query)
+            
+            # Send the response
+            await update.message.reply_text(response["answer"])
+            
+            # If there are sources, send them in a followup message
+            if response["sources"]:
+                sources_text = "*Sources:*\n" + "\n".join([
+                    f"- {s['file_name']} ({s['source']})"
+                    for s in response["sources"]
+                ])
+                await update.message.reply_text(sources_text, parse_mode='Markdown')
+        except Exception as e:
+            logger.error(f"Error processing search: {e}")
+            await update.message.reply_text(f"Error processing your search: {str(e)}")
+    
+    async def handle_message(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
+        """Handle normal messages."""
+        # Check if user is allowed
+        if self.allowed_user_ids and update.message.from_user.id not in self.allowed_user_ids:
+            await update.message.reply_text("You're not authorized to use this bot.")
+            return
+            
+        # Get the message text
+        query = update.message.text
+        
+        # Show typing status
+        await context.bot.send_chat_action(chat_id=update.effective_chat.id, action="typing")
+        
+        # Process the query
+        try:
+            # Process the message
+            response = await self.process_query(query)
+            
+            # Store in message history
+            self.message_history.append({
+                "user": update.message.from_user.username or str(update.message.from_user.id),
+                "user_id": update.message.from_user.id,
+                "query": query,
+                "response": response["answer"],
+                "timestamp": datetime.now().isoformat(),
+                "chat_id": update.effective_chat.id
+            })
+            
+            # Send the response
+            await update.message.reply_text(response["answer"])
+            
+            # If there are sources, send them in a followup message
+            if response["sources"]:
+                sources_text = "*Sources:*\n" + "\n".join([
+                    f"- {s['file_name']} ({s['source']})"
+                    for s in response["sources"]
+                ])
+                await update.message.reply_text(sources_text, parse_mode='Markdown')
+        except Exception as e:
+            logger.error(f"Error processing message: {e}")
+            await update.message.reply_text(f"I encountered an error: {str(e)}")
+    
+    async def error_handler(self, update, context):
+        """Handle errors."""
+        logger.error(f"Error: {context.error} - caused by update {update}")
+        
+        # Send a message to the user
+        if update and update.effective_chat:
+            await context.bot.send_message(
+                chat_id=update.effective_chat.id,
+                text="Sorry, an error occurred while processing your message."
+            )
+    
+    async def process_query(self, query):
+        """Process a query using the agent and return a response."""
+        # Create a new event loop for the thread
+        loop = asyncio.get_event_loop()
+        
+        # Run the query in a separate thread to avoid blocking
+        def run_query():
+            return self.agent.query(query)
+        
+        # Execute the query
+        response = await loop.run_in_executor(None, run_query)
+        
+        # Add the conversation to the agent's memory
+        if "answer" in response:
+            def add_to_memory():
+                self.agent.add_conversation_to_memory(query, response["answer"])
+            
+            await loop.run_in_executor(None, add_to_memory)
+            
+        return response
+    
+    def setup_application(self):
+        """Set up the Telegram application with handlers."""
+        # Create the Application
+        self.application = Application.builder().token(self.token).build()
+        
+        # Add command handlers
+        self.application.add_handler(CommandHandler("start", self.start_command))
+        self.application.add_handler(CommandHandler("help", self.help_command))
+        self.application.add_handler(CommandHandler("search", self.search_command))
+        
+        # Add message handler
+        self.application.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, self.handle_message))
+        
+        # Add error handler
+        self.application.add_error_handler(self.error_handler)
+        
+        logger.info("Telegram application set up successfully")
+    
+    def start(self):
+        """Start the Telegram bot in a separate thread."""
+        if not self.token:
+            logger.error("Telegram bot token not found")
+            return False
+            
+        try:
+            # Set up the application
+            self.setup_application()
+            
+            # Run the bot in a separate thread
+            def run_bot():
+                asyncio.set_event_loop(asyncio.new_event_loop())
+                self.application.run_polling(stop_signals=None)
+            
+            self.bot_thread = threading.Thread(target=run_bot, daemon=True)
+            self.bot_thread.start()
+            
+            logger.info("Telegram bot started in background thread")
+            return True
+        except Exception as e:
+            logger.error(f"Error starting Telegram bot: {e}")
+            return False
+    
+    def stop(self):
+        """Stop the Telegram bot."""
+        if self.application:
+            logger.info("Stopping Telegram bot...")
+            
+            async def stop_app():
+                await self.application.stop()
+                await self.application.shutdown()
+            
+            # Run the stop function in a new event loop
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            try:
+                loop.run_until_complete(stop_app())
+            finally:
+                loop.close()
+            
+            logger.info("Telegram bot stopped")
+            return True
+        return False
+    
+    def get_message_history(self):
+        """Get the message history."""
+        return self.message_history 

app/ui/streamlit_app.py

@@ -3,6 +3,7 @@ import os
 import sys
 import tempfile
 from datetime import datetime
+import pandas as pd
 from typing import List, Dict, Any
 import time
 import logging
@@ -18,20 +19,32 @@ sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(
 try:
     from app.core.agent import AssistantAgent
     from app.core.ingestion import DocumentProcessor
+    from app.core.telegram_bot import TelegramBot
+    from app.core.chat_history import ChatHistoryManager
     from app.utils.helpers import get_document_path, format_sources, save_conversation, copy_uploaded_file
-    from app.config import LLM_MODEL, EMBEDDING_MODEL
+    from app.config import (
+        LLM_MODEL, EMBEDDING_MODEL, TELEGRAM_ENABLED, 
+        TELEGRAM_BOT_TOKEN, TELEGRAM_ALLOWED_USERS,
+        HF_DATASET_NAME
+    )
 except ImportError:
     # Fallback to direct imports if app is not recognized as a package
     sys.path.append(os.path.abspath('.'))
     from app.core.agent import AssistantAgent
     from app.core.ingestion import DocumentProcessor
+    from app.core.telegram_bot import TelegramBot
+    from app.core.chat_history import ChatHistoryManager
     from app.utils.helpers import get_document_path, format_sources, save_conversation, copy_uploaded_file
-    from app.config import LLM_MODEL, EMBEDDING_MODEL
+    from app.config import (
+        LLM_MODEL, EMBEDDING_MODEL, TELEGRAM_ENABLED, 
+        TELEGRAM_BOT_TOKEN, TELEGRAM_ALLOWED_USERS,
+        HF_DATASET_NAME
+    )
 
 # Set page config
 st.set_page_config(
-    page_title="Personal AI Assistant (Hugging Face)",
-    page_icon="🤗",
+    page_title="Personal AI Second Brain",
+    page_icon="🧠",
     layout="wide"
 )
 
@@ -75,23 +88,146 @@ def get_document_processor(_agent):
                 return ["dummy-id"]
         return DummyProcessor()
 
+# Function to initialize chat history manager
+@st.cache_resource
+def get_chat_history_manager():
+    logger.info("Initializing ChatHistoryManager")
+    try:
+        return ChatHistoryManager(dataset_name=HF_DATASET_NAME)
+    except Exception as e:
+        logger.error(f"Error initializing chat history manager: {e}")
+        st.error(f"Could not initialize chat history: {str(e)}")
+        # Return a dummy manager as fallback
+        class DummyHistoryManager:
+            def load_history(self, *args, **kwargs):
+                return []
+            def save_conversation(self, *args, **kwargs):
+                return True
+            def sync_to_hub(self, *args, **kwargs):
+                return False
+        return DummyHistoryManager()
+
+# Function to initialize Telegram bot
+@st.cache_resource
+def get_telegram_bot(_agent):
+    """Initialize Telegram bot with unhashable agent parameter."""
+    if not TELEGRAM_ENABLED or not TELEGRAM_BOT_TOKEN:
+        logger.info("Telegram bot disabled or token missing")
+        return None
+        
+    logger.info("Initializing Telegram bot")
+    try:
+        bot = TelegramBot(
+            agent=_agent,
+            token=TELEGRAM_BOT_TOKEN,
+            allowed_user_ids=TELEGRAM_ALLOWED_USERS
+        )
+        return bot
+    except Exception as e:
+        logger.error(f"Error initializing Telegram bot: {e}")
+        return None
+
 # Initialize session state variables
 if "messages" not in st.session_state:
     st.session_state.messages = []
+if "telegram_status" not in st.session_state:
+    st.session_state.telegram_status = "Not started"
+if "history_filter" not in st.session_state:
+    st.session_state.history_filter = ""
+if "current_tab" not in st.session_state:
+    st.session_state.current_tab = "Chat"
 
-# Initialize agent and document processor with caching to prevent multiple instances
+# Initialize agent and other components with caching
 agent = get_agent()
 document_processor = get_document_processor(agent)
+chat_history_manager = get_chat_history_manager()
+telegram_bot = get_telegram_bot(agent)
 
-# App title
-st.title("🤗 Personal AI Assistant (Hugging Face)")
+# Load initial messages from history
+if not st.session_state.messages:
+    try:
+        recent_history = chat_history_manager.load_history()
+        # Take the last 10 conversations and convert to messages format
+        for conv in recent_history[-10:]:
+            if "user_query" in conv and "assistant_response" in conv:
+                st.session_state.messages.append({"role": "user", "content": conv["user_query"]})
+                st.session_state.messages.append({"role": "assistant", "content": conv["assistant_response"]})
+    except Exception as e:
+        logger.error(f"Error loading initial history: {e}")
 
-# Create a sidebar for uploading documents and settings
-with st.sidebar:
-    st.header("Upload Documents")
+# Main UI
+st.title("🧠 Personal AI Second Brain")
+
+# Create tabs for different functionality
+tabs = st.tabs(["Chat", "Documents", "History", "Settings"])
+
+# Chat tab
+with tabs[0]:
+    if st.session_state.current_tab != "Chat":
+        st.session_state.current_tab = "Chat"
+        
+    # Display chat messages from history
+    for message in st.session_state.messages:
+        with st.chat_message(message["role"]):
+            st.markdown(message["content"])
     
-    # Add file uploader with error handling
-    try:
+    # Accept user input
+    if prompt := st.chat_input("Ask me anything..."):
+        # Add user message to chat history
+        st.session_state.messages.append({"role": "user", "content": prompt})
+        
+        # Display user message in chat
+        with st.chat_message("user"):
+            st.markdown(prompt)
+        
+        # Generate and display assistant response
+        with st.chat_message("assistant"):
+            message_placeholder = st.empty()
+            message_placeholder.markdown("Thinking...")
+            
+            try:
+                response = agent.query(prompt)
+                answer = response["answer"]
+                sources = response["sources"]
+                
+                # Update the placeholder with the response
+                message_placeholder.markdown(answer)
+                
+                # Add assistant response to chat history
+                st.session_state.messages.append({"role": "assistant", "content": answer})
+                
+                # Save conversation to history manager
+                chat_history_manager.save_conversation({
+                    "user_query": prompt,
+                    "assistant_response": answer,
+                    "sources": [s["source"] for s in sources] if sources else [],
+                    "timestamp": datetime.now().isoformat()
+                })
+                
+                # Display sources if available
+                if sources:
+                    with st.expander("Sources"):
+                        st.markdown(format_sources(sources))
+                
+                # Add to agent's memory
+                agent.add_conversation_to_memory(prompt, answer)
+                
+            except Exception as e:
+                logger.error(f"Error generating response: {e}")
+                error_message = f"I'm sorry, I encountered an error: {str(e)}"
+                message_placeholder.markdown(error_message)
+                st.session_state.messages.append({"role": "assistant", "content": error_message})
+
+# Documents tab (existing functionality)
+with tabs[1]:
+    if st.session_state.current_tab != "Documents":
+        st.session_state.current_tab = "Documents"
+    
+    st.header("Upload & Manage Documents")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
         st.subheader("Upload a File")
         
         # Show supported file types info
@@ -198,168 +334,270 @@ with st.sidebar:
                         if "403" in str(e) or "forbidden" in str(e).lower():
                             st.warning("This appears to be a permissions issue. Try using a different file format or using the text input option instead.")
                         elif "unsupported" in str(e).lower() or "not supported" in str(e).lower() or "no specific loader" in str(e).lower():
-                            st.warning("This file type may not be fully supported. Try converting to PDF or TXT format.")
-                        elif "memory" in str(e).lower():
-                            st.warning("The file may be too large to process. Try a smaller file or split the content.")
-                        elif "timeout" in str(e).lower():
-                            st.warning("Processing timed out. Try a smaller file or try again later.")
-                        
-                        # Show troubleshooting tips
-                        with st.expander("Troubleshooting Tips"):
-                            st.markdown("""
-                            - Convert your document to PDF or plain text format
-                            - Try a smaller file (under 1MB)
-                            - Remove any password protection from the file
-                            - Try the text input option below instead
-                            - Check if the file contains complex formatting or images
-                            """)
-                
-        st.markdown("---")
-    except Exception as e:
-        logger.error(f"File uploader error: {str(e)}")
-        st.error(f"File upload functionality is currently unavailable: {str(e)}")
+                            st.warning("This file format may not be supported. Try converting to PDF or TXT first.")
     
-    st.subheader("Raw Text Input")
-    st.markdown("Alternatively, paste text directly to add to the knowledge base:")
-    text_input = st.text_area("Enter text to add to the knowledge base", height=150)
-    
-    if st.button("Add Text"):
-        if text_input:
-            with st.spinner("Adding text to knowledge base..."):
+    with col2:
+        st.subheader("Add Text Directly")
+        
+        # Text input for adding content directly
+        text_content = st.text_area("Enter text to add to your knowledge base:", height=200)
+        text_title = st.text_input("Give this text a title:")
+        
+        if st.button("Process Text") and text_content and text_title:
+            with st.spinner("Processing text..."):
+                status_placeholder = st.empty()
+                status_placeholder.info("Processing your text...")
+                
                 try:
-                    # Create metadata
-                    metadata = {
-                        "type": "manual_input",
-                        "timestamp": str(datetime.now())
-                    }
-                    
-                    # Ingest the text with progress indication
-                    status_text = st.empty()
-                    status_text.info("Processing text...")
+                    # Process the text content
+                    metadata = {"title": text_title, "source": "direct_input"}
+                    ids = document_processor.ingest_text(text_content, metadata)
                     
-                    # Ingest the text
-                    ids = document_processor.ingest_text(text_input, metadata)
-                    
-                    if ids and not any(str(id).startswith("error-") for id in ids):
-                        status_text.success("✅ Text added to knowledge base successfully!")
+                    if ids:
+                        status_placeholder.success("✅ Text processed successfully!")
                     else:
-                        status_text.warning("⚠️ Text processing completed with warnings")
+                        status_placeholder.warning("⚠️ Text processed with warnings.")
                 except Exception as e:
-                    logger.error(f"Error adding text: {str(e)}")
-                    st.error(f"Error adding text: {str(e)}")
-        else:
-            st.warning("Please enter some text to add")
+                    logger.error(f"Error processing text: {str(e)}")
+                    status_placeholder.error(f"❌ Error processing text: {str(e)}")
+
+# History tab (new)
+with tabs[2]:
+    if st.session_state.current_tab != "History":
+        st.session_state.current_tab = "History"
     
-    # Display model information
-    st.header("Models")
-    st.write(f"**LLM**: [{LLM_MODEL}](https://huggingface.co/{LLM_MODEL})")
-    st.write(f"**Embeddings**: [{EMBEDDING_MODEL}](https://huggingface.co/{EMBEDDING_MODEL})")
+    st.header("Chat History")
     
-    # Add Hugging Face deployment info
-    st.header("Deployment")
-    st.write("This app can be easily deployed to [Hugging Face Spaces](https://huggingface.co/spaces) for free hosting.")
+    # Search and filtering options
+    col1, col2, col3 = st.columns([2, 1, 1])
     
-    # Link to Hugging Face
-    st.markdown("""
-    <div style="text-align: center; margin-top: 20px;">
-        <a href="https://huggingface.co" target="_blank">
-            <img src="https://huggingface.co/front/assets/huggingface_logo.svg" width="200" alt="Hugging Face">
-        </a>
-    </div>
-    """, unsafe_allow_html=True)
-
-# Display chat messages
-for message in st.session_state.messages:
-    with st.chat_message(message["role"]):
-        st.write(message["content"])
+    with col1:
+        search_query = st.text_input("Search conversations:", st.session_state.history_filter)
+        if search_query != st.session_state.history_filter:
+            st.session_state.history_filter = search_query
+    
+    with col2:
+        st.text("Date Range (optional)")
+        start_date = st.date_input("Start date", None)
+    
+    with col3:
+        st.text("\u00A0")  # Non-breaking space for alignment
+        end_date = st.date_input("End date", None)
+    
+    # Load and filter history
+    try:
+        history = chat_history_manager.load_history()
         
-        # Display sources if available
-        if message["role"] == "assistant" and "sources" in message:
-            with st.expander("View Sources"):
-                sources = message["sources"]
-                if sources:
-                    for i, source in enumerate(sources, 1):
-                        st.write(f"{i}. {source.get('file_name', 'Unknown')}" + 
-                                (f" (Page {source['page']})" if source.get('page') else ""))
-                        st.text(source.get('content', 'No content available'))
+        # Apply search filter if provided
+        if search_query:
+            history = chat_history_manager.search_conversations(search_query)
+        
+        # Apply date filtering if provided
+        if start_date or end_date:
+            # Convert datetime.date to datetime.datetime for filtering
+            start_datetime = datetime.combine(start_date, datetime.min.time()) if start_date else None
+            end_datetime = datetime.combine(end_date, datetime.max.time()) if end_date else None
+            history = chat_history_manager.get_conversations_by_date(start_datetime, end_datetime)
+        
+        # Display history
+        if not history:
+            st.info("No conversation history found matching your criteria.")
+        else:
+            # Sort by timestamp (newest first)
+            history.sort(key=lambda x: x.get("timestamp", ""), reverse=True)
+            
+            # Create a DataFrame for display
+            df = pd.DataFrame(history)
+            if not df.empty:
+                # Select and rename columns for display
+                if all(col in df.columns for col in ["timestamp", "user_query", "assistant_response"]):
+                    display_df = df[["timestamp", "user_query", "assistant_response"]]
+                    display_df = display_df.rename(columns={
+                        "timestamp": "Date",
+                        "user_query": "Your Question",
+                        "assistant_response": "AI Response"
+                    })
+                    
+                    # Format timestamp
+                    if "Date" in display_df.columns:
+                        display_df["Date"] = pd.to_datetime(display_df["Date"]).dt.strftime('%Y-%m-%d %H:%M')
+                    
+                    # Truncate long text
+                    for col in ["Your Question", "AI Response"]:
+                        if col in display_df.columns:
+                            display_df[col] = display_df[col].apply(lambda x: x[:100] + "..." if isinstance(x, str) and len(x) > 100 else x)
+                    
+                    # Display as table
+                    st.dataframe(display_df, use_container_width=True)
+                    
+                    # Add option to view full conversation
+                    if not df.empty:
+                        selected_idx = st.selectbox("Select conversation to view details:", 
+                                                  range(len(df)),
+                                                  format_func=lambda i: f"{df.iloc[i].get('timestamp', 'Unknown')} - {df.iloc[i].get('user_query', '')[:30]}...")
+                        
+                        if selected_idx is not None:
+                            selected_conv = df.iloc[selected_idx]
+                            st.subheader("Conversation Details")
+                            
+                            st.markdown("**Your Question:**")
+                            st.markdown(selected_conv.get("user_query", ""))
+                            
+                            st.markdown("**AI Response:**")
+                            st.markdown(selected_conv.get("assistant_response", ""))
+                            
+                            # Display sources if available
+                            if "sources" in selected_conv and selected_conv["sources"]:
+                                st.markdown("**Sources:**")
+                                for src in selected_conv["sources"]:
+                                    st.markdown(f"- {src}")
+                            
+                            # Option to use this conversation in chat
+                            if st.button("Continue this conversation"):
+                                # Add to current chat session
+                                st.session_state.messages.append({"role": "user", "content": selected_conv.get("user_query", "")})
+                                st.session_state.messages.append({"role": "assistant", "content": selected_conv.get("assistant_response", "")})
+                                # Switch to chat tab
+                                st.session_state.current_tab = "Chat"
+                                st.experimental_rerun()
                 else:
-                    st.write("No specific sources used.")
+                    st.error("Unexpected history format. Some columns are missing.")
+            else:
+                st.info("No conversation history found.")
+    except Exception as e:
+        logger.error(f"Error displaying history: {e}")
+        st.error(f"Error loading conversation history: {str(e)}")
+    
+    # Sync to Hugging Face Hub button
+    if HF_DATASET_NAME:
+        if st.button("Sync History to Hugging Face Hub"):
+            with st.spinner("Syncing history..."):
+                success = chat_history_manager.sync_to_hub()
+                if success:
+                    st.success("History successfully synced to Hugging Face Hub!")
+                else:
+                    st.error("Failed to sync history. Check logs for details.")
 
-# Chat input
-if prompt := st.chat_input("Ask a question..."):
-    # Add user message to chat history
-    st.session_state.messages.append({"role": "user", "content": prompt})
+# Settings tab (new)
+with tabs[3]:
+    if st.session_state.current_tab != "Settings":
+        st.session_state.current_tab = "Settings"
     
-    # Display user message
-    with st.chat_message("user"):
-        st.write(prompt)
+    st.header("Settings")
     
-    # Generate response
-    with st.chat_message("assistant"):
-        with st.spinner("Thinking..."):
-            try:
-                # Add retry mechanism for vector store issues
-                max_retries = 3
-                for attempt in range(max_retries):
-                    try:
-                        response = agent.query(prompt)
-                        break
-                    except Exception as e:
-                        if "already accessed by another instance" in str(e) and attempt < max_retries - 1:
-                            logger.warning(f"Vector store access conflict, retrying ({attempt+1}/{max_retries})...")
-                            time.sleep(1)  # Wait before retrying
-                        else:
-                            raise
-                
-                # Extract answer and sources, with fallbacks if missing
-                answer = response.get("answer", "I couldn't generate a proper response.")
-                sources = response.get("sources", [])
-                
-                # Display the response
-                st.write(answer)
-                
-                # Display sources in an expander
-                with st.expander("View Sources"):
-                    if sources:
-                        for i, source in enumerate(sources, 1):
-                            st.write(f"{i}. {source.get('file_name', 'Unknown')}" + 
-                                    (f" (Page {source['page']})" if source.get('page') else ""))
-                            st.text(source.get('content', 'No content available'))
-                    else:
-                        st.write("No specific sources used.")
-                
-                # Save conversation
+    # System information
+    st.subheader("System Information")
+    system_info = {
+        "LLM Model": LLM_MODEL,
+        "Embedding Model": EMBEDDING_MODEL,
+        "HF Dataset": HF_DATASET_NAME or "Not configured",
+        "Telegram Enabled": "Yes" if TELEGRAM_ENABLED else "No"
+    }
+    
+    for key, value in system_info.items():
+        st.markdown(f"**{key}:** {value}")
+    
+    # Telegram settings
+    st.subheader("Telegram Integration")
+    
+    telegram_status = "Not configured"
+    if telegram_bot:
+        telegram_status = st.session_state.telegram_status
+    
+    st.markdown(f"**Status:** {telegram_status}")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        if telegram_bot and st.session_state.telegram_status != "Running":
+            if st.button("Start Telegram Bot"):
                 try:
-                    save_conversation(prompt, answer, sources)
-                except Exception as save_error:
-                    logger.error(f"Error saving conversation: {save_error}")
-                
-                # Add assistant response to chat history
-                st.session_state.messages.append({
-                    "role": "assistant", 
-                    "content": answer,
-                    "sources": sources
-                })
-                
-                # Update the agent's memory
+                    success = telegram_bot.start()
+                    if success:
+                        st.session_state.telegram_status = "Running"
+                        st.success("Telegram bot started!")
+                    else:
+                        st.error("Failed to start Telegram bot. Check logs for details.")
+                except Exception as e:
+                    logger.error(f"Error starting Telegram bot: {e}")
+                    st.error(f"Error: {str(e)}")
+    
+    with col2:
+        if telegram_bot and st.session_state.telegram_status == "Running":
+            if st.button("Stop Telegram Bot"):
                 try:
-                    agent.add_conversation_to_memory(prompt, answer)
-                except Exception as memory_error:
-                    logger.error(f"Error adding to memory: {memory_error}")
+                    telegram_bot.stop()
+                    st.session_state.telegram_status = "Stopped"
+                    st.info("Telegram bot stopped.")
+                except Exception as e:
+                    logger.error(f"Error stopping Telegram bot: {e}")
+                    st.error(f"Error: {str(e)}")
+    
+    if telegram_bot:
+        with st.expander("Telegram Bot Settings"):
+            st.markdown("""
+            To configure the Telegram bot, set these environment variables:
+            - `TELEGRAM_ENABLED`: Set to `true` to enable the bot
+            - `TELEGRAM_BOT_TOKEN`: Your Telegram bot token
+            - `TELEGRAM_ALLOWED_USERS`: Comma-separated list of Telegram user IDs (optional)
+            """)
+            
+            if telegram_bot.allowed_user_ids:
+                st.markdown("**Allowed User IDs:**")
+                for user_id in telegram_bot.allowed_user_ids:
+                    st.markdown(f"- {user_id}")
+            else:
+                st.markdown("The bot will respond to all users (no user restrictions configured).")
                 
-            except Exception as e:
-                error_msg = f"Error generating response: {str(e)}"
-                logger.error(error_msg)
-                st.error(error_msg)
-                st.session_state.messages.append({
-                    "role": "assistant", 
-                    "content": "I'm sorry, I encountered an error while processing your request. Please try again or refresh the page.",
-                    "sources": []
-                })
+            # Show Telegram bot instructions
+            st.markdown("### Telegram Bot Commands")
+            st.markdown("""
+            - **/start**: Start a conversation with the bot
+            - **/help**: Shows available commands
+            - **/search**: Use `/search your query` to search your knowledge base
+            - **Direct messages**: Send any message to chat with your second brain
+            
+            #### How to Set Up Your Telegram Bot
+            1. Talk to [@BotFather](https://t.me/botfather) on Telegram
+            2. Use the `/newbot` command to create a new bot
+            3. Get your bot token and add it to your `.env` file
+            4. Set `TELEGRAM_ENABLED=true` in your `.env` file
+            5. To find your Telegram user ID, talk to [@userinfobot](https://t.me/userinfobot)
+            """)
+    else:
+        st.info("Telegram integration is not enabled. Configure your .env file to enable it.")
+    
+    # Settings for Hugging Face Dataset persistence
+    st.subheader("Hugging Face Dataset Settings")
+    
+    if HF_DATASET_NAME:
+        st.markdown(f"**Dataset Name:** {HF_DATASET_NAME}")
+        st.markdown(f"**Local History File:** {chat_history_manager.local_file}")
+        
+        # HF Dataset instructions
+        with st.expander("Setup Instructions"):
+            st.markdown("""
+            ### Setting up Hugging Face Dataset Persistence
+            
+            1. Create a private dataset repository on Hugging Face Hub
+            2. Set your API token in the `.env` file as `HF_API_KEY`
+            3. Set your dataset name as `HF_DATASET_NAME` (format: username/repo-name)
+            
+            Your chat history will be automatically synced to the Hub.
+            """)
+    else:
+        st.info("Hugging Face Dataset persistence is not configured. Set HF_DATASET_NAME in your .env file.")
 
-# Add a footer
-st.markdown("---")
-st.markdown("Built with LangChain, Hugging Face, and Qdrant")
+# Run Telegram bot on startup if enabled
+if telegram_bot and TELEGRAM_ENABLED and st.session_state.telegram_status == "Not started":
+    try:
+        success = telegram_bot.start()
+        if success:
+            st.session_state.telegram_status = "Running"
+            logger.info("Telegram bot started automatically")
+    except Exception as e:
+        logger.error(f"Error auto-starting Telegram bot: {e}")
+        st.session_state.telegram_status = "Error"
 
 if __name__ == "__main__":
     # This is used when running the file directly

deploy_fixes.py

@@ -0,0 +1,130 @@
+#!/usr/bin/env python
+"""
+Deploy fixes for AI responses and file uploading to Hugging Face Spaces
+"""
+import os
+import subprocess
+import sys
+import time
+from getpass import getpass
+
+def deploy_fixes():
+    """Deploy fixes to Hugging Face Space."""
+    print("=" * 60)
+    print("  Deploy AI Response and File Upload Fixes to Hugging Face Space")
+    print("=" * 60)
+    
+    # Get credentials
+    username = input("Enter your Hugging Face username: ")
+    token = getpass("Enter your Hugging Face token: ")
+    space_name = input("Enter your Space name: ")
+    
+    # Set environment variables
+    os.environ["HUGGINGFACEHUB_API_TOKEN"] = token
+    os.environ["HF_API_KEY"] = token
+    
+    # Create a commit message describing the changes
+    commit_message = """
+Fix AI responses and file uploading functionality
+
+- Improved AI responses with better prompt formatting and instructions
+- Enhanced file upload handling with better error recovery
+- Added support for more file types (docx, html, md, etc.)
+- Improved UI with progress tracking and better error messages
+- Fixed edge cases with empty files and error handling
+"""
+    
+    # Add the remote URL with credentials embedded
+    remote_url = f"https://{username}:{token}@huggingface.co/spaces/{username}/{space_name}"
+    
+    try:
+        print("\n1. Configuring Git repository...")
+        # Configure git remote
+        remotes = subprocess.run(["git", "remote"], capture_output=True, text=True).stdout.strip().split('\n')
+        if "hf" not in remotes:
+            subprocess.run(["git", "remote", "add", "hf", remote_url], check=True)
+            print("   Added 'hf' remote.")
+        else:
+            subprocess.run(["git", "remote", "set-url", "hf", remote_url], check=True)
+            print("   Updated 'hf' remote.")
+        
+        print("\n2. Pulling latest changes...")
+        try:
+            # Try to pull any changes
+            subprocess.run(["git", "pull", "hf", "main"], check=True)
+            print("   Successfully pulled latest changes.")
+        except subprocess.CalledProcessError:
+            print("   Warning: Could not pull latest changes. Will attempt to push anyway.")
+        
+        print("\n3. Staging changes...")
+        # Stage all files
+        subprocess.run(["git", "add", "app/core/memory.py", "app/core/ingestion.py", "app/ui/streamlit_app.py"], check=True)
+        
+        print("\n4. Committing changes...")
+        # Commit changes
+        try:
+            subprocess.run(["git", "commit", "-m", commit_message], check=True)
+            print("   Changes committed successfully.")
+        except subprocess.CalledProcessError:
+            # Check if there are changes to commit
+            status = subprocess.run(["git", "status", "--porcelain"], capture_output=True, text=True).stdout.strip()
+            if not status:
+                print("   No changes to commit.")
+            else:
+                print("   Error making commit. Will try to push existing commits.")
+        
+        print("\n5. Pushing changes to Hugging Face Space...")
+        # Multiple push strategies
+        push_success = False
+        
+        # Strategy 1: Standard push
+        try:
+            subprocess.run(["git", "push", "hf", "main"], check=True)
+            push_success = True
+            print("   Push successful!")
+        except subprocess.CalledProcessError as e:
+            print(f"   Standard push failed: {e}")
+            print("   Trying force push...")
+            
+            # Strategy 2: Force push
+            try:
+                time.sleep(1)  # Brief pause
+                subprocess.run(["git", "push", "-f", "hf", "main"], check=True)
+                push_success = True
+                print("   Force push successful!")
+            except subprocess.CalledProcessError as e:
+                print(f"   Force push failed: {e}")
+                print("   Trying alternative push approach...")
+                
+                # Strategy 3: Set upstream and force push
+                try:
+                    time.sleep(1)  # Brief pause
+                    subprocess.run(["git", "push", "-f", "--set-upstream", "hf", "main"], check=True)
+                    push_success = True
+                    print("   Alternative push successful!")
+                except subprocess.CalledProcessError as e:
+                    print(f"   Alternative push failed: {e}")
+        
+        if push_success:
+            print("\n✅ Success! Your fixes have been deployed to Hugging Face Space.")
+            print(f"   View your Space at: https://huggingface.co/spaces/{username}/{space_name}")
+            print("   Note: It may take a few minutes for changes to appear as the Space rebuilds.")
+            return True
+        else:
+            print("\n❌ All push attempts failed. Please check the error messages above.")
+            return False
+    except Exception as e:
+        print(f"\n❌ Unexpected error during deployment: {e}")
+        return False
+
+if __name__ == "__main__":
+    try:
+        result = deploy_fixes()
+        if result:
+            print("\nDeployment completed successfully.")
+        else:
+            print("\nDeployment failed. Please try again or deploy manually.")
+            sys.exit(1)
+    except KeyboardInterrupt:
+        print("\nDeployment cancelled by user.")
+        sys.exit(1) 

direct_upload.py

@@ -0,0 +1,136 @@
+#!/usr/bin/env python
+"""
+Direct uploader for Hugging Face Spaces - simpler approach
+"""
+import os
+import sys
+import requests
+from getpass import getpass
+
+def upload_file(file_path, space_id, token):
+    """Upload a single file to Hugging Face Space using API"""
+    # Read the file content
+    with open(file_path, 'rb') as f:
+        file_content = f.read()
+    
+    # Construct the API URL
+    api_url = f"https://huggingface.co/api/spaces/{space_id}/upload/{file_path}"
+    
+    # Set headers
+    headers = {
+        "Authorization": f"Bearer {token}"
+    }
+    
+    # Upload the file
+    response = requests.post(
+        api_url,
+        headers=headers,
+        files={"file": (os.path.basename(file_path), file_content)}
+    )
+    
+    # Check response
+    if response.status_code == 200:
+        return True
+    else:
+        print(f"Error: {response.status_code} - {response.text}")
+        return False
+
+def main():
+    print("=" * 60)
+    print("  Direct File Upload to Hugging Face Space")
+    print("=" * 60)
+    
+    # Get required information
+    print("\nPlease enter your Hugging Face details:")
+    username = input("Username: ")
+    token = getpass("Access Token: ")
+    
+    # Space name with validation
+    while True:
+        space_name = input("Space Name (without username prefix): ")
+        if "/" in space_name:
+            print("Error: Please enter just the Space name without username or slashes")
+        else:
+            break
+    
+    # Construct full space ID
+    space_id = f"{username}/{space_name}"
+    
+    # Validate the space exists
+    print(f"\nValidating Space: {space_id}")
+    validation_url = f"https://huggingface.co/api/spaces/{space_id}"
+    headers = {"Authorization": f"Bearer {token}"}
+    
+    try:
+        validation_response = requests.get(validation_url, headers=headers)
+        if validation_response.status_code != 200:
+            print(f"Error: Space '{space_id}' not found or not accessible.")
+            print(f"Please check the Space name and your permissions.")
+            print(f"Space URL would be: https://huggingface.co/spaces/{space_id}")
+            return False
+        else:
+            print(f"✅ Space found! URL: https://huggingface.co/spaces/{space_id}")
+    except Exception as e:
+        print(f"Error validating space: {e}")
+        return False
+    
+    # Files to upload
+    files_to_upload = [
+        "app/core/memory.py",
+        "app/core/ingestion.py",
+        "app/ui/streamlit_app.py"
+    ]
+    
+    # Verify files exist locally
+    missing_files = [f for f in files_to_upload if not os.path.exists(f)]
+    if missing_files:
+        print(f"Error: The following files don't exist locally: {missing_files}")
+        return False
+    
+    # Upload each file
+    print("\nUploading files:")
+    success_count = 0
+    
+    for file_path in files_to_upload:
+        print(f"📤 Uploading {file_path}... ", end="", flush=True)
+        if upload_file(file_path, space_id, token):
+            print("✅ Success!")
+            success_count += 1
+        else:
+            print("❌ Failed!")
+    
+    # Print summary
+    print(f"\nUpload summary: {success_count}/{len(files_to_upload)} files uploaded successfully.")
+    
+    if success_count == len(files_to_upload):
+        print("\n✅ All files uploaded successfully!")
+        print(f"View your Space at: https://huggingface.co/spaces/{space_id}")
+        print("Note: It may take a few minutes for your Space to rebuild with the new changes.")
+        return True
+    else:
+        print("\n⚠️ Some files failed to upload. Please check the errors above.")
+        return False
+
+if __name__ == "__main__":
+    try:
+        # Check for required packages
+        try:
+            import requests
+        except ImportError:
+            print("Installing required package: requests")
+            import subprocess
+            subprocess.check_call([sys.executable, "-m", "pip", "install", "requests"])
+            import requests
+        
+        # Run the main function
+        success = main()
+        if success:
+            sys.exit(0)
+        else:
+            sys.exit(1)
+    except KeyboardInterrupt:
+        print("\nUpload cancelled by user.")
+        sys.exit(1)
+    except Exception as e:
+        print(f"\nUnexpected error: {e}")
+        sys.exit(1) 

push_to_huggingface.py

@@ -0,0 +1,86 @@
+#!/usr/bin/env python
+"""
+Push fixes directly to Hugging Face using the Hub API for more reliable authentication
+"""
+import os
+import sys
+import tempfile
+import shutil
+from getpass import getpass
+from huggingface_hub import HfApi, create_repo
+
+def push_fixes():
+    print("=" * 60)
+    print("  Push AI Response and File Upload Fixes to Hugging Face Space")
+    print("=" * 60)
+    
+    # Get credentials
+    username = input("Enter your Hugging Face username: ")
+    token = getpass("Enter your Hugging Face token: ")
+    space_name = input("Enter your Space name (just the name, not including your username): ")
+    
+    try:
+        # Initialize the Hugging Face API
+        api = HfApi(token=token)
+        
+        # Print user info to confirm authentication
+        print("\nAuthenticating with Hugging Face...")
+        user_info = api.whoami()
+        print(f"Authenticated as: {user_info['name']} (@{user_info['fullname']})")
+        
+        # Space repository ID
+        repo_id = f"{username}/{space_name}"
+        print(f"\nPreparing to update Space: {repo_id}")
+        print(f"Space URL: https://huggingface.co/spaces/{repo_id}")
+        
+        # Create a list of files to upload
+        files_to_upload = [
+            "app/core/memory.py",
+            "app/core/ingestion.py", 
+            "app/ui/streamlit_app.py"
+        ]
+        
+        # Upload each file
+        print("\nUploading files:")
+        for file_path in files_to_upload:
+            try:
+                print(f"  - Uploading {file_path}...")
+                api.upload_file(
+                    path_or_fileobj=file_path,
+                    path_in_repo=file_path,
+                    repo_id=repo_id,
+                    repo_type="space",
+                    commit_message=f"Fix: Improve {os.path.basename(file_path)} for better AI responses and file uploads"
+                )
+                print(f"    Success!")
+            except Exception as e:
+                print(f"    Error uploading {file_path}: {str(e)}")
+                return False
+        
+        print("\n✅ All files uploaded successfully!")
+        print(f"View your Space at: https://huggingface.co/spaces/{username}/{space_name}")
+        print("Note: It may take a few minutes for your Space to rebuild with the new changes.")
+        return True
+        
+    except Exception as e:
+        print(f"\n❌ Error: {str(e)}")
+        return False
+
+if __name__ == "__main__":
+    # Check if huggingface_hub is installed
+    try:
+        import huggingface_hub
+    except ImportError:
+        print("Error: huggingface_hub package is not installed.")
+        print("Installing huggingface_hub...")
+        import subprocess
+        subprocess.check_call([sys.executable, "-m", "pip", "install", "huggingface_hub"])
+        print("huggingface_hub installed. Please run the script again.")
+        sys.exit(1)
+        
+    # Run the push function
+    if push_fixes():
+        print("\nPush completed successfully.")
+    else:
+        print("\nPush failed. Please check the error messages above.")
+        sys.exit(1) 

requirements.txt

@@ -1,15 +1,19 @@
-langchain==0.1.3
-langchain-community==0.0.16
-huggingface-hub==0.20.2
-transformers==4.36.2
-sentence-transformers==2.2.2
-numpy==1.26.3
-qdrant-client==1.7.0
-fastapi==0.104.1
-uvicorn==0.24.0
-python-dotenv==1.0.0
-pydantic==2.5.2
-tiktoken==0.5.2
-pypdf==3.17.1
-streamlit==1.29.0
-torch==2.1.2 
+langchain>=0.1.0
+langchain-community>=0.0.10
+sentence-transformers>=2.2.2
+streamlit>=1.28.1
+qdrant-client>=1.6.3
+transformers>=4.34.1
+accelerate>=0.25.0
+torch>=2.0.0
+tqdm>=4.66.1
+python-dotenv>=1.0.0
+pydantic>=2.4.2
+fastapi>=0.104.1
+uvicorn>=0.24.0
+Pillow>=10.1.0
+docx2txt>=0.8
+unstructured>=0.10.30
+python-telegram-bot>=20.6
+datasets>=2.15.0
+huggingface_hub>=0.19.0 

update_imports.py

@@ -0,0 +1,59 @@
+#!/usr/bin/env python
+"""
+Update deprecated langchain imports to langchain_community in project files
+"""
+import os
+import re
+
+def update_imports(file_path):
+    """Update imports in a single file"""
+    print(f"Processing {file_path}")
+    
+    with open(file_path, 'r', encoding='utf-8') as file:
+        content = file.read()
+    
+    # Define import replacements
+    replacements = [
+        (r'from langchain\.vectorstores import (.*)', r'from langchain_community.vectorstores import \1'),
+        (r'from langchain\.llms import (.*)', r'from langchain_community.llms import \1'),
+        (r'from langchain\.document_loaders import (.*)', r'from langchain_community.document_loaders import \1'),
+        (r'from langchain\.embeddings import (.*)', r'from langchain_community.embeddings import \1'),
+        (r'import langchain\.vectorstores', r'import langchain_community.vectorstores'),
+        (r'import langchain\.llms', r'import langchain_community.llms'),
+        (r'import langchain\.document_loaders', r'import langchain_community.document_loaders'),
+        (r'import langchain\.embeddings', r'import langchain_community.embeddings'),
+    ]
+    
+    # Apply all replacements
+    for pattern, replacement in replacements:
+        content = re.sub(pattern, replacement, content)
+    
+    # Write updated content back to the file
+    with open(file_path, 'w', encoding='utf-8') as file:
+        file.write(content)
+    
+    return True
+
+def main():
+    """Main function to update all files"""
+    # Files to update
+    files_to_update = [
+        'app/core/memory.py',
+        'app/core/llm.py',
+        'app/core/ingestion.py',
+        'app/core/agent.py'
+    ]
+    
+    updated_count = 0
+    for file_path in files_to_update:
+        if os.path.exists(file_path):
+            success = update_imports(file_path)
+            if success:
+                updated_count += 1
+        else:
+            print(f"File not found: {file_path}")
+    
+    print(f"\nCompleted! Updated {updated_count}/{len(files_to_update)} files.")
+
+if __name__ == "__main__":
+    main() 

upload_with_commit.py

@@ -0,0 +1,157 @@
+#!/usr/bin/env python
+"""
+Hugging Face Space Uploader using the new commit endpoint
+"""
+import os
+import sys
+import json
+import base64
+import requests
+from getpass import getpass
+
+def upload_files_commit(space_id, token, files_to_upload):
+    """Upload files using the commit endpoint"""
+    # API URL for commits
+    api_url = f"https://huggingface.co/api/spaces/{space_id}/commit"
+    
+    # Headers
+    headers = {
+        "Authorization": f"Bearer {token}",
+        "Content-Type": "application/json"
+    }
+    
+    # Prepare operations (files to add/modify)
+    operations = []
+    for file_path in files_to_upload:
+        # Read the file content and base64 encode it
+        with open(file_path, 'rb') as f:
+            content = f.read()
+            content_b64 = base64.b64encode(content).decode("ascii")
+        
+        # Add the operation
+        operations.append({
+            "operation": "addOrUpdate",
+            "path": file_path,
+            "content": content_b64,
+            "encoding": "base64"
+        })
+    
+    # Prepare the commit payload
+    payload = {
+        "operations": operations,
+        "commit_message": "Fix AI responses and file upload handling"
+    }
+    
+    # Make the API request
+    response = requests.post(api_url, headers=headers, json=payload)
+    
+    # Check response
+    if response.status_code == 200:
+        return True, "Commit successful"
+    else:
+        return False, f"Error: {response.status_code} - {response.text}"
+
+def main():
+    print("=" * 60)
+    print("  Hugging Face Space File Uploader (Commit Method)")
+    print("=" * 60)
+    
+    # Get required information
+    print("\nPlease enter your Hugging Face details:")
+    username = input("Username: ")
+    token = getpass("Access Token: ")
+    
+    # Space name with validation
+    while True:
+        space_name = input("Space Name (without username prefix): ")
+        if "/" in space_name:
+            print("Error: Please enter just the Space name without username or slashes")
+        else:
+            break
+    
+    # Construct full space ID
+    space_id = f"{username}/{space_name}"
+    
+    # Validate the space exists
+    print(f"\nValidating Space: {space_id}")
+    validation_url = f"https://huggingface.co/api/spaces/{space_id}"
+    headers = {"Authorization": f"Bearer {token}"}
+    
+    try:
+        validation_response = requests.get(validation_url, headers=headers)
+        if validation_response.status_code != 200:
+            print(f"Error: Space '{space_id}' not found or not accessible.")
+            print(f"Please check the Space name and your permissions.")
+            print(f"Space URL would be: https://huggingface.co/spaces/{space_id}")
+            return False
+        else:
+            space_info = validation_response.json()
+            print(f"✅ Space found: {space_info.get('title', space_id)}")
+            print(f"URL: https://huggingface.co/spaces/{space_id}")
+    except Exception as e:
+        print(f"Error validating space: {e}")
+        return False
+    
+    # Files to upload
+    files_to_upload = [
+        "app/core/memory.py",
+        "app/core/ingestion.py", 
+        "app/ui/streamlit_app.py"
+    ]
+    
+    # Verify files exist locally
+    missing_files = [f for f in files_to_upload if not os.path.exists(f)]
+    if missing_files:
+        print(f"Error: The following files don't exist locally: {missing_files}")
+        return False
+    
+    # Display summary before upload
+    print("\nPreparing to upload these files:")
+    for file_path in files_to_upload:
+        file_size = os.path.getsize(file_path) / 1024  # KB
+        print(f"  - {file_path} ({file_size:.1f} KB)")
+    
+    # Confirm upload
+    confirm = input("\nProceed with upload? (y/n): ").lower()
+    if confirm != 'y':
+        print("Upload cancelled by user.")
+        return False
+    
+    # Upload files with commit
+    print("\n📤 Uploading files in a single commit... ", end="", flush=True)
+    success, message = upload_files_commit(space_id, token, files_to_upload)
+    
+    if success:
+        print("✅ Success!")
+        print("\n✅ All files uploaded successfully!")
+        print(f"View your Space at: https://huggingface.co/spaces/{space_id}")
+        print("Note: It may take a few minutes for your Space to rebuild with the new changes.")
+        return True
+    else:
+        print("❌ Failed!")
+        print(f"Error: {message}")
+        return False
+
+if __name__ == "__main__":
+    try:
+        # Check for required packages
+        try:
+            import requests
+        except ImportError:
+            print("Installing required package: requests")
+            import subprocess
+            subprocess.check_call([sys.executable, "-m", "pip", "install", "requests"])
+            import requests
+        
+        # Run the main function
+        success = main()
+        if success:
+            sys.exit(0)
+        else:
+            sys.exit(1)
+    except KeyboardInterrupt:
+        print("\nUpload cancelled by user.")
+        sys.exit(1)
+    except Exception as e:
+        print(f"\nUnexpected error: {e}")
+        sys.exit(1) 

upload_with_hf_lib.py

@@ -0,0 +1,137 @@
+#!/usr/bin/env python
+"""
+Upload files to Hugging Face Space using the official huggingface_hub library
+"""
+import os
+import sys
+from getpass import getpass
+
+def main():
+    print("=" * 60)
+    print("  Upload to Hugging Face Space using huggingface_hub")
+    print("=" * 60)
+    
+    try:
+        # Import huggingface_hub
+        from huggingface_hub import HfApi, login
+        
+        # Get required information
+        print("\nPlease enter your Hugging Face details:")
+        username = input("Username: ")
+        token = getpass("Access Token: ")
+        
+        # Login using the token
+        login(token=token, add_to_git_credential=True)
+        
+        # Space name with validation
+        while True:
+            space_name = input("Space Name (without username prefix): ")
+            if "/" in space_name:
+                print("Error: Please enter just the Space name without username or slashes")
+            else:
+                break
+        
+        # Construct full space ID
+        space_id = f"{username}/{space_name}"
+        
+        # Initialize the API
+        api = HfApi()
+        
+        # Validate the user is logged in
+        try:
+            user_info = api.whoami()
+            print(f"\nAuthenticated as: {user_info['name']}")
+        except Exception as e:
+            print(f"Error authenticating: {e}")
+            return False
+        
+        # Files to upload
+        files_to_upload = [
+            "app/core/memory.py",
+            "app/core/ingestion.py", 
+            "app/ui/streamlit_app.py"
+        ]
+        
+        # Verify files exist locally
+        missing_files = [f for f in files_to_upload if not os.path.exists(f)]
+        if missing_files:
+            print(f"Error: The following files don't exist locally: {missing_files}")
+            return False
+        
+        # Display summary before upload
+        print("\nPreparing to upload these files:")
+        for file_path in files_to_upload:
+            file_size = os.path.getsize(file_path) / 1024  # KB
+            print(f"  - {file_path} ({file_size:.1f} KB)")
+        
+        # Confirm upload
+        confirm = input("\nProceed with upload? (y/n): ").lower()
+        if confirm != 'y':
+            print("Upload cancelled by user.")
+            return False
+        
+        # Upload each file
+        print("\nUploading files:")
+        success_count = 0
+        
+        for file_path in files_to_upload:
+            try:
+                print(f"📤 Uploading {file_path}... ", end="", flush=True)
+                
+                # Upload the file
+                api.upload_file(
+                    path_or_fileobj=file_path,
+                    path_in_repo=file_path,
+                    repo_id=space_id,
+                    repo_type="space",
+                    commit_message=f"Fix: Improve {os.path.basename(file_path)} for better responses and file handling"
+                )
+                
+                print("✅ Success!")
+                success_count += 1
+            except Exception as e:
+                print("❌ Failed!")
+                print(f"  Error: {str(e)}")
+        
+        # Print summary
+        print(f"\nUpload summary: {success_count}/{len(files_to_upload)} files uploaded successfully.")
+        
+        if success_count == len(files_to_upload):
+            print("\n✅ All files uploaded successfully!")
+            print(f"View your Space at: https://huggingface.co/spaces/{space_id}")
+            print("Note: It may take a few minutes for your Space to rebuild with the new changes.")
+            return True
+        else:
+            print("\n⚠️ Some files failed to upload. Please check the errors above.")
+            print("You may need to upload the files manually through the web interface.")
+            print(f"Go to: https://huggingface.co/spaces/{space_id}/tree/main")
+            return False
+            
+    except Exception as e:
+        print(f"\n❌ Error: {str(e)}")
+        return False
+
+if __name__ == "__main__":
+    try:
+        # Check if huggingface_hub is installed
+        try:
+            import huggingface_hub
+        except ImportError:
+            print("Installing required package: huggingface_hub")
+            import subprocess
+            subprocess.check_call([sys.executable, "-m", "pip", "install", "huggingface_hub"])
+            import huggingface_hub
+        
+        # Run the main function
+        success = main()
+        if success:
+            sys.exit(0)
+        else:
+            sys.exit(1)
+            
+    except KeyboardInterrupt:
+        print("\nUpload cancelled by user.")
+        sys.exit(1)
+    except Exception as e:
+        print(f"\nUnexpected error: {e}")
+        sys.exit(1)