Review and update Polyglot Chat README

README.md

@@ -252,6 +252,10 @@ cd graalvm-demos
       <td align="left" width="30%"><a href="/graalpy-notebook-example/">graalpy-notebook-example</a><br><a href="https://github.com/graalvm/graalvm-demos/actions/workflows/graalpy-notebook-example.yml"><img alt="graalpy-notebook-example" src="https://github.com/graalvm/graalvm-demos/actions/workflows/graalpy-notebook-example.yml/badge.svg" /></a></td>
       <td align="left" width="70%">Demonstrates how to embed Python in a Java application running on GraalVM <br><strong>Technologies: </strong>GraalPy</td>
     </tr>
+    <tr>
+      <td align="left" width="30%"><a href="/polyglot-chat-app/">polyglot-chat-app</a><br><a href="https://github.com/graalvm/graalvm-demos/actions/workflows/polyglot-chat-app.yml"><img alt="polyglot-chat-app" src="https://github.com/graalvm/graalvm-demos/actions/workflows/polyglot-chat-app.yml/badge.svg" /></a></td>
+      <td align="left" width="70%">Demonstrates how to integrate Python in a Micronaut Java application and build using Gradle <br><strong>Technologies: </strong>Java, GraalPy, Micronaut</td>
+    </tr>
   </tbody>
 </table>
 
@@ -265,10 +269,6 @@ cd graalvm-demos
     </tr>
   </thead>
   <tbody>
-    <tr>
-      <td align="left" width="30%"><a href="/polyglot-chat-app/">polyglot-chat-app</a><br><a href="https://github.com/graalvm/graalvm-demos/actions/workflows/polyglot-chat-app.yml"><img alt="polyglot-chat-app" src="https://github.com/graalvm/graalvm-demos/actions/workflows/polyglot-chat-app.yml/badge.svg" /></a></td>
-      <td align="left" width="70%">Demonstrates how to build a polyglot chat application by embedding Python and R into the Java host language <br><strong>Technologies: </strong>Java, GraalPy, FastR, Micronaut</td>
-    </tr>
     <tr>
       <td align="left" width="30%"><a href="/polyglot-debug/">polyglot-debug</a><br><a href="https://github.com/graalvm/graalvm-demos/actions/workflows/polyglot-debug.yml"><img alt="polyglot-debug" src="https://github.com/graalvm/graalvm-demos/actions/workflows/polyglot-debug.yml/badge.svg" /></a></td>
       <td align="left" width="70%">Demonstrates how to debug a polyglot Java and JavaScript application using GraalVM Tools for Java in VS Code <br><strong>Technologies: </strong>Java, JavaScript, Maven, GraalVM Extension Pack</td>

polyglot-chat-app/.gitignore

@@ -12,3 +12,4 @@ out/
 .settings
 .classpath
 .factorypath
+src/main/resources/venv/pyvenv.cfg

polyglot-chat-app/README.md

@@ -1,67 +1,82 @@
 # Polyglot Chat Application
 
