initial commit to hf spaces

BuildingAChainlitApp.md

@@ -0,0 +1,227 @@
+# Building a Chainlit App
+
+What if we want to take our Week 1 Day 2 assignment - [Pythonic RAG](https://github.com/AI-Maker-Space/AIE4/tree/main/Week%201/Day%202) - and bring it out of the notebook?
+
+Well - we'll cover exactly that here!
+
+## Anatomy of a Chainlit Application
+
+[Chainlit](https://docs.chainlit.io/get-started/overview) is a Python package similar to Streamlit that lets users write a backend and a front end in a single (or multiple) Python file(s). It is mainly used for prototyping LLM-based Chat Style Applications - though it is used in production in some settings with 1,000,000s of MAUs (Monthly Active Users).
+
+The primary method of customizing and interacting with the Chainlit UI is through a few critical [decorators](https://blog.hubspot.com/website/decorators-in-python).
+
+> NOTE: Simply put, the decorators (in Chainlit) are just ways we can "plug-in" to the functionality in Chainlit. 
+
+We'll be concerning ourselves with three main scopes:
+
+1. On application start - when we start the Chainlit application with a command like `chainlit run app.py`
+2. On chat start - when a chat session starts (a user opens the web browser to the address hosting the application)
+3. On message - when the users sends a message through the input text box in the Chainlit UI
+
+Let's dig into each scope and see what we're doing!
+
+## On Application Start:
+
+The first thing you'll notice is that we have the traditional "wall of imports" this is to ensure we have everything we need to run our application. 
+
+```python
+import os
+from typing import List
+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
+import chainlit as cl
+```
+
+Next up, we have some prompt templates. As all sessions will use the same prompt templates without modification, and we don't need these templates to be specific per template - we can set them up here - at the application scope. 
+
+```python
+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)
+
+user_prompt_template = """\
+Context:
+{context}
+
+Question:
+{question}
+"""
+user_role_prompt = UserRolePrompt(user_prompt_template)
+```
+
+> NOTE: You'll notice that these are the exact same prompt templates we used from the Pythonic RAG Notebook in Week 1 Day 2!
+
+Following that - we can create the Python Class definition for our RAG pipeline - or *chain*, as we'll refer to it in the rest of this walkthrough. 
+
+Let's look at the definition first:
+
+```python
+class RetrievalAugmentedQAPipeline:
+    def __init__(self, llm: ChatOpenAI(), vector_db_retriever: VectorDatabase) -> None:
+        self.llm = llm
+        self.vector_db_retriever = vector_db_retriever
+
+    async def arun_pipeline(self, user_query: str):
+        ### RETRIEVAL
+        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"
+
+        ### AUGMENTED
+        formatted_system_prompt = system_role_prompt.create_message()
+
+        formatted_user_prompt = user_role_prompt.create_message(question=user_query, context=context_prompt)
+
+
+        ### GENERATION
+        async def generate_response():
+            async for chunk in self.llm.astream([formatted_system_prompt, formatted_user_prompt]):
+                yield chunk
+
+        return {"response": generate_response(), "context": context_list}
+```
+
+Notice a few things:
+
+1. We have modified this `RetrievalAugmentedQAPipeline` from the initial notebook to support streaming. 
+2. In essence, our pipeline is *chaining* a few events together:
+    1. We take our user query, and chain it into our Vector Database to collect related chunks
+    2. We take those contexts and our user's questions and chain them into the prompt templates
+    3. We take that prompt template and chain it into our LLM call
+    4. We chain the response of the LLM call to the user
+3. We are using a lot of `async` again!
+
+Now, we're going to create a helper function for processing uploaded text files.
+
+First, we'll instantiate a shared `CharacterTextSplitter`.
+
+```python
+text_splitter = CharacterTextSplitter()
+```
+
+Now we can define our helper.
+
+```python
+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
+```
+
+Simply put, this downloads the file as a temp file, we load it in with `TextFileLoader` and then split it with our `TextSplitter`, and returns that list of strings!
+
+#### QUESTION #1:
+
+Why do we want to support streaming? What about streaming is important, or useful?
+
+#### ANSWER #1:
+
+Streaming is needed to accommodate transfer of data packets over a network (eg internet).
+Important because nearly all applications are written to be hosted on a network 
+(corporate intranet or over the internet) to be used by many people.
+
+
+## On Chat Start:
+
+The next scope is where "the magic happens". On Chat Start is when a user begins a chat session. This will happen whenever a user opens a new chat window, or refreshes an existing chat window.
+
+You'll see that our code is set-up to immediately show the user a chat box requesting them to upload a file. 
+
+```python
+while files == None:
+        files = await cl.AskFileMessage(
+            content="Please upload a Text File file to begin!",
+            accept=["text/plain"],
+            max_size_mb=2,
+            timeout=180,
+        ).send()
+```
+
+Once we've obtained the text file - we'll use our processing helper function to process our text!
+
+After we have processed our text file - we'll need to create a `VectorDatabase` and populate it with our processed chunks and their related embeddings!
+
+```python
+vector_db = VectorDatabase()
+vector_db = await vector_db.abuild_from_list(texts)
+```
+
+Once we have that piece completed - we can create the chain we'll be using to respond to user queries!
+
+```python
+retrieval_augmented_qa_pipeline = RetrievalAugmentedQAPipeline(
+        vector_db_retriever=vector_db,
+        llm=chat_openai
+    )
+```
+
+Now, we'll save that into our user session!
+
+> NOTE: Chainlit has some great documentation about [User Session](https://docs.chainlit.io/concepts/user-session). 
+
+### QUESTION #2: 
+
+Why are we using User Session here? What about Python makes us need to use this? Why not just store everything in a global variable?
+
+### ANSWER #2:
+User Session creates a scope akin to a local scope in Python.  i.e., setting up and managing variables, etc. for the
+duration of a chat session with a specific user.  This provides a clean separation across users (which would not
+happen if everything was stored in a global variable) and lets the app function smoothly for all users (e.g., by preventing the occurrence of race conditions).
+
+
+## On Message
+
+First, we load our chain from the user session:
+
+```python
+chain = cl.user_session.get("chain")
+```
+
+Then, we run the chain on the content of the message - and stream it to the front end - that's it!
+
+```python
+msg = cl.Message(content="")
+result = await chain.arun_pipeline(message.content)
+
+async for stream_resp in result["response"]:
+    await msg.stream_token(stream_resp)
+```
+
+## 🎉
+
+With that - you've created a Chainlit application that moves our Pythonic RAG notebook to a Chainlit application!
+
+## 🚧 CHALLENGE MODE 🚧
+
+For an extra challenge - modify the behaviour of your applciation by integrating changes you made to your Pythonic RAG notebook (using new retrieval methods, etc.)
+
+If you're still looking for a challenge, or didn't make any modifications to your Pythonic RAG notebook:
+
+1) Allow users to upload PDFs (this will require you to build a PDF parser as well)
+2) Modify the VectorStore to leverage [Qdrant](https://python-client.qdrant.tech/)
+
+> NOTE: The motivation for these challenges is simple - the beginning of the course is extremely information dense, and people come from all kinds of different technical backgrounds. In order to ensure that all learners are able to engage with the content confidently and comfortably, we want to focus on the basic units of technical competency required. This leads to a situation where some learners, who came in with more robust technical skills, find the introductory material to be too simple - and these open-ended challenges help us do this! 
+
+
+
+
+

Dockerfile

@@ -0,0 +1,11 @@
+FROM python:3.9
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+WORKDIR $HOME/app
+COPY --chown=user . $HOME/app
+COPY ./requirements.txt ~/app/requirements.txt
+RUN pip install -r requirements.txt
+COPY . .
+CMD ["chainlit", "run", "app_v1.py", "--port", "7860"]

README.md

@@ -9,3 +9,131 @@ license: apache-2.0
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+
+# Summary
+
+This is my completed pythonic RAG assignment, completed for Session 3 of the AI Engineering Cohort 4.
+I implemented the following:
+1. Allow user to upload TWO documents (instead of a single document)
+2. Format of doc: they can be either text files or pdf docs.
+3. Text splitter - RecursiveTextSplitter from Langchain
+4. Vector store - using Chroma db
+5. Coded the chain in two ways for my own education
+    a. traditional Langchain syntax - two step process of with 'stuff documents chain' and 'retrieval chain'
+    b. using LCEL syntax with Runnables
+6. Most processing pythonic steps implemented via a single class with modular components
+    that can be replaced with others (e.g., text splitter, vector store, etc.)
+
+
+# Retaining the original content of the README.md for my future reference!!
+
+
+# Deploying Pythonic Chat With Your Text File Application
+
+In today's breakout rooms, we will be following the processed that you saw during the challenge - for reference, the instructions for that are available [here](https://github.com/AI-Maker-Space/Beyond-ChatGPT/tree/main).
+
+Today, we will repeat the same process - but powered by our Pythonic RAG implementation we created last week. 
+
+You'll notice a few differences in the `app.py` logic - as well as a few changes to the `aimakerspace` package to get things working smoothly with Chainlit.
+
+## Reference Diagram (It's Busy, but it works)
+
+![image](https://i.imgur.com/IaEVZG2.png)
+
+## Deploying the Application to Hugging Face Space
+
+Due to the way the repository is created - it should be straightforward to deploy this to a Hugging Face Space!
+
+> NOTE: If you wish to go through the local deployments using `chainlit run app.py` and Docker - please feel free to do so!
+
+<details>
+    <summary>Creating a Hugging Face Space</summary>
+
+1.  Navigate to the `Spaces` tab.
+
+![image](https://i.imgur.com/aSMlX2T.png)
+
+2. Click on `Create new Space`
+
+![image](https://i.imgur.com/YaSSy5p.png)
+
+3. Create the Space by providing values in the form. Make sure you've selected "Docker" as your Space SDK.
+
+![image](https://i.imgur.com/6h9CgH6.png)
+
+</details>
+
+<details>
+    <summary>Adding this Repository to the Newly Created Space</summary>
+
+1. Collect the SSH address from the newly created Space. 
+
+![image](https://i.imgur.com/Oag0m8E.png)
+
+> NOTE: The address is the component that starts with `[email protected]:spaces/`.
+
+2. Use the command:
+
+```bash
+git remote add hf HF_SPACE_SSH_ADDRESS_HERE
+```
+
+3. Use the command:
+
+```bash
+git pull hf main --no-rebase --allow-unrelated-histories -X ours
+```
+
+4. Use the command: 
+
+```bash 
+git add .
+```
+
+5. Use the command:
+
+```bash
+git commit -m "Deploying Pythonic RAG"
+```
+
+6. Use the command: 
+
+```bash
+git push hf main
+```
+
+7. The Space should automatically build as soon as the push is completed!
+
+> NOTE: The build will fail before you complete the following steps!
+
+</details>
+
+<details>
+    <summary>Adding OpenAI Secrets to the Space</summary>
+
+1. Navigate to your Space settings.
+
+![image](https://i.imgur.com/zh0a2By.png)
+
+2. Navigate to `Variables and secrets` on the Settings page and click `New secret`: 
+
+![image](https://i.imgur.com/g2KlZdz.png)
+
+3. In the `Name` field - input `OPENAI_API_KEY` in the `Value (private)` field, put your OpenAI API Key.
+
+![image](https://i.imgur.com/eFcZ8U3.png)
+
+4. The Space will begin rebuilding!
+
+</details>
+
+## 🎉
+
+You just deployed Pythonic RAG!
+
+Try uploading a text file and asking some questions!
+
+## 🚧CHALLENGE MODE 🚧
+
+For more of a challenge, please reference [Building a Chainlit App](./BuildingAChainlitApp.md)!

app_v1.py

@@ -0,0 +1,360 @@
+"""
+app_v1.py:  v1 of the app
+
+1. allows the user to upload multiple files at runtime (upto a maximum, that is set via a paremeter)
+    a. user is told about the max; cl max is 10 files
+    b. file type can either be .txt or .pdf
+    c. see the use of the accept option in the cl.AskFileMessage object: 
+        set this as: accept=["text/plain", "application/pdf"]
+2. uploaded files are processed on start:
+    if pdf, then first convert to text: i.e., the collection of uploaded files is converted to text if needed
+    text is split into chunks using langchain RecursiveCharacterTextSplitter util - 
+        options TBD
+3. uses openai embeddings (specifically, text-embedding-3-small embeddings) to convert chunks into embeddings
+    note - the choice of embeddings model can be controlled via optional parameters to be passed in when
+            the vector db is instantiated
+4. save these embeddings in a vector db
+    hope to use Chroma or Qdrant
+    NOTES here...
+
+5. instantiate the RAQA (retrieval augmented qa) pipeline
+    use LangChain
+    chat memory needed
+
+    requires instantiation of an openai client session and the vector db
+    in addition, of course we need to set up system and user prompts
+        here this is set up using aimakerspace.openai.utils prompts.py module classes
+6. the cl.on_message decorator wraps the main function
+    this function 
+        a. receives the query that the user types in
+        b. runs the RAQA pipeline
+        c. sends results back to UI for dislay
+
+Additional Notes:
+a. note the use of async functions and await async syntax throughout the module here!
+b. note the use of yield rather than return in certain key functions
+c. note the use of streaming capabilities when needed
+d. the use of the python tempfile module when the user input text file is processed
+    (i) NamedTemporaryFile 
+    (ii) with options to persist the storage of the temp file
+
+"""
+
+import os
+from typing import List
+from dotenv import load_dotenv
+import tempfile
+import getpass
+from uuid import uuid4
+import tempfile
+
+# chainlit imports
+import chainlit as cl
+from chainlit.types import AskFileResponse
+
+# langchain imports
+# document loader
+from langchain_community.document_loaders import TextLoader, PyPDFLoader
+# text splitter
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+# embeddings model to embed each chunk of text in doc
+from langchain_openai import OpenAIEmbeddings
+# vector store
+from langchain_chroma import Chroma
+# llm for text generation using prompt plus retrieved context plus query
+from langchain_openai import ChatOpenAI
+# templates to create custom prompts
+from langchain_core.prompts import ChatPromptTemplate, PromptTemplate
+# chains 
+from langchain.chains import create_retrieval_chain
+from langchain.chains.combine_documents import create_stuff_documents_chain
+# LCEL Runnable Passthrough
+from langchain_core.runnables import RunnablePassthrough
+# to parse output from llm
+from langchain_core.output_parsers import StrOutputParser
+
+from langchain.docstore.document import Document
+
+# aimakerspace imports
+# 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
+
+
+# use getpass to load api keys at runtime
+# alternative is to use load_dotenv() 
+# or, load secrets (eg on hf)
+# os.environ["OPENAI_API_KEY"] = getpass.getpass("Enter your OpenAI API key: ")
+load_dotenv()
+
+
+# parameters to manage number of files imported via cl onstart
+max_file_count = 2
+
+# parameters to manage splitting
+chunk_kwargs = {
+    'chunk_size': 1000,
+    'chunk_overlap': 100
+}
+
+# openai embeddings model parameters
+openai_embed_kwargs = {
+    'model': 'text-embedding-3-small',
+    # With the `text-embedding-3` class
+    # of models, you can specify the size
+    # of the embeddings you want returned.
+    # 'dimensions': 1024
+}
+
+# chat model parameters
+chat_model_name = {
+    'model_name': 'gpt-4o-mini'
+}
+
+openai_embed_kwargs = {
+    'model': 'text-embedding-3-large',
+    # With the `text-embedding-3` class
+    # of models, you can specify the size
+    # of the embeddings you want returned.
+    # 'dimensions': 1024
+}
+
+retriever_kwargs = {
+    'search_type': 'similarity',
+    'search_kwargs': {
+        'k': 20
+    }
+}
+
+system_prompt = (
+        """You are an assistant for question-answering tasks.
+        You will be given political speeches by leading politicians and
+        will be asked questions based on these speeches.
+
+        Use the following pieces of retrieved context to answer 
+        the question. 
+        
+        You must answer the question only based on the context provided.
+        
+        If you don't know the answer or if the context does not provide sufficient information, 
+        then say that you don't know. 
+        
+        Think through your answer step-by-step.
+
+        \n\n
+
+        Context:
+        {context}
+        """
+    )
+
+custom_rag_template = """\
+You are an assistant for question-answering tasks.
+You will be given political speeches by leading politicians and
+will be asked questions based on these speeches.
+
+Use the following pieces of retrieved context to answer 
+the question. 
+
+You must answer the question only based on the context provided.
+
+If you don't know the answer or if the context does not provide sufficient information, 
+then say that you don't know. 
+
+Think through your answer step-by-step.
+
+Context:
+{context}
+
+Question: 
+{question}
+
+Helpful Answer:
+"""
+
+
+class RetrievalAugmentedQAPipelineWithLangchain:
+    def __init__(self, 
+                 list_of_files: List[AskFileResponse],
+                 chunk_kwargs,
+                 embed_kwargs,
+                 retriever_kwargs,
+                 system_prompt,
+                 chat_model_name,
+                 system_prompt_template=None,
+                 use_lcel_for_chain=False):
+        self.list_of_files = list_of_files
+        self.chunk_kwargs = chunk_kwargs
+        self.embed_kwargs = embed_kwargs
+        self.retriever_kwargs = retriever_kwargs
+        self.system_prompt = system_prompt
+        self.chat_model_name = chat_model_name
+        self.system_prompt_template = system_prompt_template
+        self.use_lcel_for_chain = use_lcel_for_chain
+
+        self._setup_text_splitter()
+        self._setup_embeddings()
+        self._setup_llm()
+        return
+    
+    def _setup_text_splitter(self):
+        self.text_splitter = RecursiveCharacterTextSplitter(
+            add_start_index=True,
+            **self.chunk_kwargs
+        )
+        return self
+    
+    def _setup_embeddings(self):
+        self.embeddings = OpenAIEmbeddings(**self.embed_kwargs)
+        return self
+    
+    def _setup_llm(self):
+        self.llm = ChatOpenAI(**self.chat_model_name)
+        return self
+    
+    def format_docs(self):
+        return "\n\n".join(doc.page_content for doc in self.all_splits)
+
+    def process_all_uploaded_files(self):
+        self.all_splits = []
+        for file in self.list_of_files:
+            # set loader depending on type of file
+            if file.type == "text/plain":
+                Loader = TextLoader
+            elif file.type == "application/pdf":
+                Loader = PyPDFLoader
+            
+            import tempfile
+            # make temporary copy of file and split into chunks
+            with tempfile.NamedTemporaryFile() as tempfile:
+                tempfile.write(file.content)
+                loader = Loader(tempfile.name)
+                documents = loader.load()
+                splits = self.text_splitter.split_documents(documents)
+                for i, split in enumerate(splits):
+                    split.metadata["source"] = f"{file.name}_source_{i}"
+                self.all_splits.extend(splits)
+        return self
+
+    def make_chroma_vector_db(self):
+        # initialize vector store
+        vectorstore = Chroma.from_documents(documents=self.all_splits, embedding=self.embeddings)
+        self.retriever = vectorstore.as_retriever(**self.retriever_kwargs)
+        return self
+    
+    def setup_chat_prompt_from_messages(self):
+        self.chat_prompt = ChatPromptTemplate.from_messages(
+            [
+                ("system", self.system_prompt),
+                ("human", "{input}"),
+            ]
+        )
+        return self
+    
+    def qa_chain(self):
+        self.question_answer_chain = create_stuff_documents_chain(self.llm, self.chat_prompt)
+        return self
+    
+    def rag_chain(self):
+        self.rag_chain = create_retrieval_chain(self.retriever, self.question_answer_chain)
+        return self
+
+    def setup_prompt_from_template(self):
+        self.prompt_from_template = PromptTemplate.from_template(self.system_prompt_template)
+        return self
+
+    def lcel_rag_chain(self):
+        self.rag_chain = (
+            {"context": self.retriever | self.format_docs, "question": RunnablePassthrough()}
+            | self.prompt_from_template
+            | self.llm
+            | StrOutputParser()
+        )
+    
+    def make_raqa_pipeline(self):
+        # load all docs uploaded by user, convert into text if needed and split into chunks
+        self.process_all_uploaded_files()
+
+        # load all splits and embeddings into vector db
+        self.make_chroma_vector_db()
+
+        if self.use_lcel_for_chain is False:
+            self.setup_chat_prompt_from_messages()
+            self.qa_chain()
+            self.rag_chain()
+        else:
+            self.setup_prompt_from_template()
+            self.lcel_rag_chain()
+        return self.rag_chain
+
+
+@cl.on_chat_start
+async def on_chat_start():
+    files = None
+
+    # Wait for the user to upload one or more files
+    user_input_files = []
+    filecount = 0
+    user_signals_done = False
+    while filecount < max_file_count and user_signals_done is False:
+    # while files == None:
+        files = await cl.AskFileMessage(
+            content=f"Please upload {max_file_count} text files or pdf documents to begin!",
+            accept=["text/plain", "application/pdf"],
+            max_size_mb=20,
+            max_files=2,
+            timeout=180,
+        ).send()
+
+        if files:
+            user_input_files.append(files[0])
+            filecount += 1
+        else:
+            user_signals_done = True
+
+    user_input_file_names = [x.name for x in user_input_files]
+
+    msg = cl.Message(
+        content=f"Processing `{user_input_file_names}`...", disable_human_feedback=True
+    )
+    await msg.send()
+
+    # instantiate raqa pipeline object
+    qabot = RetrievalAugmentedQAPipelineWithLangchain(
+        list_of_files=user_input_files,
+        chunk_kwargs=chunk_kwargs,
+        embed_kwargs=openai_embed_kwargs,
+        retriever_kwargs=retriever_kwargs,
+        system_prompt=system_prompt,
+        chat_model_name=chat_model_name
+    )
+
+    raqa_chain = qabot.make_raqa_pipeline()
+
+    # Let the user know that the system is ready
+    msg.content = f"Processing `{user_input_file_names}` done. You can now ask questions!"
+    await msg.update()
+
+    cl.user_session.set("raqa_chain", raqa_chain)
+
+
+@cl.on_message
+async def main(message):
+    raqa_chain = cl.user_session.get("raqa_chain")
+
+    msg = cl.Message(content="")
+
+    # result = await raqa_chain.invoke({"input": message.content})
+    result = await cl.make_async(raqa_chain.invoke)({"input": message.content})
+
+    # async for stream_resp in result["answer"]:
+    for stream_resp in result["answer"]:
+        await msg.stream_token(stream_resp)
+
+    await msg.send()

chainlit.md

@@ -0,0 +1,20 @@
+# Welcome to Chat with Your Uploaded Files!!
+
+This is my completed pythonic RAG assignment, completed for Session 3 of the AI Engineering Cohort 4.
+
+With this application, you can chat with TWO uploaded text or pdf fileis that is smaller than 20MB!
+
+App features:
+1. Allow user to upload TWO documents (instead of a single document)
+2. Format of doc: they can be either text files or pdf docs.
+
+Code features:
+1. Text splitter - RecursiveTextSplitter from Langchain
+2. Vector store - using Chroma db
+3. Coded the chain in two ways for my own education
+    a. traditional Langchain syntax - two step process of with 'stuff documents chain' and 'retrieval chain'
+    b. using LCEL syntax with Runnables
+4. Most processing pythonic steps implemented via a single class with modular components
+    that can be replaced with others (e.g., text splitter, vector store, etc.)
+
+

requirements.txt

@@ -0,0 +1,7 @@
+numpy
+chainlit==0.7.700
+openai
+langchain
+langchain_community 
+langchain_chroma
+langchain-openai