Upload 11 files

README.md

@@ -1,60 +1,76 @@
----
-title: RAG Implementation Notebook
-emoji: 🔍
-colorFrom: blue
-colorTo: purple
-sdk: gradio
-sdk_version: 5.23.3
-app_file: app.py
-pinned: false
----
-
-# RAG Implementation Notebook
-
-
-# 🧑‍💻 What is [AI Engineering](https://maven.com/aimakerspace/ai-eng-bootcamp)?
-
-AI Engineering refers to the industry-relevant skills that data science and engineering teams need to successfully **build, deploy, operate, and improve Large Language Model (LLM) applications in production environments**.  
-
-In practice, this requires understanding both prototyping and production deployments.
-
-During the *prototyping* phase, Prompt Engineering, Retrieval Augmented Generation (RAG), Agents, and Fine-Tuning are all necessary tools to be able to understand and leverage. Prototyping includes:
-1. Building RAG Applications
-2. Building with Agent and Multi-Agent Frameworks
-3. Fine-Tuning LLMs & Embedding Models
-4. Deploying LLM Prototype Applications to Users
-
-When *productionizing* LLM application prototypes, there are many important aspects ensuring helpful, harmless, honest, reliable, and scalable solutions for your customers or stakeholders. Productionizing includes:
-1. Evaluating RAG and Agent Applications
-2. Improving Search and Retrieval Pipelines for Production
-3. Monitoring Production KPIs for LLM Applications
-4. Setting up Inference Servers for LLMs and Embedding Models
-5. Building LLM Applications with Scalable, Production-Grade Components
-
-This bootcamp builds on our two previous courses, [LLM Engineering](https://maven.com/aimakerspace/llm-engineering) and [LLM Operations](https://maven.com/aimakerspace/llmops) 👇
-
-- Large Language Model Engineering (LLM Engineering) refers to the emerging best-practices and tools for pretraining, post-training, and optimizing LLMs prior to production deployment.  Pre- and post-training techniques include unsupervised pretraining, supervised fine-tuning, alignment, model merging, distillation, quantization. and others.
-    
-- Large Language Model Ops (LLM Ops, or LLMOps (as from [WandB](https://docs.wandb.ai/guides/prompts) and [a16z](https://a16z.com/emerging-architectures-for-llm-applications/))) refers to the emerging best-practices, tooling, and improvement processes used to manage production LLM applications throughout the AI product lifecycle.  LLM Ops is a subset of Machine Learning Operations (MLOps) that focuses on LLM-specific infrastructure and ops capabilities required to build, deploy, monitor, and scale complex LLM applications in production environments.  _This term is being used much less in industry these days._
-
-# 🏆 **Grading and Certification**
-
-To become **AI-Makerspace Certified**, which will open you up to additional opportunities for full and part-time work within our community and network, you must:
-
-1. Complete all project assignments.
-2. Complete a project and present during Demo Day.
-3. Receive at least an 85% total grade in the course.
-
-If you do not complete all assignments, participate in Demo Day, or maintain a high-quality standard of work, you may still be eligible for a *certificate of completion* if you miss no more than 2 live sessions.
-
-# 📚 About
-
-This GitHub repository is your gateway to mastering the art of AI Engineering.  ***All assignments for the course will be released here for your building, shipping, and sharing adventures!***
-
-# 🙏 Contributions
-
-We believe in the power of collaboration. Contributions, ideas, and feedback are highly encouraged! Let's build the ultimate resource for AI Engineering together.
-
-Please to reach out with any questions or suggestions. 
-
-Happy coding! 🚀🚀🚀
+---
+title: RAG Implementation Notebook
+emoji: 🔍
+colorFrom: blue
+colorTo: purple
+sdk: gradio
+sdk_version: 3.50.2
+app_file: app.py
+pinned: false
+---
+
+# RAG Implementation Notebook
+
+This space contains a Jupyter notebook demonstrating a Retrieval Augmented Generation (RAG) implementation using OpenAI's API and Hugging Face models.
+
+## Features
+- PDF document processing
+- Text chunking and embedding
+- Vector database implementation
+- RAG pipeline with context-aware responses
+
+## How to Use
+1. Clone this repository
+2. Install the requirements: `pip install -r requirements.txt`
+3. Open the notebook: `jupyter notebook Pythonic_RAG_Assignment.ipynb`
+
+## Requirements
+See `requirements.txt` for the complete list of dependencies.
+
+# 🧑‍💻 What is [AI Engineering](https://maven.com/aimakerspace/ai-eng-bootcamp)?
+
+AI Engineering refers to the industry-relevant skills that data science and engineering teams need to successfully **build, deploy, operate, and improve Large Language Model (LLM) applications in production environments**.  
+
+In practice, this requires understanding both prototyping and production deployments.
+
+During the *prototyping* phase, Prompt Engineering, Retrieval Augmented Generation (RAG), Agents, and Fine-Tuning are all necessary tools to be able to understand and leverage. Prototyping includes:
+1. Building RAG Applications
+2. Building with Agent and Multi-Agent Frameworks
+3. Fine-Tuning LLMs & Embedding Models
+4. Deploying LLM Prototype Applications to Users
+
+When *productionizing* LLM application prototypes, there are many important aspects ensuring helpful, harmless, honest, reliable, and scalable solutions for your customers or stakeholders. Productionizing includes:
+1. Evaluating RAG and Agent Applications
+2. Improving Search and Retrieval Pipelines for Production
+3. Monitoring Production KPIs for LLM Applications
+4. Setting up Inference Servers for LLMs and Embedding Models
+5. Building LLM Applications with Scalable, Production-Grade Components
+
+This bootcamp builds on our two previous courses, [LLM Engineering](https://maven.com/aimakerspace/llm-engineering) and [LLM Operations](https://maven.com/aimakerspace/llmops) 👇
+
+- Large Language Model Engineering (LLM Engineering) refers to the emerging best-practices and tools for pretraining, post-training, and optimizing LLMs prior to production deployment.  Pre- and post-training techniques include unsupervised pretraining, supervised fine-tuning, alignment, model merging, distillation, quantization. and others.
+    
+- Large Language Model Ops (LLM Ops, or LLMOps (as from [WandB](https://docs.wandb.ai/guides/prompts) and [a16z](https://a16z.com/emerging-architectures-for-llm-applications/))) refers to the emerging best-practices, tooling, and improvement processes used to manage production LLM applications throughout the AI product lifecycle.  LLM Ops is a subset of Machine Learning Operations (MLOps) that focuses on LLM-specific infrastructure and ops capabilities required to build, deploy, monitor, and scale complex LLM applications in production environments.  _This term is being used much less in industry these days._
+
+# 🏆 **Grading and Certification**
+
+To become **AI-Makerspace Certified**, which will open you up to additional opportunities for full and part-time work within our community and network, you must:
+
+1. Complete all project assignments.
+2. Complete a project and present during Demo Day.
+3. Receive at least an 85% total grade in the course.
+
+If you do not complete all assignments, participate in Demo Day, or maintain a high-quality standard of work, you may still be eligible for a *certificate of completion* if you miss no more than 2 live sessions.
+
+# 📚 About
+
+This GitHub repository is your gateway to mastering the art of AI Engineering.  ***All assignments for the course will be released here for your building, shipping, and sharing adventures!***
+
+# 🙏 Contributions
+
+We believe in the power of collaboration. Contributions, ideas, and feedback are highly encouraged! Let's build the ultimate resource for AI Engineering together.
+
+Please to reach out with any questions or suggestions. 
+
+Happy coding! 🚀🚀🚀
+

aimakerspace/__init__.py

@@ -0,0 +1,15 @@
+from .text_utils import PDFLoader, CharacterTextSplitter
+from .vectordatabase import VectorDatabase
+from .openai_utils.prompts import SystemRolePrompt, UserRolePrompt
+from .openai_utils.chatmodel import ChatOpenAI
+from .openai_utils.embedding import EmbeddingModel
+
+__all__ = [
+    'PDFLoader',
+    'CharacterTextSplitter',
+    'VectorDatabase',
+    'SystemRolePrompt',
+    'UserRolePrompt',
+    'ChatOpenAI',
+    'EmbeddingModel'
+] 

aimakerspace/openai_utils/__init__.py

@@ -0,0 +1,10 @@
+from .prompts import SystemRolePrompt, UserRolePrompt
+from .chatmodel import ChatOpenAI
+from .embedding import EmbeddingModel
+
+__all__ = [
+    'SystemRolePrompt',
+    'UserRolePrompt',
+    'ChatOpenAI',
+    'EmbeddingModel'
+] 

aimakerspace/openai_utils/chatmodel.py

@@ -0,0 +1,25 @@
+import os
+import openai
+from typing import List, Dict, Union
+
+class ChatOpenAI:
+    def __init__(self, model_name: str = "gpt-4"):
+        self.model_name = model_name
+        self.openai_api_key = os.getenv("OPENAI_API_KEY")
+        if self.openai_api_key is None:
+            raise ValueError("OPENAI_API_KEY is not set")
+
+    def run(self, messages: List[Dict[str, str]], text_only: bool = True) -> Union[str, Dict]:
+        if not isinstance(messages, list):
+            raise ValueError("messages must be a list")
+
+        openai.api_key = self.openai_api_key
+        response = openai.ChatCompletion.create(
+            model=self.model_name,
+            messages=messages
+        )
+
+        if text_only:
+            return response.choices[0].message.content
+
+        return response 

aimakerspace/openai_utils/embedding.py

@@ -0,0 +1,28 @@
+import os
+import openai
+import numpy as np
+from typing import List, Union
+import asyncio
+
+class EmbeddingModel:
+    def __init__(self, model_name: str = "text-embedding-3-small"):
+        self.model_name = model_name
+        self.openai_api_key = os.getenv("OPENAI_API_KEY")
+        if self.openai_api_key is None:
+            raise ValueError("OPENAI_API_KEY is not set")
+
+    def get_embedding(self, text: str) -> np.ndarray:
+        openai.api_key = self.openai_api_key
+        response = openai.Embedding.create(
+            model=self.model_name,
+            input=text
+        )
+        return np.array(response.data[0].embedding)
+
+    async def async_get_embeddings(self, list_of_text: List[str]) -> List[np.ndarray]:
+        openai.api_key = self.openai_api_key
+        response = await openai.Embedding.acreate(
+            model=self.model_name,
+            input=list_of_text
+        )
+        return [np.array(item.embedding) for item in response.data] 

aimakerspace/openai_utils/prompts.py

@@ -0,0 +1,34 @@
+import re
+from typing import Dict
+
+class BasePrompt:
+    def __init__(self, prompt: str):
+        self.prompt = prompt
+        self._pattern = re.compile(r"\{([^}]+)\}")
+
+    def format_prompt(self, **kwargs) -> str:
+        matches = self._pattern.findall(self.prompt)
+        return self.prompt.format(**{match: kwargs.get(match, "") for match in matches})
+
+    def get_input_variables(self) -> list:
+        return self._pattern.findall(self.prompt)
+
+class RolePrompt(BasePrompt):
+    def __init__(self, prompt: str, role: str):
+        super().__init__(prompt)
+        self.role = role
+
+    def create_message(self, **kwargs) -> Dict[str, str]:
+        return {"role": self.role, "content": self.format_prompt(**kwargs)}
+
+class SystemRolePrompt(RolePrompt):
+    def __init__(self, prompt: str):
+        super().__init__(prompt, "system")
+
+class UserRolePrompt(RolePrompt):
+    def __init__(self, prompt: str):
+        super().__init__(prompt, "user")
+
+class AssistantRolePrompt(RolePrompt):
+    def __init__(self, prompt: str):
+        super().__init__(prompt, "assistant") 

aimakerspace/text_utils.py

@@ -0,0 +1,34 @@
+import PyPDF2
+from typing import List
+
+class PDFLoader:
+    def __init__(self, path: str):
+        self.path = path
+
+    def load_documents(self) -> List[str]:
+        documents = []
+        with open(self.path, 'rb') as file:
+            pdf_reader = PyPDF2.PdfReader(file)
+            for page in pdf_reader.pages:
+                documents.append(page.extract_text())
+        return documents
+
+class CharacterTextSplitter:
+    def __init__(self, chunk_size: int = 1500, chunk_overlap: int = 300):
+        self.chunk_size = chunk_size
+        self.chunk_overlap = chunk_overlap
+
+    def split_texts(self, texts: List[str]) -> List[str]:
+        split_texts = []
+        for text in texts:
+            split_texts.extend(self._split_text(text))
+        return split_texts
+
+    def _split_text(self, text: str) -> List[str]:
+        chunks = []
+        start = 0
+        while start < len(text):
+            end = min(start + self.chunk_size, len(text))
+            chunks.append(text[start:end])
+            start = end - self.chunk_overlap
+        return chunks 

aimakerspace/vectordatabase.py

@@ -0,0 +1,29 @@
+import numpy as np
+from typing import List, Tuple, Dict
+from .openai_utils.embedding import EmbeddingModel
+
+class VectorDatabase:
+    def __init__(self, embedding_model: EmbeddingModel = None):
+        self.vectors: Dict[str, np.ndarray] = {}
+        self.texts: List[str] = []
+        self.embedding_model = embedding_model or EmbeddingModel()
+
+    async def abuild_from_list(self, list_of_text: List[str]) -> 'VectorDatabase':
+        embeddings = await self.embedding_model.async_get_embeddings(list_of_text)
+        for text, embedding in zip(list_of_text, embeddings):
+            self.insert(text, np.array(embedding))
+        return self
+
+    def insert(self, text: str, vector: np.ndarray):
+        self.texts.append(text)
+        self.vectors[text] = vector
+
+    def search_by_text(self, query: str, k: int = 4) -> List[Tuple[str, float]]:
+        query_embedding = self.embedding_model.get_embedding(query)
+        similarities = []
+        
+        for text, vector in self.vectors.items():
+            similarity = np.dot(query_embedding, vector) / (np.linalg.norm(query_embedding) * np.linalg.norm(vector))
+            similarities.append((text, similarity))
+        
+        return sorted(similarities, key=lambda x: x[1], reverse=True)[:k] 

app.py

@@ -7,37 +7,6 @@ from aimakerspace.openai_utils.chatmodel import ChatOpenAI
 from aimakerspace.openai_utils.embedding import EmbeddingModel
 import asyncio
 
-def load_notebook():
-    notebook_path = "Pythonic_RAG_Assignment.ipynb"
-    if os.path.exists(notebook_path):
-        with open(notebook_path, "r", encoding="utf-8") as f:
-            return f.read()
-    return "Notebook not found"
-
-with gr.Blocks() as demo:
-    gr.Markdown("# RAG Implementation Notebook")
-    gr.Markdown("This space contains a Jupyter notebook demonstrating a Retrieval Augmented Generation (RAG) implementation.")
-    
-    with gr.Tabs():
-        with gr.TabItem("Notebook Preview"):
-            notebook_content = gr.Markdown(load_notebook())
-        
-        with gr.TabItem("About"):
-            gr.Markdown("""
-            ## About This Space
-            
-            This space contains a Jupyter notebook that demonstrates:
-            - PDF document processing
-            - Text chunking and embedding
-            - Vector database implementation
-            - RAG pipeline with context-aware responses
-            
-            To run the notebook locally:
-            1. Clone this repository
-            2. Install requirements: `pip install -r requirements.txt`
-            3. Run: `jupyter notebook Pythonic_RAG_Assignment.ipynb`
-            """)
-
 # Initialize the RAG pipeline
 def initialize_rag():
     # Load the PDF

requirements.txt

@@ -10,5 +10,5 @@ datasets
 huggingface_hub
 openai>=1.0.0
 python-dotenv>=1.0.0
-aimakerspace>=0.1.0
+PyPDF2>=3.0.0
 asyncio>=3.4.3