-This example demonstrates how to integrate Python on GraalVM with a Micronaut application.
-The application uses the Gradle build tool.
-
-### Prerequisites
-- [Native Image](https://www.graalvm.org/latest/reference-manual/native-image/)
-- [Python support](https://www.graalvm.org/latest/reference-manual/python/)
+This example demonstrates how to integrate Python in a Micronaut Java application using the Gradle build tool.
+The application uses the [Natural Language Toolkit (nltk)](https://www.nltk.org/) module to analyze the sentiment of user input.
+The example also shows how to create a native executable from the application using GraalVM.
 
 ## Preparation
 
-1. Download the latest GraalPy as described on [https://www.graalvm.org/python/](https://www.graalvm.org/python/). For example on Linux:
+1. Download or clone the GraalVM demos repository and navigate into the _polyglot-chat-app_ directory:
+    ```bash
+    git clone https://github.com/graalvm/graalvm-demos
+    ```
     ```bash
-    wget https://github.com/oracle/graalpython/releases/download/graal-23.1.1/graalpy-23.1.1-linux-amd64.tar.gz
-    tar xzf graalpy-23.1.1-linux-amd64.tar.gz
+    cd graalvm-demos/polyglot-chat-app
     ```
 
-2. Install the required packages for this demo into the _resources_ directory:
+2. Download and install the latest GraalPy as described in the [Getting Started guide](https://www.graalvm.org/latest/reference-manual/python/#installing-graalpy). For example:
+   ```bash
+   pyenv install graalpy-23.1.2
+   pyenv shell graalpy-23.1.2
+   ```
+
+3. Create a virtual environment for the demo in the _resources_ directory, activate it, install the required package, and download a lexicon:
+   ```bash
+   graalpy -m venv src/main/resources/venv
+   ```
+   ```bash
+   source src/main/resources/venv/bin/activate
+   ```
+   ```bash
+   graalpy -m pip install nltk
+   ```
    ```bash
-   graalpy-23.1.1-linux-amd64/bin/graalpy -m venv src/main/resources/venv
-   src/main/resources/venv/bin/graalpy -m pip install nltk
+   graalpy -c "import nltk; nltk.download('vader_lexicon')"
    ```
 
-3. Optional: Download and install GraalVM JDK for Java 21 or later to run Python with runtime compilation and to build a native image.
-   The demo will work on any OpenJDK distribution, but will be much faster on GraalVM JDK.
+4. The demo will work with any OpenJDK distribution, but will be much faster on [GraalVM JDK for Java 21](https://www.graalvm.org/downloads/). 
 
-## Building and Running the application:
 
-1. Build application with Gradle:
-    ```bash
-    ./gradlew run
-    ```
+## Building and Running the Application
 
-2. Navigate to http://localhost:12345/#/chat/bob
+1. Build and run the application using Gradle:
+   ```bash
+   ./gradlew run
+   ```
+
+2. Navigate to [http://localhost:12345/#/chat/bob](http://localhost:12345/#/chat/bob).
 
     You can connect from multiple browsers and chat via websockets.
-    The Python code will load a language model in the background.
-    Once it is ready, it will analyse the sentiments of all messages and add an emoji to the message to indicate the feelings conveyed.
+    The Python code loads a language model in the background—this can take up to 5 minutes.
+    Once it is ready, it analyzes the sentiments of messages and add an emoji to each message to indicate the feelings conveyed.
     A chat may look like this (newest message at the top):
 
     ```
     [bob 😀] awesome, GraalVM and GraalPy rock!
     [bob 🫥] are we done yet?
-    [bob 💬] still loading the sentiment model I believe
+    [bob 💬] Joined!
     ```
 
-## Building a Native Image
+## (Optional) Building a Native Executable
+
+> Note: this requires [GraalVM JDK for Java 21](https://www.graalvm.org/downloads/) or later.
 
-The application can be AOT compiled using GraalVM Native Image.
-The Python code has to be shipped in a _resources_ directory that is kept next to the native executable.
+The application can be compiled ahead-of-time to a native executable using GraalVM Native Image.
+The Python code must be copied to the _build/_ directory that is kept next to the native executable.
 
-1. Build a native executable with the Micronaut AOT support:
+1. Build a native executable using Micronaut AOT support:
    ```bash
    ./gradlew nativeCompile
    ```
 
-2. Copy the venv into the output _resources_ directory:
+2. Copy the _venv_ directory into the output _resources_ directory:
    ```bash
    cp -R src/main/resources/venv/ build/native/nativeCompile/resources/python/
    ```
 
 3. Run the native executable:
    ```bash
-   build/native/nativeCompile/websocket.chat
+   ./build/native/nativeCompile/websocket.chat
    ```
 
 ### Learn More 

polyglot-chat-app/build.gradle

@@ -31,9 +31,9 @@ dependencies {
 
     implementation("jakarta.inject:jakarta.inject-api:2.0.1")
 
-    implementation("org.graalvm.sdk:graal-sdk:23.1.1")
-    implementation("org.graalvm.polyglot:python:23.1.1")
-    implementation("org.graalvm.sdk:nativeimage:23.1.1")
+    implementation("org.graalvm.sdk:graal-sdk:23.1.2")
+    implementation("org.graalvm.polyglot:python:23.1.2")
+    implementation("org.graalvm.sdk:nativeimage:23.1.2")
 }
 
 
@@ -65,7 +65,4 @@ micronaut {
         deduceEnvironment = true
         optimizeNetty = true
     }
-}
-
-
-
+}

polyglot-chat-app/settings.gradle

@@ -1,3 +1 @@
-
 rootProject.name="websocket.chat"
-