vania-janet/multiturn-rag-retrieval-data huggingface dataset:
A historical record of tasks from any time period is available through the [IBM Cloud® Activity Tracker integration](https://cloud.ibm.com/docs/databases-for-mysql?topic=cloud-databases-activity-tracker).





 Endpoints 

The Endpoints pane within the Overview pane contains connection strings for your deployment. Each tab contains connection information that is tailored to the type of connection or the protocol that uses it. Basic information includes things like hostname and port, as well as the TLS self-signed certificate, TLS/SSL parameters, and the default database of your deployment.

Reference tables for the different connection types are available on the [Getting Credentials and Connection Strings](https://cloud.ibm.com/docs/databases-for-mysql?topic=databases-for-mysql-connection-strings) page.

Connection strings reflect whether your deployment uses public endpoints, private endpoints, or both. You can configure which endpoints are available on your deployment. For more information, see the [Service Endpoints Integration](https://cloud.ibm.com/docs/databases-for-mysql?topic=cloud-databases-service-endpoints) page.

You can manage your Databases for MySQL service through the Cloud Databases API. This panel provides the essential information for using the API. For more information about the Cloud Databases API, see the [API reference](https://cloud.ibm.com/apidocs/cloud-databases-api) page.







 Resources 

The resources tab contains information and configuration options on the size and resource usage of your deployment. You can



* [scale disk, memory, and CPU](https://cloud.ibm.com/docs/databases-for-mysql?topic=databases-for-mysql-resources-scaling)
* [configure Autoscaling](https://cloud.ibm.com/docs/databases-for-mysql?topic=databases-for-mysql-autoscaling)







 Backups 

The Backups tab is the UI for managing your deployment backups.
Using the Cloud Object Storage importer to migrate chat logs 

You can use the Cloud Object Storage importer service to migrate your chat logs from one installation of Watson Assistant to another.

This diagram shows two clusters:



Diagram clusters

 Cluster Description 

 Cloud Object Storage consumer Red Hat OpenShift cluster with the Watson Assistant installation used to export chat log data to Cloud Object Storage 
 Cloud Object Storage importer Red Hat OpenShift cluster with the Watson Assistant installation that imports chat log data from the Cloud Object Storage consumer cluster's copied bucket 



![Architecture Diagram](https://cloud.ibm.com/docs-content/v1/content/a2b18c153837bce00a5b4de496e4b4ca64bbf56e/assistant-data/images/data-governor-architecture.png)



 Configuring the data governor Cloud Object Storage consumer service 



1. Use the script to create a new file on the Cloud Object Storage consumer cluster.

COS_ACCESS_KEY=echo -n "<enter_COS_key_here>"|base64
COS_SECRET_ACCESS_KEY=echo -n "<enter_COS_secret_access_key_here>"|base64
COS_ENDPOINT="<enter_COS_endpoint here>"
For e.g. COS_ENDPOINT="https://s3.us.cloud-object-storage.appdomain.cloud"

cat <<EOF | oc apply -f -

apiVersion: v1
kind: Secret
metadata:
name: wa-data-governor-cos-credentials
namespace: cpd
data:
COS_ACCESS_KEY: ${COS_ACCESS_KEY}
COS_SECRET_KEY: ${COS_SECRET_ACCESS_KEY}
type: Opaque

EOF

cat <<EOF | oc apply -f -
apiVersion: assistant.watson.ibm.com/v1
kind: TemporaryPatch
metadata:
name: wa-data-governor
namespace: cpd
spec:
COS_ACCESS_KEY: ${COS_ACCESS_KEY}
COS_SECRET_KEY: ${COS_SECRET_ACCESS_KEY}
type: Opaque

EOF

cat <<EOF | oc apply -f -
apiVersion: assistant.watson.ibm.com/v1
kind: TemporaryPatch
metadata:
name: wa-data-governor
namespace: cpd
spec:
apiVersion: assistant.watson.ibm.com/v1
kind: WatsonAssistant
name: wa
patch:
data-governor:
dataexhaust:
spec:
consumers:
cosConsumer: true
cos:
endpoint: ${COS_ENDPOINT}
secret:
accessKey: COS_ACCESS_KEY
name: wa-data-governor-cos-credentials
secretKey: COS_SECRET_KEY
patchType: patchStrategicMerge
EOF
Show more
2. In the script, replace these placeholders with the actual values:



* <enter_COS_key_here>
* <enter_COS_secret_access_key_here>
* <enter_COS_endpoint here>



3. Run the script.
4. Wait 15 to 20 minutes and then check if the data governor pods are stable.
5. When the pods are stable, log in to Watson Assistant.
6. Select the correct assistant, then click the Preview icon on the left vertical bar and generate chat logs.
7. Check if the Cloud Object Storage objects are getting created in the data-exhaust-backup-wa-data-governor-e58d5f4a1344 Cloud Object Storage bucket.







 Configuring the data governor Cloud Object Storage importer service 

Create a file on the Cloud Object Storage Importer cluster and copy the following script into it.
These events can be used to navigate to a specific page when the user starts a journey or reaches a certain step, or to show a survey after a journey ends.
* New journey instance methods: The new [tours](https://web-chat.global.assistant.watson.cloud.ibm.com/docs.html?to=api-instance-methodstours) object supports instance methods that provide better control over journeys. You can use these methods to start or end a journey, or to automatically navigate through a journey in response to user actions.
* Added journey strings to the language pack: New strings for journeys have been added to the language pack. You can modify the strings in the language pack by using the [updateLanguagePack()](https://web-chat.global.assistant.watson.cloud.ibm.com/docs.html?to=api-instance-methodsupdatelanguagepack) instance method. For more information about language packs, see [Languages](https://cloud.ibm.com/docs/watson-assistant?topic=watson-assistant-topicid).



For more information about the journeys beta feature, see [Guiding customers with journeys](https://cloud.ibm.com/docs/watson-assistant?topic=watson-assistant-journeys).





 7.1.0 

Release date: 17 January 2023



* Updated Zendesk agent app: The agent app for Zendesk has been updated for compatibility with Zendesk workspaces.
* In the service desk starter kits, the instance of the web chat integration has been added to the [serviceDeskFactory parameters](https://github.com/watson-developer-cloud/assistant-web-chat-service-desk-starter/blob/main/src/common/types/serviceDesk.ts) to make it accessible to custom service desk implementations.
Similarly, you can extract Cloud Object Storage importer instances, assistants, and workspaces target_id values from assistant settings for the Cloud Object Storage importer cluster.





 Generating a JSON ID mapping definition for the data governor importer service 

You can use the Analytics reports in your development environment to gain insight into your production chat logs.

You need to move your production chat logs data to your development environment, and then transform the production chat logs data to be used by the Analytics reports in your development assistants.

For the moved chat logs data to be used by the Analytics reports in a different Watson Assistant instance and assistant in your development environment, the various IDs of the chat log Elastic documents need to be transformed from the source to the target.

Use this code for the ID mapping definition.



* This mapping definition supports transforming the chat logs for multiple Watson Assistant instances and assistants.
* The mapping is hierarchical, so each instance level mapping also contains multiple assistant-level mappings for such instance.
* Each mapping contains two ID fields: source_id and target_id. You need to supply data for each mapping at the instance and assistant levels.



You can look up the ID data in applicable Watson Assistant instances and assistants.

{
"instances": [
{
"source_id": "<string>",
"target_id": "<string>",
"assistants":
{
"source_id": "<string>",
"target_id": "<string>"
}
],
"workspaces":
{
"source_id": "<string>",
"target_id": "<string>"
}
]
}
]
}
Show more



 Usage examples 

Map assistants from one source instance to assistants in multiple target instances.

The following example maps 2 assistants in 1 source instance to 2 assistants in 2 target instances.

{
"instances": [
{
"source_id": "07079e0a-a8cd-4dc5-b3a4-7879d7cf0a8f",
: The following new and updated methods are available in expressions:



* The [Array.joinToArray()](https://cloud.ibm.com/docs/watson-assistant?topic=watson-assistant-expression-methods-actionsexpression-methods-actions-arrays-join-to-array) method now supports a new boolean parameter you can use to specify that the data type of values from the input array should be preserved in the returned array.
* The new [String.toJson()](https://cloud.ibm.com/docs/watson-assistant?topic=watson-assistant-expression-methods-actionsexpression-methods-actions-strings-toJson) method parses a string containing JSON data and returns a JSON object or array. This method is supported in both actions and dialog.







 5 December 2022 

Live integrations deleted in assistants created before June 24, 2022
: For assistants created before June 24, 2022, using the new Watson Assistant user experience, the live integrations for these assistants were mistakenly deleted during a software upgrade. These integrations should now be restored. If you are still experiencing issues, please contact IBM support.

Unsupported HTML removed from text responses in channel integrations
: HTML tags (except for links) are now automatically removed from text responses that are sent to the Facebook, WhatsApp, and Slack integrations, because those channels do not support HTML formatting. HTML tags are still handled appropriately in channels that support them (such as the web chat) and stored in the session history.





 2 December 2022 

Pause response type
: Use a Pause response to have your assistant wait for a specified interval before displaying the next response. This pause might be to allow time for a request to complete, or simply to mimic the appearance of a live agent who might pause between responses. The pause can be of any duration from 1 to 10 seconds. For more information, see [Pause response](https://cloud.ibm.com/docs/watson-assistant?topic=watson-assistant-respondrespond-pause-response).





 17 November 2022 

Use unrecognized requests to get action recommendations
[External link icon](https://cloud.ibm.com/docs-content/v1/content/icons/launch-glyph.svg)](https://developer.ibm.com/patterns/snap-translate-using-tesseract-ocr-watson-language-translator/)
* [Get the Code ![External link icon](https://cloud.ibm.com/docs-content/v1/content/icons/launch-glyph.svg)](https://github.com/IBM/snap-and-translate)







 Analyze product reviews and generate a shopping guide 

Create a Node.js app to make cognitive decisions using product reviews evaluated by Watson Natural Language Understanding.



* [Learn more ![External link icon](https://cloud.ibm.com/docs-content/v1/content/icons/launch-glyph.svg)](https://developer.ibm.com/patterns/analyze-product-reviews-and-generate-a-shopping-guide/)
* [Get the Code ![External link icon](https://cloud.ibm.com/docs-content/v1/content/icons/launch-glyph.svg)](https://github.com/IBM/watson-second-opinion?cm_sp=Developer-_-slug-_-Get-the-Code)
* [View the Demo ![External link icon](https://cloud.ibm.com/docs-content/v1/content/icons/launch-glyph.svg)](https://www.youtube.com/watch?v=wwNAEvbxd54)







 Create a Banking Chatbot 

Use Node.js and Watson to detect emotion, identify entities, and discover answers.



* [Learn more ![External link icon](https://cloud.ibm.com/docs-content/v1/content/icons/launch-glyph.svg)](https://developer.ibm.com/patterns/create-cognitive-banking-chatbot/)
* [Get the Code !
ibmcloud ce project create --name slackbot

Then select the project as the active one:

ibmcloud ce project select --name slackbot

Then, deploy the app naming it slackbot-backend. Replace the value for the API_TOKEN (MY_SECRET) with your own secret. It is used to secure the calls to the REST API. For DB2_URI replace the parts with the database connection URL from above.

ibmcloud ce app create --name slackbot-backend --image icr.io/solution-tutorials/tutorial-slack-chatbot-database:latest --min-scale 1 -e API_TOKEN=MY_SECRET -e DB2_URI="ibm_db_sa://username:password@database-hostname:port/bludb?Security=SSL;"

Note the reported URI for the app. It is needed in the next steps.

Instead of deploying a pre-built container image you could also build and deploy your own image from the provided code. See the Code Engine documentation on [building a container image](https://cloud.ibm.com/docs/codeengine?topic=codeengine-build-image) or [deploying your application code from local source](https://cloud.ibm.com/docs/codeengine?topic=codeengine-migrate-cf-ce-local) for details.
7. Test the deployment by calling a REST API provided by the app to (re-)create the database schema and insert few sample records. Replace projectid, region, and MY_SECRET accordingly.

curl -X 'POST' 'https://slackbot-backend.projectid.region.codeengine.appdomain.cloud/database/recreate' -H 'accept: application/json' -H 'API_TOKEN: MY_SECRET'

The above request should return an error message that the confirmation is missing. Now try again with a query parameter:
You can use the same subdomain in each resource or different subdomains in each resource. For example, if you use a wildcard domain, you can append a wildcard subdomain to the beginning of the domain, such as subdomain1.custom_domain.net or subdomain1.mycluster-<hash>-0000.us-south.containers.appdomain.cloud. Do not use * for your host or leave the host property empty to avoid failures during Ingress creation.

path
: Replace <app_path> with the path that your app is listening on. The path is appended to the IBM-provided or your custom domain to create a unique route to your app. When you enter this route into a web browser, network traffic is routed to the Ingress controller. The Ingress controller looks up the associated service, and the Ingress controller sends network traffic to the service. The service then forwards the traffic to the pods where the app runs. Many apps don't listen on a specific path, but use the root path and a specific port. In this case, define the root path as / and don't specify an individual path for your app. For http://domain/, enter / as the path. For http://domain/app1_path, enter /app1_path as the path.

name
: Replace <app1_service> and <app2_service>, and so on, with the name of the services you created to expose your apps. If your apps are exposed by services in different projects in the cluster, include only app services that are in the same project. You must create one Ingress resource for each project where you have apps that you want to expose.

port
: The port that your service listens to. Use the same port that you defined when you created the Kubernetes service for your app.
2. Create the Ingress resource for your cluster. Ensure that the resource deploys into the same project as the app services that you specified in the resource.

oc apply -f myingressresource.yaml -n <project>
3. Verify that the Ingress resource was created successfully.
You can use the same subdomain in each resource or different subdomains in each resource. For example, if you use a wildcard domain, you can append a wildcard subdomain to the beginning of the domain, such as subdomain1.custom_domain.net.
: Do not use * for your host or leave the host property empty to avoid failures during Ingress creation.

path
: Replace <app_path> with the path that your app is listening on. The path is appended to the IBM-provided or your custom domain to create a unique route to your app. When you enter this route into a web browser, network traffic is routed to the Ingress controller. The Ingress controller looks up the associated service, and sends network traffic to the service. The service then forwards the traffic to the pods where the app runs. Many apps don't listen on a specific path, but use the root path and a specific port. In this case, define the root path as / and don't specify an individual path for your app.
: For example, to use http://domain/, enter / as the path. For http://domain/app1_path, enter /app1_path as the path.

serviceName
: Replace <app1_service> and <app2_service>, and so on, with the name of the services you created to expose your apps. If your apps are exposed by services in different projects in the cluster, include only app services that are in the same project. You must create one Ingress resource for each project that contains apps that you want to expose.

servicePort
: The port that your service listens to. Use the same port that you defined when you created the Kubernetes service for your app.
2. Create the Ingress resource for your cluster. Ensure that the resource deploys into the same project as the app services that you specified in the resource.

oc apply -f myingressresource.yaml -n <project>
3. Verify that the Ingress resource was created successfully.
- host: <domain>
http:
paths:
- path: /<app1_path>
backend:
service:
name: <app1_service>
port:
number: 80
- path: /<app2_path>
backend:
service:
name: <app2_service>
port:
number: 80
Show more

tls
: If you want to use TLS, include this TLS section in your resource.
: Replace <domain> with your subdomain. Do not use * for your host or leave the host property empty to avoid failures during Ingress creation.
: Replace <tls_secret_name> with the secret that you created earlier that holds your TLS certificate and key for a custom domain or the TLS secret that was automatically generated for an IBM-provided subdomain.

host
: Replace <domain> with the IBM-provided Ingress subdomain or your custom domain.
: If your cluster has multiple projects where apps are exposed, one Ingress resource is required per project. You can use the same subdomain in each resource or different subdomains in each resource. For example, if you use a wildcard domain, you can append a wildcard subdomain to the beginning of the domain, such as subdomain1.custom_domain.net or subdomain1.mycluster-<hash>-0000.us-south.containers.appdomain.cloud. Do not use* for your host or leave the host property empty to avoid failures during Ingress creation.

path
: Replace <app_path> with the path that your app is listening on. The path is appended to the IBM-provided or your custom domain to create a unique route to your app. When you enter this route into a web browser, network traffic is routed to the Ingress controller. The Ingress controller looks up the associated service, and sends network traffic to the service. The service then forwards the traffic to the pods where the app runs. Many apps don't listen on a specific path, but use the root path and a specific port.
; Specify 0 to disable or 1 to enable the TCP/IP protocol.

TCPENABLED="1"

; Specify 0 to disable or 1 to enable the Named Pipes protocol.

NPENABLED="0"

; Startup type for Browser Service.

BROWSERSVCSTARTUPTYPE="Disabled"

; Use SQLMAXMEMORY to minimize the risk of the OS experiencing detrimental memory pressure.

SQLMAXMEMORY="2147483647"

; Use SQLMINMEMORY to reserve a minimum amount of memory available to the SQL Server Memory Manager.

SQLMINMEMORY="0"

; Accept the SQL Server License Terms

IACCEPTSQLSERVERLICENSETERMS="True"

Show more
Still in the browser tab Kubernetes dashboard, click on the three dots menu again and then with a left-click on Logs. In the new three dots menu enable Auto refresh.

Last, open a tab with the [Activity Tracker services](https://cloud.ibm.com/observe/activitytracker) and select the Frankfurt instance (Activity Tracker logs).
2. In the browser tab container shell, run the following command in the shell to test the app:

curl -s localhost:8080

The above should return a JSON object with the codeversion and result. You should see some new log activity in the Kubernetes dashboard tab with the logs. Next, in the container shell tab, run the following command:

curl -s localhost:8080/api/listresources_crn | jq

The command invokes the app, trying to retrieve the list of resources in the account, but no trusted profile name is provided. The result should be a formatted JSON object with an error message.
3. Repeat the above command, but now specify which trusted profile to use:

curl -s localhost:8080/api/listresources_crn?tpname=TPwithCR | jq

Now, the result should be formatted JSON object with information about the resources in your account. For readability, only the resource CRNs are returned. Use localhost:8080/api/listresources for the full object details. You may also want to try a different, non-existing trusted profile name and examine the error message.

When invoked, the app first reads the token for the compute resource. Then, it [turns the token into an IAM access token](https://cloud.ibm.com/apidocs/iam-identity-token-apigettoken-crtoken) for the specified trusted profile. Last, it calls the [IBM Cloud resource controller API](https://cloud.ibm.com/apidocs/resource-controller/resource-controller) to retrieve information about service instances. The result depends on the trusted profile's configured privileges.
Encryption 

Services MUST support HTTPS and MUST NOT allow clients to make unencrypted, HTTP-only requests.

Services MUST use TLS 1.2 or higher. Deprecated encryption protocols including (as of this writing) TLS 1.0 and 1.1 and all versions of SSL MUST be fully disabled such that they are not supported for clients that attempt to negotiate use of them.

Services MUST comply with all current IBM security policies on cipher support and certificate management.
serviceAccountName: default
volumes:
- name: sa-token
projected:
sources:
- serviceAccountToken:
path: sa-token
expirationSeconds: 3600
audience: iam
Show more

Then, click Upload to create the resources for the app. It includes a new Kubernetes namespace tptest, a deployment and a service with a pod.

You can find the [source code for the above YAML configuration on GitHub](https://raw.githubusercontent.com/IBM-Cloud/trusted-profile-enterprise-security/main/app.yaml).
4. In the left navigation column, click on Deployments to check for the state of the new deployment trustedprofile-test-deployment. Next, click on Pods in the same navigation column and notice a pod with a name starting with trustedprofile-test-deployment. Once it is showing the status green, move on to the next section.







 Step 5: Test the trusted profile 

With the trusted profile and the Kubernetes cluster with the running app in place, it is time to test. Start by opening a browser-based shell to run commands, a tab for the container logs, and another one for Activity Tracker logs.



1. In the currently active tab Kubernetes dashboard with the pods, click on the menu with three dots on the right and right-click on Exec in that menu. Choose to open the link in a new tab (container shell). It opens a shell for the running container. Still in the browser tab Kubernetes dashboard, click on the three dots menu again and then with a left-click on Logs. In the new three dots menu enable Auto refresh.

Last, open a tab with the [Activity Tracker services](https://cloud.ibm.com/observe/activitytracker) and select the Frankfurt instance (Activity Tracker logs).
2. In the browser tab container shell, run the following command in the shell to test the app:

curl -s localhost:8080