vania-janet/multiturn-rag-retrieval-data huggingface dataset:
* UI
* CLI
* API
* Terraform







 Creating workspaces and importing your Terraform template 

Use a Schematics to manage your IBM Cloud Schematics resources using Terraform. Workspace settings define the Terraform template hosted in a Git repository to be used, along with any input variables to customize the template.

IBM Cloud Schematics deprecates older version of Terraform. For more information, see [Deprecating older version of Terraform process in IBM Cloud Schematics](https://cloud.ibm.com/docs/schematics?topic=schematics-deprecate-tf-version).



 Before you begin 



* [Create a Terraform configuration](https://cloud.ibm.com/docs/schematics?topic=schematics-create-tf-config), and store the configuration in a GitHub, GitLab, or Bitbucket repository. You can also upload a tape archive file (.tar) from your local workstation to provide your template to IBM Cloud Schematics. For more information, see the [ibmcloud schematics workspace upload](https://cloud.ibm.com/docs/schematics?topic=schematics-schematics-cli-referenceschematics-workspace-upload) command and see the [upload a tar file to your workspace](https://cloud.ibm.com/apidocs/schematics/schematicsupload-template-tar) API.
* Make sure that you have the [permissions](https://cloud.ibm.com/docs/schematics?topic=schematics-access) to create a workspace.



Ensure the location and the url endpoint are pointing to the same region when you create or update the Schematics Workspaces and actions. For more information about location and endpoint, see [Where is your information stored](https://cloud.ibm.com/docs/schematics?topic=schematics-secure-datapi-location)?





 Creating a workspace using the UI 



1.
* Click Use this template/repository
* Select Create a new repository
* Use the Owner drop-down menu, and select the account where want to create the new repository
* Type a name for your repository
* Click Create repository from template







 Clone repo to local machine 

Clone your new template repository to your local machine for editing:



* Navigate to the main page of your new repository
* Click <> Code (Download Code)
* [Clone the repo](https://docs.github.com/en/repositories/creating-and-managing-repositories/cloning-a-repository) to your local machine using: HTTPS, SSH, GitHub CLI or Github Desktop







 Editing in VSCode 



* Open the local folder containing the template repo contents as a new VSCode workspace
* Optionally rename the template and input files for your blueprint.
* Select the blueprint template YAML file for editing



* The YAML language extension will provide YAML syntax and blueprint schema validation



* Just above the top of the file contents, the selected blueprint schema is displayed.
* Select the blueprint input YAML file for editing



* The YAML language extension will provide YAML syntax validation





With the extension and schema configured, VSCode will provide assisted editing for blueprint templates.



 Blueprint usage and configuration documentation 

To customize the template and input file to deploy your own infrastructure, refer to the Blueprint documentation for an overview of [blueprint templates and configuration](https://cloud.ibm.com/docs/schematics?topic=schematics-blueprint-templates&interface=ui).





 Push edited template 

After editing the template push it back to the Git repo to make it available to be deployed by Schematics.

Within VSCode, click on the “Source Control” button in the Activity Bar. It’s located on the side of VS Code’s client. Alternatively, you can use the keyboard shortcut Ctrl+Shift+G or Ctrl+Shift+G on MacOS to open the Source Control screen.



* Enter a commit message
* Click Commit
* Click Sync changes
This section describes how to create a case for Maximo Application Suite as a Service (MAS SaaS)



1. Access the IBM Support Community:

[https://www.ibm.com/mysupport](https://www.ibm.com/mysupport)
2. Click the Open a case button on top right of page.
3. Sign in with valid IBMid:

Please note: If you do not have an IBMid, or your IBMid has not been registered with a valid product and customer account, go to the following link(s):

[How to Create An IBMid](https://cloud.ibm.com/docs/mas-saas?topic=mas-saas-getting-started-with-ibm-maximo-application-suite-saashow-to-create-an-ibmid)

[Register for Maximo Application Suite Support](https://cloud.ibm.com/docs/mas-saas?topic=mas-saas-getting-started-with-ibm-maximo-application-suite-saashow-to-register-for-mas-support)
4. On the following page, populate all required (*) fields ensuring Maximo Application Suite on Cloud is selected for Product and click on the Submit Case button.
5. Case Creation will be confirmed and case number referenced:

Note: Cases are nine digit numbers preceded with “TS”.

You will also receive an email confirming the Case number.
6. Click Back to all cases (in the upper left hand corner) or go to [https://www.ibm.com/mysupport/s/my-cases](https://www.ibm.com/mysupport/s/my-cases) to see a full list of your cases.







 Next steps 



1. Designate member(s) of your staff to subscribe to the [Client Communications Center (CCC)](https://cloud.ibm.com/docs/mas-ms?topic=mas-ms-client-communications-center) to receive important information and notifications regarding your environment(s):
Login to IBM Cloud and navigate to the IBM Schematics service as shown in the figure below: ![SchematicsMenuItem](https://cloud.ibm.com/docs-content/v1/content/d50364af907081c3c38f99c11f35dd9cab4b2510/vpc-journey/images/provision-vpc/schematics-menu-item.png)
2. From the Schematics Workspace tab, choose to create a new project workspace. ![CreateWorkspace](https://cloud.ibm.com/docs-content/v1/content/d50364af907081c3c38f99c11f35dd9cab4b2510/vpc-journey/images/provision-vpc/schematics-create-workspace.png)
3. Schematics can automatically pull terraform code from a GitHub repo. Enter https://github.com/IBM-Cloud/cloud-journey/tree/main/VPC as the repository URL (which represents the VPC architecture depicted above) and select terraform_v1.0. ![CreateWorkspace2](https://cloud.ibm.com/docs-content/v1/content/d50364af907081c3c38f99c11f35dd9cab4b2510/vpc-journey/images/provision-vpc/schematics-create-workspace2.png)
4. Specify the workspace details values based on your preferences. ![CreateWorkspace3](https://cloud.ibm.com/docs-content/v1/content/d50364af907081c3c38f99c11f35dd9cab4b2510/vpc-journey/images/provision-vpc/schematics-create-workspace3.png)

As a best practice, do NOT use the "default" resource group. Create a resource group for this network or project provides more flexibility.
[More about toolkit.properties](https://www.enterprisedb.com/edb-docs/d/edb-postgres-migration-toolkit/user-guides/user-guide/53.0.2/building_toolkit.properties_file.html)
2. Following the setup steps, the toolkit.properties file now resembles:

SRC_DB_URL=jdbc:oracle:thin:@localhost:1521:ORCL
SRC_DB_USER=ot
SRC_DB_PASSWORD=password

TARGET_DB_URL=jdbc:edb://$TARGET_HOST:TARGET_PORT/ot_migration
TARGET_DB_USER=enterprisedb
TARGET_DB_PASSWORD=password
3. Start MTK to begin the data migration process from OT Oracle schema to ot EnterpriseDB schema under ot_migration database. For more about MTK args, see [Migration Tookit](https://www.enterprisedb.com/edb-docs/d/edb-postgres-migration-toolkit/user-guides/user-guide/53.0.2/mtk_command_options.html)

/usr/edb/migrationtoolkit/bin/runMTK.sh -dataOnly -targetSchema ot -truncLoad OT
4. A successful migration output sample:

Enabling FK constraints & triggers on ot.warehouses...
Enabling indexes on ot.warehouses after data load...
Data Load Summary: Total Time (sec): 8.764 Total Rows: 2981 Total Size(MB): 0.105

Schema OT imported successfully.

Migration process completed successfully.

Migration logs have been saved to /root/.enterprisedb/migration-toolkit/logs

 Migration Summary 
Tables: 12 out of 12

Total objects: 12
Successful count: 12
Failed count: 0
Invalid count: 0


Show more









 Oracle to Databases for EnterpriseDB Migration by using MTK only 

You can run schema extraction, schema migration, and data migration by using Migration Toolkit (MTK) only.
Or work from the [sample template](https://github.com/Cloud-Schematics/blueprint-sample-template/).
* Review the module metadata and readme file information for the selected [modules](https://github.com/terraform-ibm-modules) to guide writing the template blueprint [module definitions](https://cloud.ibm.com/docs/schematics?topic=schematics-bp-template-schema-yamlbp-modules-schema).
* Define the [variable dependencies](https://cloud.ibm.com/docs/schematics?topic=schematics-bp-template-schema-yamlbp-modules-inputs-value) between modules to pass the resource dependency data for provisioned resources.
* Specify the [inputs](https://cloud.ibm.com/docs/schematics?topic=schematics-bp-template-schema-yamlbp-inputs) the template requires, guided by the inputs required for module configuration. Review the section on [Customizing environments with inputs](https://cloud.ibm.com/docs/schematics?topic=schematics-define-blueprintsdefine-blueprint-steps) to determine which inputs will be defined in the input file or specified as defaults. The input values are specified in step 4.
* Specify the template [outputs](https://cloud.ibm.com/docs/schematics?topic=schematics-bp-template-schema-yamlbp-outputs) that are to be returned when the environment is deployed. The values returned are typically an application URL or the IDs of provisioned resources.
* Optional: Create a readme file to document the template, inputs, and outputs. Best practice is to include an image of the reference architecture.



3. Push the completed blueprint template to a Git repo. If needed, create a Git version release tag for blueprint version management. [Semantic versioning](https://semver.org/) is strongly recommended.
4.
See [Enabling system entities](https://cloud.ibm.com/docs/assistant-data?topic=assistant-data-entitiesentities-enable-system-entities) for more detail.
2. Click Create entity.
3. In the Entity name field, type a descriptive name for the entity.

The entity name can contain letters (in Unicode), numbers, underscores, and hyphens. For example:



* @location
* @menu_item
* @product



Do not include spaces in the name. The name cannot be longer than 64 characters. Do not begin the name with the string sys- because it is reserved for system entities.

The at sign @ is prepended to the entity name automatically to identify the term as an entity. You do not need to add it.
4. Click Create entity.

![Screen capture of creating an entity](https://cloud.ibm.com/docs-content/v1/content/a2b18c153837bce00a5b4de496e4b4ca64bbf56e/assistant-data/images/create-entity.png)
5. For this entity, choose whether you want your assistant to use a dictionary-based or annotation-based approach to find mentions of it, and then follow the appropriate procedure.

For each entity that you create, choose one entity type to use only. As soon as you add an annotation for an entity, the contextual model is initialized and becomes the primary approach for analyzing user input to find mentions of that entity. The context in which the mention is used in the user input takes precedence over any exact matches that might be present. See [Entity evaluation overview](https://cloud.ibm.com/docs/assistant-data?topic=assistant-data-entitiesentities-described) for more information about how each type is evaluated.



* [Dictionary-based entities](https://cloud.ibm.com/docs/assistant-data?topic=assistant-data-entitiesentities-create-dictionary-based)
The deployment starts and you are directed to the Schematics page that displays the script log files for you to monitor the deployment progress.







 Deploying SAP NetWeaver 7.x and Db2 by using the Schematics user interface 

Use these steps to configure the SAP NetWeaver 7.X with Db2 on your existing VPC by using the Schematics user interface. The scripts can take 1 - 2 hours to complete.



1. From the IBM Cloud menu, select [Schematics](https://cloud.ibm.com/schematics/overview).
2. Click Create workspace.
3. On the Specify template page:



* Enter the GitHub URL with the code you plan to deploy.
* Select the Terraform version that is listed in the readme file.
* Click Next.



4. On the Workspace details page:



* Enter a name for the workspace.
* Select a Resource group.
* Select a Location for your workspace. The workspace location does not have to match the resource location.
* Select Next.



5. Select Create to create your workspace.
6. On the workspace Settings page, in the Input variables section, review the default input variables and provide values that match your solution:



* Your API key
* Your private SSH key from your local machine
* (Optional) you can change the ID_RSA_FILE_PATH for your SSH key that will be autogenerated on Schematics and Bastion Server
* The ID for the SSH key that you created and uploaded to IBM Cloud. Enter the SSH key ID in square brackets and quotation marks, for example [ "ibmcloud_ssh_key_UUID1","ibmcloud_ssh_key_UUID2",... ].
* The Region for your resources
* The Zone for your resources
* Whether to use an existing VPC or create one
* Whether to use an existing subnet
* Whether to create new port only when a new subnet is created
* TCP port range, nimimun and maximum
* VPC name
Next, you learn the steps to setup the two specific databases, Db2 and Netezza, which serves as the source of data for information retrieval.



1. From the navigation menu, select Infrastructure manager.
2. To add a database, click Add component and select Add database.
3. In the Add database form, select IBM Db2 from the database type drop-down menu to create Db2 database.

Select IBM Netezza from the database type drop-down menu to create Netezza database.
4. Specify the following details:

The database name must be unique. Two databases having the same name cannot be added.



Table 1. Register database

 Field Description 

 Name Enter the name of your database. 
 Description (optional) Describe the databse. 
 Tags (optional) Enter the tag name or select from drop-down list. 



Based on the database you are adding, enter related details in appropriate fields. For example, hostname, username, and password. For more information, see [Db2 connector](https://cloud.ibm.com/docs/watsonxdata?topic=watsonxdata-db2_connector) details and [Netezza connector](https://cloud.ibm.com/docs/watsonxdata?topic=watsonxdata-netezza_connector) details.

When the SSL Connection is selected, the server-side certificate that is used by the database must be issued by one of the global trusted certification authorities (CA) such as DigiCert. This is a typical case for cloud-hosted databases.
5. Click Add.







 Step 5: Associating with engine 

You must link the Db2 and Netezza databases to the Presto engine that is used to process the data.

To associate Db2 with the Presto engine, do the following steps:



1. From the Infrastructure manager, select Db2 database. Click the overflow menu icon at the end of the row and click Associate.
2. In the Associate with engine form, select the Presto engine that you want to use to process the data.
3. Click Associate and restart engine.
However, customization must be done carefully because when you add new words to the dictionary, the changes can impact the machine learning model in unintended ways.







 Summary of inputs, outputs, and limitations 

Different stages of model development require different inputs and produce different outputs.

For each stage of the model development process, this table summarizes the typical activities that you perform, the supported input file formats, the outputs that can be produced, and any sizing limits or other requirements.



 All model types 

Table 1: All model types



 Task Typical usage Supported input formats Supported output formats Limits and requirements 

 Type system management Create a type system or upload and modify an existing type system. Define entity types and relation types for your domain. You cannot see a visualization of the type system. <br><br> * JSON file that you downloaded from a Knowledge Studio workspace.<br> * ZIP file that you downloaded from the Human Annotation Tool (HAT)<br><br><br> JSON To avoid visual overload for human annotation, define no more than 50 entity types and 50 relation types. File size limitation for uploading a type system: 20 MB 
 Dictionary management Upload a CSV dictionary file in read-only mode or a ZIP of dictionaries that you downloaded from another workspace. Create a new dictionary, and then upload a CSV file of term entries or add term entries to it.
Required.

--table-schema (string)
: The virtualized table's schema name. Required.





 Examples 

Revoke user access to the virtualized table

ibmcloud watson-query virtualized-table-user-revoke --table-name TABLE1 --table-schema DV_IBMID_270001PD8Q --user user1@ibm.com









 Roles 

Manage service roles for users and virtualized tables.



 ibmcloud watson-query virtualized-table-role-grant 

Grant a user role access to a specific virtualized table.

ibmcloud watson-query virtualized-table-role-grant --table-name TABLE-NAME --table-schema TABLE-SCHEMA --role ROLE



 Command options 

--table-name (string)
: The name of the virtualized table. Required. The minimum length is 1 character.

--table-schema (string)
: The schema of the virtualized table. Required. The minimum length is 1 character.

--role (string)
: The identifier of the authorization, if grant access to all users, the value is PUBLIC, othervise the value is the watson query username. Required. The minimum length is 1 character.





 Examples 

Grants a user role access to a specific virtualized table

ibmcloud watson-query virtualized-table-role-grant --table-name TABLE1 --table-schema DV_IBMID_270001PD8Q --role DV_ENGINEER







 ibmcloud watson-query virtualized-table-role-revoke 

Revoke roles access to a virtualized table.

ibmcloud watson-query virtualized-table-role-revoke --role ROLE --table-name TABLE-NAME --table-schema TABLE-SCHEMA



 Command options 

--role (string)
: The watson query role type. Values can be DV_ADMIN, DV_ENGINEER, DV_STEWARD, or DV_WORKER, which correspond to MANAGER, ENGINEER, STEWARD, and USER roles in the user interface. Required.
Creating an engine 

To create an engine, complete the following steps.



1.  Log in to watsonx.data console.
2.  From the navigation menu, select Infrastructure manager.
3.  To provision an engine, click Add component and select Create engine.
4.  In the Create engine window, provide the following details to a sign up new compute to work with your data.



Table 1. Provision engine

 Field                           Description                                                                                   

 Type                            Select the engine type from the list.                                                         
 Display name                    Enter your compute engine name.                                                               
 Configuration mode              Select Quick for predefined engine sizes or Custom for customized engine configuration.       
 Size                            Select the engine size. For all sizes, coordinator and worker nodes are storage-optimized.    
 Catalogs associated (optional)  Associate the available catalogs with the engine if necessary.                                



5.  Click Create.
The <columnType> can be one of the following data types: Integer, Float, Boolean, or Text.
* [ and <columnName> <columnType> ]

Specifies additional column names and types to the schema of the Document view. They follow the same rules as <columnName> and <columnType>.



In earlier versions of AQL, the schema of the special view Document was predefined to consist of either a single field (text Text) or two fields (text text, label Text). The choice between these schemas was decided at run time. By using the require document with columns statement, you can override the default input document schema at compile time.





 Usage notes 



* For modular AQL code, the scope of any require document with columns statement is the module in which it is defined.
* Only one require document with columns statement is allowed per AQL file. Within a single module, or a generic module, there can be zero, one, or multiple AQL files that have a require document with columns statement. All AQL files within a module merge their require document with columns statements at the level of the entire module to form a module-wide require document with columns. This statement defines the schema of the Document view for that module. If none of the AQL files of a module or a generic module contain a require statement, the module has a default schema for the view Document. This schema consists of two columns: (text Text, label Text). No default columns are established for the special view Document if at least one AQL file in the module has one require document with columns statement.
* When multiple modules are combined to form an extractor, the schema of the Document view of the entire extractor is defined by the duplicate-free union of Document schemas for each module. An exception is raised when any column found across the multiple require document with columns statements is found to be conflicting in its type requirements across modules. For example, a module requires a column X with type Y when another module that is being loaded with it requires a column X with type Z.
* An exception is raised when you run an extractor if the provided input document tuple does not contain all of the required columns.
Refer to the list of [limitations](https://cloud.ibm.com/docs/schematics?topic=schematics-bp-beta-limitationssc-bp-beta-limitation) for the beta release.



 ibmcloud schematics blueprint create 

Create a blueprint config from the command line using the ibmcloud schematics blueprint create command. Creating a blueprint config is the first step to deploy a blueprint environment. The blueprint config is created from user provided parameters via the command line that specifies the source of the blueprint template in a Git repository, and input values sourced from Git hosted input files and locally sourced input values.

The create command supports passing all required parameters through CLI and passing input values from local files.

A experimental file option is provided to create a blueprint config from a configuration provided as a JSON file from the local file system. Refer to the [ibmcloud schematics blueprint create - file option](https://cloud.ibm.com/docs/schematics?topic=schematics-schematics-cli-referenceschematics-blueprint-create) section. These two usage modes are mutually exclusive.

For Schematics Blueprints, the [Schematics plug-in](https://cloud.ibm.com/docs/schematics?topic=schematics-setup-cliinstall-schematics-plugin) version must be greater than the 1.12.5 version.

Refer to the section on [Creating Blueprints](https://cloud.ibm.com/docs/schematics?topic=schematics-schematics-cli-referenceschematics-blueprint-create) for examples of command syntax and output.

Before you begin:



* Install or update the [Schematics plug-in](https://cloud.ibm.com/docs/schematics?topic=schematics-setup-cliinstall-schematics-plugin) version that is greater than the 1.12.5.
* Select the IBM Cloud region that you wish to use to manage your Schematics.