Manage Models Using Jupyter Notebook Integration

Introduction

The ZEDEDA Edge AI Client (zededa-eip-client) is a Python package that provides programmatic access to ZEDEDA Edge Inference Services. You can use it to import models from external providers, upload model files from your local machine, browse available model versions, and monitor import jobs from a Jupyter Notebook, a Python script, or any other Python environment. This article covers model import and job management using the client. For console-based model management, see Manage Models. For configuring external providers before importing, see Manage Providers Using Jupyter Notebook Integration.

Prerequisites

Python 3.8 or later.
Access to ZEDEDA Edge Inference Services with a valid organization ID.
At least one external provider configured in your organization if you plan to import from an external source. See Manage Providers Using Jupyter Notebook Integration.
A Local File System provider configured in your organization if you plan to upload model files from your local machine.

Install the Client

Install the zededa-eip-client package from PyPI:

pip install zededa-eip-client

Authenticate

Authenticate with ZEDEDA Edge Inference Services before making any API calls:

from zededa_eip_client import login

login(organization_id="your-organization-id")

After authentication, initialize the client:

from zededa_eip_client.client import ZededaEIPClient

client = ZededaEIPClient()

Browse Available Model Versions

Before importing a model, use list_model_versions to browse the versions available in an external provider. This is supported for providers that offer versioned model catalogs, such as Qualcomm AI Hub.

versions = client.list_model_versions(
    provider_name="my-qualcomm-provider",
    model_path="yolov8_det",
)
print(versions["latest_version"])
for v in versions["versions"]:
    print(v)

The response includes a versions list and a latest_version field. For Qualcomm AI Hub providers, the versions represent runtime, precision, and device variant selectors.

Import a Model from an External Provider

Use import_model_from_external_provider to start an import job that fetches a model from a configured external provider into your ZEDEDA Edge Inference Services model catalog.

job = client.import_model_from_external_provider(
    payload={
        "provider_name": "my-huggingface",
        "model_identifier": "meta-llama/Llama-3-8b",
        "model_name": "llama-3-8b",
        "model_version": "1.0",
        "metadata": {"description": "LLaMA 3 8B base model"},
    }
)
print("Import job ID:", job["id"])

To block until the import completes instead of polling manually, pass wait=True:

job = client.import_model_from_external_provider(
    payload={
        "provider_name": "my-huggingface",
        "model_identifier": "meta-llama/Llama-3-8b",
        "model_name": "llama-3-8b",
    },
    wait=True,
)
print("Import complete. Status:", job["status"])

The payload dictionary accepts the following keys:

Key	Required	Description
`provider_name`	Yes	Name of the configured external provider.
`model_identifier`	Yes	Provider-specific model path or identifier.
`organization_id`	No	Target organization ID. Defaults to the current organization from login.
`model_name`	No	Name for the imported model in the catalog.
`model_version`	No	Version string for the imported model.
`metadata`	No	Dictionary of additional metadata, for example `{"description": "..."}`.
`qualcomm_device`	No	Qualcomm AI Hub device target, for example `"QCS9075"`.
`qualcomm_precision`	No	Qualcomm AI Hub precision, for example `"fp16"` or `"int8"`.

Upload a Model from Local Files

Use upload_model_from_local_files to upload model files directly from your local machine. This is the recommended method for importing models that are not stored in an external provider. A Local File System provider must be configured in your organization before uploading.

Upload a single file

job = client.upload_model_from_local_files(
    model_name="my-onnx-model",
    file_paths="/path/to/model.onnx",
    provider_name="my-local-provider",
    import_config={"model_version": "1.0"},
    wait=True,
)
print("Upload complete. Status:", job["status"])

Upload a directory

All files in the directory are uploaded recursively:

job = client.upload_model_from_local_files(
    model_name="my-model-package",
    file_paths="/path/to/model_directory",
    provider_name="my-local-provider",
    wait=True,
)

Upload to a specific organization

The Local provider you name must belong to the target organization. If it belongs to a different organization, the upload is rejected.

job = client.upload_model_from_local_files(
    model_name="my-model",
    file_paths="/path/to/model.pt",
    provider_name="my-local-provider",
    organization_id="target-organization-id",
    import_config={"model_version": "2.0"},
)

Monitor Import Jobs

Import jobs run asynchronously. Use the job management methods to track progress and handle failures.

List import jobs

jobs = client.list_import_jobs(limit=20, page=1)
for job in jobs["items"]:
    print(job["id"], job["status"])

Filter by status to find jobs in a specific state:

failed_jobs = client.list_import_jobs(status="failed")

Get a specific import job

job = client.get_import_job(job_id="your-job-id")
print(job["status"], job.get("error_message"))

Cancel a running job

You can cancel a job in the Pending or Running status.

client.cancel_import_job(job_id="your-job-id")

Retry a failed job

Only Failed jobs can be retried. File-upload jobs, such as those created by upload_model_from_local_files, cannot be retried.

client.retry_import_job(job_id="your-job-id")

Delete a job record

A Running job must be cancelled before it can be deleted.

client.delete_import_job(job_id="your-job-id")

Work Across Organizations

If you have access to multiple organizations, use list_catalogs to see all available organizations and switch_catalog to change the active organization context without logging out.

List available organizations

catalogs = client.list_catalogs()
for catalog in catalogs["catalogs"]:
    print(catalog["id"], catalog["name"])

Switch to a different organization

client.switch_catalog(organization_id="target-organization-id")

After switching, subsequent API calls use the new organization context. Environment variables for storage and MLflow access are updated automatically.

​Introduction

​Prerequisites

​Install the Client

​Authenticate

​Browse Available Model Versions

​Import a Model from an External Provider

​Upload a Model from Local Files

​Upload a single file

​Upload a directory

​Upload to a specific organization

​Monitor Import Jobs

​List import jobs

​Get a specific import job

​Cancel a running job

​Retry a failed job

​Delete a job record

​Work Across Organizations

​List available organizations

​Switch to a different organization

​In This Section