Archived content

Archive date: 2025-03-12

This content is no longer being updated or maintained. The content is provided “as is.” Given the rapid evolution of technology, some content, steps, or illustrations may have changed.

With IBM Watson NLP, IBM introduced a common library for natural language processing, document understanding, translation, and trust. IBM Watson NLP brings everything under one umbrella for consistency and ease of development and deployment.

In this tutorial, learn how to build and deploy a Watson NLP client application. The sample client application is a web service built in Python that performs Tone Classification on user-supplied texts. The client application uses the Watson NLP Python client library to interact with a back-end model service. You can adapt the sample code from this tutorial to your own projects.

Architecture diagram

Reference architecture

Prerequisites

Docker Desktop must be installed
Python 3.9 or later must be installed

Tip: Podman provides a Docker-compatible command-line front end. Unless otherwise noted, all of the Docker commands in this tutorial should work for Podman if you simply alias the Docker CLI with the alias docker=podman shell command.

Estimated time

It should take you approximately 30 minutes to complete this tutorial.

Steps

Step 1. Clone the GitHub repository

Clone the repository that contains the sample code used in this tutorial.
```
git clone https://github.com/ibm-build-lab/Watson-NLP
```
Go to the root directory for this tutorial.
```
cd Watson-NLP/MLOps/Dash-App-gRPC-Client
```

Step 2. Start the model service

Use the following commands to build a model image and run it, to serve the classification_ensemble-workflow_lang_en_tone-stock Watson NLP pretrained model.
```
cd runtime
```
```
docker build . -t watson-nlp-container:v1
```
```
docker run -d -e ACCEPT_LICENSE=true -p 8085:8085 watson-nlp-container:v1
```
Check that the service is running.
```
docker ps
```

Step 3. Run the gRPC dash application

Return to the tutorial's root directory.
```
cd ..
```

Prepare your Python environment.

python3 -m venv client-env

source client-env/bin/activate

Install the required libraries.
```
pip3 install -r requirements.txt
```
Note: This step installs the Watson NLP Runtime client library, among other things.
Run the application.
```
python3 Tone_dash_app.py
```

Step 4. Test

You can now access the application from your browser at the following URL.

http://localhost:8050

Understanding the application code

This application relies on the watson-nlp-runtime-client Watson NLP Python client library to communicate with the Watson NLP Runtime by using gRPC.

The gRPC code is in the GrpcClient.py file. The following code fragment creates a gRPC channel and then uses the channel object to create the client stub to communicate to the server.

GRPC_SERVER_URL = os.getenv("GRPC_SERVER_URL", default="localhost:8085")
channel = grpc.insecure_channel(GRPC_SERVER_URL)
self.stub = common_service_pb2_grpc.NlpServiceStub(channel)

The client stub accepts two parameters: a request object and a header parameter.

def call_tone_model(self, inputText):
    request = common_service_pb2.EmotionRequest(
        raw_document=syntax_types_pb2.RawDocument(text=inputText)
    )
    TONE_CLASSIFICATION_STOCK_MODEL = os.getenv(
        "TONE_CLASSIFICATION_STOCK_MODEL",
        default="classification_ensemble-workflow_lang_en_tone-stock",
    )
    response = self.stub.ClassificationPredict(
        request,
        metadata=[(self.NLP_MODEL_SERVICE_TYPE, TONE_CLASSIFICATION_STOCK_MODEL)],
    )
    return response

Summary

This tutorial explained how to use Watson NLP and Python to create an application that performs Tone Classification on user-supplied texts. Take a look at more Embeddable AI content and Watson NLP on IBM Developer.

Build and deploy a Watson NLP client app using the Watson NLP Python client library

Build and deploy a Watson NLP client app using the Watson NLP Python client library