ibm-watsonx-orchestrate 1.0.0__py3-none-any.whl

ibm_watsonx_orchestrate/cli/commands/environment/environment_controller.py

@@ -0,0 +1,189 @@
+import logging
+import rich
+import jwt
+import getpass
+
+from ibm_watsonx_orchestrate.cli.commands.tools.types import RegistryType
+from ibm_watsonx_orchestrate.cli.config import (
+    Config,
+    AUTH_CONFIG_FILE_FOLDER,
+    AUTH_CONFIG_FILE,
+    AUTH_SECTION_HEADER,
+    AUTH_MCSP_TOKEN_OPT,
+    AUTH_MCSP_TOKEN_EXPIRY_OPT,
+    CONTEXT_ACTIVE_ENV_OPT,
+    CONTEXT_SECTION_HEADER,
+    ENV_WXO_URL_OPT,
+    ENV_IAM_URL_OPT,
+    ENVIRONMENTS_SECTION_HEADER,
+    PROTECTED_ENV_NAME,
+    ENV_AUTH_TYPE, PYTHON_REGISTRY_HEADER, PYTHON_REGISTRY_TYPE_OPT, PYTHON_REGISTRY_TEST_PACKAGE_VERSION_OVERRIDE_OPT,
+    DEFAULT_CONFIG_FILE_CONTENT
+)
+from ibm_watsonx_orchestrate.client.client import Client
+from ibm_watsonx_orchestrate.client.client_errors import ClientError
+from ibm_watsonx_orchestrate.client.credentials import Credentials
+from threading import Lock
+from ibm_watsonx_orchestrate.client.utils import is_local_dev, check_token_validity
+from ibm_watsonx_orchestrate.cli.commands.environment.types import EnvironmentAuthType
+
+logger = logging.getLogger(__name__)
+
+lock = Lock()
+
+def _decode_token(token: str, is_local: bool = False) -> dict:
+    try:
+        claimset = jwt.decode(token, options={"verify_signature": False})
+        data = {AUTH_MCSP_TOKEN_OPT: token}
+        if not is_local:
+            data[AUTH_MCSP_TOKEN_EXPIRY_OPT] = claimset["exp"]
+        return data
+    except jwt.DecodeError as e:
+        logger.error("Invalid token format")
+        raise e
+
+def _login(name: str, apikey: str = None) -> None:
+    cfg = Config()
+    auth_cfg = Config(AUTH_CONFIG_FILE_FOLDER, AUTH_CONFIG_FILE)
+
+    env_cfg = cfg.get(ENVIRONMENTS_SECTION_HEADER, name)
+    url = env_cfg.get(ENV_WXO_URL_OPT)
+    iam_url = env_cfg.get(ENV_IAM_URL_OPT)
+    is_local = name == PROTECTED_ENV_NAME or is_local_dev(url=url)
+    try:
+        auth_type = cfg.get(ENVIRONMENTS_SECTION_HEADER, name, ENV_AUTH_TYPE)
+    except (KeyError, AttributeError):
+        auth_type = None
+
+
+    if apikey is None and not is_local:
+        apikey = getpass.getpass("Please enter WXO API key: ")
+
+    try:
+        creds = Credentials(url=url, api_key=apikey, iam_url=iam_url, auth_type=auth_type)
+        client = Client(creds)
+        token = _decode_token(client.token, is_local)
+        with lock:
+            auth_cfg.save(
+                {
+                    AUTH_SECTION_HEADER: {
+                        name: token
+                    },
+                }
+            )
+    except ClientError as e:
+        raise ClientError(e)
+
+def activate(name: str, apikey: str=None, registry: RegistryType=None, test_package_version_override=None) -> None:
+    cfg = Config()
+    auth_cfg = Config(AUTH_CONFIG_FILE_FOLDER, AUTH_CONFIG_FILE)
+    env_cfg = cfg.read(ENVIRONMENTS_SECTION_HEADER, name)
+    url = cfg.get(ENVIRONMENTS_SECTION_HEADER, name, ENV_WXO_URL_OPT)
+    is_local = is_local_dev(url)
+
+    if not env_cfg:
+        logger.error(f"Environment '{name}' does not exist. Please create it with `orchestrate env add`")
+        return
+    elif not env_cfg.get(ENV_WXO_URL_OPT):
+        logger.error(f"Environment '{name}' is misconfigured. Please re-create it with `orchestrate env add`")
+        return
+
+    existing_auth_config = auth_cfg.get(AUTH_SECTION_HEADER).get(name, {})
+    existing_token = existing_auth_config.get(AUTH_MCSP_TOKEN_OPT) if existing_auth_config else None
+
+    if not check_token_validity(existing_token) or is_local:
+        _login(name=name, apikey=apikey)
+
+    with lock:
+        cfg.write(CONTEXT_SECTION_HEADER, CONTEXT_ACTIVE_ENV_OPT, name)
+        if registry is not None:
+            cfg.write(PYTHON_REGISTRY_HEADER, PYTHON_REGISTRY_TYPE_OPT, str(registry))
+            cfg.write(PYTHON_REGISTRY_HEADER, PYTHON_REGISTRY_TEST_PACKAGE_VERSION_OVERRIDE_OPT, test_package_version_override)
+        elif cfg.read(PYTHON_REGISTRY_HEADER, PYTHON_REGISTRY_TYPE_OPT) is None:
+            cfg.write(PYTHON_REGISTRY_HEADER, PYTHON_REGISTRY_TYPE_OPT, DEFAULT_CONFIG_FILE_CONTENT[PYTHON_REGISTRY_HEADER][PYTHON_REGISTRY_TYPE_OPT])
+            cfg.write(PYTHON_REGISTRY_HEADER, PYTHON_REGISTRY_TEST_PACKAGE_VERSION_OVERRIDE_OPT, test_package_version_override)
+
+    logger.info(f"Environment '{name}' is now active")
+
+def add(name: str, url: str, should_activate: bool=False, iam_url: str=None, type: EnvironmentAuthType=None) -> None:
+    if name == PROTECTED_ENV_NAME:
+        logger.error(f"The name '{PROTECTED_ENV_NAME}' is a reserved environment name. Please select a diffrent name or use `orchestrate env activate {PROTECTED_ENV_NAME}` to swap to '{PROTECTED_ENV_NAME}'")
+        return
+
+    cfg = Config()
+    existing_env_cfg = cfg.read(ENVIRONMENTS_SECTION_HEADER, name)
+    if existing_env_cfg:
+        logger.info(f"Existing environment with name '{name}' found.")
+        update_response = input(f"Would you like to update the environment '{name}'? (Y/n)")
+        if update_response.lower() == "n":
+            logger.info(f"No changes made to environments")
+            return
+    with lock:
+        cfg.write(ENVIRONMENTS_SECTION_HEADER, name, {ENV_WXO_URL_OPT: url})
+        if iam_url:
+            cfg.write(ENVIRONMENTS_SECTION_HEADER, name, {ENV_IAM_URL_OPT: iam_url})
+        if type:
+            cfg.write(ENVIRONMENTS_SECTION_HEADER, name, {ENV_AUTH_TYPE: str(type)})
+        
+
+    logger.info(f"Environment '{name}' has been created")
+    if should_activate:
+        activate(name)
+
+def remove(name: str) -> None:
+    if name == PROTECTED_ENV_NAME:
+        logger.error(f"The environment '{PROTECTED_ENV_NAME}' is a default environment and cannot be removed.")
+        return
+
+    cfg = Config()
+    auth_cfg = Config(AUTH_CONFIG_FILE_FOLDER, AUTH_CONFIG_FILE)
+    active_env = cfg.read(CONTEXT_SECTION_HEADER, CONTEXT_ACTIVE_ENV_OPT)
+    existing_env_cfg = cfg.read(ENVIRONMENTS_SECTION_HEADER, name)
+    existing_auth_env_cfg = auth_cfg.read(AUTH_SECTION_HEADER, name)
+
+    if not existing_env_cfg:
+        logger.info(f"No environment named '{name}' exists")
+        return
+
+    if name == active_env:
+        remove_confirmation = input(f"The environment '{name}' is currently active, are you sure you wish to remove it? (y/N)")
+        if remove_confirmation.lower() != 'y':
+            logger.info("No changes made to environments")
+            return
+        cfg.write(CONTEXT_SECTION_HEADER, CONTEXT_ACTIVE_ENV_OPT, None)
+
+    cfg.delete(ENVIRONMENTS_SECTION_HEADER, name)
+    if existing_auth_env_cfg:
+        auth_cfg.delete(AUTH_SECTION_HEADER, name)
+    logger.info(f"Successfully removed environment '{name}'")
+
+def list_envs() -> None:
+    cfg = Config()
+    active_env = cfg.read(CONTEXT_SECTION_HEADER, CONTEXT_ACTIVE_ENV_OPT)
+    envs = cfg.get(ENVIRONMENTS_SECTION_HEADER)
+
+    table = rich.table.Table(
+        show_header=False,
+        box=None
+    )
+    columns = ["Environment", "Url", ""]
+    for col in columns:
+        table.add_column(col)
+
+    # Make order active first followed alphabetically
+    env_names = []
+    if active_env:
+        env_names.append(active_env)
+    else:
+        logger.warning("No active environment is currently set. Use `orchestrate env activate` to set one")
+    envs_keys = list(envs.keys())
+    if active_env in envs_keys: envs_keys.remove(active_env)
+    envs_keys.sort()
+    env_names += envs_keys
+
+    for env in env_names:
+        active_tag = "[green](active)[/green]" if env == active_env else ""
+        table.add_row(env, envs.get(env, {}).get(ENV_WXO_URL_OPT, "N/A"), active_tag)
+    
+    console = rich.console.Console()
+    console.print(table)

