change into langchain style

aimakerspace/openai_utils/chatmodel.py

@@ -1,45 +0,0 @@
-from openai import OpenAI, AsyncOpenAI
-from dotenv import load_dotenv
-import os
-
-load_dotenv()
-
-
-class ChatOpenAI:
-    def __init__(self, model_name: str = "gpt-4o-mini"):
-        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, text_only: bool = True, **kwargs):
-        if not isinstance(messages, list):
-            raise ValueError("messages must be a list")
-
-        client = OpenAI()
-        response = client.chat.completions.create(
-            model=self.model_name, messages=messages, **kwargs
-        )
-
-        if text_only:
-            return response.choices[0].message.content
-
-        return response
-    
-    async def astream(self, messages, **kwargs):
-        if not isinstance(messages, list):
-            raise ValueError("messages must be a list")
-        
-        client = AsyncOpenAI()
-
-        stream = await client.chat.completions.create(
-            model=self.model_name,
-            messages=messages,
-            stream=True,
-            **kwargs
-        )
-
-        async for chunk in stream:
-            content = chunk.choices[0].delta.content
-            if content is not None:
-                yield content

aimakerspace/openai_utils/embedding.py

@@ -1,59 +0,0 @@
-from dotenv import load_dotenv
-from openai import AsyncOpenAI, OpenAI
-import openai
-from typing import List
-import os
-import asyncio
-
-
-class EmbeddingModel:
-    def __init__(self, embeddings_model_name: str = "text-embedding-3-small"):
-        load_dotenv()
-        self.openai_api_key = os.getenv("OPENAI_API_KEY")
-        self.async_client = AsyncOpenAI()
-        self.client = OpenAI()
-
-        if self.openai_api_key is None:
-            raise ValueError(
-                "OPENAI_API_KEY environment variable is not set. Please set it to your OpenAI API key."
-            )
-        openai.api_key = self.openai_api_key
-        self.embeddings_model_name = embeddings_model_name
-
-    async def async_get_embeddings(self, list_of_text: List[str]) -> List[List[float]]:
-        embedding_response = await self.async_client.embeddings.create(
-            input=list_of_text, model=self.embeddings_model_name
-        )
-
-        return [embeddings.embedding for embeddings in embedding_response.data]
-
-    async def async_get_embedding(self, text: str) -> List[float]:
-        embedding = await self.async_client.embeddings.create(
-            input=text, model=self.embeddings_model_name
-        )
-
-        return embedding.data[0].embedding
-
-    def get_embeddings(self, list_of_text: List[str]) -> List[List[float]]:
-        embedding_response = self.client.embeddings.create(
-            input=list_of_text, model=self.embeddings_model_name
-        )
-
-        return [embeddings.embedding for embeddings in embedding_response.data]
-
-    def get_embedding(self, text: str) -> List[float]:
-        embedding = self.client.embeddings.create(
-            input=text, model=self.embeddings_model_name
-        )
-
-        return embedding.data[0].embedding
-
-
-if __name__ == "__main__":
-    embedding_model = EmbeddingModel()
-    print(asyncio.run(embedding_model.async_get_embedding("Hello, world!")))
-    print(
-        asyncio.run(
-            embedding_model.async_get_embeddings(["Hello, world!", "Goodbye, world!"])
-        )
-    )

aimakerspace/openai_utils/prompts.py

@@ -1,78 +0,0 @@
-import re
-
-
-class BasePrompt:
-    def __init__(self, prompt):
-        """
-        Initializes the BasePrompt object with a prompt template.
-
-        :param prompt: A string that can contain placeholders within curly braces
-        """
-        self.prompt = prompt
-        self._pattern = re.compile(r"\{([^}]+)\}")
-
-    def format_prompt(self, **kwargs):
-        """
-        Formats the prompt string using the keyword arguments provided.
-
-        :param kwargs: The values to substitute into the prompt string
-        :return: The formatted prompt string
-        """
-        matches = self._pattern.findall(self.prompt)
-        return self.prompt.format(**{match: kwargs.get(match, "") for match in matches})
-
-    def get_input_variables(self):
-        """
-        Gets the list of input variable names from the prompt string.
-
-        :return: List of input variable names
-        """
-        return self._pattern.findall(self.prompt)
-
-
-class RolePrompt(BasePrompt):
-    def __init__(self, prompt, role: str):
-        """
-        Initializes the RolePrompt object with a prompt template and a role.
-
-        :param prompt: A string that can contain placeholders within curly braces
-        :param role: The role for the message ('system', 'user', or 'assistant')
-        """
-        super().__init__(prompt)
-        self.role = role
-
-    def create_message(self, format=True, **kwargs):
-        """
-        Creates a message dictionary with a role and a formatted message.
-
-        :param kwargs: The values to substitute into the prompt string
-        :return: Dictionary containing the role and the formatted message
-        """
-        if format:
-            return {"role": self.role, "content": self.format_prompt(**kwargs)}
-        
-        return {"role": self.role, "content": self.prompt}
-
-
-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")
-
-
-if __name__ == "__main__":
-    prompt = BasePrompt("Hello {name}, you are {age} years old")
-    print(prompt.format_prompt(name="John", age=30))
-
-    prompt = SystemRolePrompt("Hello {name}, you are {age} years old")
-    print(prompt.create_message(name="John", age=30))
-    print(prompt.get_input_variables())

