Fix Capacity Command (#49 )

* fix: capacity while replace if * fix: command name in config
Remove Bot User ID from Prompt (#48 )
2024-04-20 10:03:22 -07:00 · 2024-04-20 10:01:42 -07:00 · 2024-04-13 21:34:55 -07:00 · 2024-04-13 19:59:57 -07:00 · 2024-04-13 19:07:49 -07:00 · 2024-04-07 16:09:27 -07:00
40 changed files with 1691 additions and 597 deletions
--- a/.env.sample
+++ b/.env.sample
@@ -0,0 +1,27 @@
+# Discord token for the bot
+CLIENT_TOKEN = BOT_TOKEN
+
+# id token of a discord server
+GUILD_ID = GUILD_ID
+
+# Channel where the bot listens to messages
+CHANNEL_ID = CHANNEL_ID
+
+# model for the bot to query from (i.e. llama2 [llama2:13b], mistral, codellama, etc... )
+MODEL = MODEL_NAME
+
+# discord bot user id for mentions
+CLIENT_UID = BOT_USER_ID
+
+# ip/port address of docker container, I use 172.18.X.X for docker, 127.0.0.1 for local
+OLLAMA_IP = IP_ADDRESS
+OLLAMA_PORT = PORT
+
+# ip address for discord bot container, I use 172.18.X.X, use different IP than ollama_ip
+DISCORD_IP = IP_ADDRESS
+
+# subnet address, ex. 172.18.0.0 as we use /16.
+SUBNET_ADDRESS = ADDRESS
+
+# list of admins to handle admin commands for the bot, use single quotes
+ADMINS=['username1', 'username2', 'username3', ...]
--- a/.github/CONTRIBUTING.md
+++ b/.github/CONTRIBUTING.md
@@ -0,0 +1,35 @@
+<!-- 
+    Author: Kevin Dang 
+    Date: 1-30-2024    
+-->
+## Run the Bot
+* Refer to all sections below before running the bot.
+* You should now have `Ollama`, `NodeJS`, ran `npm install`.
+* You will also need a discord bot to run. Refer to the [developer portal](https://discord.com/developers/) to learn how to set one up and invite it to your server. If that does not help then look up a YouTube video like this [one](https://www.youtube.com/watch?v=KZ3tIGHU314&ab_channel=UnderCtrl).
+* Now run `npm run start` to run the client and ollama at the same time (this must be one in wsl or a Linux distro)
+
+
+## Set up (Development-side)
+* Pull the repository using `https://github.com/kevinthedang/discord-ollama.git`.
+* Refer to `Ollama Setup` in the readme to set up Ollama.
+  * This must be set up in a Linux environment or wsl2.
+* Install NodeJS `v18.18.2`
+  * You can check out `Resources` and `To Run` in the readme for a bit of help.
+  * You can also reference [NodeJS Setup](#nodejs-setup)
+* When you have the project pulled from github, open up a terminal and run `npm i` or `npm install` to get all of the packages for the project.
+* In some kind of terminal (`git bash` is good) to run the client. You can run Ollama but opening up wsl2 and typing `ollama serve`.
+  * Refer to `Ollama Setup` if there are any issues.
+
+## Environment
+* You will need two environment files:
+  * `.env`: for running the bot
+    * Please refer to `.env.sample` for all environment variables to include
+  * `.env.dev.local`: also runs the bot, but with development variables
+    * Currently there are no differences between the two, but when needed, you may add environment variables as needed.
+
+## NodeJS Setup
+* Install [nvm](https://github.com/nvm-sh/nvm?tab=readme-ov-file#installing-and-updating) using `curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash`
+  * Ensure this in the profile of what shell you use (for `git bash` it would be `.bash_profile` found in your home directory)
+* Ensure it has been install correctly by running `nvm -v`
+* Now, install `v18.18.2` by running `nvm install 18.18.2`
+* Then run `nvm use 18.18.2 | nvm alias default 18.18.2` or you can run them separately if that does not work. This just sets the default NodeJS to `v18.18.2` when launching a shell.
--- a/.github/style.md
+++ b/.github/style.md
@@ -0,0 +1,5 @@
+## Style Preferences
+* Please just make sure that you are using a `Tab Default` of 4 for spacing
+* You don't need semicolons at the end of everything.
+* Comments for functions would be nice to help explain what they do and what the parameters are for.
+* If there are any other issues, just refer to the [Google Style Guide](https://google.github.io/styleguide/tsguide.html)
--- a/.github/workflows/build-test.yml
+++ b/.github/workflows/build-test.yml
@@ -0,0 +1,84 @@
+name: Builds
+run-name: Validate Node and Docker Builds
+on:
+    push:
+        branches:
+            - master
+
+jobs: 
+    Discord-Node-Build: # test if the node install and run
+        runs-on: ubuntu-latest
+        timeout-minutes: 2
+        steps:
+            - name: Checkout Repository
+              uses: actions/checkout@v4
+
+            - name: Set up Node Environment v18.18.2
+              uses: actions/setup-node@v4
+              with:
+                node-version: 18.18.2
+                cache: 'npm'
+
+            - name: Install Project Dependencies
+              run: |
+                npm install
+
+            - name: Build Application
+              run: |
+                npm run build
+
+            - name: Create Environment Variables
+              run: |
+                touch .env
+                echo CLIENT_TOKEN = ${{ secrets.BOT_TOKEN }} >> .env
+                echo GUILD_ID = ${{ secrets.GUILD_ID }} >> .env
+                echo CHANNEL_ID = ${{ secrets.CHANNEL_ID }} >> .env
+                echo MODEL = ${{ secrets.MODEL }} >> .env
+                echo CLIENT_UID = ${{ secrets.CLIENT_UID }} >> .env
+                echo OLLAMA_IP = ${{ secrets.OLLAMA_IP }} >> .env
+                echo OLLAMA_PORT = ${{ secrets.OLLAMA_PORT }} >> .env
+                echo ADMINS = ${{ secrets.ADMINS }} >> .env
+              
+              # set -e ensures if nohup fails, this section fails
+            - name: Startup Discord Bot Client
+              run: |
+                set -e
+                nohup npm run prod &
+
+    Discord-Ollama-Container-Build: # test docker build and run
+      runs-on: ubuntu-latest
+      timeout-minutes: 2
+      steps:
+          - name: Checkout Repository
+            uses: actions/checkout@v4
+
+          - name: Set up Node Environment v18.18.2
+            uses: actions/setup-node@v4
+            with:
+              node-version: 18.18.2
+              cache: 'npm'
+
+          - name: Create Environment Variables
+            run: |
+              touch .env
+              echo CLIENT_TOKEN = ${{ secrets.BOT_TOKEN }} >> .env
+              echo GUILD_ID = ${{ secrets.GUILD_ID }} >> .env
+              echo CHANNEL_ID = ${{ secrets.CHANNEL_ID }} >> .env
+              echo MODEL = ${{ secrets.MODEL }} >> .env
+              echo CLIENT_UID = ${{ secrets.CLIENT_UID }} >> .env
+              echo OLLAMA_IP = ${{ secrets.OLLAMA_IP }} >> .env
+              echo OLLAMA_PORT = ${{ secrets.OLLAMA_PORT }} >> .env
+              echo ADMINS = ${{ secrets.ADMINS }} >> .env
+
+          - name: Setup Docker Network and Images
+            run: |
+              npm run docker:start-cpu
+          
+          - name: Check Images Exist
+            run: |
+              (docker images | grep -q 'discord/bot' && docker images | grep -qE 'ollama/ollama') || exit 1
+
+          - name: Check Containers Exist
+            run: |
+              (docker ps | grep -q 'ollama' && docker ps | grep -q 'discord') || exit 1
+
--- a/.gitignore
+++ b/.gitignore
@@ -1,6 +1,16 @@
 # Created by https://www.toptal.com/developers/gitignore/api/node
 # Edit at https://www.toptal.com/developers/gitignore?templates=node

+# config
+config.json
+
+# builds
+build/
+dist/
+app/
+tmp/
+data/
+
 # dotenv environment variable files
 .env
 .env.dev.local
--- a/19
+++ b/19
@@ -0,0 +1,19 @@
+# use node LTS image for version 18
+FROM node:18.18.2
+
+# set working directory inside container
+WORKDIR /app
+
+# copy package.json and the lock file into the container, and src files
+COPY ./src ./src
+COPY ./*.json ./
+COPY ./.env ./
+
+# install dependencies, breaks
+RUN npm install
+
+# build the typescript code
+RUN npm run build
+
+# start the application
+CMD ["npm", "run", "prod"]
--- a/395
+++ b/395
@@ -0,0 +1,395 @@
+Attribution 4.0 International
+
+=======================================================================
+
+Creative Commons Corporation ("Creative Commons") is not a law firm and
+does not provide legal services or legal advice. Distribution of
+Creative Commons public licenses does not create a lawyer-client or
+other relationship. Creative Commons makes its licenses and related
+information available on an "as-is" basis. Creative Commons gives no
+warranties regarding its licenses, any material licensed under their
+terms and conditions, or any related information. Creative Commons
+disclaims all liability for damages resulting from their use to the
+fullest extent possible.
+
+Using Creative Commons Public Licenses
+
+Creative Commons public licenses provide a standard set of terms and
+conditions that creators and other rights holders may use to share
+original works of authorship and other material subject to copyright
+and certain other rights specified in the public license below. The
+following considerations are for informational purposes only, are not
+exhaustive, and do not form part of our licenses.
+
+     Considerations for licensors: Our public licenses are
+     intended for use by those authorized to give the public
+     permission to use material in ways otherwise restricted by
+     copyright and certain other rights. Our licenses are
+     irrevocable. Licensors should read and understand the terms
+     and conditions of the license they choose before applying it.
+     Licensors should also secure all rights necessary before
+     applying our licenses so that the public can reuse the
+     material as expected. Licensors should clearly mark any
+     material not subject to the license. This includes other CC-
+     licensed material, or material used under an exception or
+     limitation to copyright. More considerations for licensors:
+    wiki.creativecommons.org/Considerations_for_licensors
+
+     Considerations for the public: By using one of our public
+     licenses, a licensor grants the public permission to use the
+     licensed material under specified terms and conditions. If
+     the licensor's permission is not necessary for any reason--for
+     example, because of any applicable exception or limitation to
+     copyright--then that use is not regulated by the license. Our
+     licenses grant only permissions under copyright and certain
+     other rights that a licensor has authority to grant. Use of
+     the licensed material may still be restricted for other
+     reasons, including because others have copyright or other
+     rights in the material. A licensor may make special requests,
+     such as asking that all changes be marked or described.
+     Although not required by our licenses, you are encouraged to
+     respect those requests where reasonable. More considerations
+     for the public:
+    wiki.creativecommons.org/Considerations_for_licensees
+
+=======================================================================
+
+Creative Commons Attribution 4.0 International Public License
+
+By exercising the Licensed Rights (defined below), You accept and agree
+to be bound by the terms and conditions of this Creative Commons
+Attribution 4.0 International Public License ("Public License"). To the
+extent this Public License may be interpreted as a contract, You are
+granted the Licensed Rights in consideration of Your acceptance of
+these terms and conditions, and the Licensor grants You such rights in
+consideration of benefits the Licensor receives from making the
+Licensed Material available under these terms and conditions.
+
+
+Section 1 -- Definitions.
+
+  a. Adapted Material means material subject to Copyright and Similar
+     Rights that is derived from or based upon the Licensed Material
+     and in which the Licensed Material is translated, altered,
+     arranged, transformed, or otherwise modified in a manner requiring
+     permission under the Copyright and Similar Rights held by the
+     Licensor. For purposes of this Public License, where the Licensed
+     Material is a musical work, performance, or sound recording,
+     Adapted Material is always produced where the Licensed Material is
+     synched in timed relation with a moving image.
+
+  b. Adapter's License means the license You apply to Your Copyright
+     and Similar Rights in Your contributions to Adapted Material in
+     accordance with the terms and conditions of this Public License.
+
+  c. Copyright and Similar Rights means copyright and/or similar rights
+     closely related to copyright including, without limitation,
+     performance, broadcast, sound recording, and Sui Generis Database
+     Rights, without regard to how the rights are labeled or
+     categorized. For purposes of this Public License, the rights
+     specified in Section 2(b)(1)-(2) are not Copyright and Similar
+     Rights.
+
+  d. Effective Technological Measures means those measures that, in the
+     absence of proper authority, may not be circumvented under laws
+     fulfilling obligations under Article 11 of the WIPO Copyright
+     Treaty adopted on December 20, 1996, and/or similar international
+     agreements.
+
+  e. Exceptions and Limitations means fair use, fair dealing, and/or
+     any other exception or limitation to Copyright and Similar Rights
+     that applies to Your use of the Licensed Material.
+
+  f. Licensed Material means the artistic or literary work, database,
+     or other material to which the Licensor applied this Public
+     License.
+
+  g. Licensed Rights means the rights granted to You subject to the
+     terms and conditions of this Public License, which are limited to
+     all Copyright and Similar Rights that apply to Your use of the
+     Licensed Material and that the Licensor has authority to license.
+
+  h. Licensor means the individual(s) or entity(ies) granting rights
+     under this Public License.
+
+  i. Share means to provide material to the public by any means or
+     process that requires permission under the Licensed Rights, such
+     as reproduction, public display, public performance, distribution,
+     dissemination, communication, or importation, and to make material
+     available to the public including in ways that members of the
+     public may access the material from a place and at a time
+     individually chosen by them.
+
+  j. Sui Generis Database Rights means rights other than copyright
+     resulting from Directive 96/9/EC of the European Parliament and of
+     the Council of 11 March 1996 on the legal protection of databases,
+     as amended and/or succeeded, as well as other essentially
+     equivalent rights anywhere in the world.
+
+  k. You means the individual or entity exercising the Licensed Rights
+     under this Public License. Your has a corresponding meaning.
+
+
+Section 2 -- Scope.
+
+  a. License grant.
+
+       1. Subject to the terms and conditions of this Public License,
+          the Licensor hereby grants You a worldwide, royalty-free,
+          non-sublicensable, non-exclusive, irrevocable license to
+          exercise the Licensed Rights in the Licensed Material to:
+
+            a. reproduce and Share the Licensed Material, in whole or
+               in part; and
+
+            b. produce, reproduce, and Share Adapted Material.
+
+       2. Exceptions and Limitations. For the avoidance of doubt, where
+          Exceptions and Limitations apply to Your use, this Public
+          License does not apply, and You do not need to comply with
+          its terms and conditions.
+
+       3. Term. The term of this Public License is specified in Section
+          6(a).
+
+       4. Media and formats; technical modifications allowed. The
+          Licensor authorizes You to exercise the Licensed Rights in
+          all media and formats whether now known or hereafter created,
+          and to make technical modifications necessary to do so. The
+          Licensor waives and/or agrees not to assert any right or
+          authority to forbid You from making technical modifications
+          necessary to exercise the Licensed Rights, including
+          technical modifications necessary to circumvent Effective
+          Technological Measures. For purposes of this Public License,
+          simply making modifications authorized by this Section 2(a)
+          (4) never produces Adapted Material.
+
+       5. Downstream recipients.
+
+            a. Offer from the Licensor -- Licensed Material. Every
+               recipient of the Licensed Material automatically
+               receives an offer from the Licensor to exercise the
+               Licensed Rights under the terms and conditions of this
+               Public License.
+
+            b. No downstream restrictions. You may not offer or impose
+               any additional or different terms or conditions on, or
+               apply any Effective Technological Measures to, the
+               Licensed Material if doing so restricts exercise of the
+               Licensed Rights by any recipient of the Licensed
+               Material.
+
+       6. No endorsement. Nothing in this Public License constitutes or
+          may be construed as permission to assert or imply that You
+          are, or that Your use of the Licensed Material is, connected
+          with, or sponsored, endorsed, or granted official status by,
+          the Licensor or others designated to receive attribution as
+          provided in Section 3(a)(1)(A)(i).
+
+  b. Other rights.
+
+       1. Moral rights, such as the right of integrity, are not
+          licensed under this Public License, nor are publicity,
+          privacy, and/or other similar personality rights; however, to
+          the extent possible, the Licensor waives and/or agrees not to
+          assert any such rights held by the Licensor to the limited
+          extent necessary to allow You to exercise the Licensed
+          Rights, but not otherwise.
+
+       2. Patent and trademark rights are not licensed under this
+          Public License.
+
+       3. To the extent possible, the Licensor waives any right to
+          collect royalties from You for the exercise of the Licensed
+          Rights, whether directly or through a collecting society
+          under any voluntary or waivable statutory or compulsory
+          licensing scheme. In all other cases the Licensor expressly
+          reserves any right to collect such royalties.
+
+
+Section 3 -- License Conditions.
+
+Your exercise of the Licensed Rights is expressly made subject to the
+following conditions.
+
+  a. Attribution.
+
+       1. If You Share the Licensed Material (including in modified
+          form), You must:
+
+            a. retain the following if it is supplied by the Licensor
+               with the Licensed Material:
+
+                 i. identification of the creator(s) of the Licensed
+                    Material and any others designated to receive
+                    attribution, in any reasonable manner requested by
+                    the Licensor (including by pseudonym if
+                    designated);
+
+                ii. a copyright notice;
+
+               iii. a notice that refers to this Public License;
+
+                iv. a notice that refers to the disclaimer of
+                    warranties;
+
+                 v. a URI or hyperlink to the Licensed Material to the
+                    extent reasonably practicable;
+
+            b. indicate if You modified the Licensed Material and
+               retain an indication of any previous modifications; and
+
+            c. indicate the Licensed Material is licensed under this
+               Public License, and include the text of, or the URI or
+               hyperlink to, this Public License.
+
+       2. You may satisfy the conditions in Section 3(a)(1) in any
+          reasonable manner based on the medium, means, and context in
+          which You Share the Licensed Material. For example, it may be
+          reasonable to satisfy the conditions by providing a URI or
+          hyperlink to a resource that includes the required
+          information.
+
+       3. If requested by the Licensor, You must remove any of the
+          information required by Section 3(a)(1)(A) to the extent
+          reasonably practicable.
+
+       4. If You Share Adapted Material You produce, the Adapter's
+          License You apply must not prevent recipients of the Adapted
+          Material from complying with this Public License.
+
+
+Section 4 -- Sui Generis Database Rights.
+
+Where the Licensed Rights include Sui Generis Database Rights that
+apply to Your use of the Licensed Material:
+
+  a. for the avoidance of doubt, Section 2(a)(1) grants You the right
+     to extract, reuse, reproduce, and Share all or a substantial
+     portion of the contents of the database;
+
+  b. if You include all or a substantial portion of the database
+     contents in a database in which You have Sui Generis Database
+     Rights, then the database in which You have Sui Generis Database
+     Rights (but not its individual contents) is Adapted Material; and
+
+  c. You must comply with the conditions in Section 3(a) if You Share
+     all or a substantial portion of the contents of the database.
+
+For the avoidance of doubt, this Section 4 supplements and does not
+replace Your obligations under this Public License where the Licensed
+Rights include other Copyright and Similar Rights.
+
+
+Section 5 -- Disclaimer of Warranties and Limitation of Liability.
+
+  a. UNLESS OTHERWISE SEPARATELY UNDERTAKEN BY THE LICENSOR, TO THE
+     EXTENT POSSIBLE, THE LICENSOR OFFERS THE LICENSED MATERIAL AS-IS
+     AND AS-AVAILABLE, AND MAKES NO REPRESENTATIONS OR WARRANTIES OF
+     ANY KIND CONCERNING THE LICENSED MATERIAL, WHETHER EXPRESS,
+     IMPLIED, STATUTORY, OR OTHER. THIS INCLUDES, WITHOUT LIMITATION,
+     WARRANTIES OF TITLE, MERCHANTABILITY, FITNESS FOR A PARTICULAR
+     PURPOSE, NON-INFRINGEMENT, ABSENCE OF LATENT OR OTHER DEFECTS,
+     ACCURACY, OR THE PRESENCE OR ABSENCE OF ERRORS, WHETHER OR NOT
+     KNOWN OR DISCOVERABLE. WHERE DISCLAIMERS OF WARRANTIES ARE NOT
+     ALLOWED IN FULL OR IN PART, THIS DISCLAIMER MAY NOT APPLY TO YOU.
+
+  b. TO THE EXTENT POSSIBLE, IN NO EVENT WILL THE LICENSOR BE LIABLE
+     TO YOU ON ANY LEGAL THEORY (INCLUDING, WITHOUT LIMITATION,
+     NEGLIGENCE) OR OTHERWISE FOR ANY DIRECT, SPECIAL, INDIRECT,
+     INCIDENTAL, CONSEQUENTIAL, PUNITIVE, EXEMPLARY, OR OTHER LOSSES,
+     COSTS, EXPENSES, OR DAMAGES ARISING OUT OF THIS PUBLIC LICENSE OR
+     USE OF THE LICENSED MATERIAL, EVEN IF THE LICENSOR HAS BEEN
+     ADVISED OF THE POSSIBILITY OF SUCH LOSSES, COSTS, EXPENSES, OR
+     DAMAGES. WHERE A LIMITATION OF LIABILITY IS NOT ALLOWED IN FULL OR
+     IN PART, THIS LIMITATION MAY NOT APPLY TO YOU.
+
+  c. The disclaimer of warranties and limitation of liability provided
+     above shall be interpreted in a manner that, to the extent
+     possible, most closely approximates an absolute disclaimer and
+     waiver of all liability.
+
+
+Section 6 -- Term and Termination.
+
+  a. This Public License applies for the term of the Copyright and
+     Similar Rights licensed here. However, if You fail to comply with
+     this Public License, then Your rights under this Public License
+     terminate automatically.
+
+  b. Where Your right to use the Licensed Material has terminated under
+     Section 6(a), it reinstates:
+
+       1. automatically as of the date the violation is cured, provided
+          it is cured within 30 days of Your discovery of the
+          violation; or
+
+       2. upon express reinstatement by the Licensor.
+
+     For the avoidance of doubt, this Section 6(b) does not affect any
+     right the Licensor may have to seek remedies for Your violations
+     of this Public License.
+
+  c. For the avoidance of doubt, the Licensor may also offer the
+     Licensed Material under separate terms or conditions or stop
+     distributing the Licensed Material at any time; however, doing so
+     will not terminate this Public License.
+
+  d. Sections 1, 5, 6, 7, and 8 survive termination of this Public
+     License.
+
+
+Section 7 -- Other Terms and Conditions.
+
+  a. The Licensor shall not be bound by any additional or different
+     terms or conditions communicated by You unless expressly agreed.
+
+  b. Any arrangements, understandings, or agreements regarding the
+     Licensed Material not stated herein are separate from and
+     independent of the terms and conditions of this Public License.
+
+
+Section 8 -- Interpretation.
+
+  a. For the avoidance of doubt, this Public License does not, and
+     shall not be interpreted to, reduce, limit, restrict, or impose
+     conditions on any use of the Licensed Material that could lawfully
+     be made without permission under this Public License.
+
+  b. To the extent possible, if any provision of this Public License is
+     deemed unenforceable, it shall be automatically reformed to the
+     minimum extent necessary to make it enforceable. If the provision
+     cannot be reformed, it shall be severed from this Public License
+     without affecting the enforceability of the remaining terms and
+     conditions.
+
+  c. No term or condition of this Public License will be waived and no
+     failure to comply consented to unless expressly agreed to by the
+     Licensor.
+
+  d. Nothing in this Public License constitutes or may be interpreted
+     as a limitation upon, or waiver of, any privileges and immunities
+     that apply to the Licensor or You, including from the legal
+     processes of any jurisdiction or authority.
+
+
+=======================================================================
+
+Creative Commons is not a party to its public
+licenses. Notwithstanding, Creative Commons may elect to apply one of
+its public licenses to material it publishes and in those instances
+will be considered the “Licensor.” The text of the Creative Commons
+public licenses is dedicated to the public domain under the CC0 Public
+Domain Dedication. Except for the limited purpose of indicating that
+material is shared under a Creative Commons public license or as
+otherwise permitted by the Creative Commons policies published at
+creativecommons.org/policies, Creative Commons does not authorize the
+use of the trademark "Creative Commons" or any other trademark or logo
+of Creative Commons without its prior written consent including,
+without limitation, in connection with any unauthorized modifications
+to any of its public licenses or any other arrangements,
+understandings, or agreements concerning use of licensed material. For
+the avoidance of doubt, this paragraph does not form part of the
+public licenses.
+
+Creative Commons may be contacted at creativecommons.org.
--- a/README.md
+++ b/README.md
@@ -1,36 +1,53 @@
-# Discord Ollama Integration [![License: CC BY-NC 4.0](https://img.shields.io/badge/License-CC_BY--NC_4.0-darkgreen.svg)](https://creativecommons.org/licenses/by-nc/4.0/) [![Release Badge](https://img.shields.io/github/v/release/kevinthedang/discord-ollama?logo=github)](https://github.com/kevinthedang/discord-ollama/releases/latest)
-Ollama is an AI model management tool that allows users to install and use custom large language models locally. The goal is to create a discord bot that will utilize Ollama and chat with it on a Discord!
+<div align="center">
+    <p><a href="#"><a href="https://ollama.ai/"><img alt="ollama" src="./imgs/ollama-icon.png" width="200px" /></a><img alt="+" src="./imgs/grey-plus.png" width="100px" /></a><a href="https://discord.com/"><img alt="discord" src="./imgs/discord-icon.png" width="195px" /></a></p>
+    <h1>Discord Ollama Integration</h1>
+    <h3><a href="#"></a>Ollama as your Discord AI Assistant</h3>
+    <p><a href="#"></a><a href="https://creativecommons.org/licenses/by/4.0/"><img alt="License" src="https://img.shields.io/badge/License-CC_BY_4.0-darkgreen.svg" /></a>
+    <a href="#"></a><a href="https://github.com/kevinthedang/discord-ollama/releases/latest"><img alt="Release" src="https://img.shields.io/github/v/release/kevinthedang/discord-ollama?logo=github" /></a>
+    <a href="#"></a><a href="https://github.com/kevinthedang/discord-ollama/actions/workflows/build-test.yml"><img alt="Build Status" src="https://github.com/kevinthedang/discord-ollama/actions/workflows/build-test.yml/badge.svg" /></a>
+</div>

-## Ollama Setup
-* Go to Ollama's [Linux download page](https://ollama.ai/download/linux) and run the simple curl command they provide. The command should be `curl https://ollama.ai/install.sh | sh`.
-* Now the the following commands in separate terminals to test out how it works!
-    * In terminal 1 -> `ollama serve` to setup ollama
-    * In terminal 2 -> `ollama run [model name]`, for example `ollama run llama2`
-        * The models can vary as you can create your own model. You can also view ollama's [library](https://ollama.ai/library) of models.
-    * This can also be done in [wsl](https://learn.microsoft.com/en-us/windows/wsl/install) for Windows machines.
-* You can now interact with the model you just ran (it might take a second to startup).
-    * Response time varies with processing power!
+## About/Goals
+Ollama is an AI model management tool that allows users to install and use custom large language models locally.  
+The project aims to:
+* [x] Create a Discord bot that will utilize Ollama and chat to chat with users! 
+  * [ ] User Preferences on Chat
+  * [ ] Message Persistance on Channels and Threads
+  * [x] Containerization with Docker
+  * [x] Slash Commands Compatible
+  * [x] Generated Token Length Handling for >2000 ~~or >6000 characters~~
+    * [ ] Token Length Handling of any message size
+  * [ ] External WebUI Integration
+  * [ ] Administrator Role Compatible
+* [ ] Allow others to create their own models personalized for their own servers!
+  * [ ] Documentation on creating your own LLM
+  * [ ] Documentation on web scrapping and cleaning

-## To Run
+## Environment Setup
 * Clone this repo using `git clone https://github.com/kevinthedang/discord-ollama.git` or just use [GitHub Desktop](https://desktop.github.com/) to clone the repo.
-* Run `npm install` to install the npm packages.
-* You will need a `.env` file in the root of the project directory with the bot's token. 
+* You will need a `.env` file in the root of the project directory with the bot's token. There is a `.env.sample` is provided for you as a reference for what environment variables.
    * For example, `CLIENT_TOKEN = [Bot Token]`
-* Now, you can run the bot by running `npm run start` which will build and run the decompiled typescript and run the setup for ollama.
-    * **IMPORTANT**: This must be ran in the wsl/Linux instance to work properly! Using Command Prompt/Powershell/Git Bash/etc. will not work on Windows (at least in my experience).
-    * Refer to the [resources](#resources) on what node version to use.
+* Please refer to the docs for bot setup. **NOTE**: These guides assume you already know how to setup a bot account for discord.
+    * [Local Machine Setup](./docs/setup-local.md)
+    * [Docker Setup for Servers and Local Machines](./docs/setup-docker.md)
+        * Local use is not recommended.

 ## Resources
 * [NodeJS](https://nodejs.org/en)
-    * This project uses `v20.10.0` (npm `10.2.5`). Consider using [nvm](https://github.com/nvm-sh/nvm) for multiple NodeJS versions.
+    * This project uses `v20.10.0+` (npm `10.2.5`). Consider using [nvm](https://github.com/nvm-sh/nvm) for multiple NodeJS versions.
        * To run dev in `ts-node`, using `v18.18.2` is recommended. **CAUTION**: `v18.19.0` or `lts/hydrogen` will not run properly.
        * To run dev with `tsx`, you can use `v20.10.0` or earlier.
    * This project supports any NodeJS version above `16.x.x` to only allow ESModules.
 * [Ollama](https://ollama.ai/)
+    * [Ollama Docker Image](https://hub.docker.com/r/ollama/ollama)
+    * **IMPORTANT**: For Nvidia GPU setup, **install** `nvidia container toolkit/runtime` then **configure** it with Docker to utilize Nvidia driver.
 * [Discord Developer Portal](https://discord.com/developers/docs/intro)
 * [Discord.js Docs](https://discord.js.org/docs/packages/discord.js/main)
+* [Setting up Docker (Ubuntu 20.04)](https://www.digitalocean.com/community/tutorials/how-to-install-and-use-docker-on-ubuntu-20-04)
+    * [Setting up Nvidia Container Toolkit](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html)

 ## Acknowledgement
 * [Kevin Dang](https://github.com/kevinthedang)
+* [Jonathan Smoley](https://github.com/JT2M0L3Y)

-[discord-ollama](https://github.com/kevinthedang/discord-ollama) © 2023 by [Kevin Dang](https://github.com/kevinthedang) is licensed under [CC BY-NC 4.0](https://creativecommons.org/licenses/by-nc/4.0/?ref=chooser-v1)
+[discord-ollama](https://github.com/kevinthedang/discord-ollama) © 2023 by [Kevin Dang](https://github.com/kevinthedang) is licensed under [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/)
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -0,0 +1,55 @@
+# creates the docker compose 
+version: '3.7'
+
+# build individual services 
+services:
+  # setup discord bot container
+  discord:
+    build: ./                     # find docker file in designated path
+    container_name: discord
+    restart: always               # rebuild container always
+    image: discord/bot:0.4.0
+    environment:
+      CLIENT_TOKEN: ${CLIENT_TOKEN}
+      GUILD_ID: ${GUILD_ID}
+      CHANNEL_ID: ${CHANNEL_ID}
+      MODEL: ${MODEL}
+      CLIENT_UID: ${CLIENT_UID}
+      OLLAMA_IP: ${OLLAMA_IP}
+      OLLAMA_PORT: ${OLLAMA_PORT}
+      ADMINS: ${ADMINS}
+    networks:
+      ollama-net:
+        ipv4_address: ${DISCORD_IP}
+    volumes: 
+      - discord:/src/app          # docker will not make this for you, make it yourself
+
+  # setup ollama container
+  ollama:
+    image: ollama/ollama:latest   # build the image using ollama
+    container_name: ollama
+    restart: always
+    networks:
+      ollama-net:
+        ipv4_address: ${OLLAMA_IP}
+
+    runtime: nvidia             # use Nvidia Container Toolkit for GPU support
+    devices:
+      - /dev/nvidia0
+    volumes:
+      - ollama:/root/.ollama
+    ports: 
+      - ${OLLAMA_PORT}:${OLLAMA_PORT}
+
+# create a network that supports giving addresses withing a specific subnet
+networks:
+  ollama-net:
+    driver: bridge
+    ipam:
+      driver: default
+      config:
+        - subnet: ${SUBNET_ADDRESS}/16
+
+volumes:
+  ollama:
+  discord:
--- a/docs/setup-docker.md
+++ b/docs/setup-docker.md
@@ -0,0 +1,74 @@
+## Docker Setup
+* Follow this guide to setup [Docker](https://www.digitalocean.com/community/tutorials/how-to-install-and-use-docker-on-ubuntu-20-04)
+    * If on Windows, download [Docker Desktop](https://docs.docker.com/desktop/install/windows-install/) to get the docker engine.
+* Please also install [Docker Compose](https://docs.docker.com/compose/install/linux/) for easy running. If not, there are [scripts](#manual-run-with-docker) to set everything up.
+* **IMPORTANT NOTE**: Currently, it seems like wsl does not like Nvidia Container Toolkit. It will work initially then reset it for some odd reason. For now, it is advised to use an actually Linux machine to run using Docker. If you do not care about utilizing your GPU or don't even have a Nvidia GPU then disregard this.
+
+## Nvidia Container Toolkit Setup
+### Installation with Apt
+* Instructions can be found [here](https://github.com/kevinthedang/discord-ollama/issues/23) in **Steps to reproduce** or below:
+  * Step 1. Configure the production repository on machine:
+```sh
+curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg \
+  && curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | \
+    sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
+    sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list
+```
+  * Step 2. Update the packages list from the repository:
+```sh
+sudo apt-get update
+```
+  * Step 3. Install the Nvidia Container Toolkit:
+```sh
+sudo apt-get install -y nvidia-container-toolkit
+```
+
+### Configurating with Docker
+Step 1.Configure the container runtime by using the `nvidia-ctk` command:
+```sh
+sudo nvidia-ctk runtime configure --runtime=docker
+```
+
+The `nvidia-ctk` command modifies the `/etc/docker/daemon.json` file on the host. The file is updated so that Docker can use the NVIDIA Container Runtime.
+
+Step 2. Restart the Docker daemon:
+```sh
+sudo systemctl restart docker
+```
+
+### References for setup
+* Guide to installing [Nvidia Container Toolkit](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html)
+* [GitHub repository](https://github.com/NVIDIA/nvidia-container-toolkit?tab=readme-ov-file) for Nvidia Container Toolkit
+
+## To Run (with Docker and Docker Compose)
+* With the inclusion of subnets in the `docker-compose.yml`, you will need to set the `SUBNET_ADDRESS`, `OLLAMA_IP`, `OLLAMA_PORT`, and `DISCORD_IP`. Here are some default values if you don't care:
+    * `OLLAMA_IP = 172.18.0.2`
+    * `OLLAMA_PORT = 11434`
+    * `DISCORD_IP = 172.18.0.3`
+    * `SUBNET_ADDRESS = 172.18.0.0`
+    * Don't understand any of this? watch a Networking video to understand subnetting.
+* You will need a model in the container for this to work properly, on Docker Desktop go to the `Containers` tab, select the `ollama` container, and select `Exec` to run as root on your container. Now, run `ollama pull [model name]` to get your model.
+    * For Linux Servers, you need another shell to pull the model, or if you run `docker compose build && docker compose up -d`, then it will run in the background to keep your shell. Run `docker exec -it ollama bash` to get into the container and run the samme pull command above.
+* Otherwise, there is no need to install any npm packages for this, you just need to run `npm run start` to pull the containers and spin them up.
+* For cleaning up on Linux (or Windows), run the following commands:
+    * `docker compose stop`
+    * `docker compose rm`
+    * `docker ps` to check if containers have been removed.
+* You can also use `npm run clean` to clean up the containers and remove the network to address a possible `Address already in use` problem.
+
+## Manual Run (with Docker)
+* Run the following commands:
+    * `npm run docker:build`
+    * `npm run docker:ollama`
+    * `npm run docker:client`
+    * `docker ps` to see if the containers are there!
+        * Names should be **discord** and **ollama**.
+    * You can also just run `npm run docker:start` now for the above commands.
+* Clean-up:
+    * `docker ps` for the conatiner id's. Use `-a` flag as necessary.
+    * `docker rm -f discord && docker rm -f ollama` to remove the containers.
+        * `docker rm -f CONTAINER_ID` do for both containers if naming issues arise.
+    * `docker network rm ollama-net` removes the network.
+        * `docker network prune` will also work so long as the network is unused.
+* Remove Image:
+    * If you need to remove the image run `docker image rm IMAGE_ID`. You can get the image id by running `docker images`.
--- a/docs/setup-local.md
+++ b/docs/setup-local.md
@@ -0,0 +1,19 @@
+## Ollama Setup
+* Go to Ollama's [Linux download page](https://ollama.ai/download/linux) and run the simple curl command they provide. The command should be `curl https://ollama.ai/install.sh | sh`.
+* Now the the following commands in separate terminals to test out how it works!
+    * In terminal 1 -> `ollama serve` to setup ollama
+    * In terminal 2 -> `ollama run [model name]`, for example `ollama run llama2`
+        * The models can vary as you can create your own model. You can also view ollama's [library](https://ollama.ai/library) of models.
+    * If there are any issues running ollama because of missing LLMs, run `ollama pull [model name]` as it will pull the model if Ollama has it in their library.
+    * This can also be done in [wsl](https://learn.microsoft.com/en-us/windows/wsl/install) for Windows machines.
+* You can now interact with the model you just ran (it might take a second to startup).
+    * Response time varies with processing power!
+
+## To Run Locally (without Docker)
+* Run `npm install` to install the npm packages.
+* Ensure that your [.env](../.env.sample) file's `OLLAMA_IP` is `127.0.0.1` to work properly.
+* Now, you can run the bot by running `npm run client` which will build and run the decompiled typescript and run the setup for ollama.
+    * **IMPORTANT**: This must be ran in the wsl/Linux instance to work properly! Using Command Prompt/Powershell/Git Bash/etc. will not work on Windows (at least in my experience).
+    * Refer to the [resources](../README.md#resources) on what node version to use.
+* Open up a separate terminal/shell (you will need wsl for this if on windows) and run `ollama serve` to startup ollama.
+    * If you do not have a model, you will need to run `ollama pull [model name]` in a separate terminal to get it.
--- a/imgs/discord-icon.png
+++ b/imgs/discord-icon.png
--- a/imgs/grey-plus.png
+++ b/imgs/grey-plus.png
--- a/imgs/ollama-icon.png
+++ b/imgs/ollama-icon.png
--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@@ -1,26 +1,33 @@
 {
  "name": "discord-ollama",
-  "version": "0.1.2",
+  "version": "0.4.0",
  "description": "Ollama Integration into discord",
-  "main": "dist/index.js",
-  "exports": "./dist/index.js",
+  "main": "build/index.js",
+  "exports": "./build/index.js",
  "scripts": {
    "dev-tsx": "tsx watch src/index.ts",
    "dev-mon": "nodemon --config nodemon.json src/index.ts",
    "build": "tsc",
    "prod": "node .",
    "client": "npm run build && npm run prod",
-    "API": "ollama serve",
-    "start": "concurrently \"npm:API\" \"npm:client\""
+    "clean": "docker compose down && docker rmi $(docker images | grep $(node -p \"require('./package.json').version\") | tr -s ' ' | cut -d ' ' -f 3) && docker rmi $(docker images --filter \"dangling=true\" -q --no-trunc)",
+    "start": "docker compose build --no-cache && docker compose up -d",
+    "docker:start": "npm run docker:network && npm run docker:build && npm run docker:client && npm run docker:ollama",
+    "docker:start-cpu": "npm run docker:network && npm run docker:build && npm run docker:client && npm run docker:ollama-cpu",
+    "docker:clean": "docker rmi $(docker images --filter \"dangling=true\" -q --no-trunc)",
+    "docker:network": "docker network create --subnet=172.18.0.0/16 ollama-net",
+    "docker:build": "docker build --no-cache -t discord/bot:$(node -p \"require('./package.json').version\") .",
+    "docker:client": "docker run -d -v discord:/src/app --name discord --network ollama-net --ip 172.18.0.3 discord/bot:$(node -p \"require('./package.json').version\")",
+    "docker:ollama": "docker run -d --gpus=all -v ollama:/root/.ollama -p 11434:11434 --name ollama --network ollama-net --ip 172.18.0.2 ollama/ollama:latest",
+    "docker:ollama-cpu": "docker run -d -v ollama:/root/.ollama -p 11434:11434 --name ollama --network ollama-net --ip 172.18.0.2 ollama/ollama:latest"
  },
  "author": "Kevin Dang",
  "license": "ISC",
  "dependencies": {
    "axios": "^1.6.2",
-    "concurrently": "^8.2.2",
    "discord.js": "^14.14.1",
    "dotenv": "^16.3.1",
-    "ollama": "^0.4.3"
+    "ollama": "^0.5.0"
  },
  "devDependencies": {
    "@types/node": "^20.10.5",
--- a/src/client.ts
+++ b/src/client.ts
@@ -1,10 +1,14 @@
-import { Client, GatewayIntentBits } from "discord.js";
-import { registerEvents } from "./utils/events.js";
-import Events from "./events/index.js";
+import { Client, GatewayIntentBits } from 'discord.js'
+import { UserMessage, registerEvents } from './utils/events.js'
+import Events from './events/index.js'
+import { Ollama } from 'ollama'
+import { Queue } from './queues/queue.js'

 // Import keys/tokens
-import Keys from "./keys.js";
+import Keys from './keys.js'

+
+// initialize the client with the following permissions when logging in
 const client = new Client({
    intents: [
        GatewayIntentBits.Guilds,
@@ -14,18 +18,32 @@ const client = new Client({
    ]
 });

-const messageHistory = [
-    {
-        role: 'assistant',
-        content: 'My name is Ollama GU.'
-    }
-]
+// initialize connection to ollama container
+const ollama = new Ollama({
+    host: `http://${Keys.ipAddress}:${Keys.portAddress}`,
+})

-registerEvents(client, Events, messageHistory)
+// Create Queue managed by Events
+const messageHistory: Queue<UserMessage> = new Queue<UserMessage>
+
+/**
+ * register events for bot to listen to in discord
+ * @param messageHistory message history for the llm
+ * @param Events events to register
+ * @param client the bot reference
+ * @param Keys tokens from .env files
+ */
+registerEvents(client, Events, messageHistory, Keys, ollama)

 // Try to log in the client
-client.login(Keys.clientToken)
-    .catch((error) => {
-        console.error('[Login Error]', error);
-        process.exit(1);
-    });
+await client.login(Keys.clientToken)
+.catch((error) => {
+    console.error('[Login Error]', error)
+    process.exit(1)
+})
+
+// queue up bots name
+messageHistory.enqueue({
+    role: 'assistant',
+    content: `My name is ${client.user?.username}`
+})
--- a/src/commands/capacity.ts
+++ b/src/commands/capacity.ts
@@ -0,0 +1,33 @@
+import { ChannelType, Client, CommandInteraction, ApplicationCommandOptionType } from 'discord.js'
+import { SlashCommand } from '../utils/commands.js'
+import { openFile } from '../utils/jsonHandler.js'
+
+export const Capacity: SlashCommand = {
+    name: 'modify-capacity',
+    description: 'number of messages bot will hold for context.',
+
+    // set available user options to pass to the command
+    options: [
+        {
+            name: 'context-capacity',
+            description: 'a number to set capacity',
+            type: ApplicationCommandOptionType.Number,
+            required: true
+        }
+    ],
+
+    // Query for message information and set the style
+    run: async (client: Client, interaction: CommandInteraction) => {
+        // fetch channel and message
+        const channel = await client.channels.fetch(interaction.channelId)
+        if (!channel || channel.type !== ChannelType.GuildText) return
+
+        // set state of bot chat features
+        openFile('config.json', interaction.commandName, interaction.options.get('context-capacity')?.value)
+
+        interaction.reply({
+            content: `Message History Capacity has been set to \`${interaction.options.get('context-capacity')?.value}\``,
+            ephemeral: true
+        })
+    }
+}
--- a/src/commands/disable.ts
+++ b/src/commands/disable.ts
@@ -0,0 +1,33 @@
+import { ChannelType, Client, CommandInteraction, ApplicationCommandOptionType } from 'discord.js'
+import { SlashCommand } from '../utils/commands.js'
+import { openFile } from '../utils/jsonHandler.js'
+
+export const Disable: SlashCommand = {
+    name: 'toggle-chat',
+    description: 'toggle all chat features, slash commands will still work.',
+
+    // set available user options to pass to the command
+    options: [
+        {
+            name: 'enabled',
+            description: 'true = enabled, false = disabled',
+            type: ApplicationCommandOptionType.Boolean,
+            required: true
+        }
+    ],
+
+    // Query for message information and set the style
+    run: async (client: Client, interaction: CommandInteraction) => {
+        // fetch channel and message
+        const channel = await client.channels.fetch(interaction.channelId)
+        if (!channel || channel.type !== ChannelType.GuildText) return
+
+        // set state of bot chat features
+        openFile('config.json', interaction.commandName, interaction.options.get('enabled')?.value)
+
+        interaction.reply({
+            content: `Chat features has been \`${interaction.options.get('enabled')?.value ?  "enabled" : "disabled" }\``,
+            ephemeral: true
+        })
+    }
+}
--- a/src/commands/index.ts
+++ b/src/commands/index.ts
@@ -0,0 +1,16 @@
+import { SlashCommand } from '../utils/commands.js'
+import { ThreadCreate } from './threadCreate.js'
+import { MessageStyle } from './messageStyle.js'
+import { MessageStream } from './messageStream.js'
+import { Disable } from './disable.js'
+import { Shutoff } from './shutoff.js'
+import { Capacity } from './capacity.js'
+
+export default [
+    ThreadCreate,
+    MessageStyle,
+    MessageStream,
+    Disable,
+    Shutoff,
+    Capacity
+] as SlashCommand[]
--- a/src/commands/messageStream.ts
+++ b/src/commands/messageStream.ts
@@ -0,0 +1,33 @@
+import { ApplicationCommandOptionType, ChannelType, Client, CommandInteraction } from 'discord.js'
+import { SlashCommand } from '../utils/commands.js'
+import { openFile } from '../utils/jsonHandler.js'
+
+export const MessageStream: SlashCommand = {
+    name: 'message-stream',
+    description: 'change preference on message streaming from ollama. WARNING: can be very slow.',
+
+    // user option(s) for setting stream
+    options: [
+        {
+            name: 'stream',
+            description: 'enable or disable stream preference',
+            type: ApplicationCommandOptionType.Boolean,
+            required: true
+        }
+    ],
+
+    // change preferences based on command
+    run: async (client: Client, interaction: CommandInteraction) => {
+        // verify channel
+        const channel = await client.channels.fetch(interaction.channelId)
+        if (!channel || channel.type !== ChannelType.GuildText) return
+
+        // save value to json and write to it
+        openFile('config.json', interaction.commandName, interaction.options.get('stream')?.value)
+
+        interaction.reply({
+            content: `Message streaming preferences for embed set to: \`${interaction.options.get('stream')?.value}\``,
+            ephemeral: true
+        })
+    }
+}
--- a/src/commands/messageStyle.ts
+++ b/src/commands/messageStyle.ts
@@ -0,0 +1,33 @@
+import { ChannelType, Client, CommandInteraction, ApplicationCommandOptionType } from 'discord.js'
+import { SlashCommand } from '../utils/commands.js'
+import { openFile } from '../utils/jsonHandler.js'
+
+export const MessageStyle: SlashCommand = {
+    name: 'message-style',
+    description: 'sets the message style to embed or normal',
+
+    // set available user options to pass to the command
+    options: [
+        {
+            name: 'embed',
+            description: 'toggle embedded or normal message',
+            type: ApplicationCommandOptionType.Boolean,
+            required: true
+        }
+    ],
+
+    // Query for message information and set the style
+    run: async (client: Client, interaction: CommandInteraction) => {
+        // fetch channel and message
+        const channel = await client.channels.fetch(interaction.channelId)
+        if (!channel || channel.type !== ChannelType.GuildText) return
+
+        // set the message style
+        openFile('config.json', interaction.commandName, interaction.options.get('embed')?.value)
+
+        interaction.reply({
+            content: `Message style preferences for embed set to: \`${interaction.options.get('embed')?.value}\``,
+            ephemeral: true
+        })
+    }
+}
--- a/src/commands/shutoff.ts
+++ b/src/commands/shutoff.ts
@@ -0,0 +1,54 @@
+import { ChannelType, Client, CommandInteraction, ApplicationCommandOptionType } from 'discord.js'
+import { SlashCommand } from '../utils/commands.js'
+import Keys from '../keys.js'
+
+export const Shutoff: SlashCommand = {
+    name: 'shutoff',
+    description: 'shutdown the bot. You will need to manually bring it online again.',
+
+    // set available user options to pass to the command
+    options: [
+        {
+            name: 'are-you-sure',
+            description: 'true = yes, false = I\'m scared',
+            type: ApplicationCommandOptionType.Boolean,
+            required: true
+        }
+    ],
+
+    // Query for message information and set the style
+    run: async (client: Client, interaction: CommandInteraction) => {
+        // fetch channel and message
+        const channel = await client.channels.fetch(interaction.channelId)
+        if (!channel || channel.type !== ChannelType.GuildText) return
+
+        // log this, this will probably be improtant for logging who did this
+        console.log(`User -> ${interaction.user.tag} attempting to shutdown ${client.user!!.tag}`)
+
+        // create list of superUsers based on string parse
+        const superUsers: string[] = JSON.parse(Keys.superUser.replace(/'/g, '"'))
+
+        // check if admin or false on shutdown
+        if (interaction.user.tag !in superUsers) {
+            interaction.reply({
+                content: `Shutdown failed:\n\n${interaction.user.tag}, You do not have permission to shutoff **${client.user?.tag}**.`,
+                ephemeral: true
+            })
+            return // stop from shutting down
+        } else if (!interaction.options.get('are-you-sure')?.value) {
+            interaction.reply({
+                content: `Shutdown failed:\n\n${interaction.user.tag}, You didn't want to shutoff **${client.user?.tag}**.`,
+                ephemeral: true
+            })
+            return
+        }
+
+        interaction.reply({
+            content: `${client.user?.tag} is ${interaction.options.get('are-you-sure')?.value ?  "shutting down now." : "not shutting down." }`,
+            ephemeral: true
+        })
+
+        // clean up client instance and stop
+        client.destroy()
+    }
+}
--- a/src/commands/threadCreate.ts
+++ b/src/commands/threadCreate.ts
@@ -0,0 +1,28 @@
+import { ChannelType, Client, CommandInteraction, TextChannel } from 'discord.js'
+import { SlashCommand } from '../utils/commands.js'
+
+export const ThreadCreate: SlashCommand = {
+    name: 'thread',
+    description: 'creates a thread and mentions user',
+
+    // Query for server information
+    run: async (client: Client, interaction: CommandInteraction) => {
+        // fetch the channel
+        const channel = await client.channels.fetch(interaction.channelId)
+        if (!channel || channel.type !== ChannelType.GuildText) return
+
+        const thread = await (channel as TextChannel).threads.create({
+            name: `support-${Date.now()}`,
+            reason: `Support ticket ${Date.now()}`
+        })
+
+        // Send a message in the thread
+        thread.send(`**User:** ${interaction.user} \n**People in Coversation:** ${thread.memberCount}`)
+
+        // user only reply
+        return interaction.reply({
+            content: `I can help you in the Thread below. \n**Thread ID:** ${thread.id}`,
+            ephemeral: true
+        })
+    }
+}
--- a/src/events/index.ts
+++ b/src/events/index.ts
@@ -1,9 +1,11 @@
 import { Event } from '../utils/index.js'
+import interactionCreate from './interactionCreate.js'
 import messageCreate from './messageCreate.js'
 import ready from './ready.js'

 // Centralized export for all events
 export default [
    ready,
-    messageCreate
+    messageCreate,
+    interactionCreate
 ] as Event[] // staticly is better ts practice, dynamic exporting is possible
--- a/src/events/interactionCreate.ts
+++ b/src/events/interactionCreate.ts
@@ -0,0 +1,19 @@
+import { event, Events } from '../utils/index.js'
+import commands from '../commands/index.js'
+
+/**
+ * Interaction creation listener for the client
+ * @param interaction the interaction received from the server
+ */
+export default event(Events.InteractionCreate, async ({ log, client }, interaction) => {
+    if (!interaction.isCommand() || !interaction.isChatInputCommand()) return
+    
+    log(`Interaction called \'${interaction.commandName}\' from ${interaction.user.tag}.`)
+
+    // ensure command exists, otherwise kill event
+    const command = commands.find(command => command.name === interaction.commandName)
+    if (!command) return
+
+    // the command exists, execute it
+    command.run(client, interaction)
+})
--- a/src/events/messageCreate.ts
+++ b/src/events/messageCreate.ts
@@ -1,90 +1,85 @@
-import { event, Events } from '../utils/index.js'
-import { EmbedBuilder } from 'discord.js'
-import ollama from 'ollama'
-import Axios from 'axios'
+import { ChatResponse } from 'ollama'
+import { embedMessage, event, Events, normalMessage } from '../utils/index.js'
+import { Configuration, getConfig, openFile } from '../utils/jsonHandler.js'
+import { clean } from '../utils/mentionClean.js'

 /** 
 * Max Message length for free users is 2000 characters (bot or not).
 * @param message the message received from the channel
 */
-export default event(Events.MessageCreate, async ({ log, msgHist }, message) => {
-    log(`Message created \"${message.content}\" from ${message.author.tag}.`)
+export default event(Events.MessageCreate, async ({ log, msgHist, tokens, ollama }, message) => {
+    log(`Message \"${clean(message.content)}\" from ${message.author.tag} in channel/thread ${message.channelId}.`)

    // Hard-coded channel to test output there only, in our case "ollama-endpoint"
-    if (message.channelId != '1188262786497785896') return
+    if (message.channelId != tokens.channel) return

    // Do not respond if bot talks in the chat
    if (message.author.tag === message.client.user.tag) return

-    // push user response
-    msgHist.push({
-        role: 'user',
-        content: message.content
-    })
+    // Only respond if message mentions the bot
+    if (!message.mentions.has(tokens.clientUid)) return

-    const botMessage = new EmbedBuilder()
-    .setTitle(`Response to ${message.author.tag}`)
-    .setDescription('Generating Response . . .')
-    .setColor('#00FF00')
+    // Try to query and send embed     
+    try {
+        const config: Configuration = await new Promise((resolve, reject) => {
+            getConfig('config.json', (config) => {
+                // check if config.json exists
+                if (config === undefined) {
+                    reject(new Error('No Configuration is set up.\n\nCreating \`config.json\` with \`message-style\` set as \`false\` for regular messages.\nPlease try chatting again.'))
+                    return
+                }

-    const sentMessage = await message.channel.send({ embeds: [botMessage] })
+                // check if chat is disabled
+                if (!config.options['toggle-chat']) {
+                    reject(new Error('Admin(s) have disabled chat features.\n\n Please contact your server\'s admin(s).'))
+                    return
+                }

-    const request = async () => {
-        try {
-            // change this when using an actual hosted server or use ollama.js
-            const response = await ollama.chat({
-                model: 'llama2',
-                messages: msgHist,
-                stream: false
+                // check if there is a set capacity in config
+                if (typeof config.options['modify-capacity'] !== 'number')
+                    log(`Capacity is undefined, using default capacity of ${msgHist.capacity}.`)
+                else if (config.options['modify-capacity'] === msgHist.capacity)
+                    log(`Capacity matches config as ${msgHist.capacity}, no changes made.`)
+                else {
+                    log(`New Capacity found. Setting Context Capacity to ${config.options['modify-capacity']}.`)
+                    msgHist.capacity = config.options['modify-capacity']
+                }
+
+                resolve(config)
            })
+        })

-            const embed = new EmbedBuilder()
-                .setTitle(`Response to ${message.author.tag}`)
-                .setDescription(response.message.content)
-                .setColor('#00FF00')
+        let response: ChatResponse    

-            sentMessage.edit({ embeds: [embed] })
+        // check if we can push, if not, remove oldest
+        while (msgHist.size() >= msgHist.capacity) msgHist.dequeue()

-            // push bot response
-            msgHist.push({
-                role: 'assistant',
-                content: response.message.content
-            })
-        } catch (error) {
-            message.edit(error as string)
-            log(error)
-        }
-    }        
+        // push user response before ollama query
+        msgHist.enqueue({
+            role: 'user',
+            content: clean(message.content)
+        })
+        
+        // undefined or false, use normal, otherwise use embed
+        if (config.options['message-style'])
+            response = await embedMessage(message, ollama, tokens, msgHist)
+        else
+            response = await normalMessage(message, ollama, tokens, msgHist)

-    // Attempt to call ollama's endpoint
-    request()
+        // If something bad happened, remove user query and stop
+        if (response == undefined) { msgHist.pop(); return }

-    // Reply with something to prompt that ollama is working, version without embed
-    message.reply("Generating Response . . .").then(sentMessage => {
-        // Request made to API
-        const request = async () => {
-            try {
-                // change this when using an actual hosted server or use ollama.js
-                const response = await Axios.post('http://127.0.0.1:11434/api/chat', {
-                    model: 'llama2',
-                    messages: msgHist,
-                    stream: false
-                })
-    
-                sentMessage.edit(response.data.message.content)
+        // if queue is full, remove the oldest message
+        while (msgHist.size() >= msgHist.capacity) msgHist.dequeue()

-                // push bot response
-                // msgHist.push({
-                //     role: 'assistant',
-                //     content: response.data.message.content
-                // })
-            } catch (error) {
-                message.edit(error as string)
-                log(error)
-            }
-        }        
-
-        // Attempt to call ollama's endpoint
-        request()
-    })
+        // successful query, save it in context history
+        msgHist.enqueue({ 
+            role: 'assistant', 
+            content: response.message.content 
+        })
+    } catch (error: any) {
+        msgHist.pop() // remove message because of failure
+        openFile('config.json', 'message-style', false)
+        message.reply(`**Error Occurred:**\n\n**Reason:** *${error.message}*`)
+    }
 })
--- a/src/events/ready.ts
+++ b/src/events/ready.ts
@@ -1,6 +1,17 @@
-import { event, Events } from '../utils/index.js'
+import { event, Events, registerCommands } from '../utils/index.js'
+import { ActivityType } from 'discord.js'
+import commands from '../commands/index.js'

 // Log when the bot successfully logs in and export it
 export default event(Events.ClientReady, ({ log }, client) => {
-    return log(`Logged in as ${client.user.username}.`)
+    // Register the commands associated with the bot upon loggin in
+    registerCommands(client, commands)
+
+    // set status of the bot
+    client.user.setActivity({
+        name: 'Powered by Ollama',
+        type: ActivityType.Custom
+    })
+
+    log(`Logged in as ${client.user.username}.`)
 })
--- a/src/keys.ts
+++ b/src/keys.ts
@@ -1,7 +1,14 @@
-import { getEnvVar } from "./utils/env.js"
+import { getEnvVar } from './utils/env.js'

 export const Keys = {
-    clientToken: getEnvVar('CLIENT_TOKEN')
+    clientToken: getEnvVar('CLIENT_TOKEN'),
+    channel: getEnvVar('CHANNEL_ID'),
+    model: getEnvVar('MODEL'),
+    clientUid: getEnvVar('CLIENT_UID'),
+    guildId: getEnvVar('GUILD_ID'),
+    ipAddress: getEnvVar('OLLAMA_IP'),
+    portAddress: getEnvVar('OLLAMA_PORT'),
+    superUser: getEnvVar('ADMINS')
 } as const // readonly keys

 export default Keys
--- a/src/queues/queue.ts
+++ b/src/queues/queue.ts
@@ -0,0 +1,62 @@
+// Queue interfaces for any queue class to follow
+interface IQueue<T> {
+    enqueue(item: T): void
+    dequeue(): T | undefined
+    size(): number
+}
+
+/**
+ * Queue for UserMessages
+ *      When the limit for messages is met, we want to clear
+ *      out the oldest message in the queue
+ */
+export class Queue<T> implements IQueue<T> {
+    private storage: T[] = []
+
+    /**
+     * Set up Queue
+     * @param capacity max length of queue
+     */
+    constructor(public capacity: number = 5) {}
+
+    /**
+     * Put item in front of queue
+     * @param item object of type T to add into queue
+     */
+    enqueue(item: T): void {
+        if (this.size() === this.capacity)
+            throw Error('Queue has reached max capacity, you cannot add more items.')
+        this.storage.push(item)
+    }
+
+    /**
+     * Remove item at end of queue
+     * @returns object of type T in queue
+     */
+    dequeue(): T | undefined {
+        return this.storage.shift()
+    }
+
+    /**
+     * Size of the queue
+     * @returns length of queue as a int/number
+     */
+    size(): number {
+        return this.storage.length
+    }
+
+    /**
+     * Remove the front of the queue, typically for errors
+     */
+    pop(): void {
+        this.storage.pop()
+    }
+
+    /**
+     * Geet the queue as an array
+     * @returns a array of T items
+     */
+    getItems(): T[] {
+        return this.storage
+    }
+}
--- a/src/utils/commands.ts
+++ b/src/utils/commands.ts
@@ -0,0 +1,47 @@
+import { CommandInteraction, ChatInputApplicationCommandData, Client, ApplicationCommandOption } from 'discord.js'
+
+/**
+ * interface for how slash commands should be run
+ */
+export interface SlashCommand extends ChatInputApplicationCommandData {
+    run: (
+        client: Client,
+        interaction: CommandInteraction,
+        options?: ApplicationCommandOption[]
+    ) => void
+}
+
+/**
+ * register the command to discord for the channel
+ * @param client the bot reference
+ * @param commands commands to register to the bot
+ */
+export function registerCommands(client: Client, commands: SlashCommand[]): void {
+    // ensure the bot is online before registering
+    if (!client.application) return
+
+    // map commands into an array of names, used to checking registered commands
+    const commandsToRegister: string[] = commands.map(command => command.name)
+
+    // fetch all the commands and delete them
+    client.application.commands.fetch().then((fetchedCommands) => {
+        for (const command of fetchedCommands.values()) {
+            if (!commandsToRegister.includes(command.name)) {
+                command.delete().catch(console.error)
+                console.log(`[Command: ${command.name}] Removed from Discord`)
+            }
+        }
+    })
+
+    // clear the cache of the commands
+    client.application.commands.cache.clear()
+
+    // iterate through all commands and register them with the bot
+    for (const command of commands)
+        client.application.commands
+            .create(command)
+            .then((c) => {
+                console.log(`[Command: ${c.name}] Registered on Discord`)
+                c.options?.forEach((o) => console.log(`  - ${o.name}`))
+            })
+}
--- a/src/utils/env.ts
+++ b/src/utils/env.ts
@@ -1,8 +1,8 @@
-import { resolve } from "path"
-import { config } from "dotenv"
+import { resolve } from 'path'
+import { config } from 'dotenv'

 // Find config - ONLY WORKS WITH NODEMON
-const envFile = process.env.NODE_ENV === "development" ? ".env.dev.local" : ".env"
+const envFile = process.env.NODE_ENV === 'development' ? '.env.dev.local' : '.env'

 // resolve config file
 const envFilePath = resolve(process.cwd(), envFile)
--- a/src/utils/events.ts
+++ b/src/utils/events.ts
@@ -1,4 +1,6 @@
-import type { ClientEvents, Awaitable, Client } from 'discord.js'
+import type { ClientEvents, Awaitable, Client, User } from 'discord.js'
+import { Ollama } from 'ollama'
+import { Queue } from '../queues/queue.js'

 // Export events through here to reduce amount of imports
 export { Events } from 'discord.js'
@@ -6,11 +8,35 @@ export { Events } from 'discord.js'
 export type LogMethod = (...args: unknown[]) => void
 export type EventKeys = keyof ClientEvents // only wants keys of ClientEvents object

+/**
+ * Tokens to run the bot as intended
+ * @param channel the channel where the bot will respond to queries
+ * @param model chosen model for the ollama to utilize
+ * @param clientUid the discord id for the bot
+ */
+export type Tokens = {
+    channel: string,
+    model: string,
+    clientUid: string
+}
+
+/** 
+ * Format for the messages to be stored when communicating when the bot
+ * @param role either assistant, user, or system
+ * @param content string of the message the user or assistant provided
+ */
+export type UserMessage = {
+    role: string,
+    content: string
+}
+
 // Event properties
 export interface EventProps {
    client: Client
    log: LogMethod
-    msgHist: { role: string, content: string }[]
+    msgHist: Queue<UserMessage>
+    tokens: Tokens,
+    ollama: Ollama
 }
 export type EventCallback<T extends EventKeys> = (
    props: EventProps,
@@ -27,7 +53,21 @@ export function event<T extends EventKeys>(key: T, callback: EventCallback<T>):
    return { key, callback }
 }

-export function registerEvents(client: Client, events: Event[], msgHist: { role: string, content: string }[]): void {
+/**
+ * Method to register events to the bot per file in the events directory
+ * @param client initialized bot client
+ * @param events all the exported events from the index.ts in the events dir
+ * @param msgHist The message history of the bot
+ * @param tokens the passed in environment tokens for the service
+ * @param ollama the initialized ollama instance
+ */
+export function registerEvents(
+    client: Client, 
+    events: Event[], 
+    msgHist: Queue<UserMessage>,
+    tokens: Tokens,
+    ollama: Ollama
+): void {
    for (const { key, callback } of events) {
        client.on(key, (...args) => {
            // Create a new log method for this event
@@ -35,7 +75,7 @@ export function registerEvents(client: Client, events: Event[], msgHist: { role:

            // Handle Errors, call callback, log errors as needed
            try {
-                callback({ client, log, msgHist }, ...args)
+                callback({ client, log, msgHist, tokens, ollama }, ...args)
            } catch (error) {
                log('[Uncaught Error]', error)
            }
--- a/src/utils/index.ts
+++ b/src/utils/index.ts
@@ -1,3 +1,6 @@
 // Centralized import index
-export * from './env.js';
-export * from './events.js';
+export * from './env.js'
+export * from './events.js'
+export * from './messageEmbed.js'
+export * from './messageNormal.js'
+export * from './commands.js'
--- a/src/utils/jsonHandler.ts
+++ b/src/utils/jsonHandler.ts
@@ -0,0 +1,58 @@
+import fs from 'fs'
+
+export interface Configuration {
+    readonly name: string
+    options: {
+        'message-stream'?: boolean,
+        'message-style'?: boolean,
+        'toggle-chat'?: boolean,
+        'modify-capacity'?: number
+    }
+}
+
+/**
+ * Method to open a file in the working directory and modify/create it
+ * 
+ * @param filename name of the file
+ * @param key key value to access
+ * @param value new value to assign
+ */
+export function openFile(filename: string, key: string, value: any) {
+    // check if the file exists, if not then make the config file
+    if (fs.existsSync(filename)) {
+        fs.readFile(filename, 'utf8', (error, data) => {
+            if (error)
+                console.log(`[Error: openFile] Incorrect file format`)
+            else {
+                const object = JSON.parse(data)
+                object['options'][key] = value
+                fs.writeFileSync(filename, JSON.stringify(object, null, 2))
+            }
+        })
+    } else {
+        const object: Configuration = JSON.parse('{ \"name\": \"Discord Ollama Confirgurations\" }')
+
+        // set standard information for config file and options
+        object['options'] = {
+            [key]: value
+        }
+
+        fs.writeFileSync(filename, JSON.stringify(object, null, 2))
+        console.log(`[Util: openFile] Created 'config.json' in working directory`)
+    }
+}
+
+export async function getConfig(filename: string, callback: (config: Configuration | undefined) => void): Promise<void> {
+    // attempt to read the file and get the configuration
+    if (fs.existsSync(filename)) {
+        fs.readFile(filename, 'utf8', (error, data) => {
+            if (error) {
+                callback(undefined) 
+                return // something went wrong... stop
+            }
+            callback(JSON.parse(data))
+        })
+    } else {
+        callback(undefined) // file not found
+    }
+}
--- a/src/utils/mentionClean.ts
+++ b/src/utils/mentionClean.ts
@@ -0,0 +1,16 @@
+import Keys from "../keys.js"
+
+/**
+ * Clean up the bot user_id so it only has the prompt
+ * 
+ * Sample: <@CLIENT_ID> Hello
+ *  - we want to remove <@CLIENT_ID>
+ *  - replace function works well for this
+ * 
+ * @param message 
+ * @returns 
+ */
+export function clean(message: string): string {
+    const cleanedMessage: string = message.replace(`<@${Keys.clientUid}>`, '').trim()
+    return cleanedMessage
+}
--- a/src/utils/messageEmbed.ts
+++ b/src/utils/messageEmbed.ts
@@ -0,0 +1,68 @@
+import { EmbedBuilder, Message } from 'discord.js'
+import { ChatResponse, Ollama } from 'ollama'
+import { UserMessage } from './events.js'
+import { Queue } from '../queues/queue.js'
+
+/**
+ * Method to send replies as normal text on discord like any other user
+ * @param message message sent by the user
+ * @param tokens tokens to run query
+ * @param msgHist message history between user and model
+ */
+export async function embedMessage(
+    message: Message,
+    ollama: Ollama,
+    tokens: {
+        channel: string,
+        model: string
+    },
+    msgHist: Queue<UserMessage>
+) {
+    // bot response
+    let response: ChatResponse
+
+    // initial message to client
+    const botMessage = new EmbedBuilder()
+    .setTitle(`Responding to ${message.author.tag}`)
+    .setDescription('Generating Response . . .')
+    .setColor('#00FF00')
+
+    // send the message
+    const sentMessage = await message.channel.send({ embeds: [botMessage] })
+
+    try {
+        // Attempt to query model for message
+        response = await ollama.chat({
+            model: tokens.model,
+            messages: msgHist.getItems(),
+            options: {
+                num_thread: 8, // remove if optimization needed further
+                mirostat: 1,
+                mirostat_tau: 2.0,
+                top_k: 70
+            },
+            stream: false
+        })
+
+        // dummy message to let user know that query is underway
+        const newEmbed = new EmbedBuilder()
+            .setTitle(`Responding to ${message.author.tag}`)
+            .setDescription(response.message.content || 'No Content to Provide...')
+            .setColor('#00FF00')
+
+        // edit the message
+        sentMessage.edit({ embeds: [newEmbed] })
+    } catch(error: any) {
+        console.log(`[Util: messageEmbed] Error creating message: ${error.message}`)
+        const errorEmbed = new EmbedBuilder()
+            .setTitle(`Responding to ${message.author.tag}`)
+            .setDescription(`**Response generation failed.**\n\nReason: ${error.message}`)
+            .setColor('#00FF00')
+        
+        // send back error
+        sentMessage.edit({ embeds: [errorEmbed] })
+    } 
+
+    // Hope there is a response! undefined otherwie
+    return response!!
+}
--- a/src/utils/messageNormal.ts
+++ b/src/utils/messageNormal.ts
@@ -0,0 +1,53 @@
+import { Message } from 'discord.js'
+import { ChatResponse, Ollama } from 'ollama'
+import { UserMessage } from './events.js'
+import { Queue } from '../queues/queue.js'
+
+/**
+ * Method to send replies as normal text on discord like any other user
+ * @param message message sent by the user
+ * @param tokens tokens to run query
+ * @param msgHist message history between user and model
+ */
+export async function normalMessage(
+    message: Message,
+    ollama: Ollama,
+    tokens: {
+        channel: string,
+        model: string
+    },
+    msgHist: Queue<UserMessage>
+) {
+    // bot's respnse
+    let response: ChatResponse
+
+    await message.channel.send('Generating Response . . .').then(async sentMessage => {
+        try {
+            // Attempt to query model for message
+            response = await ollama.chat({
+                model: tokens.model,
+                messages: msgHist.getItems(),
+                options: {
+                    num_thread: 8, // remove if optimization needed further
+                    mirostat: 1,
+                    mirostat_tau: 2.0,
+                    top_k: 70
+                },
+                stream: false
+            })
+
+            // check if message length > discord max for normal messages
+            if (response.message.content.length > 2000) {
+                sentMessage.edit(response.message.content.slice(0, 2000))
+                message.channel.send(response.message.content.slice(2000))
+            } else // edit the 'generic' response to new message
+                sentMessage.edit(response.message.content)            
+        } catch(error: any) {
+            console.log(`[Util: messageNormal] Error creating message: ${error.message}`)
+            sentMessage.edit(`**Response generation failed.**\n\nReason: ${error.message}`)
+        }
+    })
+
+    // Hope there is a response, force client to believe
+    return response!!
+}
--- a/src/utils/streamParse.ts
+++ b/src/utils/streamParse.ts
@@ -1,7 +1,11 @@
-import { AxiosResponse } from "axios";
+import { AxiosResponse } from 'axios'

 /**
 * When running a /api/chat stream, the output needs to be parsed into an array of objects
+ *  This method is used for development purposes and testing
+ * 
+ * This will not work as intended with the inclusion of ollama-js, needs to be modified to work with it
+ * 
 * @param stream Axios response to from Ollama
 */
 export function parseStream(stream: AxiosResponse<any, any>) {
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -14,7 +14,8 @@
    // We can import json files like JavaScript
    "resolveJsonModule": true,
    // Decompile .ts to .js into a folder named dist
-    "outDir": "dist"
+    "outDir": "build",
+    "rootDir": "src"
  },
  // environment for env vars
  "include": ["src/**/*"],
Author	SHA1	Message	Date
Kevin Dang	bc989580a9	Fix Capacity Command (#49 ) * fix: capacity while replace if * fix: command name in config	2024-04-20 10:03:22 -07:00
Kevin Dang	477567b05d	Remove Bot User ID from Prompt (#48 )	2024-04-20 10:01:42 -07:00
Kevin Dang	6a1d66fd36	fix: updated ollama icon (#46 )	2024-04-13 21:34:55 -07:00
Kevin Dang	ca865b322e	Dependency Updates (#44 ) * update: newer ollama icon * update: ollama-js dependency * update: other updated dependencies	2024-04-13 19:59:57 -07:00
Kevin Dang	615ee2029b	Change of License (#41 ) * update: license * update: CC by 4.0	2024-04-13 19:07:49 -07:00
Kevin Dang	da1f08a070	Message Blocks for Normal Message Style (#37 ) * add: if check for message length * update: version increment * update: readme	2024-04-07 16:09:27 -07:00
Kevin Dang	2bdc7b8583	Capacity Context Modify Command (#35 ) * add: modify capacity command * update: version increment	2024-04-03 15:22:34 -07:00
Kevin Dang	727731695e	Chat Queue Persistence (#33 ) * fix: workflow env * update: center title on readme * update: readme goals and format * add: icons in readme * fix: plus margin * update: environment variables in contr. * add: queue for chat history * add: set -e for workflow failure * update: version increment * fix: client null info * fix: shutoff issues	2024-04-02 22:04:09 -07:00
Kevin Dang	5f8b513269	Workflows Fix (#32 ) * fix: workflows missing new env	2024-04-01 00:51:07 -07:00
Kevin Dang	fcb0267559	Shutoff Bot Command (#30 ) * add: disable chat command * update: workflow name * add: shutoff using admin env list * update: sample env for admins * fix: shutdown booleans * update: version increment	2024-04-01 00:43:19 -07:00
Kevin Dang	6b903cff5e	Auto-Generate Config (#29 ) * fix: name in job * add: auto create config.json on missing * update: readme goals * add: clarify instructions on fail chat * update: reduced redundancy in package file	2024-03-30 22:02:49 -07:00
Kevin Dang	9320a7476e	CI for Application Builds (#27 )	2024-03-29 23:33:03 -07:00
Kevin Dang	1b70fc2787	Nvidia Container Toolkit Setup and Docs (#26 ) * update: nvidia as runtime * add: setup instructions for nvidia * update: setup-docker.md	2024-03-28 12:01:33 -07:00
Kevin Dang	43fb2ea94e	User Preferences and Setup Docs (#20 ) * added message style command * docker setup scripts * reformat messageStyle.ts * fix: register unregister on deploy * add: messageStream preference * add: json config handler * update: messageCreate gets config * update: shifted chat to config callback * fix: naming conventions based on discord * update: setup in docs now * add: static docker ips * version increment * add: bot message for no config * fix: no config case * add: clarification for subnetting * update: version increment in lock file --------- Co-authored-by: JT2M0L3Y <jtsmoley@icloud.com>	2024-03-22 10:37:06 -07:00
Kevin Dang	5e74736c57	Small Documentation and Refactoring (#18 ) * cleanup and documentation * added dev message for parser * grammar and other type replacements	2024-02-18 17:39:00 -08:00
Kevin Dang	1c62958c9f	docker setup instructions	2024-02-07 11:41:15 -08:00
Kevin Dang	ca6b8c3f9c	Docker Container Setup (#15 ) * minor package update and env * added docker scripts * added working docker compose * fixed docker container bridge	2024-02-07 09:59:06 -08:00
Kevin Dang	89c19990fa	slash commands integrated * sample env and late version incr * added slash command compatibility * updated command name * updated environment sample * updated interaction comment	2024-01-31 10:28:02 -08:00
Kevin Dang	b94ff55449	formatting and contributing * fixed some formatting * contributing format * simple style rules	2024-01-30 16:15:35 -08:00
Kevin Dang	9247463480	hardcoded and mentions * added options to queries * removed hard coded vals, added message options * updated importing * added check for message mentions * fix missing botID * updated token to uid * added contributer --------- Co-authored-by: JT2M0L3Y <jtsmoley@icloud.com>	2024-01-29 12:50:59 -08:00