Initial commit - Personal RAG Assistant with Hugging Face integration

.gitattributes

@@ -0,0 +1,34 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text 

.gitignore

@@ -0,0 +1,45 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual Environment
+venv/
+ENV/
+.env
+
+# Data directories
+data/
+
+# IDE files
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Streamlit
+.streamlit/
+
+# Logs
+*.log
+
+# OS specific
+.DS_Store
+Thumbs.db

Dockerfile

@@ -0,0 +1,30 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+# Install required system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the rest of the application
+COPY . .
+
+# Create necessary directories
+RUN mkdir -p data/documents data/vector_db
+
+# Set environment variable to avoid TOKENIZERS_PARALLELISM warning
+ENV TOKENIZERS_PARALLELISM=false
+
+# Expose the Streamlit port
+EXPOSE 8501
+
+# Set the entrypoint command to run the Streamlit app
+CMD ["streamlit", "run", "app/ui/streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"] 

README.md

@@ -0,0 +1,95 @@
+# Personal AI Assistant with RAG (Hugging Face Edition)
+
+A powerful personal AI assistant built with LangChain, integrating Retrieval-Augmented Generation (RAG) with a vector database (Qdrant) for improved contextual awareness and memory. This version uses Hugging Face models and can be deployed to Hugging Face Spaces for free hosting.
+
+[![Open In Spaces](https://huggingface.co/datasets/huggingface/badges/resolve/main/open-in-spaces-sm.svg)](https://huggingface.co/spaces)
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com)
+
+## Features
+
+- Large Language Model integration using Hugging Face's free models
+- RAG-based memory system with vector database storage
+- Document ingestion pipeline for various file types
+- Simple web UI built with Streamlit
+- Conversation history tracking and retrieval
+- Free deployment on Hugging Face Spaces
+
+## Project Structure
+
+```
+.
+├── README.md
+├── requirements.txt
+├── .env.example
+├── app.py                 # Main entry point for Hugging Face Spaces
+├── space.py               # Hugging Face Spaces SDK integration
+├── app/
+│   ├── main.py            # FastAPI application entry point
+│   ├── config.py          # Configuration settings
+│   ├── ui/
+│   │   └── streamlit_app.py # Streamlit web interface
+│   ├── core/
+│   │   ├── llm.py         # LLM integration (Hugging Face)
+│   │   ├── memory.py      # RAG and vector store integration
+│   │   ├── agent.py       # Agent orchestration
+│   │   └── ingestion.py   # Document processing pipeline
+│   └── utils/
+│       └── helpers.py     # Utility functions
+└── data/
+    ├── documents/         # Store for uploaded documents
+    └── vector_db/         # Local vector database storage
+```
+
+## Setup
+
+1. Clone this repository
+2. Install dependencies:
+   ```
+   pip install -r requirements.txt
+   ```
+3. Copy `.env.example` to `.env` and fill in your Hugging Face API keys (optional)
+4. Start the Streamlit UI:
+   ```
+   streamlit run app/ui/streamlit_app.py
+   ```
+
+## Usage
+
+1. Upload documents through the web interface
+2. Chat with your assistant, which can now reference your documents
+3. The assistant will automatically leverage your document knowledge to provide more personalized responses
+
+## Deployment to Hugging Face Spaces
+
+This app can be easily deployed to Hugging Face Spaces for free hosting:
+
+1. Create a Hugging Face account at [huggingface.co](https://huggingface.co)
+2. Set environment variables:
+   ```
+   export HF_USERNAME=your-username
+   export HF_TOKEN=your-huggingface-token
+   export SPACE_NAME=personal-rag-assistant  # optional
+   ```
+3. Run the deployment script:
+   ```
+   python space.py
+   ```
+4. Visit your deployed app at `https://huggingface.co/spaces/{your-username}/{space-name}`
+
+Alternatively, you can manually create a new Space on Hugging Face and link it to your GitHub repository.
+
+## Models Used
+
+This implementation uses the following free models from Hugging Face:
+
+- LLM: [google/flan-t5-large](https://huggingface.co/google/flan-t5-large) - A powerful instruction-tuned model
+- Embeddings: [sentence-transformers/all-MiniLM-L6-v2](https://huggingface.co/sentence-transformers/all-MiniLM-L6-v2) - Efficient embedding model
+
+You can change these in the `.env` file.
+
+## Extending
+
+- Add more document loaders in `ingestion.py`
+- Integrate additional tools in `agent.py`
+- Customize the UI in `streamlit_app.py`
+- Switch to a different LLM in `llm.py` and `.env` 

app.py

@@ -0,0 +1,18 @@
+#!/usr/bin/env python
+"""
+Main entry point for Hugging Face Spaces deployment.
+This file starts the Streamlit UI when deployed to Hugging Face Spaces.
+"""
+import subprocess
+import os
+import sys
+
+# Make sure the app directory is in the path
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+# Create necessary directories
+os.makedirs('data/documents', exist_ok=True)
+os.makedirs('data/vector_db', exist_ok=True)
+
+# Run the Streamlit app
+subprocess.run(["streamlit", "run", "app/ui/streamlit_app.py"]) 

app/config.py

@@ -0,0 +1,46 @@
+import os
+from dotenv import load_dotenv
+from pathlib import Path
+
+# Load environment variables
+env_path = Path('.') / '.env'
+load_dotenv(dotenv_path=env_path)
+
+# API Keys
+HF_API_KEY = os.getenv('HF_API_KEY', '')
+
+# LLM Configuration
+LLM_MODEL = os.getenv('LLM_MODEL', 'google/flan-t5-large')
+EMBEDDING_MODEL = os.getenv('EMBEDDING_MODEL', 'sentence-transformers/all-MiniLM-L6-v2')
+
+# Vector Database
+VECTOR_DB_PATH = os.getenv('VECTOR_DB_PATH', './data/vector_db')
+COLLECTION_NAME = os.getenv('COLLECTION_NAME', 'personal_assistant')
+
+# Application Settings
+DEFAULT_TEMPERATURE = float(os.getenv('DEFAULT_TEMPERATURE', 0.7))
+CHUNK_SIZE = int(os.getenv('CHUNK_SIZE', 1000))
+CHUNK_OVERLAP = int(os.getenv('CHUNK_OVERLAP', 200))
+MAX_TOKENS = int(os.getenv('MAX_TOKENS', 512))
+
+# 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
+
+# LLM Configuration
+LLM_MODEL=google/flan-t5-large  # Free model with good performance
+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=1000
+CHUNK_OVERLAP=200
+MAX_TOKENS=512
+""") 

app/core/agent.py

@@ -0,0 +1,73 @@
+import sys
+import os
+from typing import List, Dict, Any
+from langchain.prompts import PromptTemplate
+
+# Add project root to path for imports
+sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+from app.core.memory import MemoryManager
+from app.core.llm import get_llm
+
+class AssistantAgent:
+    """Orchestrates the assistant's functionality, managing RAG and tools."""
+    
+    def __init__(self):
+        self.memory_manager = MemoryManager()
+        self.rag_chain = self.memory_manager.create_rag_chain()
+        self.llm = get_llm()
+        
+        # Define a system prompt template
+        self.system_template = """You are a personal AI assistant that helps the user with their tasks and questions.
+You have access to the user's documents and notes through a retrieval system.
+When answering questions, leverage this knowledge base to provide specific, factual information.
+If the answer is not in the provided context, acknowledge that and give the best general answer you can.
+
+Context from the user's documents:
+{context}
+
+Chat History:
+{chat_history}
+
+User: {question}
+Assistant:"""
+        
+        self.rag_prompt = PromptTemplate(
+            input_variables=["context", "chat_history", "question"],
+            template=self.system_template
+        )
+    
+    def query(self, question: str) -> Dict[str, Any]:
+        """Process a user query and return a response."""
+        # Use the RAG chain to get an answer
+        response = self.rag_chain({"question": question})
+        
+        # Extract the answer and source documents
+        answer = response["answer"]
+        source_docs = response["source_documents"] if "source_documents" in response else []
+        
+        # Format source documents for display
+        sources = []
+        for doc in source_docs:
+            metadata = doc.metadata
+            sources.append({
+                "content": doc.page_content[:100] + "..." if len(doc.page_content) > 100 else doc.page_content,
+                "source": metadata.get("source", "Unknown"),
+                "file_name": metadata.get("file_name", "Unknown"),
+                "page": metadata.get("page", "N/A") if "page" in metadata else None
+            })
+        
+        return {
+            "answer": answer,
+            "sources": sources
+        }
+    
+    def add_conversation_to_memory(self, question: str, answer: str):
+        """Add a conversation exchange to the memory for future context."""
+        # Create metadata for the conversation
+        metadata = {
+            "type": "conversation",
+            "question": question
+        }
+        
+        # Add the exchange to the vector store
+        self.memory_manager.add_texts([answer], [metadata]) 

app/core/ingestion.py

@@ -0,0 +1,102 @@
+import os
+import sys
+from typing import List, Dict, Any
+from langchain.document_loaders import (
+    PyPDFLoader,
+    TextLoader,
+    CSVLoader
+)
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+
+# Add project root to path for imports
+sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+from app.config import CHUNK_SIZE, CHUNK_OVERLAP
+from app.core.memory import MemoryManager
+
+class DocumentProcessor:
+    """Processes documents for ingestion into the vector database."""
+    
+    def __init__(self, memory_manager: MemoryManager):
+        self.memory_manager = memory_manager
+        self.text_splitter = RecursiveCharacterTextSplitter(
+            chunk_size=CHUNK_SIZE,
+            chunk_overlap=CHUNK_OVERLAP
+        )
+    
+    def process_file(self, file_path: str) -> List[str]:
+        """Process a file and return a list of document chunks."""
+        if not os.path.exists(file_path):
+            raise FileNotFoundError(f"File not found: {file_path}")
+        
+        # Get the file extension
+        _, extension = os.path.splitext(file_path)
+        extension = extension.lower()
+        
+        # Load the file using the appropriate loader
+        if extension == '.pdf':
+            loader = PyPDFLoader(file_path)
+        elif extension == '.txt':
+            loader = TextLoader(file_path)
+        elif extension == '.csv':
+            loader = CSVLoader(file_path)
+        else:
+            raise ValueError(f"Unsupported file type: {extension}")
+        
+        # Load and split the documents
+        documents = loader.load()
+        chunks = self.text_splitter.split_documents(documents)
+        
+        return chunks
+    
+    def ingest_file(self, file_path: str, metadata: Dict[str, Any] = None) -> List[str]:
+        """Ingest a file into the vector database."""
+        # Process the file
+        chunks = self.process_file(file_path)
+        
+        # Add metadata to each chunk
+        if metadata is None:
+            metadata = {}
+        
+        # Add file path to metadata
+        base_metadata = {
+            "source": file_path,
+            "file_name": os.path.basename(file_path)
+        }
+        base_metadata.update(metadata)
+        
+        # Prepare chunks and metadatas
+        texts = [chunk.page_content for chunk in chunks]
+        metadatas = []
+        
+        for i, chunk in enumerate(chunks):
+            chunk_metadata = base_metadata.copy()
+            if hasattr(chunk, 'metadata'):
+                chunk_metadata.update(chunk.metadata)
+            chunk_metadata["chunk_id"] = i
+            metadatas.append(chunk_metadata)
+        
+        # Store in vector database
+        ids = self.memory_manager.add_texts(texts, metadatas)
+        
+        return ids
+    
+    def ingest_text(self, text: str, metadata: Dict[str, Any] = None) -> List[str]:
+        """Ingest raw text into the vector database."""
+        if metadata is None:
+            metadata = {}
+        
+        # Split the text
+        chunks = self.text_splitter.split_text(text)
+        
+        # Prepare metadatas
+        metadatas = []
+        for i in range(len(chunks)):
+            chunk_metadata = metadata.copy()
+            chunk_metadata["chunk_id"] = i
+            chunk_metadata["source"] = "direct_input"
+            metadatas.append(chunk_metadata)
+        
+        # Store in vector database
+        ids = self.memory_manager.add_texts(chunks, metadatas)
+        
+        return ids 

app/core/llm.py

@@ -0,0 +1,60 @@
+from langchain.llms import HuggingFaceHub
+from langchain_community.embeddings import HuggingFaceEmbeddings
+from langchain.chains import LLMChain
+from langchain.prompts import PromptTemplate
+import sys
+import os
+
+# Add project root to path for imports
+sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+from app.config import HF_API_KEY, LLM_MODEL, EMBEDDING_MODEL, DEFAULT_TEMPERATURE, MAX_TOKENS
+
+def get_llm():
+    """Initialize and return the language model."""
+    if not HF_API_KEY:
+        # Can still work without API key but with rate limits
+        print("Warning: Hugging Face API key not set. Using models without authentication.")
+    
+    llm = HuggingFaceHub(
+        huggingfacehub_api_token=HF_API_KEY,
+        repo_id=LLM_MODEL,
+        model_kwargs={
+            "temperature": DEFAULT_TEMPERATURE,
+            "max_length": MAX_TOKENS
+        }
+    )
+    
+    return llm
+
+def get_embeddings():
+    """Initialize and return the embeddings model."""
+    # SentenceTransformers can be used locally without an API key
+    return HuggingFaceEmbeddings(
+        model_name=EMBEDDING_MODEL
+    )
+
+def get_chat_model():
+    """
+    Create a chat-like interface using a regular LLM.
+    This is necessary because many free HF models don't have chat interfaces.
+    """
+    llm = get_llm()
+    
+    # Create a chat-like prompt template
+    chat_template = """
+    Context: {context}
+    
+    Chat History:
+    {chat_history}
+    
+    User: {question}
+    AI Assistant:
+    """
+    
+    prompt = PromptTemplate(
+        input_variables=["context", "chat_history", "question"],
+        template=chat_template
+    )
+    
+    # Create a chain
+    return LLMChain(llm=llm, prompt=prompt) 

app/core/memory.py

@@ -0,0 +1,76 @@
+import os
+import sys
+from langchain.vectorstores import Qdrant
+from langchain.chains import ConversationalRetrievalChain
+from langchain.memory import ConversationBufferMemory
+from qdrant_client import QdrantClient
+from qdrant_client.models import Distance, VectorParams
+
+# Add project root to path for imports
+sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+from app.config import VECTOR_DB_PATH, COLLECTION_NAME
+from app.core.llm import get_llm, get_embeddings, get_chat_model
+
+class MemoryManager:
+    """Manages the RAG memory system using a vector database."""
+    
+    def __init__(self):
+        self.embeddings = get_embeddings()
+        self.llm = get_llm()
+        self.chat_model = get_chat_model()
+        self.client = self._init_qdrant_client()
+        self.vectorstore = self._init_vector_store()
+        self.memory = ConversationBufferMemory(
+            memory_key="chat_history",
+            return_messages=True
+        )
+        
+    def _init_qdrant_client(self):
+        """Initialize the Qdrant client."""
+        os.makedirs(VECTOR_DB_PATH, exist_ok=True)
+        return QdrantClient(path=VECTOR_DB_PATH)
+    
+    def _init_vector_store(self):
+        """Initialize the vector store."""
+        collections = self.client.get_collections().collections
+        collection_names = [collection.name for collection in collections]
+        
+        # Get vector dimension from the embedding model
+        vector_size = len(self.embeddings.embed_query("test"))
+        
+        if COLLECTION_NAME not in collection_names:
+            self.client.create_collection(
+                collection_name=COLLECTION_NAME,
+                vectors_config=VectorParams(size=vector_size, distance=Distance.COSINE),
+            )
+            
+        return Qdrant(
+            client=self.client, 
+            collection_name=COLLECTION_NAME,
+            embeddings=self.embeddings
+        )
+    
+    def get_retriever(self):
+        """Get the retriever for RAG."""
+        return self.vectorstore.as_retriever(
+            search_type="similarity",
+            search_kwargs={"k": 5}
+        )
+    
+    def create_rag_chain(self):
+        """Create a RAG chain for question answering."""
+        # Using the chat model created with the regular LLM
+        return ConversationalRetrievalChain.from_llm(
+            llm=self.llm,
+            retriever=self.get_retriever(),
+            memory=self.memory,
+            return_source_documents=True
+        )
+    
+    def add_texts(self, texts, metadatas=None):
+        """Add texts to the vector store."""
+        return self.vectorstore.add_texts(texts=texts, metadatas=metadatas)
+    
+    def similarity_search(self, query, k=5):
+        """Perform a similarity search."""
+        return self.vectorstore.similarity_search(query, k=k) 

app/main.py

@@ -0,0 +1,117 @@
+import os
+import sys
+import uvicorn
+from fastapi import FastAPI, HTTPException, Depends, Request, File, UploadFile
+from fastapi.responses import JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from typing import List, Dict, Any, Optional
+import tempfile
+
+# Add project root to path for imports
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from app.core.agent import AssistantAgent
+from app.core.ingestion import DocumentProcessor
+from app.utils.helpers import get_document_path
+from app.config import create_env_example
+
+# Create .env.example file if it doesn't exist
+create_env_example()
+
+# Create FastAPI app
+app = FastAPI(
+    title="Personal AI Assistant API",
+    description="API for a personal AI assistant with RAG capabilities",
+    version="1.0.0"
+)
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Initialize the agent and document processor
+agent = AssistantAgent()
+document_processor = DocumentProcessor(agent.memory_manager)
+
+# Define request and response models
+class QueryRequest(BaseModel):
+    query: str
+
+class QueryResponse(BaseModel):
+    answer: str
+    sources: List[Dict[str, Any]]
+
+class TextIngestionRequest(BaseModel):
+    text: str
+    metadata: Optional[Dict[str, Any]] = None
+
+# Define API endpoints
+@app.get("/")
+async def root():
+    return {"message": "Welcome to the Personal AI Assistant API"}
+
+@app.post("/query", response_model=QueryResponse)
+async def query(request: QueryRequest):
+    """Query the assistant with a question."""
+    try:
+        response = agent.query(request.query)
+        
+        # Add the conversation to memory
+        agent.add_conversation_to_memory(request.query, response["answer"])
+        
+        return response
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/ingest/text")
+async def ingest_text(request: TextIngestionRequest):
+    """Ingest text into the knowledge base."""
+    try:
+        metadata = request.metadata or {}
+        
+        # Add the text to the knowledge base
+        ids = document_processor.ingest_text(request.text, metadata)
+        
+        return {"message": "Text ingested successfully", "ids": ids}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/ingest/file")
+async def ingest_file(file: UploadFile = File(...)):
+    """Ingest a file into the knowledge base."""
+    try:
+        # Create a temporary file
+        with tempfile.NamedTemporaryFile(delete=False, suffix=f".{file.filename.split('.')[-1]}") as tmp:
+            content = await file.read()
+            tmp.write(content)
+            tmp_path = tmp.name
+        
+        # Get a path to store the document
+        doc_path = get_document_path(file.filename)
+        
+        # Copy the file to the documents directory
+        with open(doc_path, "wb") as f:
+            # Seek to the beginning of the file
+            await file.seek(0)
+            content = await file.read()
+            f.write(content)
+        
+        # Ingest the document
+        metadata = {"original_name": file.filename}
+        ids = document_processor.ingest_file(tmp_path, metadata)
+        
+        # Clean up the temporary file
+        os.unlink(tmp_path)
+        
+        return {"message": f"File {file.filename} ingested successfully", "ids": ids}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+# Run the application
+if __name__ == "__main__":
+    uvicorn.run("app.main:app", host="0.0.0.0", port=8000, reload=True) 

app/ui/streamlit_app.py

@@ -0,0 +1,167 @@
+import streamlit as st
+import os
+import sys
+import tempfile
+from datetime import datetime
+from typing import List, Dict, Any
+
+# Add project root to path for imports
+sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+from app.core.agent import AssistantAgent
+from app.core.ingestion import DocumentProcessor
+from app.utils.helpers import get_document_path, format_sources, save_conversation
+from app.config import LLM_MODEL, EMBEDDING_MODEL
+
+# Set page config
+st.set_page_config(
+    page_title="Personal AI Assistant (Hugging Face)",
+    page_icon="🤗",
+    layout="wide"
+)
+
+# Initialize session state variables
+if "messages" not in st.session_state:
+    st.session_state.messages = []
+
+if "agent" not in st.session_state:
+    st.session_state.agent = AssistantAgent()
+
+if "document_processor" not in st.session_state:
+    st.session_state.document_processor = DocumentProcessor(st.session_state.agent.memory_manager)
+
+# App title
+st.title("🤗 Personal AI Assistant (Hugging Face)")
+
+# Create a sidebar for uploading documents and settings
+with st.sidebar:
+    st.header("Upload Documents")
+    uploaded_file = st.file_uploader("Choose a file", type=["pdf", "txt", "csv"])
+    
+    if uploaded_file is not None:
+        # Create a temporary file
+        with tempfile.NamedTemporaryFile(delete=False, suffix=f".{uploaded_file.name.split('.')[-1]}") as tmp:
+            tmp.write(uploaded_file.getvalue())
+            tmp_path = tmp.name
+        
+        if st.button("Process Document"):
+            with st.spinner("Processing document..."):
+                try:
+                    # Get a path to store the document
+                    doc_path = get_document_path(uploaded_file.name)
+                    
+                    # Copy the file to the documents directory
+                    with open(doc_path, "wb") as f:
+                        f.write(uploaded_file.getvalue())
+                    
+                    # Ingest the document
+                    st.session_state.document_processor.ingest_file(tmp_path, {"original_name": uploaded_file.name})
+                    
+                    # Clean up the temporary file
+                    os.unlink(tmp_path)
+                    
+                    st.success(f"Document {uploaded_file.name} processed successfully!")
+                except Exception as e:
+                    st.error(f"Error processing document: {str(e)}")
+    
+    st.header("Raw Text Input")
+    text_input = st.text_area("Enter text to add to the knowledge base")
+    
+    if st.button("Add Text"):
+        if text_input:
+            with st.spinner("Adding text to knowledge base..."):
+                try:
+                    # Create metadata
+                    metadata = {
+                        "type": "manual_input",
+                        "timestamp": str(datetime.now())
+                    }
+                    
+                    # Ingest the text
+                    st.session_state.document_processor.ingest_text(text_input, metadata)
+                    
+                    st.success("Text added to knowledge base successfully!")
+                except Exception as e:
+                    st.error(f"Error adding text: {str(e)}")
+    
+    # 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})")
+    
+    # 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.")
+    
+    # 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"])
+        
+        # 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['file_name']}" + (f" (Page {source['page']})" if source.get('page') else ""))
+                        st.text(source['content'])
+                else:
+                    st.write("No specific sources used.")
+
+# 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})
+    
+    # Display user message
+    with st.chat_message("user"):
+        st.write(prompt)
+    
+    # Generate response
+    with st.chat_message("assistant"):
+        with st.spinner("Thinking..."):
+            response = st.session_state.agent.query(prompt)
+            answer = response["answer"]
+            sources = response["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['file_name']}" + (f" (Page {source['page']})" if source.get('page') else ""))
+                        st.text(source['content'])
+                else:
+                    st.write("No specific sources used.")
+            
+            # Save conversation
+            save_conversation(prompt, answer, sources)
+            
+            # Add assistant response to chat history
+            st.session_state.messages.append({
+                "role": "assistant", 
+                "content": answer,
+                "sources": sources
+            })
+            
+            # Update the agent's memory
+            st.session_state.agent.add_conversation_to_memory(prompt, answer)
+
+# Add a footer
+st.markdown("---")
+st.markdown("Built with LangChain, Hugging Face, and Qdrant")
+
+if __name__ == "__main__":
+    # This is used when running the file directly
+    pass

app/utils/helpers.py

@@ -0,0 +1,67 @@
+import os
+import sys
+from datetime import datetime
+from typing import List, Dict, Any
+
+def sanitize_filename(filename: str) -> str:
+    """Sanitize a filename by removing invalid characters."""
+    # Replace invalid characters with underscores
+    invalid_chars = '<>:"/\\|?*'
+    for char in invalid_chars:
+        filename = filename.replace(char, '_')
+    return filename
+
+def get_document_path(filename: str) -> str:
+    """Get the path to store a document."""
+    # Get the documents directory
+    docs_dir = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), 'data', 'documents')
+    
+    # Create the directory if it doesn't exist
+    os.makedirs(docs_dir, exist_ok=True)
+    
+    # Sanitize the filename
+    filename = sanitize_filename(filename)
+    
+    # Add a timestamp to make the filename unique
+    timestamp = datetime.now().strftime('%Y%m%d%H%M%S')
+    base, ext = os.path.splitext(filename)
+    unique_filename = f"{base}_{timestamp}{ext}"
+    
+    return os.path.join(docs_dir, unique_filename)
+
+def format_sources(sources: List[Dict[str, Any]]) -> str:
+    """Format source documents for display."""
+    if not sources:
+        return "No sources found."
+    
+    formatted = []
+    for i, source in enumerate(sources, 1):
+        source_str = f"{i}. {source['file_name']} "
+        if source.get('page'):
+            source_str += f"(Page {source['page']}) "
+        formatted.append(source_str)
+    
+    return "\n".join(formatted)
+
+def save_conversation(question: str, answer: str, sources: List[Dict[str, Any]]) -> str:
+    """Save a conversation to a file."""
+    # Create a directory for conversations
+    conv_dir = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), 'data', 'conversations')
+    os.makedirs(conv_dir, exist_ok=True)
+    
+    # Create a filename based on the timestamp and first few words of the question
+    timestamp = datetime.now().strftime('%Y%m%d%H%M%S')
+    question_slug = "_".join(question.split()[:5]).lower()
+    question_slug = sanitize_filename(question_slug)
+    filename = f"{timestamp}_{question_slug}.txt"
+    
+    # Format the conversation
+    formatted_sources = format_sources(sources)
+    content = f"Question: {question}\n\nAnswer: {answer}\n\nSources:\n{formatted_sources}\n"
+    
+    # Save the conversation
+    filepath = os.path.join(conv_dir, filename)
+    with open(filepath, 'w') as f:
+        f.write(content)
+    
+    return filepath 