aimakerspace/text_utils.py

@@ -1,77 +0,0 @@
-import os
-from typing import List
-
-
-class TextFileLoader:
-    def __init__(self, path: str, encoding: str = "utf-8"):
-        self.documents = []
-        self.path = path
-        self.encoding = encoding
-
-    def load(self):
-        if os.path.isdir(self.path):
-            self.load_directory()
-        elif os.path.isfile(self.path) and self.path.endswith(".txt"):
-            self.load_file()
-        else:
-            raise ValueError(
-                "Provided path is neither a valid directory nor a .txt file."
-            )
-
-    def load_file(self):
-        with open(self.path, "r", encoding=self.encoding) as f:
-            self.documents.append(f.read())
-
-    def load_directory(self):
-        for root, _, files in os.walk(self.path):
-            for file in files:
-                if file.endswith(".txt"):
-                    with open(
-                        os.path.join(root, file), "r", encoding=self.encoding
-                    ) as f:
-                        self.documents.append(f.read())
-
-    def load_documents(self):
-        self.load()
-        return self.documents
-
-
-class CharacterTextSplitter:
-    def __init__(
-        self,
-        chunk_size: int = 1000,
-        chunk_overlap: int = 200,
-    ):
-        assert (
-            chunk_size > chunk_overlap
-        ), "Chunk size must be greater than chunk overlap"
-
-        self.chunk_size = chunk_size
-        self.chunk_overlap = chunk_overlap
-
-    def split(self, text: str) -> List[str]:
-        chunks = []
-        for i in range(0, len(text), self.chunk_size - self.chunk_overlap):
-            chunks.append(text[i : i + self.chunk_size])
-        return chunks
-
-    def split_texts(self, texts: List[str]) -> List[str]:
-        chunks = []
-        for text in texts:
-            chunks.extend(self.split(text))
-        return chunks
-
-
-if __name__ == "__main__":
-    loader = TextFileLoader("data/KingLear.txt")
-    loader.load()
-    splitter = CharacterTextSplitter()
-    chunks = splitter.split_texts(loader.documents)
-    print(len(chunks))
-    print(chunks[0])
-    print("--------")
-    print(chunks[1])
-    print("--------")
-    print(chunks[-2])
-    print("--------")
-    print(chunks[-1])

aimakerspace/vectordatabase.py

