clarifai 11.6.3__tar.gz → 11.6.4rc1__tar.gz

{clarifai-11.6.3/clarifai.egg-info → clarifai-11.6.4rc1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clarifai
-Version: 11.6.3
+Version: 11.6.4rc1
 Home-page: https://github.com/Clarifai/clarifai-python
 Author: Clarifai
 Author-email: support@clarifai.com

clarifai-11.6.4rc1/clarifai/__init__.py

@@ -0,0 +1 @@
+__version__ = "11.6.4rc1"

{clarifai-11.6.3 → clarifai-11.6.4rc1}/clarifai/cli/base.py

@@ -154,11 +154,12 @@ def env(ctx_obj):
 
 
 @cli.command()
-@click.argument('api_url', default="https://api.clarifai.com")
+@click.argument('api_url', default=DEFAULT_BASE)
 @click.option('--user_id', required=False, help='User ID')
 @click.pass_context
 def login(ctx, api_url, user_id):
     """Login command to set PAT and other configurations."""
+    from clarifai.utils.cli import validate_context_auth
 
     name = input('context name (default: "default"): ')
     user_id = user_id if user_id is not None else input('user id: ')
@@ -167,6 +168,9 @@ def login(ctx, api_url, user_id):
         'ENVVAR',
     )
 