ibm_watsonx_orchestrate/cli/commands/environment/types.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class EnvironmentAuthType(str, Enum):
+    IBM_CLOUD_IAM = 'ibm_iam'
+    MCSP = 'mcsp'
+
+    def __str__(self):
+        return self.value

ibm_watsonx_orchestrate/cli/commands/knowledge_bases/knowledge_bases_command.py

@@ -0,0 +1,79 @@
+import typer
+from typing_extensions import Annotated
+from ibm_watsonx_orchestrate.cli.commands.knowledge_bases.knowledge_bases_controller import KnowledgeBaseController
+
+knowledge_bases_app = typer.Typer(no_args_is_help=True)
+
+
+@knowledge_bases_app.command(name="import", help="Import a knowledge-base by uploading documents, or providing an external vector index")
+def knowledge_base_import(
+    file: Annotated[
+        str,
+        typer.Option("--file", "-f", help="YAML file with knowledge base definition"),
+    ],
+    app_id: Annotated[
+        str, typer.Option(
+            '--app-id', '-a',
+            help='The app id of the connection to associate with this knowledge base. A application connection represents the authentication credentials needed to connection to the external Milvus or Elasticsearch instance (for example Api Keys, Basic, Bearer or OAuth credentials).'
+        )
+    ] = None,
+):
+    controller = KnowledgeBaseController()
+    controller.import_knowledge_base(file=file, app_id=app_id)
+
+@knowledge_bases_app.command(name="patch", help="Patch a knowledge base by uploading documents, or providing an external vector index")
+def knowledge_base_patch(
+    file: Annotated[
+        str,
+        typer.Option("--file", "-f", help="YAML file with knowledge base definition"),
+    ],
+    name: Annotated[
+        str,
+        typer.Option("--name", "-n", help="Name of the knowledge base you wish to update"),
+    ]=None,
+    id: Annotated[
+        str,
+        typer.Option("--id", "-i", help="ID of the knowledge base you wish to update"),
+    ]=None
+):
+    controller = KnowledgeBaseController()
+    controller.update_knowledge_base(id=id, name=name, file=file)
+
+
+@knowledge_bases_app.command(name="list", help="List all knowledge bases")
+def list_knowledge_bases(
+    verbose: Annotated[
+        bool,
+        typer.Option("--verbose", "-v", help="List full details of all knowledge bases in json format"),
+    ] = False,
+):  
+    controller = KnowledgeBaseController()
+    controller.list_knowledge_bases(verbose=verbose)
+
+@knowledge_bases_app.command(name="remove", help="Delete a knowlege base and all ingested documents")
+def remove_knowledge_base(
+    name: Annotated[
+        str,
+        typer.Option("--name", "-n", help="Name of the knowledge base you wish to remove"),
+    ]=None,
+    id: Annotated[
+        str,
+        typer.Option("--id", "-i", help="ID of the knowledge base you wish to remove"),
+    ]=None
+):  
+    controller = KnowledgeBaseController()
+    controller.remove_knowledge_base(id=id, name=name)
+
+@knowledge_bases_app.command(name="status", help="Get the status of a knowlege base")
+def knowledge_base_status(
+    name: Annotated[
+        str,
+        typer.Option("--name", "-n", help="Name of the knowledge base you wish to get the status of"),
+    ]=None,
+    id: Annotated[
+        str,
+        typer.Option("--id", "-i", help="ID of the knowledge base you wish to get the status of"),
+    ]=None
+):  
+    controller = KnowledgeBaseController()
+    controller.knowledge_base_status(id=id, name=name)

