Set up GitHub Actions deployment to Hugging Face

.github/workflows/deploy.yml

@@ -0,0 +1,20 @@
+name: Deploy to Hugging Face Space
+
+on:
+  push:
+    branches: [main]
+
+jobs:
+  sync-to-hub:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          
+      - name: Push to Hugging Face
+        env:
+          HF_TOKEN: ${{ secrets.HF_TOKEN }}
+        run: |
+          git push --force https://parthtamu:$HF_TOKEN@huggingface.co/spaces/parthtamu/rag-code-assistant main

Dockerfile

@@ -2,17 +2,39 @@ FROM python:3.10-slim
 
 WORKDIR /app
 
+# 1. Install C++ Build Tools (Required for pybind11 and CMake)
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    cmake \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# 2. Setup Virtual Environment
 RUN python -m venv /opt/venv
 ENV PATH="/opt/venv/bin:$PATH"
 
+# 3. Install basic Python dependencies first (helps with Docker caching)
 COPY requirements.txt .
-
 RUN pip install --no-cache-dir --upgrade pip \
     && pip install --no-cache-dir torch --index-url https://download.pytorch.org/whl/cpu \
     && pip install --no-cache-dir -r requirements.txt
 
+# 4. Copy the ENTIRE fast_tokenizer directory into the container
+# This ensures setup.py, CMakeLists.txt, and the cpp files are all present
+COPY src/fast_tokenizer/ ./src/fast_tokenizer/
+
+# 5. Compile and install your C++ extension locally
+# Navigate into the specific folder we just copied and install it
+RUN cd src/fast_tokenizer && pip install .
+
+# 6. Pre-download the Hugging Face model
 RUN python -c "from sentence_transformers import SentenceTransformer; SentenceTransformer('all-MiniLM-L6-v2')"
 
+# 7. Copy the rest of your agent's source code
 COPY src/rag_code_assistant/agent.py .
 
-CMD ["python", "agent.py"]
+# 8. Expose Hugging Face Port
+EXPOSE 7860
+
+# 9. Start FastAPI via uvicorn
+CMD ["uvicorn", "agent:app", "--host", "0.0.0.0", "--port", "7860"]

requirements.txt

@@ -6,3 +6,11 @@ langchain-ollama
 langchain-text-splitters
 langchain-chroma
 sentence-transformers
+python-dotenv
+
+fastapi
+uvicorn
+python-multipart
+pinecone-client
+langchain-pinecone
+pypdf

src/fast_tokenizer/src/tokenizer.cpp

@@ -22,8 +22,16 @@ std::vector<std::string> tokenize(std::string s) {
     return result;
 }
 
+// Inside your C++ code
+size_t count_tokens(const std::string& text) {
+    // Assuming tokenize() is your existing function that returns std::vector<std::string>
+    std::vector<std::string> tokens = tokenize(text);
+    return tokens.size();
+}
+
 /* pybind11 bindings */
 PYBIND11_MODULE(fast_tokenizer, m) {
     m.doc() = "Fast C++ tokenizer plugin for RAG Code Assistant"; 
     m.def("tokenize", &tokenize, "A function that splits a string by whitespace and lowercases it");
+    m.def("count_tokens", &count_tokens, "Returns the number of tokens in the text");
 }

src/rag_code_assistant/agent.py

@@ -1,33 +1,51 @@
-from langchain_chroma import Chroma
+import os
+import uvicorn
+from dotenv import load_dotenv
+
+load_dotenv()
+from fastapi import FastAPI, UploadFile, File
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import StreamingResponse
+from pydantic import BaseModel
+
+from langchain_pinecone import PineconeVectorStore # Changed from Chroma
 from langchain_ollama import ChatOllama
 from langchain_huggingface import HuggingFaceEmbeddings
 from langchain_core.tools.retriever import create_retriever_tool
 from langchain.agents import create_agent
 from langchain_core.messages import HumanMessage, AIMessage, AIMessageChunk
-import os
+
+from langchain_community.document_loaders import PyPDFLoader
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+
+import fast_tokenizer
+from pathlib import Path
+from langchain_community.document_loaders import UnstructuredHTMLLoader, UnstructuredMarkdownLoader, TextLoader, BSHTMLLoader
 
 def load_vectorstore():
     embeddings = HuggingFaceEmbeddings(model_name="all-MiniLM-L6-v2")
