docfixes and added welcome [skip ci]

erhant · erhant · commit e63e00a7ab52 · 2024-09-06T15:30:35.000+03:00
diff --git a/docs/NODE_GUIDE.md b/docs/NODE_GUIDE.md
@@ -1,21 +1,26 @@
 ## Running the Compute Node
 
-Running a Dria Compute Node is pretty straightforward! You can either follow the guide here for all platforms, or follow a much-more user-friendly guide at <https://dria.co/guide> for MacOS in particular.
+Running a Dria Compute Node is pretty straightforward! It comes with a cross-platform launcher, and is itself a cross-platform executable. By using platform-specific builds instead of Docker we ensure:
+
+- Best performance from LLMs
+- Best networking for the p2p network
+
+You can either follow the guide here for all platforms, or follow a much-more user-friendly guide at <https://dria.co/guide> for MacOS in particular.
 
 ## Requirements
 
 ### Software
 
-You only **Docker** to run the node! You can check if you have it by printing its version:
+Depending the AI models of your choice, you may have to install software:
+
+- **OpenAI models**: you don't have to do anything!
+- **Ollama models**: you have to install Ollama
 
 ```sh
-docker -v
+# prints Ollama version
+ollama -v
 ```
 
-> [!CAUTION]
->
-> In **Windows** machines, Docker Desktop is requried to be running with **WSL2**. You can check the Docker Desktop Windows installation guide from [here](https://docs.docker.com/desktop/install/windows-install/)
-
 ### Hardware
 
 **To learn about hardware specifications such as required CPU and RAM, please refer to [node specifications](./NODE_SPECS.md).**
@@ -107,35 +112,37 @@ Download the appropriate ZIP file for your system using the commands below or fr
 1. Check your architecture:
 
    - Open System Information:
-     - Press `Win + R` to open the Run dialog.
-     - Type `msinfo32` and press Enter.
+     - Press <kbd>⊞ Win + R</kbd> to open the Run dialog.
+     - Type `msinfo32` and press <kbd>Enter</kbd>.
    - Look for the line labeled "Processor" or "CPU":
      - If it includes "x64" or refers to Intel or AMD, it is likely x86 (amd64).
      - If it mentions ARM, then it's an ARM processor.
 
 2. Download the ZIP file using a web browser or in PowerShell:
 
-   ```cmd
+   ```sh
    # for x64, use amd64
    Invoke-WebRequest -Uri "https://github.com/firstbatchxyz/dkn-compute-launcher/releases/latest/download/dkn-compute-launcher-windows-amd64.zip" -OutFile "dkn-compute-node.zip"
    ```
 
-   ```cmd
+   ```sh
    # for ARM, use arm64
    Invoke-WebRequest -Uri "https://github.com/firstbatchxyz/dkn-compute-launcher/releases/latest/download/dkn-compute-launcher-windows-arm64.zip" -OutFile "dkn-compute-node.zip"
    ```
 
 3. Unzip the downloaded file using File Explorer or in PowerShell:
-   ```cmd
+   ```sh
    Expand-Archive -Path "dkn-compute-node.zip" -DestinationPath "dkn-compute-node"
    cd dkn-compute-node
    ```
 
 ### 2. Prepare Environment Variables
 
-With our launcher, setting up the environment variables happen on the fly by just running the `dkn-compute-launcher` CLI application directly, it'll ask you to enter the required environment variables if you don't have them! This way, you won't have to manually do the copying and creating environment variables yourself, and instead let the CLI do it for you.
+With our launcher, setting up the environment variables happen on the fly! The CLI application will ask you to enter the required environment variables if you don't have them.
+
+This way, you won't have to manually do the copying and creating environment variables yourself, and instead let the CLI do it for you. You can move directly on to the [Usage](#usage) section.
 
-If you prefer this method, you can move directly on to the [Usage](#usage) section. If you would like to do this part manually, you can continue reading this section.
+> If you would like to do this part manually, you can continue reading this section.
 
 #### Create `.env` File
 
@@ -191,11 +198,9 @@ OPENAI_API_KEY=<YOUR_KEY>
 
 #### For Ollama
 
-First you have to install Ollama, if you haven't already! See their [download page](https://ollama.com/download) and follow their instructions there. The models that we want to use have to be pulled to Ollama before we can use them.
+First you have to install [Ollama](#requirements), if you haven't already! The compute node is set to download any missing model automatically at the start by default. This is enabled via the `OLLAMA_AUTO_PULL=true` in `.env`.
 
-> [!TIP]
->
-> The compute node is set to download any missing model automatically at the start by default. This is enabled via the `OLLAMA_AUTO_PULL=true` in `.env`. If you would like to disable this feature, set `OLLAMA_AUTO_PULL=false` and then continue reading this section, otherwise you can skip to [optional services](#optional-services).
+If you would like to disable this feature, set `OLLAMA_AUTO_PULL=false` and then continue reading this section, otherwise you can skip to [optional services](#optional-services).
 
 First, you must **first pull a small embedding model that is used internally**.
 
@@ -221,56 +226,16 @@ JINA_API_KEY=<key-here>
 
 ## Usage
 
-With all setup steps above completed, we are ready to start a node!
-
-### 1. Choose Model(s)
-
-Based on the resources of your machine, you must decide which models that you will be running locally. For example, you can use OpenAI with their models, not running anything locally at all; or you can use Ollama with several models loaded to disk, and only one loaded to memory during its respective task. Available models (see [here](https://github.com/andthattoo/ollama-workflows/blob/main/src/program/atomics.rs#L269) for latest) are:
-
-#### Ollama Models
-
-- `finalend/hermes-3-llama-3.1:8b-q8_0`
-- `phi3:14b-medium-4k-instruct-q4_1`
-- `phi3:14b-medium-128k-instruct-q4_1`
-- `phi3.5:3.8b`
-- `phi3.5:3.8b-mini-instruct-fp16`
-- `llama3.1:latest`
-- `llama3.1:8b-instruct-q8_0`
-- `gemma2:9b-instruct-q8_0`
-
-#### OpenAI Models
-
-- `gpt-3.5-turbo`
-- `gpt-4-turbo`
-- `gpt-4o`
-- `gpt-4o-mini`
-
-> [!TIP]
->
-> If you are using Ollama, make sure you have pulled the required models, as specified in the [section above](#4-setup-ollama-for-ollama-users)!
-
-### 2. Start Docker
-
-Our node will be running within a Docker container, so we should make sure that Docker is running before the next step. You can launch Docker via its [desktop application](https://www.docker.com/products/docker-desktop/), or a command such as:
-
-```sh
-sudo systemctl start docker
-```
-
-> [!NOTE]
->
-> You don't need to do this step if Docker is already running in the background.
-
-### 3. Run Node
-
-It's time to run our compute node. We have a launcher cli app that makes this much easier: you can either run it by double-clicking the `dkn-compute-launcher` app (`dkn-compute-launcher.exe` on Windows) from your file explorer, or use it from terminal (or cmd/powershell in Windows).
+**With all setup steps above completed, we are ready to start a node!** Either double-click the downloaded launcher `dkn-compute-launcher` app (`dkn-compute-launcher.exe` on Windows), or run it from the terminal from your file explorer, or use it from terminal (or `cmd/powershell` in Windows).
 
 See the available commands with:
 
 ```sh
 # macos or linux
 ./dkn-compute-launcher --help
+```
 
+```sh
 # windows
 .\dkn-compute-launcher.exe --help
 ```
@@ -280,81 +245,58 @@ Then simply run the cli app, it will ask you to enter required inputs:
 ```sh
 # macos or linux
 ./dkn-compute-launcher
-
-# windows
-.\dkn-compute-launcher.exe
 ```
 
-Or you can directly pass the running models using `-m` flags
-
 ```sh
-# macos or linux
-./dkn-compute-launcher -m=llama3.1:latest -m=gpt-3.5-turbo
-
 # windows
-.\dkn-compute-launcher.exe -m=llama3.1:latest -m=gpt-3.5-turbo
-```
-
-Launcher app will run the containers in the background. You can check their logs either via the terminal or from [Docker Desktop](https://www.docker.com/products/docker-desktop/).
-
-#### Running in Debug Mode
-
-To print DEBUG-level logs for the compute node, you can add `--dev` argument to the launcher app. For example:
-
-```sh
-./dkn-compute-launcher -m=gpt-4o-mini --dev
+.\dkn-compute-launcher.exe
 ```
 
-Running in debug mode will also allow you to see behind the scenes of Ollama Workflows, i.e. you can see the reasoning of the LLM as it executes the task.
-
-> Similarly, you can run in trace mode with `--trace` to see trace logs, which cover low-level logs from the p2p client.
+You will see logs of the compute node on the same terminal!
 
-### 4. Looking at Logs
+You can stop the node as usual by pressing <kbd>Control + C</kbd>, or kill it from the terminal.
 
-To see your logs, you can go to [Docker Desktop](https://www.docker.com/products/docker-desktop/) and see the running containers and find `dkn-compute-node`. There, open the containers within the compose (click on `>` to the left) and click on any of the container to see its logs.
+### Choosing Models
 
-Alternatively, you can use `docker compose logs` such as below:
+You will be asked to provide your choice of models within the CLI. You can also pass them from the command line using `-m` flags:
 
 ```sh
-docker compose logs -f compute  # compute node logs
-docker compose logs -f ollama   # ollama logs
+# macos or linux
+./dkn-compute-launcher -m=llama3.1:latest -m=gpt-3.5-turbo
 ```
 
-The `-f` option is so that you can track the logs from terminal. If you prefer to simply check the latest logs, you can use a command such as:
-
 ```sh
-# logs from last 1 hour
-docker compose logs --since=1h compute
-
-# logs from last 30 minutes
-docker compose logs --since=30m compute
+# windows
+.\dkn-compute-launcher.exe -m=llama3.1:latest -m=gpt-3.5-turbo
 ```
 
-### 5. Stopping the Node
-
-When you start your node with `dkn-compute-launcher`, it will wait for you in the same terminal to do CTRL+C before stopping. Once you do that, the containers will be stopped and removed. You can also kill the containers manually, doing CTRL+C afterwards will do nothing in such a case.
-
-> [!NOTE]
->
-> Sometimes it may not immediately exit whilst executing a task, if you REALLY need to quite the process you can kill it manually.
-
-### Using Ollama
+[Available models](https://github.com/andthattoo/ollama-workflows/blob/main/src/program/models.rs) are given below:
 
-> If you don't have Ollama installed, you can ignore this section.
+#### Ollama Models
 
-If you have Ollama installed already (e.g. via `brew install ollama`) then the launcher script app always use it. Even if the Ollama server is not running, the launcher app will initiate it with `ollama serve` and terminate it when the node is being stopped.
+- `finalend/hermes-3-llama-3.1:8b-q8_0`
+- `phi3:14b-medium-4k-instruct-q4_1`
+- `phi3:14b-medium-128k-instruct-q4_1`
+- `phi3.5:3.8b`
+- `phi3.5:3.8b-mini-instruct-fp16`
+- `llama3.1:latest`
+- `llama3.1:8b-instruct-q8_0`
+- `gemma2:9b-instruct-q8_0`
 
-If you would like to explicitly use Docker Ollama instead, you can do this by passing the `--docker-ollama` option.
+#### OpenAI Models
 
-```sh
-# Run with local ollama
-./dkn-compute-launcher -m=phi3 --docker-ollama
-```
+- `gpt-3.5-turbo`
+- `gpt-4-turbo`
+- `gpt-4o`
+- `gpt-4o-mini`
 
-> [!TIP]
->
-> There are three Docker Compose Ollama options: `ollama-cpu`, `ollama-cuda`, and `ollama-rocm`. The launcher app will decide which option to use based on the host machine's GPU specifications.
+Launcher app will run the containers in the background. You can check their logs either via the terminal or from [Docker Desktop](https://www.docker.com/products/docker-desktop/).
 
 ### Additional Static Nodes
 
 You can add additional relay nodes & bootstrap nodes from environment, using the `DKN_RELAY_NODES` and `DKN_BOOTSTRAP_NODES` variables respectively. Simply write the `Multiaddr` string of the static nodes as comma-separated values, and the compute node will pick them up at the start.
+
+```sh
+# dummy example
+DKN_BOOTSTRAP_NODES=/ip4/44.206.245.139/tcp/4001/p2p/16Uiu2HAm4q3LZU2TeeejKK4fff6KZdddq8Kcccyae4bbbF7uqaaa
+```
diff --git a/src/main.rs b/src/main.rs
@@ -10,8 +10,17 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     env_logger::builder()
         .format_timestamp(Some(env_logger::TimestampPrecision::Millis))
         .init();
+
     log::info!(
-        "Initializing Dria Compute Node (version {})",
+        r#"
+
+██████╗ ██████╗ ██╗ █████╗ 
+██╔══██╗██╔══██╗██║██╔══██╗   Dria Compute Node 
+██║  ██║██████╔╝██║███████║   v{}
+██║  ██║██╔══██╗██║██╔══██║   https://dria.co
+██████╔╝██║  ██║██║██║  ██║
+╚═════╝ ╚═╝  ╚═╝╚═╝╚═╝  ╚═╝
+"#,
         dkn_compute::DRIA_COMPUTE_NODE_VERSION
     );
 
