Fixed README conflict

.chainlit/config.toml

@@ -0,0 +1,84 @@
+[project]
+# Whether to enable telemetry (default: true). No personal data is collected.
+enable_telemetry = true
+
+# List of environment variables to be provided by each user to use the app.
+user_env = []
+
+# Duration (in seconds) during which the session is saved when the connection is lost
+session_timeout = 3600
+
+# Enable third parties caching (e.g LangChain cache)
+cache = false
+
+# Follow symlink for asset mount (see https://github.com/Chainlit/chainlit/issues/317)
+# follow_symlink = false
+
+[features]
+# Show the prompt playground
+prompt_playground = true
+
+# Process and display HTML in messages. This can be a security risk (see https://stackoverflow.com/questions/19603097/why-is-it-dangerous-to-render-user-generated-html-or-javascript)
+unsafe_allow_html = false
+
+# Process and display mathematical expressions. This can clash with "$" characters in messages.
+latex = false
+
+# Authorize users to upload files with messages
+multi_modal = true
+
+# Allows user to use speech to text
+[features.speech_to_text]
+    enabled = false
+    # See all languages here https://github.com/JamesBrill/react-speech-recognition/blob/HEAD/docs/API.md#language-string
+    # language = "en-US"
+
+[UI]
+# Name of the app and chatbot.
+name = "Chatbot"
+
+# Show the readme while the conversation is empty.
+show_readme_as_default = true
+
+# Description of the app and chatbot. This is used for HTML tags.
+# description = ""
+
+# Large size content are by default collapsed for a cleaner ui
+default_collapse_content = true
+
+# The default value for the expand messages settings.
+default_expand_messages = false
+
+# Hide the chain of thought details from the user in the UI.
+hide_cot = false
+
+# Link to your github repo. This will add a github button in the UI's header.
+# github = ""
+
+# Specify a CSS file that can be used to customize the user interface.
+# The CSS file can be served from the public directory or via an external link.
+# custom_css = "/public/test.css"
+
+# Override default MUI light theme. (Check theme.ts)
+[UI.theme.light]
+    #background = "#FAFAFA"
+    #paper = "#FFFFFF"
+
+    [UI.theme.light.primary]
+        #main = "#F80061"
+        #dark = "#980039"
+        #light = "#FFE7EB"
+
+# Override default MUI dark theme. (Check theme.ts)
+[UI.theme.dark]
+    #background = "#FAFAFA"
+    #paper = "#FFFFFF"
+
+    [UI.theme.dark.primary]
+        #main = "#F80061"
+        #dark = "#980039"
+        #light = "#FFE7EB"
+
+
+[meta]
+generated_by = "0.7.700"

.gitignore

@@ -0,0 +1,160 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

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.py", "--port", "7860"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Ruben Alvarez
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

aimakerspace/openai_utils/chatmodel.py

@@ -0,0 +1,38 @@
+from openai import OpenAI
+from dotenv import load_dotenv
+from prompts import UserRolePrompt, SystemRolePrompt
+import os
+
+load_dotenv()
+
+
+class ChatOpenAI:
+    def __init__(self, model_name: str = "gpt-3.5-turbo"):
+        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):
+        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
+        )
+
+        if text_only:
+            return response.choices[0].message.content
+
+        return response
+
+
+if __name__ == "__main__":
+    chat = ChatOpenAI()
+    prompt = UserRolePrompt("Hello, I am a human.")
+    prompt = prompt.create_message()
+    print(prompt)
+
+    response = chat.run([prompt])
+    print(response)

aimakerspace/openai_utils/embedding.py

@@ -0,0 +1,59 @@
+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-ada-002"):
+        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