huggingface-space.yml

@@ -0,0 +1,9 @@
+title: Personal AI Assistant with RAG
+emoji: 🤗
+colorFrom: indigo
+colorTo: purple
+sdk: docker
+app_port: 8501
+pinned: true
+license: mit
+duplicated_from: huggingface/transformers-examples

requirements.txt

@@ -0,0 +1,15 @@
+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 

run.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python
+import os
+import sys
+import argparse
+import subprocess
+
+def setup_environment():
+    """Check if the environment is set up correctly."""
+    # Check if .env file exists
+    if not os.path.exists('.env'):
+        if os.path.exists('.env.example'):
+            print("Warning: .env file not found. Creating from .env.example...")
+            with open('.env.example', 'r') as example, open('.env', 'w') as env:
+                env.write(example.read())
+            print("Created .env file. Please edit it with your API keys and settings.")
+            sys.exit(1)
+        else:
+            print("Error: Neither .env nor .env.example file found.")
+            sys.exit(1)
+    
+    # Create necessary directories
+    os.makedirs('data/documents', exist_ok=True)
+    os.makedirs('data/vector_db', exist_ok=True)
+
+def run_api():
+    """Run the FastAPI server."""
+    print("Starting API server...")
+    subprocess.run(["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000", "--reload"])
+
+def run_ui():
+    """Run the Streamlit UI."""
+    print("Starting Streamlit UI...")
+    subprocess.run(["streamlit", "run", "app/ui/streamlit_app.py"])
+
+def main():
+    parser = argparse.ArgumentParser(description="Run the Personal AI Assistant")
+    parser.add_argument('--api', action='store_true', help='Run the FastAPI server')
+    parser.add_argument('--ui', action='store_true', help='Run the Streamlit UI')
+    args = parser.parse_args()
+    
+    setup_environment()
+    
+    if args.api:
+        run_api()
+    elif args.ui:
+        run_ui()
+    else:
+        print("Please specify either --api or --ui")
+        print("Examples:")
+        print("  python run.py --api   # Run the API server")
+        print("  python run.py --ui    # Run the Streamlit UI")
+
+if __name__ == "__main__":
+    main() 

space.py

@@ -0,0 +1,49 @@
+#!/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()