@@ -1,81 +0,0 @@
-import numpy as np
-from collections import defaultdict
-from typing import List, Tuple, Callable
-from aimakerspace.openai_utils.embedding import EmbeddingModel
-import asyncio
-
-
-def cosine_similarity(vector_a: np.array, vector_b: np.array) -> float:
-    """Computes the cosine similarity between two vectors."""
-    dot_product = np.dot(vector_a, vector_b)
-    norm_a = np.linalg.norm(vector_a)
-    norm_b = np.linalg.norm(vector_b)
-    return dot_product / (norm_a * norm_b)
-
-
-class VectorDatabase:
-    def __init__(self, embedding_model: EmbeddingModel = None):
-        self.vectors = defaultdict(np.array)
-        self.embedding_model = embedding_model or EmbeddingModel()
-
-    def insert(self, key: str, vector: np.array) -> None:
-        self.vectors[key] = vector
-
-    def search(
-        self,
-        query_vector: np.array,
-        k: int,
-        distance_measure: Callable = cosine_similarity,
-    ) -> List[Tuple[str, float]]:
-        scores = [
-            (key, distance_measure(query_vector, vector))
-            for key, vector in self.vectors.items()
-        ]
-        return sorted(scores, key=lambda x: x[1], reverse=True)[:k]
-
-    def search_by_text(
-        self,
-        query_text: str,
-        k: int,
-        distance_measure: Callable = cosine_similarity,
-        return_as_text: bool = False,
-    ) -> List[Tuple[str, float]]:
-        query_vector = self.embedding_model.get_embedding(query_text)
-        results = self.search(query_vector, k, distance_measure)
-        return [result[0] for result in results] if return_as_text else results
-
-    def retrieve_from_key(self, key: str) -> np.array:
-        return self.vectors.get(key, None)
-
-    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
-
-
-if __name__ == "__main__":
-    list_of_text = [
-        "I like to eat broccoli and bananas.",
-        "I ate a banana and spinach smoothie for breakfast.",
-        "Chinchillas and kittens are cute.",
-        "My sister adopted a kitten yesterday.",
-        "Look at this cute hamster munching on a piece of broccoli.",
-    ]
-
-    vector_db = VectorDatabase()
-    vector_db = asyncio.run(vector_db.abuild_from_list(list_of_text))
-    k = 2
-
-    searched_vector = vector_db.search_by_text("I think fruit is awesome!", k=k)
-    print(f"Closest {k} vector(s):", searched_vector)
-
-    retrieved_vector = vector_db.retrieve_from_key(
-        "I like to eat broccoli and bananas."
-    )
-    print("Retrieved vector:", retrieved_vector)
-
-    relevant_texts = vector_db.search_by_text(
-        "I think fruit is awesome!", k=k, return_as_text=True
-    )
-    print(f"Closest {k} text(s):", relevant_texts)

app.py

@@ -1,68 +1,93 @@
 import os
+
+# For type hints
 from typing import List
+from langchain_core.vectorstores import VectorStoreRetriever
+from langchain_openai import ChatOpenAI
 from chainlit.types import AskFileResponse
-from aimakerspace.text_utils import CharacterTextSplitter, TextFileLoader
-from aimakerspace.openai_utils.prompts import (
-    UserRolePrompt,
-    SystemRolePrompt,
-    AssistantRolePrompt,
-)
-from aimakerspace.openai_utils.embedding import EmbeddingModel
-from aimakerspace.vectordatabase import VectorDatabase
-from aimakerspace.openai_utils.chatmodel import ChatOpenAI
+from langchain_openai.embeddings import OpenAIEmbeddings
+
+# Libraries to be used
+from langchain_community.document_loaders.text import TextLoader
+from langchain_community.document_loaders.pdf import PyPDFLoader
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_wrappers.langchain_chat_models import MyChatOpenAI
+from langchain_wrappers.langchain_embedding_models import MyOpenAIEmbeddings
+from langchain_qdrant import QdrantVectorStore
+from langchain_core.runnables import RunnablePassthrough, RunnableParallel
 import chainlit as cl
+from dotenv import load_dotenv
+
+# Cache
+from langchain.globals import set_llm_cache, get_llm_cache 
+from langchain_community.cache import InMemoryCache
+set_llm_cache(InMemoryCache())
 
 system_template = """\
-Use the following context to answer a users question. If you cannot find the answer in the context, say you don't know the answer."""
-system_role_prompt = SystemRolePrompt(system_template)
+Use the following context to answer a users question. If you cannot find the answer in the context, say you don't know the answer.\
 
-user_prompt_template = """\
 Context:
-{context}
-
+{context}    
+"""
+human_template = """\
 Question:
 {question}
 """
-user_role_prompt = UserRolePrompt(user_prompt_template)
+system_msg = ('system', system_template)
+user_msg = ('human', human_template)
 
-class RetrievalAugmentedQAPipeline:
-    def __init__(self, llm: ChatOpenAI(), vector_db_retriever: VectorDatabase) -> None:
-        self.llm = llm
-        self.vector_db_retriever = vector_db_retriever
+text_splitter = RecursiveCharacterTextSplitter()
 
-    async def arun_pipeline(self, user_query: str):
-        context_list = self.vector_db_retriever.search_by_text(user_query, k=4)
 
-        context_prompt = ""
-        for context in context_list:
-            context_prompt += context[0] + "\n"
+load_dotenv()
 
