reorganized the workshop from feedback around the python vs just using the models

Author: jjasghar

docs/lab-3.5/README.md renamed to docs/lab-1.5/README.md

@@ -4,6 +4,9 @@ description: Steps to configure Open-WebUI for usage
 logo: images/ibm-blue-background.png
 ---
 
+!!! warning
+    This should be noted that this is optional. You don't need Open-WebUI if you have AnythingLLM already running. This is **optional**.
+
 Now that you've gotten [Open-WebUI installed](../pre-work/README.md#open-webui) we need to configure it with `ollama` and Open-WebUI
 to talk to one another. The following screenshots will be from a Mac, but the gist of this should be the same on Windows and Linux.
 

docs/lab-1/README.md

@@ -1,102 +1,70 @@
 ---
-title: Building a local AI co-pilot
-description: Learn how to leverage Open Source AI
+title: Configuring AnythingLLM
+description: Steps to configure AnythingLLM for usage
 logo: images/ibm-blue-background.png
 ---
 
-## Overview
+Now that you've gotten [AnythingLLM installed](../pre-work/README.md#anythingllm) we need to configure it with `ollama` and AnythingLLM
+to talk to one another. The following screenshots will be from a Mac, but the gist of this should be the same on Windows and Linux.
 
-Success! We're ready to start with the first steps on your AI journey with us today.
-With this first lab, we'll be working through the steps in this [blogpost using Granite as a code assistant](https://developer.ibm.com/tutorials/awb-local-ai-copilot-ibm-granite-code-ollama-continue/).
+Open up AnyThingLLM, and you should see something like the following:
+![default screen](../images/anythingllm_open_screen.png)
 
-In this tutorial, we will show how to use a collection of open-source components to run a feature-rich developer code assistant in Visual Studio Code while addressing data privacy, licensing, and cost challenges that are common to enterprise users. The setup is powered by local large language models (LLMs) with IBM's open-source LLM family, [Granite Code](https://github.com/ibm-granite/granite-code-models). All components run on a developer's workstation and have business-friendly licensing.
+If you see this that means AnythingLLM is installed correctly, and we can continue configuration, if not, please find a workshop TA or
+raise your hand we'll be there to help you ASAP.
 