+    # Validate the Context Credentials
+    validate_context_auth(pat, user_id, api_url)
+
     context = Context(
         name,
         CLARIFAI_API_BASE=api_url,
@@ -181,6 +185,9 @@ def login(ctx, api_url, user_id):
     ctx.obj.current_context = context.name
 
     ctx.obj.to_yaml()
+    logger.info(
+        f"Login successful and Configuration saved successfully for context '{context.name}'"
+    )
 
 
 @cli.group(cls=AliasedGroup)
@@ -211,8 +218,10 @@ def create(
     pat=None,
 ):
     """Create a new context"""
+    from clarifai.utils.cli import validate_context_auth
+
     if name in ctx.obj.contexts:
-        print(f'{name} already exists')
+        logger.info(f'"{name}" context already exists')
         sys.exit(1)
     if not user_id:
         user_id = input('user id: ')
@@ -226,9 +235,13 @@ def create(
             'ENVVAR',
         )
 
+    # Validate the Context Credentials
+    validate_context_auth(pat, user_id, base_url)
+
     context = Context(name, CLARIFAI_USER_ID=user_id, CLARIFAI_API_BASE=base_url, CLARIFAI_PAT=pat)
     ctx.obj.contexts[context.name] = context
     ctx.obj.to_yaml()
+    logger.info(f"Context '{name}' created successfully")
 
 
 # write a click command to delete a context

{clarifai-11.6.3 → clarifai-11.6.4rc1}/clarifai/cli/model.py

@@ -4,20 +4,65 @@ import tempfile
 
 import click
 
-from clarifai.cli.base import cli
+from clarifai.cli.base import cli, pat_display
 from clarifai.utils.cli import validate_context
 from clarifai.utils.constants import (
-    DEFAULT_LOCAL_DEV_APP_ID,
-    DEFAULT_LOCAL_DEV_COMPUTE_CLUSTER_CONFIG,
-    DEFAULT_LOCAL_DEV_COMPUTE_CLUSTER_ID,
-    DEFAULT_LOCAL_DEV_DEPLOYMENT_ID,
-    DEFAULT_LOCAL_DEV_MODEL_ID,
-    DEFAULT_LOCAL_DEV_MODEL_TYPE,
-    DEFAULT_LOCAL_DEV_NODEPOOL_CONFIG,
-    DEFAULT_LOCAL_DEV_NODEPOOL_ID,
+    DEFAULT_LOCAL_RUNNER_APP_ID,
+    DEFAULT_LOCAL_RUNNER_COMPUTE_CLUSTER_CONFIG,
+    DEFAULT_LOCAL_RUNNER_COMPUTE_CLUSTER_ID,
+    DEFAULT_LOCAL_RUNNER_DEPLOYMENT_ID,
+    DEFAULT_LOCAL_RUNNER_MODEL_ID,
+    DEFAULT_LOCAL_RUNNER_MODEL_TYPE,
+    DEFAULT_LOCAL_RUNNER_NODEPOOL_CONFIG,
+    DEFAULT_LOCAL_RUNNER_NODEPOOL_ID,
+    DEFAULT_OLLAMA_MODEL_REPO,
+    DEFAULT_OLLAMA_MODEL_REPO_BRANCH,
 )
 from clarifai.utils.logging import logger
-from clarifai.utils.misc import clone_github_repo, format_github_repo_url
+from clarifai.utils.misc import GitHubDownloader, clone_github_repo, format_github_repo_url
+
+
+def customize_ollama_model(model_path, model_name, port, context_length):
+    """Customize the Ollama model name in the cloned template files.
+    Args:
+     model_path: Path to the cloned model directory
+     model_name: The model name to set (e.g., 'llama3.1', 'mistral')
+
+    """
+    model_py_path = os.path.join(model_path, "1", "model.py")
+
+    if not os.path.exists(model_py_path):
+        logger.warning(f"Model file {model_py_path} not found, skipping model name customization")
+        return
+
+    try:
+        # Read the model.py file
+        with open(model_py_path, 'r') as file:
+            content = file.read()
+        if model_name:
+            # Replace the default model name in the load_model method
+            content = content.replace(
+                'self.model = os.environ.get("OLLAMA_MODEL_NAME", \'llama3.2\')',
+                f'self.model = os.environ.get("OLLAMA_MODEL_NAME", \'{model_name}\')',
+            )
+
+        if port:
+            # Replace the default port variable in the model.py file
+            content = content.replace("PORT = '23333'", f"PORT = '{port}'")
+
+        if context_length:
+            # Replace the default context length variable in the model.py file
+            content = content.replace(
+                "context_length = '8192'", f"context_length = '{context_length}'"
+            )
+
+        # Write the modified content back to model.py
+        with open(model_py_path, 'w') as file:
+            file.write(content)
+
+    except Exception as e:
+        logger.error(f"Failed to customize Ollama model name in {model_py_path}: {e}")
+        raise
 
 
 @cli.group(
@@ -48,21 +93,36 @@ def model():
     help='GitHub Personal Access Token for authentication when cloning private repositories.',
 )
 @click.option(
-    '--github-repo',
+    '--github-url',
     required=False,
     help='GitHub repository URL or "user/repo" format to clone a repository from. If provided, the entire repository contents will be copied to the target directory instead of using default templates.',
 )
 @click.option(
-    '--branch',
+    '--toolkit',
+    type=click.Choice(['ollama'], case_sensitive=False),
     required=False,
-    help='Git branch to clone from the GitHub repository. If not specified, the default branch will be used.',
+    help='Toolkit to use for model initialization. Currently supports "ollama".',
 )
 @click.option(
-    '--local-ollama-model',
-    is_flag=True,
-    help='Create an Ollama model template by cloning from GitHub repository.',
+    '--model-name',
+    required=False,
+    help='Model name to configure when using --toolkit. For ollama toolkit, this sets the Ollama model to use (e.g., "llama3.1", "mistral", etc.).',
 )
-def init(model_path, model_type_id, github_pat, github_repo, branch, local_ollama_model):
+@click.option(
+    '--port',
+    type=str,
+    help='Port to run the Ollama server on. Defaults to 23333.',
+    required=False,
+)
+@click.option(
+    '--context-length',
+    type=str,
+    help='Context length for the Ollama model. Defaults to 8192.',
+    required=False,
+)
+def init(
+    model_path, model_type_id, github_pat, github_url, toolkit, model_name, port, context_length
+):
     """Initialize a new model directory structure.
 
     Creates the following structure in the specified directory:
@@ -77,42 +137,99 @@ def init(model_path, model_type_id, github_pat, github_repo, branch, local_ollam
     branch to clone from.
 
     MODEL_PATH: Path where to create the model directory structure. If not specified, the current directory is used by default.
+    model_type_id: Type of model to initialize. Options are 'mcp' for MCPModelClass or 'openai' for OpenAIModelClass.
+    github_pat: GitHub Personal Access Token for cloning private repositories.
+    github_url: GitHub repository URL or "user/repo" format to clone a repository from. If provided, the entire repository contents will be copied to the target directory instead of using default templates.
+    toolkit: Toolkit to use for model initialization. Currently supports 'ollama'.
+    model_name: Model name to configure when using --toolkit. For ollama toolkit, this sets the Ollama model to use (e.g., 'llama3.1', 'mistral', etc.).
+    port: Port to run the Ollama server on. Defaults to 23333.
+    context_length: Context length for the Ollama model. Defaults to 8192.
     """
-    # Handle the --local-ollama-model flag
-    if local_ollama_model:
-        if github_repo or branch:
-            raise click.ClickException(
-                "Cannot specify both --local-ollama-model and --github-repo/--branch"
-            )
-        github_repo = "https://github.com/Clarifai/runners-examples"
-        branch = "ollama"
-
     # Resolve the absolute path
     model_path = os.path.abspath(model_path)
 
     # Create the model directory if it doesn't exist
     os.makedirs(model_path, exist_ok=True)
 
-    # Handle GitHub repository cloning if provided
-    if github_repo:
-        logger.info(f"Initializing model from GitHub repository: {github_repo}")
+    # Validate parameters
+    if port and not port.isdigit():
+        logger.error("Invalid value: --port must be a number")
+        raise click.Abort()
+
+    if context_length and not context_length.isdigit():
+        logger.error("Invalid value: --context-length must be a number")
+        raise click.Abort()
+
+    # Validate option combinations
+    if model_name and not (toolkit):
+        logger.error("--model-name can only be used with --toolkit")
+        raise click.Abort()
+
+    if toolkit and (github_url):
+        logger.error("Cannot specify both --toolkit and --github-repo")
+        raise click.Abort()
+
+    # --toolkit option
+    if toolkit == 'ollama':
+        github_url = DEFAULT_OLLAMA_MODEL_REPO
+        branch = DEFAULT_OLLAMA_MODEL_REPO_BRANCH
+
+    if github_url:
+        if not toolkit:
+            owner, repo, branch, folder_path = GitHubDownloader().parse_github_url(url=github_url)
+            logger.info(
+                f"Parsed GitHub repository: owner={owner}, repo={repo}, branch={branch}, folder_path={folder_path}"
+            )
+            if folder_path != "":
+                downloader = GitHubDownloader(
+                    max_retries=3,
+                    github_token=github_pat,
+                )
+                try:
+                    downloader.download_github_folder(
+                        url=github_url,
+                        output_dir=model_path,
+                        github_token=github_pat,
+                    )
+                    logger.info(f"Successfully downloaded folder contents to {model_path}")
+                    logger.info("Model initialization complete with GitHub folder download")
+                    return
+
+                except Exception as e:
+                    logger.error(f"Failed to download GitHub folder: {e}")
+                    # Continue with the rest of the initialization process
+                    github_url = None  # Fall back to template mode
+
+            elif branch and folder_path == "":
+                # When we have a branch but no specific folder path
+                logger.info(
+                    f"Initializing model from GitHub repository: {github_url} (branch: {branch})"
+                )
+
+                # Check if it's a local path or normalize the GitHub repo URL
+                if os.path.exists(github_url):
+                    repo_url = github_url
+                else:
+                    repo_url = format_github_repo_url(github_url)
+                    repo_url = f"https://github.com/{owner}/{repo}"
+
+    if toolkit:
+        logger.info(f"Initializing model from GitHub repository: {github_url}")
 
         # Check if it's a local path or normalize the GitHub repo URL
-        if os.path.exists(github_repo):
-            repo_url = github_repo
+        if os.path.exists(github_url):
+            repo_url = github_url
         else:
-            repo_url = format_github_repo_url(github_repo)
+            repo_url = format_github_repo_url(github_url)
 
+    try:
         # Create a temporary directory for cloning
-        with tempfile.TemporaryDirectory() as temp_dir:
-            clone_dir = os.path.join(temp_dir, "repo")
-
-            # Clone the repository
+        with tempfile.TemporaryDirectory(prefix="clarifai_model_") as clone_dir:
+            # Clone the repository with explicit branch parameter
             if not clone_github_repo(repo_url, clone_dir, github_pat, branch):
-                logger.error(
-                    "Failed to clone repository. Falling back to template-based initialization."
-                )
-                github_repo = None  # Fall back to template mode
+                logger.error(f"Failed to clone repository from {repo_url}")
+                github_url = None  # Fall back to template mode
+
             else:
                 # Copy the entire repository content to target directory (excluding .git)
                 for item in os.listdir(clone_dir):
@@ -127,15 +244,21 @@ def init(model_path, model_type_id, github_pat, github_repo, branch, local_ollam
                     else:
                         shutil.copy2(source_path, target_path)
 
-                logger.info("Model initialization complete with GitHub repository")
-                logger.info("Next steps:")
-                logger.info("1. Review the model configuration")
-                logger.info("2. Install any required dependencies manually")
-                logger.info("3. Test the model locally using 'clarifai model local-test'")
-                return
+    except Exception as e:
+        logger.error(f"Failed to clone GitHub repository: {e}")
+        github_url = None
+
+    if (model_name or port or context_length) and (toolkit == 'ollama'):
+        customize_ollama_model(model_path, model_name, port, context_length)
+
+    logger.info("Model initialization complete with GitHub repository")
+    logger.info("Next steps:")
+    logger.info("1. Review the model configuration")
+    logger.info("2. Install any required dependencies manually")
+    logger.info("3. Test the model locally using 'clarifai model local-test'")
 
     # Fall back to template-based initialization if no GitHub repo or if GitHub repo failed
-    if not github_repo:
+    if not github_url:
         from clarifai.cli.templates.model_templates import (
             get_config_template,
             get_model_template,
@@ -421,17 +544,16 @@ def run_locally(model_path, port, mode, keep_env, keep_image, skip_dockerfile=Fa
 @click.option(
     "--pool_size",
     type=int,
-    is_flag=True,
-    default=1,  # default to 1 thread for local dev runner to avoid rapid depletion of compute time.
+    default=1,  # default to 1 thread for local runner to avoid rapid depletion of compute time.
     show_default=True,
     help="The number of threads to use. On community plan, the compute time allocation is drained at a rate proportional to the number of threads.",
 )  # pylint: disable=range-builtin-not-iterating
 @click.pass_context
-def local_dev(ctx, model_path, pool_size):
-    """Run the model as a local dev runner to help debug your model connected to the API or to
+def local_runner(ctx, model_path, pool_size):
+    """Run the model as a local runner to help debug your model connected to the API or to
     leverage local compute resources manually. This relies on many variables being present in the env
     of the currently selected context. If they are not present then default values will be used to
-    ease the setup of a local dev runner and your context yaml will be updated in place. The required
+    ease the setup of a local runner and your context yaml will be updated in place. The required
     env vars are:
 
     \b
@@ -445,7 +567,7 @@ def local_dev(ctx, model_path, pool_size):
       CLARIFAI_MODEL_ID:
 
     \b
-      # for where the local dev runner should be in a compute cluser
+      # for where the local runner should be in a compute cluster
       # note the user_id of the compute cluster is the same as the user_id of the model.
 
     \b
@@ -460,7 +582,7 @@ def local_dev(ctx, model_path, pool_size):
     Additionally using the provided model path, if the config.yaml file does not contain the model
     information that matches the above CLARIFAI_USER_ID, CLARIFAI_APP_ID, CLARIFAI_MODEL_ID then the
     config.yaml will be updated to include the model information. This is to ensure that the model
-    that starts up in the local dev runner is the same as the one you intend to call in the API.
+    that starts up in the local runner is the same as the one you intend to call in the API.
 
     MODEL_PATH: Path to the model directory. If not specified, the current directory is used by default.
     """
@@ -469,25 +591,36 @@ def local_dev(ctx, model_path, pool_size):
     from clarifai.runners.server import serve
 
     validate_context(ctx)
-    logger.info("Checking setup for local development runner...")
+    logger.info("Checking setup for local runner...")
     logger.info(f"Current context: {ctx.obj.current.name}")
     user_id = ctx.obj.current.user_id
-    user = User(user_id=user_id, pat=ctx.obj.current.pat, base_url=ctx.obj.current.api_base)
     logger.info(f"Current user_id: {user_id}")
-    logger.debug("Checking if a local dev compute cluster exists...")
+    if not user_id:
+        logger.error(f"User with ID '{user_id}' not found. Use 'clarifai login' to setup context.")
+        raise click.Abort()
+    pat = ctx.obj.current.pat
+    display_pat = pat_display(pat) if pat else ""
+    logger.info(f"Current PAT: {display_pat}")
+    if not pat:
+        logger.error(
+            "Personal Access Token (PAT) not found. Use 'clarifai login' to setup context."
+        )
+        raise click.Abort()
+    user = User(user_id=user_id, pat=ctx.obj.current.pat, base_url=ctx.obj.current.api_base)
+    logger.debug("Checking if a local runner compute cluster exists...")
 
     # see if ctx has CLARIFAI_COMPUTE_CLUSTER_ID, if not use default
     try:
         compute_cluster_id = ctx.obj.current.compute_cluster_id
     except AttributeError:
-        compute_cluster_id = DEFAULT_LOCAL_DEV_COMPUTE_CLUSTER_ID
+        compute_cluster_id = DEFAULT_LOCAL_RUNNER_COMPUTE_CLUSTER_ID
     logger.info(f"Current compute_cluster_id: {compute_cluster_id}")
 
     try:
         compute_cluster = user.compute_cluster(compute_cluster_id)
         if compute_cluster.cluster_type != 'local-dev':
             raise ValueError(
-                f"Compute cluster {user_id}/{compute_cluster_id} is not a local-dev compute cluster. Please create a local-dev compute cluster."
+                f"Compute cluster {user_id}/{compute_cluster_id} is not a local-runner compute cluster. Please create a local-runner compute cluster."
             )
         try:
             compute_cluster_id = ctx.obj.current.compute_cluster_id
@@ -503,10 +636,10 @@ def local_dev(ctx, model_path, pool_size):
         )
         if y.lower() != 'y':
             raise click.Abort()
-        # Create a compute cluster with default configuration for local dev.
+        # Create a compute cluster with default configuration for local runner.
         compute_cluster = user.create_compute_cluster(
             compute_cluster_id=compute_cluster_id,
-            compute_cluster_config=DEFAULT_LOCAL_DEV_COMPUTE_CLUSTER_CONFIG,
+            compute_cluster_config=DEFAULT_LOCAL_RUNNER_COMPUTE_CLUSTER_CONFIG,
         )
         ctx.obj.current.CLARIFAI_COMPUTE_CLUSTER_ID = compute_cluster_id
         ctx.obj.to_yaml()  # save to yaml file.
@@ -515,7 +648,7 @@ def local_dev(ctx, model_path, pool_size):
     try:
         nodepool_id = ctx.obj.current.nodepool_id
     except AttributeError:
-        nodepool_id = DEFAULT_LOCAL_DEV_NODEPOOL_ID
+        nodepool_id = DEFAULT_LOCAL_RUNNER_NODEPOOL_ID
     logger.info(f"Current nodepool_id: {nodepool_id}")
 
     try:
@@ -533,7 +666,7 @@ def local_dev(ctx, model_path, pool_size):
         if y.lower() != 'y':
             raise click.Abort()
         nodepool = compute_cluster.create_nodepool(
-            nodepool_config=DEFAULT_LOCAL_DEV_NODEPOOL_CONFIG, nodepool_id=nodepool_id
+            nodepool_config=DEFAULT_LOCAL_RUNNER_NODEPOOL_CONFIG, nodepool_id=nodepool_id
         )
         ctx.obj.current.CLARIFAI_NODEPOOL_ID = nodepool_id
         ctx.obj.to_yaml()  # save to yaml file.
@@ -543,7 +676,7 @@ def local_dev(ctx, model_path, pool_size):
     try:
         app_id = ctx.obj.current.app_id
     except AttributeError:
-        app_id = DEFAULT_LOCAL_DEV_APP_ID
+        app_id = DEFAULT_LOCAL_RUNNER_APP_ID
     logger.info(f"Current app_id: {app_id}")
 
     try:
@@ -562,11 +695,11 @@ def local_dev(ctx, model_path, pool_size):
         ctx.obj.current.CLARIFAI_APP_ID = app_id
         ctx.obj.to_yaml()  # save to yaml file.
 
-    # Within this app we now need a model to call as the local dev runner.
+    # Within this app we now need a model to call as the local runner.
     try:
         model_id = ctx.obj.current.model_id
     except AttributeError:
-        model_id = DEFAULT_LOCAL_DEV_MODEL_ID
+        model_id = DEFAULT_LOCAL_RUNNER_MODEL_ID
     logger.info(f"Current model_id: {model_id}")
 
     try:
@@ -586,7 +719,7 @@ def local_dev(ctx, model_path, pool_size):
         try:
             model_type_id = ctx.obj.current.model_type_id
         except AttributeError:
-            model_type_id = DEFAULT_LOCAL_DEV_MODEL_TYPE
+            model_type_id = DEFAULT_LOCAL_RUNNER_MODEL_TYPE
 
         model = app.create_model(model_id, model_type_id=model_type_id)
         ctx.obj.current.CLARIFAI_MODEL_TYPE_ID = model_type_id
@@ -594,10 +727,10 @@ def local_dev(ctx, model_path, pool_size):
         ctx.obj.to_yaml()  # save to yaml file.
 
     # Now we need to create a version for the model if no version exists. Only need one version that
-    # mentions it's a local dev runner.
+    # mentions it's a local runner.
     model_versions = [v for v in model.list_versions()]
     if len(model_versions) == 0:
-        logger.info("No model versions found. Creating a new version for local dev runner.")
+        logger.info("No model versions found. Creating a new version for local runner.")
         version = model.create_version(pretrained_model_config={"local_dev": True}).model_version
         logger.info(f"Created model version {version.id}")
     else:
@@ -631,12 +764,12 @@ def local_dev(ctx, model_path, pool_size):
             raise AttributeError("Runner not found in nodepool.") from e
     except AttributeError:
         logger.info(
-            f"Create the local dev runner tying this\n  {user_id}/{app_id}/models/{model.id} model (version: {version.id}) to the\n  {user_id}/{compute_cluster_id}/{nodepool_id} nodepool."
+            f"Create the local runner tying this\n  {user_id}/{app_id}/models/{model.id} model (version: {version.id}) to the\n  {user_id}/{compute_cluster_id}/{nodepool_id} nodepool."
         )
         runner = nodepool.create_runner(
             runner_config={
                 "runner": {
-                    "description": "Local dev runner for model testing",
+                    "description": "local runner for model testing",
                     "worker": worker,
                     "num_replicas": 1,
                 }
@@ -653,7 +786,7 @@ def local_dev(ctx, model_path, pool_size):
     try:
         deployment_id = ctx.obj.current.deployment_id
     except AttributeError:
-        deployment_id = DEFAULT_LOCAL_DEV_DEPLOYMENT_ID
+        deployment_id = DEFAULT_LOCAL_RUNNER_DEPLOYMENT_ID
     try:
         deployment = nodepool.deployment(deployment_id)
         # ensure the deployment is using the latest version.
@@ -708,7 +841,7 @@ def local_dev(ctx, model_path, pool_size):
             f"config.yaml not found in {model_path}. Please ensure you are passing the correct directory."
         )
     config = ModelBuilder._load_config(config_file)
-    model_type_id = config.get('model', {}).get('model_type_id', DEFAULT_LOCAL_DEV_MODEL_TYPE)
+    model_type_id = config.get('model', {}).get('model_type_id', DEFAULT_LOCAL_RUNNER_MODEL_TYPE)
     # The config.yaml doens't match what we created above.
     if 'model' in config and model_id != config['model'].get('id'):
         logger.info(f"Current model section of config.yaml: {config.get('model', {})}")
@@ -717,14 +850,14 @@ def local_dev(ctx, model_path, pool_size):
         )
         if y.lower() != 'y':
             raise click.Abort()
-        config = ModelBuilder._set_local_dev_model(
+        config = ModelBuilder._set_local_runner_model(
             config, user_id, app_id, model_id, model_type_id
         )
         ModelBuilder._backup_config(config_file)
         ModelBuilder._save_config(config_file, config)
 
     builder = ModelBuilder(model_path, download_validation_only=True)
-    # don't mock for local dev since you need the dependencies to run the code anyways.
+    # don't mock for local runner since you need the dependencies to run the code anyways.
     method_signatures = builder.get_method_signatures(mocking=False)
 
     from clarifai.runners.utils import code_script
@@ -740,12 +873,12 @@ def local_dev(ctx, model_path, pool_size):
 
     logger.info("""\n
 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
-# About to start up the local dev runner in this terminal...
+# About to start up the local runner in this terminal...
 # Here is a code snippet to call this model once it start from another terminal:
 """)
     logger.info(snippet)
 
-    logger.info("Now starting the local dev runner...")
+    logger.info("Now starting the local runner...")
 
     # This reads the config.yaml from the model_path so we alter it above first.
     serve(