-        formatted_system_prompt = system_role_prompt.create_message()
-
-        formatted_user_prompt = user_role_prompt.create_message(question=user_query, context=context_prompt)
-
-        async def generate_response():
-            async for chunk in self.llm.astream([formatted_system_prompt, formatted_user_prompt]):
-                yield chunk
+### RAG chain
+def Get_RAG_pipeline(retriever: VectorStoreRetriever, llm: ChatOpenAI):
+    
+    retriever = retriever.with_config({'run_name': 'RAG: Retriever'})
+    prompt = ChatPromptTemplate([system_msg, user_msg]).with_config({'run_name': 'RAG Step2: Prompt (Augmented)'})
+    llm = llm.with_config({'run_name': 'RAG Step3: LLM (Generation)'})
+    
+    def get_context(relevant_docs: List):
+        context = ""
+        for doc in relevant_docs:
+            context += doc.page_content + "\n"
+        return context
+    
 
-        return {"response": generate_response(), "context": context_list}
+    RAG_chain =  RunnableParallel(
+        relevant_docs = retriever,
+        question = lambda x: x 
+    ).with_config({'run_name':'RAG Step1-1: Get relevant docs (Retrieval)'}) | RunnablePassthrough.assign(
+        context = lambda x: get_context(x['relevant_docs'])
+    ).with_config({'run_name':'RAG Step1-2: Get context (Retrieval)'}) | prompt | llm
+    RAG_chain = RAG_chain.with_config({'run_name':'RAG pipeline'})
 
-text_splitter = CharacterTextSplitter()
+    return RAG_chain
 
 
 def process_text_file(file: AskFileResponse):
     import tempfile
 
-    with tempfile.NamedTemporaryFile(mode="w", delete=False, suffix=".txt") as temp_file:
-        temp_file_path = temp_file.name
-
-    with open(temp_file_path, "wb") as f:
-        f.write(file.content)
-
-    text_loader = TextFileLoader(temp_file_path)
-    documents = text_loader.load_documents()
-    texts = text_splitter.split_texts(documents)
-    return texts
+    if file.name.endswith('.pdf'):
+        print("PDF file detected")
+        with tempfile.NamedTemporaryFile(mode="w", delete=False, suffix=".pdf") as temp_file:
+            temp_file_path = temp_file.name
+        with open(temp_file_path, "wb") as f:
+            f.write(file.content)
+        document_loader = PyPDFLoader(temp_file_path)
+    elif file.name.endswith('.txt'):
+        with tempfile.NamedTemporaryFile(mode="w", delete=False, suffix=".txt") as temp_file:
+            temp_file_path = temp_file.name
+        with open(temp_file_path, "wb") as f:
+            f.write(file.content)
+        document_loader = TextLoader(temp_file_path, autodetect_encoding=True)
+       
+    documents = document_loader.load()
+    splitted_documents = [x.page_content for x in text_splitter.transform_documents(documents)]
+   
+    return splitted_documents
 
 
 @cl.on_chat_start
@@ -73,13 +98,13 @@ async def on_chat_start():
     while files == None:
         files = await cl.AskFileMessage(
             content="Please upload a Text File file to begin!",
-            accept=["text/plain"],
-            max_size_mb=2,
+            accept=["text/plain", "application/pdf"],  
+            max_size_mb=5,
             timeout=180,
         ).send()
 
-    file = files[0]
 
+    file = files[0] 
     msg = cl.Message(
         content=f"Processing `{file.name}`...", disable_human_feedback=True
     )
@@ -91,32 +116,34 @@ async def on_chat_start():
     print(f"Processing {len(texts)} text chunks")
 
     # Create a dict vector store
-    vector_db = VectorDatabase()
-    vector_db = await vector_db.abuild_from_list(texts)
+    vector_db = await QdrantVectorStore.afrom_texts(
+        texts, MyOpenAIEmbeddings.from_model('small'), location=":memory:", collection_name="texts"
+    )
     
-    chat_openai = ChatOpenAI()
 
     # Create a chain