-There are three main barriers to adopting these tools in an enterprise setting:
-
-- **Data Privacy:** Many corporations have privacy regulations that prohibit sending internal code or data to third party services.
-- **Generated Material Licensing:** Many models, even those with permissive usage licenses, do not disclose their training data and therefore may produce output that is derived from training material with licensing restrictions.
-- **Cost:** Many of these tools are paid solutions which require investment by the organization. For larger organizations, this would often include paid support and maintenance contracts which can be extremely costly and slow to negotiate.
-
-## Fetching the Granite Models
-
-Why did we select Granite as the LLM of choice for this exercise?
-
-Granite Code was produced by IBM Research, with the goal of building an LLM that had only seen code which used enterprise-friendly licenses. According to section 2 of the Granite Code paper ([Granite Code Models: A Family of Open Foundation Models for Code Intelligence][paper]), the IBM Granite Code models meticulously curated their training data for licenses, and to make sure that all text did not contain any hate, abuse, or profanity.
-
-Many open LLMs available today license the model itself for derivative work, but because they bring in large amounts of training data without discriminating by license, most companies can't use the output of those models since it potentially presents intellectual property concerns.
-
-Granite Code comes in a wide range of sizes to fit your workstation's available resources. Generally, the bigger the model, the better the results, with a tradeoff: model responses will be slower, and it will take up more resources on your machine. We chose the 20b option as my starting point for chat and the 8b option for code generation. Ollama offers a convenient pull feature to download models:
-
-Open up a second terminal, and run the following command:
-
-```bash
-ollama pull granite-code:8b
-```
-
-## Set up Continue
-
-Now we need to install [continue.dev](https://continue.dev) so VSCode can "talk" to the ollama instance, and work with the
-granite model(s). There are two different ways of getting `continue` installed. If you have your `terminal` already open
-you can run:
+Next as a sanity check, run the following command to confirm you have the [granite3.1-dense](https://ollama.com/library/granite3.1-dense)
+model downloaded in `ollama`. This may take a bit, but we should have a way to copy it directly on your laptop.
 
 ```bash
-code --install-extension continue.continue
+ollama pull granite3.1-dense:8b
 ```
 
-If not you can use these steps in VSCode:
+If you didn't know, the supported languages with `granite3.1-dense` now include:
 
-1. Open the Extensions tab.
-2. Search for "continue."
-3. Click the Install button.
+- English, German, Spanish, French, Japanese, Portuguese, Arabic, Czech, Italian, Korean, Dutch, Chinese (Simplified)
 
-Next you'll need to configure `continue` which will require you to take the following `json` and open the `config.json`
-file via the command palette.
+And the Capabilities also include:
 
-1. Open the command palette (Press Cmd+Shift+P)
-2. Select Continue: Open `config.json`.
+- Summarization
+- Text classification
+- Text extraction
+- Question-answering
+- Retrieval Augmented Generation (RAG)
+- Code related tasks
+- Function-calling tasks
+- Multilingual dialog use cases
+- Long-context tasks including long document/meeting summarization, long document QA, etc.
 
-In `config.json`, add a section for each model you want to use. Here, we're registering the Granite Code 8b model we downloaded earlier. Replace the line that says `"models": []` with the following:
+!!! note
+    We need to figure out a way to copy the models into ollama without downloading, conference wifi is never fast enough.
 
-```json
-  "models": [
-    {
-      "title": "Granite Code 8b",
-      "provider": "ollama",
-      "model": "granite-code:8b"
-    }
-  ],
-```
-
-For inline code suggestions, we're going to use the smaller 8b model since tab completion runs constantly as you type. This will reduce load on the machine. In the section that starts with `"tabAutocompleteModel"`, replace the whole section with the following:
+Next click on the `wrench` icon, and open up the settings. For now we are going to configure the global settings for `ollama`
+but you may want to change it in the future.
 
-```json
-  "tabAutocompleteModel": {
-    "title": "Granite Code 8b",
-    "provider": "ollama",
-    "model": "granite-code:8b"
-  },
-```
+![wrench icon](../images/anythingllm_wrench_icon.png)
 
-## Sanity Check
+Click on the "LLM" section, and select **Ollama** as the LLM Provider. Also select the `granite3-dense:8b` model. (You should be able to
+see all the models you have access to through `ollama` there.)
 
-Now that you have everything wired together in VSCode, let's make sure that everything works. Go ahead and open
-up `continue` on the extension bar:
+![llm configuration](../images/anythingllm_llm_config.png)
 
-![](https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/lKHl3FNCegebKYdHuXR-GA/continue-sidebar.png)
+Click the "Back to workspaces" button where the wrench was. And Click "New Workspace."
 
-And ask it something! Something fun I like is:
+![new workspace](../images/anythingllm_new_workspace.png)
 
-```text
-What language should I use for backend development?
-```
+Name it something like "learning llm" or the name of the event we are right now, something so you know it's somewhere you are learning
+how to use this LLM.
 
-If you open a file for editing, you should also see possible tab completions to the right of your cursor.
+![naming new workspace](../images/anythingllm_naming_workspace.png)
 
-It should give you a pretty generic answer, but as you can see, it works, and hopefully will help spur a thought
-or two.
+Now we can test our connections _through_ AnythingLLM! I like the "Who is Batman?" question, as a sanity check on connections and that
+it knows _something_.
 
-Now let's continue on to Lab 2, where we are going to actually try this process in-depth!
+![who is batman](../images/anythingllm_who_is_batman.png)
 
-[paper]: https://arxiv.org/pdf/2405.04324?utm_source=ibm_developer&utm_content=in_content_link&utm_id=tutorials_awb-local-ai-copilot-ibm-granite-code-ollama-continue
+Now you may notice that the answer is slighty different then the screen shot above. That's expected and nothing to worry about. If
+you have more questions about it raise your hand and one of the helpers would love to talk you about it.
 
+Congratulations! You have AnythingLLM running now, configured to work with `granite3.1-dense` and `ollama`!