ibm_watsonx_orchestrate/cli/commands/knowledge_bases/knowledge_bases_controller.py

@@ -0,0 +1,201 @@
+import sys
+import json
+import rich
+import requests
+import logging
+
+from ibm_watsonx_orchestrate.agent_builder.knowledge_bases.knowledge_base_requests import KnowledgeBaseCreateRequest, KnowledgeBaseUpdateRequest
+from ibm_watsonx_orchestrate.agent_builder.knowledge_bases.knowledge_base import KnowledgeBase
+from ibm_watsonx_orchestrate.client.knowledge_bases.knowledge_base_client import KnowledgeBaseClient
+from ibm_watsonx_orchestrate.client.base_api_client import ClientAPIException
+from ibm_watsonx_orchestrate.client.connections import get_connections_client
+
+from ibm_watsonx_orchestrate.client.utils import instantiate_client
+
+logger = logging.getLogger(__name__)
+
+def to_column_name(col: str):
+    return " ".join([word.capitalize() if not word[0].isupper() else word for word in col.split("_")])
+
+def get_file_name(path: str):
+    # This name prettifying currently screws up file type detection on ingestion
+    # return to_column_name(path.split("/")[-1].split(".")[0]) 
+    return path.split("/")[-1]
+
+class KnowledgeBaseController:
+    def __init__(self):
+        self.client = None
+        self.connections_client = None
+
+    def get_client(self):
+        if not self.client:
+            self.client = instantiate_client(KnowledgeBaseClient)
+        return self.client
+    
+    def import_knowledge_base(self, file: str, app_id: str):
+        client = self.get_client()
+        create_request = KnowledgeBaseCreateRequest.from_spec(file=file)
+
+        try:
+            if create_request.documents:
+                try:
+                    file_dir = "/".join(file.split("/")[:-1])
+                    files = [('files', (get_file_name(file_path), open(file_path if file_path.startswith("/") else f"{file_dir}/{file_path}", 'rb'))) for file_path in create_request.documents]
+                except Exception as e:
+                    logger.error(f"Error importing knowledge base: {str(e).replace('[Errno 2] ', '')}")
+                    sys.exit(1);
+
+                payload = create_request.model_dump(exclude_none=True);
+                payload.pop('documents');
+
+                client.create_built_in(payload=payload, files=files)
+            else:
+                if len(create_request.conversational_search_tool.index_config) != 1:
+                    raise ValueError(f"Must provide exactly one conversational_search_tool.index_config. Provided {len(create_request.conversational_search_tool.index_config)}.")
+                
+                if app_id:
+                    connections_client = get_connections_client()
+                    connection_id = None
+                    if app_id is not None:
+                        connections = connections_client.get_draft_by_app_id(app_id=app_id)
+                        if not connections:
+                            logger.error(f"No connection exists with the app-id '{app_id}'")
+                            exit(1)
+
+                        connection_id = connections.connection_id
+                        create_request.conversational_search_tool.index_config[0].connection_id = connection_id
+
+                client.create(payload=create_request.model_dump(exclude_none=True))
+            
+            logger.info(f"Successfully imported knowledge base '{create_request.name}'")
+        except ClientAPIException as e:
+            if "duplicate key value violates unique constraint" in e.response.text:
+                logger.error(f"A knowledge base with the name '{create_request.name}' already exists. Failed to import knowledge base")
+            else:
+                logger.error(f"Error importing knowledge base '{create_request.name}\n' {e.response.text}")
+    
+    def get_id(
+        self, id: str, name: str
+    ) -> str:
+        if id:
+            return id
+        
+        if not name:
+            logger.error("Either 'id' or 'name' is required")
+            sys.exit(1)
+
+        response = self.get_client().get_by_name(name)
+
+        if not response:
+            logger.warning(f"No knowledge base '{name}' found")
+            sys.exit(1)
+
+        return response.get('id')
+
+
+    def update_knowledge_base(
+        self, id: str, name: str, file: str
+    ) -> None:
+        knowledge_base_id = self.get_id(id, name)
+        update_request = KnowledgeBaseUpdateRequest.from_spec(file=file)
+
+        if update_request.documents:
+            file_dir = "/".join(file.split("/")[:-1])
+            files = [('files', (get_file_name(file_path), open(file_path if file_path.startswith("/") else f"{file_dir}/{file_path}", 'rb'))) for file_path in update_request.documents]
+            
+            payload = update_request.model_dump(exclude_none=True);
+            payload.pop('documents');
+
+            self.get_client().update_with_documents(knowledge_base_id, payload=payload, files=files)
+        else:
+            self.get_client().update(knowledge_base_id, update_request.model_dump(exclude_none=True))
+
+        logEnding = f"with ID '{id}'" if id else f"'{name}'"
+        logger.info(f"Successfully updated knowledge base {logEnding}")
+
+
+    def knowledge_base_status( self, id: str, name: str) -> None:
+        knowledge_base_id = self.get_id(id, name)
+        response = self.get_client().status(knowledge_base_id)
+
+        if 'documents' in response:
+            response[f"documents ({len(response['documents'])})"] = ", ".join([str(doc.get('metadata', {}).get('original_file_name', '<Unnamed File>')) for doc in response['documents']])
+            response.pop('documents')
+
+        table = rich.table.Table(
+            show_header=True, 
+            header_style="bold white", 
+            show_lines=True
+        )
+
+        if "id" in response:
+            kbID = response["id"]
+            del response["id"]
+
+            response["id"] = kbID
+        
+        [table.add_column(to_column_name(col), {}) for col in response.keys()]
+        table.add_row(*[str(val) for val in response.values()])
+        
+        rich.print(table)
+
+
+    def list_knowledge_bases(self, verbose: bool=False):
+        response = self.get_client().get()
+        knowledge_bases = [KnowledgeBase.model_validate(knowledge_base) for knowledge_base in response]
+
+        knowledge_base_list = []
+        if verbose:
+            for kb in knowledge_bases:
+                knowledge_base_list.append(json.loads(kb.model_dump_json(exclude_none=True)))
+            rich.print(rich.json.JSON(json.dumps(knowledge_base_list, indent=4)))
+        else:
+            table = rich.table.Table(
+                show_header=True, 
+                header_style="bold white", 
+                show_lines=True
+            )
+
+            column_args = {
+                "Name": {},
+                "Description": {},
+                "App ID": {},
+                "ID": {}
+            }
+            
+            for column in column_args:
+                table.add_column(column, **column_args[column])
+            
+            for kb in knowledge_bases:
+                app_id = ""
+                
+                if kb.conversational_search_tool is not None \
+                   and kb.conversational_search_tool.index_config is not None \
+                   and len(kb.conversational_search_tool.index_config) > 0 \
+                   and kb.conversational_search_tool.index_config[0].connection_id is not None:
+                    connections_client = get_connections_client()
+                    app_id = str(connections_client.get_draft_by_id(kb.conversational_search_tool.index_config[0].connection_id))
+
+                table.add_row(
+                    kb.name,
+                    kb.description,
+                    app_id,
+                    str(kb.id)
+                )
+
+            rich.print(table)
+        
+
+    def remove_knowledge_base(self, id: str, name: str):
+        knowledge_base_id = self.get_id(id, name)      
+        logEnding = f"with ID '{id}'" if id else f"'{name}'"
+
+        try:
+            self.get_client().delete(knowledge_base_id=knowledge_base_id)
+            logger.info(f"Successfully removed knowledge base {logEnding}")
+        except requests.HTTPError as e:
+            if e.response.status_code == 404:
+                logger.warning(f"No knowledge base {logEnding} found")
+            logger.error(e.response.text)
+            exit(1)
+