-    retrieval_augmented_qa_pipeline = RetrievalAugmentedQAPipeline(
-        vector_db_retriever=vector_db,
-        llm=chat_openai
+    RAG_chain = Get_RAG_pipeline(
+        retriever=vector_db.as_retriever(search_kwargs = {'k':3}),
+        llm=MyChatOpenAI.from_model()
     )
     
     # Let the user know that the system is ready
-    msg.content = f"Processing `{file.name}` done. You can now ask questions!"
+    msg.content = f"Processing `{file.name}` done ({len(texts)} chunks in total). You can now ask questions!"
     await msg.update()
 
-    cl.user_session.set("chain", retrieval_augmented_qa_pipeline)
+    cl.user_session.set("chain", RAG_chain)
+
+
 
 
 @cl.on_message
 async def main(message):
+    os.environ['LANGSMITH_PROJECT'] = os.getenv('LANGCHAIN_PROJECT')
+
     chain = cl.user_session.get("chain")
 
     msg = cl.Message(content="")
-    result = await chain.arun_pipeline(message.content)
-
-    async for stream_resp in result["response"]:
-        await msg.stream_token(stream_resp)
+    async for stream_resp in chain.astream(message.content):
+        await msg.stream_token(stream_resp.content)
 
     await msg.send()

{aimakerspace/langchain_wrappers → langchain_wrappers}/langchain_chat_models.py

@@ -2,10 +2,12 @@ import os
 from dotenv import load_dotenv
 from typing import Optional
 from langchain_openai import ChatOpenAI
-import inspect
 
-load_dotenv(os.path.join(os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe()))) , '.env'))
 
+# import inspect
+# load_dotenv(os.path.join(os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe()))) , '.env'))
+
+load_dotenv()
 class MyChatOpenAI:
     @classmethod
     def from_model(
@@ -17,9 +19,8 @@ class MyChatOpenAI:
         max_tokens: Optional[int] = 4096,
         max_retries: int = 1,
         **kwargs
-        )-> ChatOpenAI:
-        
-        os.environ['LANGCHAIN_PROJECT'] = langsmith_project
+        )-> ChatOpenAI:        
+
         if model in ['gpt-4o', 'GPT-4o', 'GPT-4O', 'gpt-4O', 'gpt4o', 'GPT4o', 'GPT4O', 'gpt4O']:
             model = 'gpt-4o'
         elif model in ['gpt-4o-mini', 'GPT-4o-mini', 'GPT-4O-mini', 'gpt-4O-mini', 'gpt4o-mini', 'GPT4o-mini', 'GPT4O-mini', 'gpt4O-mini', 'gpt4omini', 'GPT4omini', 'GPT4Omini', 'gpt4Omini']:
@@ -38,13 +39,5 @@ class MyChatOpenAI:
             )
 
 
-    @classmethod
-    def get_model_price(cls)-> dict:
-        # Dictionary to store the cost of input and output tokens for each model
-        supported_models = {'gpt-4o' : (5, 15)}  # gpt-4o model: input cost = $5 per 1M tokens, output cost = $15 per 1M tokens
-        supported_models.update({'gpt-4o-mini' : (0.15, 0.6)})  # gpt-4o-mini model: input cost = $0.15 per 1M tokens, output cost = $0.6 per 1M tokens
-
-        return supported_models
-
 
 

{aimakerspace/langchain_wrappers → langchain_wrappers}/langchain_embedding_models.py

@@ -2,10 +2,11 @@ import os
 from dotenv import load_dotenv
 from typing import Optional
 from langchain_openai.embeddings import OpenAIEmbeddings
-import inspect
 
-load_dotenv(os.path.join(os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe()))) , '.env'))
+# import inspect
+# load_dotenv(os.path.join(os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe()))) , '.env'))
 
+load_dotenv()
 class MyOpenAIEmbeddings:
     @classmethod
     def from_model(
@@ -36,13 +37,6 @@ class MyOpenAIEmbeddings:
             )
 
 
-    @classmethod
-    def get_model_price(cls)-> dict:
-        # Dictionary to store the cost of input and output tokens for each model
-        supported_models = {'text-embedding-3-small' : 0.02}  # text-embedding-3-small model: $0.02 per 1M tokens
-        supported_models.update({'text-embedding-3-large' : 0.13})  # text-embedding-3-large model: $0.13 per 1M tokens
-
-        return supported_models
 
 
 

requirements.txt

@@ -1,3 +1,10 @@
 numpy
 chainlit==0.7.700
-openai
+openai==1.42.0
+langchain==0.2.14
+langchain-core==0.2.34
+langchain-community==0.2.12
+langchain-openai==0.1.22
+langchain-qdrant==0.1.3
+qdrant-client==1.11.0
+pypdf==4.3.1