@@ -0,0 +1,75 @@
+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, **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
+        """
+        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")
+
+
+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

@@ -0,0 +1,136 @@
+import os
+from typing import List, Union
+from pdfminer.high_level import extract_text
+import io
+from chainlit.types import AskFileResponse
+import re
+
+
+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 PDFFileLoader(TextFileLoader):
+    def __init__(self, path: str, encoding: str = "utf-8", content=None, files: list[AskFileResponse] = None):
+        super().__init__(path, encoding)
+        self.content = content
+        self.files = files
+        
+    def load(self):
+        if isinstance(self.files, List):
+            for file in self.files:
+                if file.content and file.path.endswith(".pdf"):
+                    self.content = file.content
+                    self.load_content()
+        elif os.path.isdir(self.path):
+            self.load_directory()
+        elif os.path.isfile(self.path) and self.path.endswith(".pdf"):
+            print("loading file ...")
+            self.load_file()
+        elif self.content and self.path.endswith(".pdf"):
+            print("loading content ...")
+            self.load_content()
+        else:
+            raise ValueError(
+                "Provided path is neither a valid directory nor a .pdf file."
+            )
+        
+    def load_content(self):
+        """Load pdf already in memory"""
+        text = extract_text(io.BytesIO(self.content))
+        text = self.clean_text(text)
+        self.documents.append(text)
+
+    def clean_text(self, text):
+        """Clean text by removing special characters."""
+        # remove all \n
+        text = text.replace('\n', ' ')
+        text = re.sub(' +', ' ', text)
+        # remove page number, we find it because it appears before '\x0c', use regex to find it
+        text = re.sub(r'\d+ \x0c', '\x0c', text)
+        # remove all '\x0c'
+        text = text.replace('\x0c', ' ')
+        return text
+
+    def load_file(self):
+        text = extract_text(pdf_file=self.path, codec=self.encoding)
+        self.documents.append(text)
+
+    def load_directory(self):
+        for root, _, files in os.walk(self.path):
+            for file in files:
+                if file.endswith(".pdf"):
+                    self.documents.append(
+                        extract_text(os.path.join(root, file), encoding=self.encoding)
+                    )
+
+
+
+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

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

@@ -0,0 +1,150 @@
+# You can find this code for Chainlit python streaming here (https://docs.chainlit.io/concepts/streaming/python)
+
+# OpenAI Chat completion
+import os
+from openai import AsyncOpenAI  # importing openai for API usage
+import chainlit as cl  # importing chainlit for our app
+from chainlit.prompt import Prompt, PromptMessage  # importing prompt tools
+from chainlit.playground.providers import ChatOpenAI  # importing ChatOpenAI tools
+from dotenv import load_dotenv
+from aimakerspace.text_utils import PDFFileLoader, CharacterTextSplitter
+from aimakerspace.vectordatabase import VectorDatabase
+
+load_dotenv()
+
+# ChatOpenAI Templates
+system_template = """You are a Wizzard and everything you say is a spell!
+"""
+
+user_template = """{input}
+Wizzard, think through your response step by step.
+"""
+
+assistant_template = """Use the following context, if any, to help you
+answer the user's input, if the answer is not in the context say you don't
+know the answer.
+CONTEXT:
+===============
+{context}
+===============
+
+Spell away Wizzard!
+"""
+
+
+
+@cl.on_chat_start  # marks a function that will be executed at the start of a user session
+async def start_chat():
+    settings = {
+        "model": "gpt-3.5-turbo",
+        "temperature": 0,
+        "max_tokens": 500,
+        "top_p": 1,
+        "frequency_penalty": 0,
+        "presence_penalty": 0,
+    }
+
+    cl.user_session.set("settings", settings)
+
+    files = None
+    while files is None:
+        files = await cl.AskFileMessage(
+            content="Please upload a PDF file to begin",
+            accept=["application/pdf"],
+            max_files=10,
+            max_size_mb=10,
+            timeout=60
+        ).send()
+
+    # let the user know you are processing the file(s)
+    await cl.Message(
+        content="Loading your files..."
+    ).send()
+
+    # decode the file
+    documents = PDFFileLoader(path="", files=files).load_documents()
+
+    # split the text into chunks
+    chunks = CharacterTextSplitter(
+        chunk_size=1000,
+        chunk_overlap=200
+    ).split_texts(documents)
+
+    print(chunks[0])
+
+    # create a vector store
+    # let the user know you are processing the document(s)
+    await cl.Message(
+        content="Creating vector store"
+    ).send()
+
+    vector_db = VectorDatabase()
+    vector_db = await vector_db.abuild_from_list(chunks)
+
+    await cl.Message(
+        content="Done. Ask away!"
+    ).send()
+    
+    cl.user_session.set("vector_db", vector_db)
+
+
+@cl.on_message  # marks a function that should be run each time the chatbot receives a message from a user
+async def main(message: cl.Message):
+    vector_db = cl.user_session.get("vector_db")
+    settings = cl.user_session.get("settings")
+
+    client = AsyncOpenAI()
+
+    print(message.content)
+
+    results_list = vector_db.search_by_text(query_text=message.content, k=3, return_as_text=True)
+    if results_list:
+        results_string = "\n\n".join(results_list)
+    else:
+        results_string = ""
+
+    prompt = Prompt(
+        provider=ChatOpenAI.id,
+        messages=[
+            PromptMessage(
+                role="system",
+                template=system_template,
+                formatted=system_template,
+            ),
+            PromptMessage(
+                role="user",
+                template=user_template,
+                formatted=user_template.format(input=message.content),
+            ),
+            PromptMessage(
+                role="assistant",
+                template=assistant_template,
+                formatted=assistant_template.format(context=results_string)
+            )
+        ],
+        inputs={
+            "input": message.content,
+            "context": results_string
+            },
+        settings=settings,
+    )
+
+    print([m.to_openai() for m in prompt.messages])
+
+    msg = cl.Message(content="")
+
+    # Call OpenAI
+    async for stream_resp in await client.chat.completions.create(
+        messages=[m.to_openai() for m in prompt.messages], stream=True, **settings
+    ):
+        token = stream_resp.choices[0].delta.content
+        if not token:
+            token = ""
+        await msg.stream_token(token)
+
+    # Update the prompt object with the completion
+    prompt.completion = msg.content
+    msg.prompt = prompt
+
+    # Send and close the message stream
+    await msg.send()

chainlit.md

@@ -0,0 +1,3 @@
+# Beyond ChatGPT 
+
+Welcome to Chatito GPT, this is a prototyping space for LLM related applications. Follow me [@RubenAMtz](https://twitter.com/RubenAMtz) on Twitter

requirements.txt

@@ -0,0 +1,11 @@
+chainlit==0.7.700
+cohere==4.37
+openai==1.3.5
+tiktoken==0.5.1
+python-dotenv==1.0.0
+numpy==1.25.2
+pandas
+scikit-learn
+matplotlib
+plotly
+pdfminer.six