ibm_watsonx_orchestrate/cli/commands/login/login_command.py

@@ -0,0 +1,17 @@
+import logging
+import typer
+from typing_extensions import Annotated
+
+# REMOVE THIS FILE AFTER ONE MAJOR UPDATE
+logger = logging.getLogger(__name__)
+
+login_app = typer.Typer(no_args_is_help=True)
+
+@login_app.command(name="login", add_help_option=False, hidden=True)
+def login(
+    local: Annotated[bool, typer.Option("--local", help="local login ")] = False):
+
+    if local:
+        logger.error("The command `orchestrate login --local` has been deprecated. Please use `orchestrate env activate local` instead") 
+    else:
+        logger.error("The command `orchestrate login` has been deprecated. Please use `orchestrate env activate <env>` instead")

ibm_watsonx_orchestrate/cli/commands/models/models_command.py

@@ -0,0 +1,128 @@
+import logging
+import os
+import requests
+import sys
+import rich.highlighter
+import typer
+import rich
+import typer
+from typing_extensions import Annotated
+from ibm_watsonx_orchestrate.cli.commands.server.server_command import get_default_env_file, merge_env
+
+logger = logging.getLogger(__name__)
+models_app = typer.Typer(no_args_is_help=True)
+
+WATSONX_URL = os.getenv("WATSONX_URL")
+
+class ModelHighlighter(rich.highlighter.RegexHighlighter):
+    base_style = "model."
+    highlights = [r"(?P<name>watsonx\/.+\/.+):"]
+
+@models_app.command(name="list")
+def model_list(
+    print_raw: Annotated[
+        bool,
+        typer.Option("--raw", "-r", help="Display the list of models in a non-tabular format"),
+    ] = False,
+):
+    global WATSONX_URL
+    default_env_path = get_default_env_file()
+    merged_env_dict = merge_env(
+        default_env_path,
+        None
+    )
+
+    if 'WATSONX_URL' in merged_env_dict and merged_env_dict['WATSONX_URL']:
+        WATSONX_URL = merged_env_dict['WATSONX_URL']
+
+    watsonx_url = merged_env_dict.get("WATSONX_URL")
+    if not watsonx_url:
+        logger.error("Error: WATSONX_URL is required in the environment.")
+        sys.exit(1)
+
+    logger.info("Retrieving watsonx.ai models list...")
+    found_models = _get_wxai_foundational_models()
+
+    preferred_str = merged_env_dict.get('PREFERRED_MODELS', '')
+    incompatible_str = merged_env_dict.get('INCOMPATIBLE_MODELS', '') 
+
+    preferred_list = _string_to_list(preferred_str)
+    incompatible_list = _string_to_list(incompatible_str)
+
+    models = found_models.get("resources", [])
+    if not models:
+        logger.error("No models found.")
+    else:
+        # Remove incompatible models
+        filtered_models = []
+        for model in models:
+            model_id = model.get("model_id", "")
+            short_desc = model.get("short_description", "")
+            if any(incomp in model_id.lower() for incomp in incompatible_list):
+                continue
+            if any(incomp in short_desc.lower() for incomp in incompatible_list):
+                continue
+            filtered_models.append(model)
+        
+        # Sort to put preferred first
+        def sort_key(model):
+            model_id = model.get("model_id", "").lower()
+            is_preferred = any(pref in model_id for pref in preferred_list)
+            return (0 if is_preferred else 1, model_id)
+        
+        sorted_models = sorted(filtered_models, key=sort_key)
+        
+        if print_raw:
+            theme = rich.theme.Theme({"model.name": "bold cyan"})
+            console = rich.console.Console(highlighter=ModelHighlighter(), theme=theme)
+            console.print("[bold]Available Models:[/bold]")
+            for model in sorted_models:
+                model_id = model.get("model_id", "N/A")
+                short_desc = model.get("short_description", "No description provided.")
+                full_model_name = f"watsonx/{model_id}: {short_desc}"
+                marker = "★ " if any(pref in model_id.lower() for pref in preferred_list) else ""
+                console.print(f"- [yellow]{marker}[/yellow]{full_model_name}")
+
+            console.print("[yellow]★[/yellow] [italic dim]indicates a supported and preferred model[/italic dim]" )
+        else:
+            table = rich.table.Table(
+                show_header=True,
+                title="[bold]Available Models[/bold]",
+                caption="[yellow]★[/yellow] indicates a supported and preferred model",
+                show_lines=True)
+            columns = ["Model", "Description"]
+            for col in columns:
+                table.add_column(col)
+
+            for model in sorted_models:
+                model_id = model.get("model_id", "N/A")
+                short_desc = model.get("short_description", "No description provided.")
+                marker = "★ " if any(pref in model_id.lower() for pref in preferred_list) else ""
+                table.add_row(f"[yellow]{marker}[/yellow]watsonx/{model_id}", short_desc)
+        
+            rich.print(table)
+
+def _get_wxai_foundational_models():
+    foundation_models_url = WATSONX_URL + "/ml/v1/foundation_model_specs?version=2024-05-01"
+
+    try:
+        response = requests.get(foundation_models_url)
+    except requests.exceptions.RequestException as e:
+        logger.exception(f"Exception when connecting to Watsonx URL: {foundation_models_url}")
+        raise
+
+    if response.status_code != 200:
+        error_message = (
+            f"Failed to retrieve foundational models from {foundation_models_url}. "
+            f"Status code: {response.status_code}. Response: {response.content}"
+        )
+        raise Exception(error_message)
+    
+    json_response = response.json()
+    return json_response
+
+def _string_to_list(env_value):
+    return [item.strip().lower() for item in env_value.split(",") if item.strip()]
+
+if __name__ == "__main__":
+    models_app()