Initial commit for Hugging Face Space deployment

DEPLOYMENT.md

@@ -0,0 +1,126 @@
+# Deploying Your Personal AI Assistant to Hugging Face Spaces
+
+This guide provides detailed instructions for deploying your Personal AI Assistant with RAG to Hugging Face Spaces.
+
+## Prerequisites
+
+Before you start, make sure you have:
+
+1. **A Hugging Face Account**: Sign up at [https://huggingface.co/join](https://huggingface.co/join) if you don't have one
+2. **Hugging Face API Token**: Create a token at [https://huggingface.co/settings/tokens](https://huggingface.co/settings/tokens)
+3. **Git**: Installed and configured on your machine
+4. **Python 3.8+**: With pip for installing packages
+
+## Step 1: Install Dependencies
+
+First, install all required packages:
+
+```bash
+pip install -r requirements.txt
+```
+
+Make sure you have the huggingface_hub package installed:
+
+```bash
+pip install huggingface_hub
+```
+
+## Step 2: Check Your Git Configuration
+
+Run the check script to ensure your Git is properly configured:
+
+```bash
+python check_git_status.py
+```
+
+This will:
+- Verify Git is installed
+- Check your Git configuration
+- Confirm your repository status
+- Verify Hugging Face configuration
+
+Follow any prompts to fix issues that are detected.
+
+## Step 3: Deploy to Hugging Face Spaces
+
+Run the deployment script:
+
+```bash
+python deploy_to_hf.py
+```
+
+You will be prompted to enter:
+1. Your Hugging Face username
+2. Your Hugging Face API token
+3. A name for your Space (or accept the default: personal-rag-assistant)
+
+The script will:
+- Configure your environment
+- Create a new Hugging Face Space
+- Set up Git for pushing to Hugging Face
+- Push your code to the Space
+
+## Step 4: Monitor the Deployment
+
+After pushing your code:
+
+1. Visit [https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE_NAME](https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE_NAME)
+2. You'll see a "Building" status while Hugging Face builds your Docker container
+3. This may take 5-10 minutes for the first build
+
+## Step 5: Using Your Deployed Assistant
+
+Once deployment is complete:
+
+1. Your app will be accessible at [https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE_NAME](https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE_NAME)
+2. Upload documents through the sidebar
+3. Start asking questions about your documents
+4. The application automatically saves your conversation history
+
+## Troubleshooting
+
+### Authentication Issues
+
+If you encounter Git authentication issues:
+
+```
+remote: HTTP Basic: Access denied
+```
+
+This usually means:
+- Your Hugging Face token is invalid or expired
+- You haven't configured Git to use your token
+
+Solution: Re-run the deployment script to update your credentials.
+
+### Build Failures
+
+If your Space shows a build failure:
+
+1. Check the build logs in the Hugging Face Space UI
+2. Common issues include:
+   - Missing dependencies in requirements.txt
+   - Issues with the Dockerfile
+   - Errors in your Python code
+
+### Space Creation Errors
+
+If the Space creation fails:
+
+1. Try creating the Space manually in the Hugging Face UI
+2. Then run the deployment script again, which will detect the existing Space
+
+## Managing Your Space
+
+After deployment, you can:
+
+- **Update Your App**: Make changes locally, then run `python deploy_to_hf.py` again
+- **Change Hardware**: Upgrade to a more powerful instance in the Hugging Face UI
+- **Monitor Usage**: View usage statistics in the Hugging Face UI
+- **Share Your App**: Share the URL with others to use your assistant
+
+## Additional Resources
+
+- [Hugging Face Spaces Documentation](https://huggingface.co/docs/hub/spaces)
+- [Streamlit Documentation](https://docs.streamlit.io/)
+- [LangChain Documentation](https://python.langchain.com/docs/) 

README-HF.md

@@ -0,0 +1,41 @@
+---
+title: Personal AI Assistant with RAG
+emoji: 🤗
+colorFrom: indigo
+colorTo: purple
+sdk: docker
+app_port: 7860
+pinned: true
+license: mit
+---
+
+# Personal AI Assistant with RAG
+
+A powerful personal AI assistant that uses Retrieval-Augmented Generation (RAG) to provide responses based on your documents and notes.
+
+## 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
+
+## How to Use
+
+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
+
+## Built With
+
+- 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
+
+Created by [p3rc03](https://huggingface.co/p3rc03) 

README.md

@@ -29,6 +29,35 @@ A powerful personal AI assistant that uses Retrieval-Augmented Generation (RAG)
 3. **Ask Questions**: Chat with the assistant about your documents
 4. **View Sources**: See where information is coming from
 
+## Deployment
+
+### Local Deployment
+
+To run the app locally:
+
+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`
+
+### Deploying to Hugging Face Spaces
+
+This application can be easily deployed to Hugging Face Spaces for free hosting:
+
+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
+
+If you encounter any issues during deployment, run `python check_git_status.py` to diagnose and fix common problems.
+
+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
+
 ## Built With
 
 - Hugging Face Models
@@ -38,4 +67,8 @@ A powerful personal AI assistant that uses Retrieval-Augmented Generation (RAG)
 - Qdrant for vector storage
 - Streamlit for UI
 
-Created by [p3rc03](https://huggingface.co/p3rc03) 
+Created by [p3rc03](https://huggingface.co/p3rc03) 
+
+## License
+
+MIT License - See LICENSE file for details 

check_git_status.py

@@ -0,0 +1,141 @@
+#!/usr/bin/env python
+"""
+Check Git status and configuration for Hugging Face Space deployment.
+This script helps troubleshoot git issues when deploying to Hugging Face Spaces.
+"""
+import subprocess
+import os
+import sys
+
+def run_cmd(cmd, description, show_output=True):
+    """Run a command and return the result."""
+    print(f"\n{description}:")
+    try:
+        if show_output:
+            subprocess.run(cmd, check=True)
+            return True
+        else:
+            result = subprocess.run(cmd, check=True, capture_output=True, text=True)
+            return result.stdout.strip()
+    except subprocess.CalledProcessError as e:
+        print(f"Error: {e}")
+        if e.stderr:
+            print(f"Details: {e.stderr}")
+        return False
+
+def check_git_installation():
+    """Check if git is installed and properly configured."""
+    print("="*50)
+    print("Checking Git Installation and Configuration")
+    print("="*50)
+    
+    # Check git version
+    if not run_cmd(["git", "--version"], "Git version"):
+        print("Git is not installed. Please install Git and try again.")
+        return False
+    
+    # Check git configuration
+    user_name = run_cmd(["git", "config", "user.name"], "Git user name", False)
+    user_email = run_cmd(["git", "config", "user.email"], "Git user email", False)
+    
+    if not user_name or not user_email:
+        print("\nGit user name or email is not configured. Please set them:")
+        print("  git config --global user.name \"Your Name\"")
+        print("  git config --global user.email \"[email protected]\"")
+        
+        # Prompt to set them now
+        if input("\nDo you want to set them now? (y/n): ").lower() == 'y':
+            name = input("Enter your name: ")
+            email = input("Enter your email: ")
+            run_cmd(["git", "config", "--global", "user.name", name], "Setting Git user name", False)
+            run_cmd(["git", "config", "--global", "user.email", email], "Setting Git user email", False)
+            print("Git configuration updated.")
+        else:
+            return False
+    else:
+        print(f"\nGit user name: {user_name}")
+        print(f"Git user email: {user_email}")
+    
+    return True
+
+def check_git_repository():
+    """Check the Git repository status."""
+    print("\n" + "="*50)
+    print("Checking Git Repository Status")
+    print("="*50)
+    
+    # Check if this is a git repository
+    is_git_repo = os.path.exists(".git")
+    print(f"\nIs Git repository: {'Yes' if is_git_repo else 'No'}")
+    
+    if not is_git_repo:
+        print("This is not a git repository. You can initialize it with 'git init'")
+        
+        # Prompt to initialize git
+        if input("\nDo you want to initialize git now? (y/n): ").lower() == 'y':
+            run_cmd(["git", "init"], "Initializing Git repository")
+            print("Git repository initialized.")
+        else:
+            return False
+    
+    # Check git status
+    run_cmd(["git", "status"], "Git status")
+    
+    # Check remote repositories
+    run_cmd(["git", "remote", "-v"], "Git remotes")
+    
+    return True
+
+def check_huggingface_configuration():
+    """Check Hugging Face-specific configurations."""
+    print("\n" + "="*50)
+    print("Checking Hugging Face Configuration")
+    print("="*50)
+    
+    # Check if huggingface_hub is installed
+    try:
+        import huggingface_hub
+        print(f"\nhuggingface_hub version: {huggingface_hub.__version__}")
+    except ImportError:
+        print("\nhuggingface_hub is not installed. Installing...")
+        subprocess.run([sys.executable, "-m", "pip", "install", "huggingface_hub"], check=True)
+        print("huggingface_hub installed.")
+    
+    # Check environment variables
+    hf_username = os.environ.get("HF_USERNAME")
+    hf_token = os.environ.get("HF_TOKEN")
+    
+    print(f"\nHF_USERNAME is {'set' if hf_username else 'not set'}")
+    print(f"HF_TOKEN is {'set' if hf_token else 'not set'}")
+    
+    if not hf_username or not hf_token:
+        print("\nPlease set HF_USERNAME and HF_TOKEN environment variables.")
+        print("You can run the deploy_to_hf.py script to do this.")
+    
+    return True
+
+def main():
+    """Main function to check git status."""
+    # Check git installation
+    if not check_git_installation():
+        print("\nGit installation or configuration issue. Please fix and try again.")
+        return
+    
+    # Check git repository
+    if not check_git_repository():
+        print("\nGit repository issue. Please fix and try again.")
+        return
+    
+    # Check Hugging Face configuration
+    if not check_huggingface_configuration():
+        print("\nHugging Face configuration issue. Please fix and try again.")
+        return
+    
+    print("\n" + "="*50)
+    print("Git status check completed successfully!")
+    print("="*50)
+    print("\nYou are ready to deploy to Hugging Face Spaces.")
+    print("Run 'python deploy_to_hf.py' to begin deployment.")
+
+if __name__ == "__main__":
+    main() 

deploy_to_hf.py

@@ -0,0 +1,279 @@
+#!/usr/bin/env python
+"""
+Helper script to deploy to Hugging Face Spaces.
+This script will help you set environment variables and deploy your app.
+"""
+import os
+import sys
+import subprocess
+from getpass import getpass
+from huggingface_hub import HfApi, SpaceHardware, SpaceStage
+
+def setup_deployment():
+    """Set up deployment environment variables and authenticate."""
+    print("="*50)
+    print("Hugging Face Spaces Deployment Setup")
+    print("="*50)
+    
+    # Get user credentials
+    username = input("Enter your Hugging Face username: ")
+    token = getpass("Enter your Hugging Face token (from https://huggingface.co/settings/tokens): ")
+    space_name = input("Enter your Space name (default: personal-rag-assistant): ") or "personal-rag-assistant"
+    
+    # Set environment variables
+    os.environ["HF_USERNAME"] = username
+    os.environ["HF_TOKEN"] = token
+    os.environ["SPACE_NAME"] = space_name
+    
+    # Write credentials to .env file
+    with open(".env", "w") as f:
+        f.write(f"HF_API_KEY={token}\n")
+        f.write(f"HF_USERNAME={username}\n")
+        f.write(f"SPACE_NAME={space_name}\n")
+        f.write("LLM_MODEL=google/flan-t5-large\n")
+        f.write("EMBEDDING_MODEL=sentence-transformers/all-MiniLM-L6-v2\n")
+        f.write("VECTOR_DB_PATH=./data/vector_db\n")
+        f.write("COLLECTION_NAME=personal_assistant\n")
+        f.write("DEFAULT_TEMPERATURE=0.7\n")
+        f.write("CHUNK_SIZE=1000\n")
+        f.write("CHUNK_OVERLAP=200\n")
+        f.write("MAX_TOKENS=512\n")
+    
+    # Set up git credential helper for Hugging Face
+    try:
+        # Configure git to use credential store
+        subprocess.run(["git", "config", "--global", "credential.helper", "store"], check=True)
+        
+        # Create .git-credentials file with token
+        home_dir = os.path.expanduser("~")
+        credentials_path = os.path.join(home_dir, ".git-credentials")
+        
+        # Check if credentials already exist
+        credentials_exist = os.path.exists(credentials_path)
+        
+        with open(credentials_path, "a" if credentials_exist else "w") as f:
+            f.write(f"https://{username}:{token}@huggingface.co\n")
+        
+        # Make sure credentials file has correct permissions
+        if sys.platform != "win32":  # Skip on Windows
+            os.chmod(credentials_path, 0o600)
+        
+        print("Git credentials configured for Hugging Face.")
+    except Exception as e:
+        print(f"Warning: Could not set up git credentials: {e}")
+        print("You may need to enter your credentials manually during push.")
+    
+    print(f"\nEnvironment variables set for {username}/{space_name}")
+    return username, token, space_name
+
+def create_space(username, token, space_name):
+    """Create a Hugging Face Space directly using the HfApi."""
+    print("\nCreating Hugging Face Space...")
+    
+    try:
+        # Initialize the API
+        api = HfApi(token=token)
+        
+        # Check if space exists
+        try:
+            spaces = api.list_spaces(author=username)
+            exists = any(space.id == f"{username}/{space_name}" for space in spaces)
+            if exists:
+                print(f"Space {username}/{space_name} exists.")
+            else:
+                print(f"Space {username}/{space_name} does not exist. Creating...")
+                # Create the space
+                api.create_space(
+                    name=space_name,
+                    organization=None,  # Use None for personal account
+                    private=False,
+                    sdk="docker",
+                    hardware=SpaceHardware.CPU_BASIC,
+                    storage=1,
+                    sleep_time=3600,  # 1 hour of inactivity before sleep
+                    status=SpaceStage.RUNNING,
+                )
+                print(f"Space created successfully.")
+        except Exception as e:
+            print(f"Error checking/creating space: {e}")
+            print("You may need to create the Space manually in the Hugging Face UI.")
+            print(f"Visit: https://huggingface.co/spaces")
+            return False
+        
+        print(f"Space URL: https://huggingface.co/spaces/{username}/{space_name}")
+        return True
+    except Exception as e:
+        print(f"Error creating space: {e}")
+        print("\nTrying to proceed anyway, as the space might already exist.")
+        return True
+
+def prepare_git_push(username, space_name):
+    """Prepare git for pushing to Hugging Face Space."""
+    print("\nPreparing to push code to Hugging Face Space...")
+    
+    try:
+        # Initialize git if not already done
+        if not os.path.exists(".git"):
+            subprocess.run(["git", "init"], check=True)
+            print("Git repository initialized.")
+        
+        # Configure git remote
+        remote_url = f"https://huggingface.co/spaces/{username}/{space_name}"
+        
+        # Check all remotes
+        result = subprocess.run(["git", "remote"], capture_output=True, text=True)
+        remotes = result.stdout.strip().split('\n') if result.stdout else []
+        
+        print(f"Existing remotes: {remotes}")
+        
+        # Check if 'hf' remote exists
+        if "hf" not in remotes:
+            # Add the remote
+            print("Adding 'hf' remote...")
+            try:
+                add_result = subprocess.run(["git", "remote", "add", "hf", remote_url], capture_output=True, text=True)
+                if add_result.returncode != 0:
+                    print(f"Error adding remote: {add_result.stderr}")
+                    return False
+                print("Successfully added 'hf' remote")
+            except Exception as e:
+                print(f"Error adding remote: {e}")
+                return False
+        else:
+            # Update existing remote
+            print("Updating 'hf' remote...")
+            try:
+                update_result = subprocess.run(["git", "remote", "set-url", "hf", remote_url], capture_output=True, text=True)
+                if update_result.returncode != 0:
+                    print(f"Error updating remote: {update_result.stderr}")
+                    return False
+                print("Successfully updated 'hf' remote")
+            except Exception as e:
+                print(f"Error updating remote: {e}")
+                return False
+        
+        # Verify remote was added/updated
+        verify_remote = subprocess.run(["git", "remote", "-v"], capture_output=True, text=True)
+        print(f"Remote verification: {verify_remote.stdout}")
+        
+        # Make sure we have user details
+        try:
+            user_name = subprocess.run(["git", "config", "user.name"], capture_output=True, text=True).stdout.strip()
+            user_email = subprocess.run(["git", "config", "user.email"], capture_output=True, text=True).stdout.strip()
+            
+            if not user_name or not user_email:
+                # Set default values if not configured
+                name = input("Enter your name for git config: ") or username
+                email = input("Enter your email for git config: ") or f"{username}@example.com"
+                
+                subprocess.run(["git", "config", "--global", "user.name", name], check=True)
+                subprocess.run(["git", "config", "--global", "user.email", email], check=True)
+                print("Git user configuration updated.")
+        except subprocess.CalledProcessError:
+            print("Warning: Could not check git user configuration.")
+        
+        # Add and commit files
+        subprocess.run(["git", "add", "."], check=True)
+        try:
+            subprocess.run(["git", "commit", "-m", "Initial commit for Hugging Face Space deployment"], check=True)
+        except subprocess.CalledProcessError:
+            # Check if there are changes to commit
+            status = subprocess.run(["git", "status", "--porcelain"], capture_output=True, text=True, check=True).stdout.strip()
+            if not status:
+                print("No changes to commit.")
+            else:
+                print("Error making commit. Check git configuration.")
+                return False
+        
+        print("\nGit repository prepared for pushing")
+    except Exception as e:
+        print(f"Error preparing git: {e}")
+        return False
+    
+    return True
+
+def push_to_space(username, token):
+    """Push code to Hugging Face Space."""
+    print("\nPushing code to Hugging Face Space...")
+    print("This may take a few minutes...")
+    
+    try:
+        # Set git credentials environment variables for this push
+        env = os.environ.copy()
+        env["GIT_USERNAME"] = username
+        env["GIT_PASSWORD"] = token
+        
+        # Determine current branch
+        current_branch = subprocess.run(
+            ["git", "branch", "--show-current"], 
+            capture_output=True, text=True
+        ).stdout.strip()
+            
+        if not current_branch:
+            current_branch = "master"  # Default to master if no branch is returned
+        
+        # Push code - force push to override any existing content
+        print(f"Pushing from branch {current_branch} to main...")
+        cmd = ["git", "push", "-f", "hf", f"{current_branch}:main"]
+        
+        print("\nRunning git push command...")
+        print(f"Pushing to Space as user: {username}")
+        
+        # Try to push
+        try:
+            subprocess.run(cmd, check=True, env=env)
+        except subprocess.CalledProcessError as e:
+            print(f"Error during push: {e}")
+            
+            # Try direct URL push as alternative
+            print("\nTrying alternative direct URL push...")
+            direct_url = f"https://{username}:{token}@huggingface.co/spaces/{username}/{os.environ.get('SPACE_NAME')}"
+            alt_cmd = ["git", "push", "-f", direct_url, f"{current_branch}:main"]
+            
+            try:
+                subprocess.run(alt_cmd, check=True, env=env)
+            except subprocess.CalledProcessError as e:
+                print(f"Direct URL push also failed: {e}")
+                raise
+        
+        print("\nCode pushed to Hugging Face Space successfully!")
+    except subprocess.CalledProcessError as e:
+        print(f"Error pushing code: {e}")
+        print("\nTroubleshooting git push issues:")
+        print("1. Ensure your Hugging Face token has write access")
+        print("2. Try manually setting up git credentials:")
+        print(f"   git config --global credential.helper store")
+        print(f"   echo 'https://{username}:{token}@huggingface.co' > ~/.git-credentials")
+        print("3. Try pushing directly with:")
+        print(f"   git push -f https://{username}:{token}@huggingface.co/spaces/{username}/{os.environ.get('SPACE_NAME')} main")
+        return False
+    
+    return True
+
+def main():
+    """Main function to run the deployment process."""
+    username, token, space_name = setup_deployment()
+    
+    # Create the Space
+    if not create_space(username, token, space_name):
+        print("Failed to create Space. Attempting to continue anyway.")
+    
+    # Prepare git for pushing
+    if not prepare_git_push(username, space_name):
+        print("Failed to prepare git. Exiting.")
+        return
+    
+    # Push code to Space
+    if not push_to_space(username, token):
+        print("Failed to push code. Exiting.")
+        return
+    
+    print("\n" + "="*50)
+    print(f"Deployment completed! Your app should be available at:")
+    print(f"https://huggingface.co/spaces/{username}/{space_name}")
+    print("="*50)
+    print("\nNote: It may take a few minutes for the Space to build and deploy your app.")
+    print("You can monitor the build progress on the Space page.")
+
+if __name__ == "__main__":
+    main() 

space.py

@@ -1,49 +0,0 @@
-#!/usr/bin/env python
-"""
-Register this app with Hugging Face Spaces SDK.
-This file is used for deploying the app to Hugging Face Spaces.
-"""
-import os
-import subprocess
-import sys
-from huggingface_hub import SpaceHardware, SpaceStage, SpaceSDK
-
-def create_space():
-    """Create or update a Hugging Face Space."""
-    # Get the Space name or use a default
-    space_name = os.environ.get("SPACE_NAME", "personal-rag-assistant")
-    owner = os.environ.get("HF_USERNAME")
-    
-    if not owner:
-        print("Please set the HF_USERNAME environment variable to your Hugging Face username.")
-        sys.exit(1)
-    
-    # Initialize the SDK
-    sdk = SpaceSDK(
-        space_id=f"{owner}/{space_name}",
-        token=os.environ.get("HF_TOKEN")
-    )
-    
-    # Check if space exists, if not create it
-    try:
-        space_info = sdk.get_space_runtime()
-        print(f"Space {owner}/{space_name} exists.")
-        exists = True
-    except Exception:
-        exists = False
-    
-    # Create or update the space
-    if not exists:
-        print(f"Creating new space: {owner}/{space_name}")
-        sdk.create_space(
-            space_hardware=SpaceHardware.CPU_BASIC,
-            space_storage=1,
-            space_sleep_time=3600,  # 1 hour of inactivity before sleep
-            space_stage=SpaceStage.RUNNING,
-        )
-    
-    print(f"Space URL: https://huggingface.co/spaces/{owner}/{space_name}")
-    return sdk
-
-if __name__ == "__main__":
-    create_space()