-    return Chroma(
-        persist_directory="chroma_db",
-        embedding_function=embeddings,
-        collection_name="rag_code_assistant"
+    return PineconeVectorStore(
+        index_name="rag-agent",
+        embedding=embeddings,
+        pinecone_api_key=os.environ["PINECONE_API_KEY"],
     )
 
 def load_llm():
-    # Make sure to use the dedicated ollama import to avoid JSON parsing errors
-    base_url = os.environ.get("OLLAMA_BASE_URL", "http://localhost:11434")
-    return ChatOllama(model="llama3.1", temperature=0.1, base_url=base_url)
+    return ChatOllama(
+        model="llama3.1",
+        temperature=0.1,
+        base_url=os.environ["OLLAMA_BASE_URL"],
+    )
 
 def load_retriever(vectorstore):
+    # Kept exactly as you wrote it
     return vectorstore.as_retriever(
         search_type="mmr",
         search_kwargs={"k": 4, "fetch_k": 20}
     )
 
 def load_retriever_tool(retriever):
-    # This built-in tool automatically accepts a "query" argument from the LLM,
-    # searches the DB, and returns the raw text context back to the LLM.
+    # Kept exactly as you wrote it
     return create_retriever_tool(
         retriever, 
         "rag_retriever", 
@@ -35,6 +53,7 @@ def load_retriever_tool(retriever):
     )
 
 def load_agent(tools, llm):
+    # Kept exactly as you wrote it
     system_prompt = (
         "You are an expert all in one assistant. Follow these rules strictly:\n\n"
         "1. PYTHON QUESTIONS: YOU MUST use tools to search for the answer.\n"
@@ -54,53 +73,132 @@ def load_agent(tools, llm):
         system_prompt=system_prompt,
     )
 
-if __name__ == "__main__":
-    # --- INITIALIZATION ---
-    vectorstore = load_vectorstore()
-    llm = load_llm()
-    retriever = load_retriever(vectorstore)
 
-    retriever_tool = load_retriever_tool(retriever)
-    tools = [retriever_tool]
+# --- FASTAPI SETUP & GLOBAL INITIALIZATION ---
 
-    agent = load_agent(tools, llm)
+app = FastAPI(title="Python RAG Agent API")
 
-    # --- CONTINUOUS CHAT LOOP ---
-    print("\n" + "="*50)
-    print("🐍 Python Coding Assistant Initialized")
-    print("Type 'quit', 'exit', or 'q' to end the conversation.")
-    print("="*50 + "\n")
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"], 
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
 
-    chat_history = []
+# Initialize your agent once when the server starts
+vectorstore = load_vectorstore()
+llm = load_llm()
+retriever = load_retriever(vectorstore)
+retriever_tool = load_retriever_tool(retriever)
+tools = [retriever_tool]
+agent = load_agent(tools, llm)
+
+
+# --- API ENDPOINTS ---
 
-    while True:
-        user_input = input("You: ")
-        print("=== YOUR QUESTION ===")
-        print(user_input)
+class ChatRequest(BaseModel):
+    message: str
+    history: list[dict] = []  # Allows UI to send previous messages
 
-        if user_input.lower() in ['quit', 'exit', 'q']:
-            print("\nGoodbye!")
-            break
+@app.post("/chat")
+async def chat_endpoint(request: ChatRequest):
+    # 1. Build the chat history array from the UI's request
+    chat_history = []
+    for msg in request.history:
+        if msg["role"] == "user":
+            chat_history.append(HumanMessage(content=msg["content"]))
+        else:
+            chat_history.append(AIMessage(content=msg["content"]))
             
-        chat_history.append(HumanMessage(content=user_input))
-        
-        print("Thinking...\n")
-        print("=== ASSISTANT'S ANSWER ===")
-        
+    chat_history.append(HumanMessage(content=request.message))
+
+    # 2. Wrap your exact original streaming logic in a generator function
+    async def generate_stream():
         try:
-            full_response = ""
             for chunk, metadata in agent.stream(
                 {"messages": chat_history},
                 stream_mode="messages",
             ):
                 if isinstance(chunk, AIMessageChunk) and chunk.content:
-                    print(chunk.content, end="", flush=True)
-                    full_response += chunk.content
+                    yield chunk.content
+        except Exception as e:
+            yield f"\n[Error]: {e}"
+
+    # 3. Stream the output to the Vercel frontend
+    return StreamingResponse(generate_stream(), media_type="text/event-stream")
 
-            print("\n" + "="*50 + "\n")
+
+# 1. Add your custom token length function back
+def custom_token_length(text):
+    tokens = fast_tokenizer.tokenize(text)
+    return len(tokens)
+
+@app.post("/upload")
+async def upload_document(file: UploadFile = File(...)):
+    """Accepts PDF, HTML, MD, and TXT files and uploads them to Pinecone using fast_tokenizer."""
+    
+    ext = Path(file.filename).suffix.lower()
+    
+    supported_extensions = [".pdf", ".html", ".htm", ".md", ".txt"]
+    if ext not in supported_extensions:
+        return {"error": f"Unsupported file type. Please upload one of: {', '.join(supported_extensions)}"}
+
+    temp_file_path = f"temp_{file.filename}"
+    with open(temp_file_path, "wb") as f:
+        f.write(await file.read())
+
+    try:
+        if ext == ".pdf":
+            loader = PyPDFLoader(temp_file_path)
+            docs = loader.load()
             
-            chat_history.append(AIMessage(content=full_response))
+        elif ext in [".html", ".htm"]:
+            try:
+                loader = UnstructuredHTMLLoader(temp_file_path)
+                docs = loader.load()
+            except Exception as e:
+                print(f"Warning: UnstructuredHTMLLoader failed, trying BSHTMLLoader: {e}")
+                loader = BSHTMLLoader(temp_file_path)
+                docs = loader.load()
+                
+        elif ext == ".md":
+            loader = UnstructuredMarkdownLoader(temp_file_path)
+            docs = loader.load()
             
-        except Exception as e:
-            print(f"\n[Error]: {e}")
-            chat_history.pop()
+        elif ext == ".txt":
+            loader = TextLoader(temp_file_path)
+            docs = loader.load()
+
+        # 2. Re-implement your exact RecursiveCharacterTextSplitter settings
+        text_splitter = RecursiveCharacterTextSplitter(
+            chunk_size=350,       # Max 350 tokens per chunk
+            chunk_overlap=50,     # Overlap of 50 tokens
+            length_function=custom_token_length  # Tells LangChain to use your C++ tool
+        )
+        
+        splits = text_splitter.split_documents(docs)
+
+        # 3. Upload the perfectly tokenized chunks to Pinecone
+        vectorstore.add_documents(splits)
+
+        return {
+            "status": "success", 
+            "message": f"Successfully processed {file.filename} into {len(splits)} chunks and uploaded to Pinecone."
+        }
+        
+    except Exception as e:
+        return {"error": f"Failed to process file: {str(e)}"}
+        
+    finally:
+        # Clean up temp file
+        if os.path.exists(temp_file_path):
+            os.remove(temp_file_path)
+
+
+if __name__ == "__main__":
+    # Runs the API server on port 7860 (Required for Hugging Face Spaces)
+    print("\n" + "="*50)
+    print("🐍 Python RAG API Initialized on Port 7860")
+    print("="*50 + "\n")
+    uvicorn.run("agent:app", host="0.0.0.0", port=7860, reload=True)

src/rag_code_assistant/ingest.py

@@ -1,13 +1,19 @@
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
 from langchain_community.document_loaders import UnstructuredHTMLLoader, UnstructuredMarkdownLoader, TextLoader, BSHTMLLoader
 from langchain_text_splitters import RecursiveCharacterTextSplitter
-from langchain_community.embeddings import HuggingFaceEmbeddings
-from langchain_community.vectorstores import Chroma
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain_pinecone import PineconeVectorStore
 from pathlib import Path
 import fast_tokenizer
 
 base_dir = Path("./docs")
 paths = list(base_dir.rglob("*"))
 
+
 def load_docs(paths):
     all_docs = []
     for p in paths:
@@ -43,9 +49,16 @@ def load_docs(paths):
     
     return all_docs
 
+
+# Temporary Python fallback for local Windows ingestion
 def custom_token_length(text):
-    tokens = fast_tokenizer.tokenize(text)
-    return len(tokens)
+    # Ensure text is clean UTF-8
+    clean_text = text.encode('utf-8', 'ignore').decode('utf-8')
+    
+    # A standard rule of thumb for English text is that 1 token is roughly 4 characters.
+    # This avoids needing the C++ fast_tokenizer on Windows!
+    return len(clean_text) // 4
+
 
 def split_docs(docs):
     splitter = RecursiveCharacterTextSplitter(
@@ -55,18 +68,28 @@ def split_docs(docs):
     )
     return splitter.split_documents(docs)
 
+
 def store_docs(texts):
+    print("Embedding documents and uploading to Pinecone... (This may take a minute)")
+    
     model = HuggingFaceEmbeddings(model_name="all-MiniLM-L6-v2")
-    vectorstore = Chroma.from_documents(
+    
+    vectorstore = PineconeVectorStore.from_documents(
         documents=texts,
         embedding=model,
-        persist_directory="chroma_db",
-        collection_name="rag_code_assistant"
+        index_name="rag-agent",
+        pinecone_api_key=os.environ["PINECONE_API_KEY"],
     )
     return vectorstore
 
-docs = load_docs(paths)
-texts = split_docs(docs)
-vectorstore = store_docs(texts)
 
-print("Documents Loaded: ", len(docs))
+if __name__ == "__main__":
+    docs = load_docs(paths)
+    texts = split_docs(docs)
+    vectorstore = store_docs(texts)
+
+    print("="*50)
+    print("✅ SUCCESS!")
+    print(f"Documents Loaded: {len(docs)}")
+    print(f"Total Chunks Uploaded to Pinecone: {len(texts)}")
+    print("="*50)