fix: remove scrollbars from model cards and sort versions by date (#1498)

Signed-off-by: manaswinidas <dasmanaswini10@gmail.com>

.gitattributes

@@ -0,0 +1,2 @@
+# Always check-out / check-in files with LF line endings.
+* text=auto eol=lf

.github/dependabot.yml

@@ -6,11 +6,15 @@
 version: 2
 updates:
   - package-ecosystem: "gomod"
-    directory: "/"
+    directories: 
+      - "/"
+      - "/clients/ui/bff/"
     schedule:
       interval: "weekly"
   - package-ecosystem: "pip"
-    directory: "/clients/python/"
+    directories:
+      - "/clients/python/"
+      - "/jobs/async-upload"
     schedule:
       interval: "weekly"
   - package-ecosystem: "docker"
@@ -21,3 +25,7 @@ updates:
     directory: "/"
     schedule:
       interval: "weekly"
+  - package-ecosystem: "npm"
+    directory: "/clients/ui/frontend/"
+    schedule:
+      interval: "weekly"

.github/labeler.yml

@@ -0,0 +1,37 @@
+"Area/UI":
+- changed-files:
+  - any-glob-to-any-file: "clients/ui/**"
+
+"Area/MR Python client":
+- changed-files:
+  - any-glob-to-any-file: "clients/python/**"
+
+"Area/Go REST server":
+- changed-files:
+  - any-glob-to-any-file:
+    - "api/**"
+    - "cmd/**"
+    - "internal/**"
+    - "patches/**"
+    - "pkg/**"
+    - "templates/go-server/**"
+
+"Area/CSI":
+- changed-files:
+  - any-glob-to-any-file: "csi/**"
+
+"Area/Jobs/Async-upload":
+- changed-files:
+  - any-glob-to-any-file: "jobs/async-upload/**"
+
+"Area/Manifests":
+- changed-files:
+  - any-glob-to-any-file: "manifests/**"
+
+"Area/Documentation":
+- changed-files:
+  - any-glob-to-any-file: "docs/**"
+
+"Area/GitHub":
+- changed-files:
+  - any-glob-to-any-file: ".github/**"

.github/pull_request_template.md

@@ -2,6 +2,7 @@
 
 ## Description
 <!--- Describe your changes in detail -->
+<!--- [UI] Include any screenshots of changed UI; Include any gifs if it was a flow / UX change -->
 
 ## How Has This Been Tested?
 <!--- Please describe in detail how you tested your changes. -->
@@ -10,8 +11,18 @@
 
 ## Merge criteria:
 <!--- This PR will be merged by any repository approver when it meets all the points in the checklist -->
-<!--- Go over all the following points, and put an `x` in all the boxes that apply. -->
+- All the commits have been [_signed-off_](https://github.com/kubeflow/community/tree/master/dco-signoff-hook#signing-off-commits)  (To pass the `DCO` check)
 
-- [ ] The commits and have meaningful messages; the author will squash them [after approval](https://github.com/opendatahub-io/opendatahub-community/blob/main/contributor-cheatsheet.md#:~:text=Usually%20this%20is%20done%20in%20last%20phase%20of%20a%20PR%20revision) or will ask to merge with squash.
-- [ ] Testing instructions have been added in the PR body (for PRs involving changes that are not immediately obvious).
-- [ ] The developer has manually tested the changes and verified that the changes work
+<!--- Go over all the following points, and put an `x` in all the boxes that apply. -->
+- [ ] The commits have meaningful messages
+- [ ] Automated tests are provided as part of the PR for major new functionalities; testing instructions have been added in the PR body (for PRs involving changes that are not immediately obvious).
+- [ ] The developer has manually tested the changes and verified that the changes work.
+- [ ] Code changes follow the [kubeflow contribution guidelines](https://www.kubeflow.org/docs/about/contributing/).
+- [ ] **For first time contributors**: Please reach out to the [Reviewers](https://github.com/kubeflow/model-registry/blob/main/OWNERS) to ensure all tests are being run, ensuring the label `ok-to-test` has been added to the PR.
+
+If you have UI changes
+
+<!--- You can ignore these if you are doing Go Model Registry REST server, MR Python client, manifest, controller, internal logic, etc changes; aka non-UI / visual changes -->
+- [ ] The developer has added tests or explained why testing cannot be added.
+- [ ] Included any necessary screenshots or gifs if it was a UI change.
+- [ ] Verify that UI/UX changes conform the UX guidelines for Kubeflow.

.github/workflows/async-upload-test.yml

@@ -0,0 +1,83 @@
+name: Test async-upload Job
+on:
+  push:
+    branches:
+      - "main"
+    paths-ignore:
+      - "LICENSE*"
+      - "**.gitignore"
+      - "**.md"
+      - "**.txt"
+      - ".github/ISSUE_TEMPLATE/**"
+      - ".github/dependabot.yml"
+      - "docs/**"
+  pull_request:
+    paths:
+      - "jobs/async-upload/**"
+      - ".github/workflows/**"
+
+permissions:
+  contents: read
+
+env:
+  # Async Job
+  JOB_IMG_REGISTRY: ghcr.io
+  JOB_IMG_ORG: kubeflow
+  JOB_IMG_NAME: model-registry/job/async-upload
+  JOB_IMG_VERSION: cicd
+  # MR Server
+  IMG_REGISTRY: ghcr.io
+  IMG_ORG: kubeflow
+  IMG_REPO: model-registry/server
+  IMG_VERSION: cicd
+  PUSH_IMAGE: false
+
+jobs:
+  py-test:
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: jobs/async-upload
+    steps:
+      - uses: actions/checkout@v5
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.10" # refers to the Container image
+      - name: Install Poetry
+        run: |
+          pipx install poetry
+      - name: Install dependencies
+        run: |
+          make install
+      - name: Run tests
+        run: |
+          make test
+      - name: Remove AppArmor profile for mysql in KinD on GHA # https://github.com/kubeflow/manifests/issues/2507
+        run: |
+          set -x
+          sudo apparmor_parser -R /etc/apparmor.d/usr.sbin.mysqld
+      - name: Run E2E tests
+        run: |
+          make test-e2e
+  job-test:
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: jobs/async-upload
+    steps:
+      - uses: actions/checkout@v5
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.10" # refers to the Container image
+      - name: Install Poetry
+        run: |
+          pipx install poetry
+      - name: Remove AppArmor profile for mysql in KinD on GHA # https://github.com/kubeflow/manifests/issues/2507
+        run: |
+          set -x
+          sudo apparmor_parser -R /etc/apparmor.d/usr.sbin.mysqld
+      - name: Execute Sample Job E2E test
+        run: |
+          make test-integration

.github/workflows/build-and-push-async-upload.yml

@@ -0,0 +1,63 @@
+name: Build and Push async-upload container image
+
+on:
+  push:
+    branches:
+      - 'main'
+    tags:
+      - 'v*'
+    paths:
+      - 'jobs/async-upload/**'
+      - '!LICENSE*'
+      - '!DOCKERFILE*'
+      - '!**.gitignore'
+      - '!**.md'
+      - '!**.txt'
+
+env:
+  IMG_REGISTRY: ghcr.io
+  IMG_ORG: kubeflow
+  IMG_NAME: model-registry/job/async-upload
+  REGISTRY_USER: ${{ github.actor }}
+  REGISTRY_PWD: ${{ secrets.GITHUB_TOKEN }}
+
+jobs:
+  build-and-push:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v5
+
+    - name: Set up Docker Buildx
+      uses: docker/setup-buildx-action@v3
+
+    - name: Log in to the Container registry
+      uses: docker/login-action@v3
+      with:
+        registry: ${{ env.IMG_REGISTRY }}
+        username: ${{ env.REGISTRY_USER }}
+        password: ${{ env.REGISTRY_PWD }}
+
+    - name: Set main-branch environment # this is for main-sha tag image build
+      if: github.ref == 'refs/heads/main'
+      run: |
+        commit_sha=${{ github.sha }}
+        tag=main-${commit_sha:0:7}
+        echo "VERSION=${tag}" >> $GITHUB_ENV
+
+    - name: Set tag environment # this is for v* tag image build
+      if: startsWith(github.ref, 'refs/tags/v')
+      run: |
+        echo "VERSION=${{ github.ref_name }}" >> $GITHUB_ENV
+
+    - name: Build and push Docker image
+      uses: docker/build-push-action@v6
+      with:
+        context: ./jobs/async-upload
+        push: true
+        tags: ${{ env.IMG_REGISTRY }}/${{ env.IMG_ORG }}/${{ env.IMG_NAME }}:${{ env.VERSION }}
+        cache-from: type=gha
+        cache-to: type=gha,mode=max

.github/workflows/build-and-push-csi-image.yml

@@ -0,0 +1,85 @@
+name: CSI container image build and tag
+on:
+  push:
+    branches:
+      - 'main'
+    tags:
+      - 'v*'
+    paths-ignore:
+      - 'LICENSE*'
+      - '**.gitignore'
+      - '**.md'
+      - '**.txt'
+      - '.github/ISSUE_TEMPLATE/**'
+      - '.github/dependabot.yml'
+      - 'docs/**'
+env:
+  IMG_REGISTRY: ghcr.io
+  IMG_ORG: kubeflow
+  IMG_REPO: model-registry/storage-initializer
+  PUSH_IMAGE: true
+  DOCKER_USER: ${{ github.actor }}
+  DOCKER_PWD: ${{ secrets.GITHUB_TOKEN }}
+jobs:
+  build-csi-image:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+    steps:
+      # Assign context variable for various action contexts (tag, main, CI)
+      - name: Assigning tag context
+        if: github.head_ref == '' && startsWith(github.ref, 'refs/tags/v')
+        run: echo "BUILD_CONTEXT=tag" >> $GITHUB_ENV
+      - name: Assigning main context
+        if: github.head_ref == '' && github.ref == 'refs/heads/main'
+        run: echo "BUILD_CONTEXT=main" >> $GITHUB_ENV
+      # checkout branch
+      - uses: actions/checkout@v5
+      # set image version
+      - name: Set main-branch environment
+        if: env.BUILD_CONTEXT == 'main'
+        run: |
+          commit_sha=${{ github.event.after }}
+          tag=main-${commit_sha:0:7}
+          echo "VERSION=${tag}" >> $GITHUB_ENV
+      - name: Set tag environment
+        if: env.BUILD_CONTEXT == 'tag'
+        run: |
+          echo "VERSION=${{ github.ref_name }}" >> $GITHUB_ENV
+      # docker login
+      - name: Docker login
+        shell: bash
+        run: make docker/login
+      # build & push
+      - name: Build CSI Image
+        shell: bash
+        env:
+          IMG_ORG: ${{ env.IMG_ORG }}
+          IMG_REPO: ${{ env.IMG_REPO }}
+          IMG_VERSION: ${{ env.VERSION }}
+        run: |
+          make image/build
+      - name: Push CSI Image
+        if: env.PUSH_IMAGE == 'true'
+        shell: bash
+        env:
+          IMG: "${{ env.IMG_REGISTRY }}/${{ env.IMG_ORG }}/${{ env.IMG_REPO }}"
+        run: IMG=${{ env.IMG }} IMG_VERSION=${{ env.VERSION }} make image/push
+      # Tag latest and main
+      - name: Tag Latest
+        if: env.BUILD_CONTEXT == 'main' && env.PUSH_IMAGE == 'true'
+        shell: bash
+        env:
+          IMG: "${{ env.IMG_REGISTRY }}/${{ env.IMG_ORG }}/${{ env.IMG_REPO }}"
+        run: |
+          docker tag ${{ env.IMG }}:$VERSION ${{ env.IMG }}:latest
+          IMG=${{ env.IMG }} IMG_VERSION=latest make image/push
+      - name: Tag Main
+        if: env.BUILD_CONTEXT == 'main' && env.PUSH_IMAGE == 'true'
+        shell: bash
+        env:
+          IMG: "${{ env.IMG_REGISTRY }}/${{ env.IMG_ORG }}/${{ env.IMG_REPO }}"
+        run: |
+          docker tag ${{ env.IMG }}:$VERSION ${{ env.IMG }}:main
+          IMG=${{ env.IMG }} IMG_VERSION=main make image/push

.github/workflows/build-and-push-image.yml

@@ -14,14 +14,25 @@ on:
       - '.github/dependabot.yml'
       - 'docs/**'
 env:
+  IMG_REGISTRY: ghcr.io
   IMG_ORG: kubeflow
-  IMG_REPO: model-registry
-  DOCKER_USER: ${{ secrets.DOCKERHUB_USERNAME }}
-  DOCKER_PWD: ${{ secrets.DOCKERHUB_TOKEN }}
+  IMG_REPO: model-registry/server
   PUSH_IMAGE: true
+  DOCKER_USER: ${{ github.actor }}
+  DOCKER_PWD: ${{ secrets.GITHUB_TOKEN }}
+
+permissions: # default workflow permission, overridden for specific job where required
+  contents: read
+
 jobs:
+  prepare:
+    uses: ./.github/workflows/prepare.yml
   build-image:
+    permissions:
+      contents: read
+      packages: write
     runs-on: ubuntu-latest
+    needs: prepare
     steps:
       # Assign context variable for various action contexts (tag, main, CI)
       - name: Assigning tag context
@@ -31,7 +42,7 @@ jobs:
         if: github.head_ref == '' && github.ref == 'refs/heads/main'
         run: echo "BUILD_CONTEXT=main" >> $GITHUB_ENV
       # checkout branch
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
       # set image version
       - name: Set main-branch environment
         if: env.BUILD_CONTEXT == 'main'
@@ -50,7 +61,7 @@ jobs:
         if: env.BUILD_CONTEXT == 'main'
         shell: bash
         env:
-          IMG: ${{ env.IMG_ORG }}/${{ env.IMG_REPO }}
+          IMG: "${{ env.IMG_REGISTRY }}/${{ env.IMG_ORG }}/${{ env.IMG_REPO }}"
           BUILD_IMAGE: false # image is already built in "Build and Push Image" step
         run: |
           docker tag ${{ env.IMG }}:$VERSION ${{ env.IMG }}:latest
@@ -60,7 +71,7 @@ jobs:
         if: env.BUILD_CONTEXT == 'main'
         shell: bash
         env:
-          IMG: ${{ env.IMG_ORG }}/${{ env.IMG_REPO }}
+          IMG: "${{ env.IMG_REGISTRY }}/${{ env.IMG_ORG }}/${{ env.IMG_REPO }}"
           BUILD_IMAGE: false # image is already built in "Build and Push Image" step
         run: |
           docker tag ${{ env.IMG }}:$VERSION ${{ env.IMG }}:main

.github/workflows/build-and-push-ui-images-standalone.yml

@@ -0,0 +1,79 @@
+name: Build and Push UI Standalone Image
+# this workflow builds an image to support local testing
+on:
+  push:
+    branches:
+      - 'main'
+    tags:
+      - 'v*'
+    paths:
+      - 'clients/ui/**'
+      - '!LICENSE*'
+      - '!DOCKERFILE*'
+      - '!**.gitignore'
+      - '!**.md'
+      - '!**.txt'
+env:
+  IMG_REGISTRY: ghcr.io
+  IMG_ORG: kubeflow
+  IMG_UI_REPO: model-registry/ui-standalone # this image is intended for local development, not production
+  DOCKER_USER: ${{ github.actor }}
+  DOCKER_PWD: ${{ secrets.GITHUB_TOKEN }}
+jobs:
+  build-and-push:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v5
+
+    - name: Set up Docker Buildx
+      uses: docker/setup-buildx-action@v3
+
+    - name: Log in to the Container registry
+      uses: docker/login-action@v3
+      with:
+        registry: ${{ env.IMG_REGISTRY }}
+        username: ${{ env.DOCKER_USER }}
+        password: ${{ env.DOCKER_PWD }}
+
+    - name: Set main-branch environment
+      if: github.ref == 'refs/heads/main'
+      run: |
+        commit_sha=${{ github.sha }}
+        tag=main-${commit_sha:0:7}
+        echo "VERSION=${tag}" >> $GITHUB_ENV
+      
+    - name: Set tag environment
+      if: startsWith(github.ref, 'refs/tags/v')
+      run: |
+        echo "VERSION=${{ github.ref_name }}" >> $GITHUB_ENV
+
+    - name: Extract metadata (tags, labels) for Docker
+      id: meta
+      uses: docker/metadata-action@v5
+      with:
+        images: "${{ env.IMG_REGISTRY }}/${{ env.IMG_ORG }}/${{ env.IMG_UI_REPO }}"
+        tags: |
+          type=ref,event=branch
+          type=ref,event=pr
+          type=semver,pattern={{version}}
+          type=semver,pattern={{major}}.{{minor}}
+          type=sha
+          type=raw,value=${{ env.VERSION }},enable=${{ env.VERSION != '' }}
+          type=raw,value=latest,enable=${{ github.ref == 'refs/heads/main' }}
+
+    - name: Build and push Docker image
+      uses: docker/build-push-action@v6
+      with:
+        context: ./clients/ui
+        push: true
+        tags: ${{ steps.meta.outputs.tags }}
+        labels: ${{ steps.meta.outputs.labels }}
+        build-args: |
+          DEPLOYMENT_MODE=standalone
+          STYLE_THEME=mui-theme
+        cache-from: type=gha
+        cache-to: type=gha,mode=max

.github/workflows/build-and-push-ui-images.yml

@@ -0,0 +1,79 @@
+name: Build and Push UI Image
+# this workflow builds an image to support local testing
+on:
+  push:
+    branches:
+      - 'main'
+    tags:
+      - 'v*'
+    paths:
+      - 'clients/ui/**'
+      - '!LICENSE*'
+      - '!DOCKERFILE*'
+      - '!**.gitignore'
+      - '!**.md'
+      - '!**.txt'
+env:
+  IMG_REGISTRY: ghcr.io
+  IMG_ORG: kubeflow
+  IMG_UI_REPO: model-registry/ui # this image is intended for local development, not production
+  DOCKER_USER: ${{ github.actor }}
+  DOCKER_PWD: ${{ secrets.GITHUB_TOKEN }}
+jobs:
+  build-and-push:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v5
+
+    - name: Set up Docker Buildx
+      uses: docker/setup-buildx-action@v3
+
+    - name: Log in to the Container registry
+      uses: docker/login-action@v3
+      with:
+        registry: ${{ env.IMG_REGISTRY }}
+        username: ${{ env.DOCKER_USER }}
+        password: ${{ env.DOCKER_PWD }}
+
+    - name: Set main-branch environment
+      if: github.ref == 'refs/heads/main'
+      run: |
+        commit_sha=${{ github.sha }}
+        tag=main-${commit_sha:0:7}
+        echo "VERSION=${tag}" >> $GITHUB_ENV
+      
+    - name: Set tag environment
+      if: startsWith(github.ref, 'refs/tags/v')
+      run: |
+        echo "VERSION=${{ github.ref_name }}" >> $GITHUB_ENV
+
+    - name: Extract metadata (tags, labels) for Docker
+      id: meta
+      uses: docker/metadata-action@v5
+      with:
+        images: "${{ env.IMG_REGISTRY }}/${{ env.IMG_ORG }}/${{ env.IMG_UI_REPO }}"
+        tags: |
+          type=ref,event=branch
+          type=ref,event=pr
+          type=semver,pattern={{version}}
+          type=semver,pattern={{major}}.{{minor}}
+          type=sha
+          type=raw,value=${{ env.VERSION }},enable=${{ env.VERSION != '' }}
+          type=raw,value=latest,enable=${{ github.ref == 'refs/heads/main' }}
+
+    - name: Build and push Docker image
+      uses: docker/build-push-action@v6
+      with:
+        context: ./clients/ui
+        push: true
+        tags: ${{ steps.meta.outputs.tags }}
+        labels: ${{ steps.meta.outputs.labels }}
+        build-args: |
+          DEPLOYMENT_MODE=kubeflow
+          STYLE_THEME=mui-theme
+        cache-from: type=gha
+        cache-to: type=gha,mode=max

.github/workflows/build-image-pr.yml

@@ -1,5 +1,6 @@
 name: Test container image build and deployment
 on:
+  workflow_dispatch:
   pull_request:
     paths-ignore:
       - "LICENSE*"
@@ -9,17 +10,22 @@ on:
       - ".github/ISSUE_TEMPLATE/**"
       - ".github/dependabot.yml"
       - "docs/**"
-      - "clients/python/docs/**"
+      - "clients/python/**"
+
+permissions:
+  contents: read
+
 env:
+  IMG_REGISTRY: ghcr.io
   IMG_ORG: kubeflow
-  IMG_REPO: model-registry
+  IMG_REPO: model-registry/server
   PUSH_IMAGE: false
   BRANCH: ${{ github.base_ref }}
 jobs:
   build-and-test-image:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
       - name: Generate Tag
         shell: bash
         id: tags
@@ -30,36 +36,27 @@ jobs:
       - name: Build Image
         shell: bash
         env:
-          VERSION: ${{ steps.tags.outputs.tag }}
-        run: ./scripts/build_deploy.sh
+          IMG_VERSION: ${{ steps.tags.outputs.tag }}
+        run: make image/build
       - name: Start Kind Cluster
-        uses: helm/kind-action@v1.10.0
+        uses: helm/kind-action@v1.12.0
         with:
           node_image: "kindest/node:v1.27.11"
+      - name: Remove AppArmor profile for mysql in KinD on GHA # https://github.com/kubeflow/manifests/issues/2507
+        run: |
+          set -x
+          sudo apparmor_parser -R /etc/apparmor.d/usr.sbin.mysqld
       - name: Load Local Registry Test Image
         env:
-          IMG: "${{ env.IMG_ORG }}/${{ env.IMG_REPO }}:${{ steps.tags.outputs.tag }}"
+          IMG: "${{ env.IMG_REGISTRY }}/${{ env.IMG_ORG }}/${{ env.IMG_REPO }}:${{ steps.tags.outputs.tag }}"
         run: |
           kind load docker-image -n chart-testing ${IMG}
-      - name: Create Test Registry
+      - name: Deploy Model Registry using manifests
         env:
-          IMG: "${{ env.IMG_ORG }}/${{ env.IMG_REPO }}:${{ steps.tags.outputs.tag }}"
+          IMG: "${{ env.IMG_REGISTRY }}/${{ env.IMG_ORG }}/${{ env.IMG_REPO }}:${{ steps.tags.outputs.tag }}"
+        run: ./scripts/deploy_on_kind.sh
+      - name: Deployment logs
         run: |
-          echo "Download kustomize 5.2.1"
-          mkdir $GITHUB_WORKSPACE/kustomize
-          curl -s "https://raw.githubusercontent.com/kubernetes-sigs/kustomize/master/hack/install_kustomize.sh" | bash -s "5.2.1" "$GITHUB_WORKSPACE/kustomize"
-          PATH=$GITHUB_WORKSPACE/kustomize:$PATH
-          echo "Display Kustomize version"
-          kustomize version 
-          echo "Deploying Model Registry using Manifests; branch ${BRANCH}"
-          kubectl create namespace kubeflow
-          cd manifests/kustomize/overlays/db
-          kustomize edit set image kubeflow/model-registry:latest $IMG
-          kustomize build | kubectl apply -f -
-      - name: Wait for Test Registry Deployment
-        run: |
-          kubectl wait --for=condition=available -n kubeflow deployment/model-registry-db --timeout=5m
-          kubectl wait --for=condition=available -n kubeflow deployment/model-registry-deployment --timeout=5m
           kubectl logs -n kubeflow deployment/model-registry-deployment
       - name: Set up Python
         uses: actions/setup-python@v5
@@ -80,6 +77,6 @@ jobs:
           pip install dist/*.whl
       - name: Connect with Python client
         run: |
-          kubectl port-forward -n kubeflow service/model-registry-service 9090:9090 &
+          kubectl port-forward -n kubeflow service/model-registry-service 8080:8080 &
           sleep 5
-          python test/python/test_mr_conn.py localhost 9090
+          python test/python/test_mr_conn.py http://localhost 8080

.github/workflows/build-image-ui-pr.yml

@@ -0,0 +1,31 @@
+name: Test UI container image build and deployment
+on:
+  workflow_dispatch:
+  pull_request:
+    paths:
+      - "clients/ui/**"
+      - ".github/workflows/**"
+      - "!LICENSE*"
+      - "!DOCKERFILE*"
+      - "!**.gitignore"
+      - "!**.md"
+      - "!**.txt"
+
+permissions:
+  contents: read
+  packages: read
+
+env:
+  IMG_ORG: kubeflow
+  IMG_REPO: model-registry/ui
+  PUSH_IMAGE: false
+  BRANCH: ${{ github.base_ref }}
+jobs:
+  build-image:
+    runs-on: ubuntu-latest
+    steps:
+      # checkout branch
+      - uses: actions/checkout@v5
+      - name: Build UI Image
+        shell: bash
+        run: ./scripts/build_deploy.sh

.github/workflows/build.yml

@@ -2,51 +2,35 @@ name: Build
 on:
   push:
     branches:
-      - 'main'
+      - "main"
   pull_request:
     paths-ignore:
-      - 'LICENSE*'
-      - 'DOCKERFILE*'
-      - '**.gitignore'
-      - '**.md'
-      - '**.txt'
-      - '.github/ISSUE_TEMPLATE/**'
-      - '.github/dependabot.yml'
-      - 'docs/**'
-      - 'scripts/**'
+      - "LICENSE*"
+      - "DOCKERFILE*"
+      - "**.gitignore"
+      - "**.md"
+      - "**.txt"
+      - ".github/ISSUE_TEMPLATE/**"
+      - ".github/dependabot.yml"
+      - "docs/**"
+
+permissions:
+  contents: read
+
 jobs:
+  prepare:
+    uses: ./.github/workflows/prepare.yml
   build:
+    needs: prepare
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - name: Checkout
+        uses: actions/checkout@v5
       - name: Setup Go
         uses: actions/setup-go@v5
         with:
-          go-version: '1.19'
-      - name: Install Protoc
-        uses: arduino/setup-protoc@v3
-        with:
-          version: "24.3"
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: 3.9
-      - name: Install makefile dependencies
-        run: make deps
-      - name: Clean
-        run: make clean
+          go-version: "1.24"
       - name: Build
-        run: make build
-      - name: Check if there are uncommitted file changes
-        run: |
-          clean=$(git status --porcelain)
-          if [[ -z "$clean" ]]; then
-              echo "Empty git status --porcelain: $clean"
-          else
-              echo "Uncommitted file changes detected: $clean"
-              git diff
-              exit 1
-          fi
+        run: make build/compile
       - name: Unit tests
         run: make test-cover

.github/workflows/check-db-schema-structs.yaml

@@ -0,0 +1,53 @@
+name: Check DB schema structs
+on:
+  pull_request:
+  push:
+    branches:
+      - 'main'
+    tags:
+      - 'v*'
+
+permissions:
+  contents: read
+
+jobs:
+  check-mysql-schema-structs:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+      - name: Setup Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: "1.24.4"
+      - name: Generate MySQL DB schema structs
+        run: make gen/gorm/mysql
+      - name: Check if there are uncommitted file changes
+        run: |
+          clean=$(git status --porcelain)
+          if [[ -z "$clean" ]]; then
+              echo "MySQL schema is up to date."
+          else
+              echo "Uncommitted file changes detected after generating MySQL schema: $clean"
+              git diff
+              exit 1
+          fi
+  check-postgres-schema-structs:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+      - name: Setup Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: "1.24.4"
+      - name: Generate PostgreSQL DB schema structs
+        run: make gen/gorm/postgres
+      - name: Check if there are uncommitted file changes
+        run: |
+          clean=$(git status --porcelain)
+          if [[ -z "$clean" ]]; then
+              echo "PostgreSQL schema is up to date."
+          else
+              echo "Uncommitted file changes detected after generating PostgreSQL schema: $clean"
+              git diff
+              exit 1
+          fi

.github/workflows/check-openapi-spec-pr.yaml

@@ -0,0 +1,18 @@
+name: Validate OpenAPI spec
+on:
+  pull_request:
+    paths:
+      - ".github/workflows/**"
+      - "api/openapi/model-registry.yaml"
+
+permissions:
+  contents: read
+
+jobs:
+  validate:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+      - name: Validate OpenAPI spec
+        run: |
+          make openapi/validate

.github/workflows/constraints.txt

@@ -1,5 +1,6 @@
-pip==23.3.1
-nox==2023.04.22
-nox-poetry==1.0.2
-poetry==1.6.1
+pip==23.3.2
+nox==2023.4.22
+nox-poetry==1.0.3
+poetry==1.8.3
+poetry-plugin-export==1.8.0
 virtualenv==20.24.6

.github/workflows/controller-test.yml

@@ -0,0 +1,44 @@
+name: Test Controller
+on:
+  push:
+    branches:
+      - "main"
+    paths-ignore:
+      - "LICENSE*"
+      - "**.gitignore"
+      - "**.md"
+      - "**.txt"
+      - ".github/ISSUE_TEMPLATE/**"
+      - ".github/dependabot.yml"
+      - "docs/**"
+  pull_request:
+    paths:
+      - "cmd/controller/**"
+      - ".github/workflows/**"
+      - "internal/controller/**"
+      - "internal/server/openapi/api_model_registry_service*"
+      - "pkg/openapi/**"
+      - "go.mod"
+
+permissions:
+  contents: read
+
+env:
+  BRANCH: ${{ github.base_ref }}
+jobs:
+  test:
+    name: Run on Ubuntu
+    runs-on: ubuntu-latest
+    steps:
+      - name: Clone the code
+        uses: actions/checkout@v5
+
+      - name: Setup Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: '~1.22'
+
+      - name: Running Tests
+        run: |
+          go mod tidy
+          make controller/test

.github/workflows/csi-test.yml

@@ -0,0 +1,85 @@
+name: Test CSI
+on:
+  push:
+    branches:
+      - "main"
+    paths-ignore:
+      - "LICENSE*"
+      - "**.gitignore"
+      - "**.md"
+      - "**.txt"
+      - ".github/ISSUE_TEMPLATE/**"
+      - ".github/dependabot.yml"
+      - "docs/**"
+  pull_request:
+    paths:
+      - "cmd/csi/**"
+      - ".github/workflows/**"
+      - "internal/csi/**"
+      - "internal/server/openapi/api_model_registry_service*"
+      - "pkg/openapi/**"
+      # csi build depends on base go.mod https://github.com/kubeflow/model-registry/issues/311
+      - "go.mod"
+
+permissions:
+  contents: read
+
+env:
+  IMG_REGISTRY: ghcr.io
+  IMG_ORG: kubeflow
+  MODEL_REGISTRY_IMG: model-registry/server
+  MODEL_REGISTRY_CSI_IMG: model-registry/storage-initializer
+  PUSH_IMAGE: false
+  BRANCH: ${{ github.base_ref }}
+jobs:
+  build-and-test-csi-image:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+
+      - name: Generate tag
+        shell: bash
+        id: tags
+        run: |
+          commit_sha=${{ github.event.after }}
+          tag=main-${commit_sha:0:7}
+          echo "tag=${tag}" >> $GITHUB_OUTPUT
+
+      - name: Install network tools
+        run: sudo apt-get update && sudo apt-get install -y netcat-openbsd
+
+      - name: Build local model registry image
+        shell: bash
+        env:
+          IMG_REPO: ${{ env.MODEL_REGISTRY_IMG }}
+          VERSION: ${{ steps.tags.outputs.tag }}
+          PUSH_IMAGE: false
+        run: ./scripts/build_deploy.sh
+
+      - name: Build local custom storage initializer
+        shell: bash
+        env:
+          IMG_REPO: ${{ env.MODEL_REGISTRY_CSI_IMG }}
+          IMG_VERSION: ${{ steps.tags.outputs.tag }}
+        run: make image/build
+
+      - name: Start KinD cluster
+        uses: helm/kind-action@v1.12.0
+        with:
+          node_image: "kindest/node:v1.27.11"
+
+      - name: Remove AppArmor profile for mysql in KinD on GHA # https://github.com/kubeflow/manifests/issues/2507
+        run: |
+          set -x
+          sudo apparmor_parser -R /etc/apparmor.d/usr.sbin.mysqld
+
+      - name: Install kustomize
+        run: ./test/scripts/install_kustomize.sh
+
+      - name: Run tests
+        shell: bash
+        env:
+          MR_IMG: "${{ env.IMG_REGISTRY }}/${{ env.IMG_ORG }}/${{ env.MODEL_REGISTRY_IMG }}:${{ steps.tags.outputs.tag }}"
+          MR_CSI_IMG: "${{ env.IMG_REGISTRY }}/${{ env.IMG_ORG }}/${{ env.MODEL_REGISTRY_CSI_IMG }}:${{ steps.tags.outputs.tag }}"
+          CLUSTER: chart-testing
+        run: ./test/csi/e2e_test.sh

.github/workflows/first-time-contributor-pr.yml

@@ -0,0 +1,49 @@
+# goal: this is meant to remind maintainers/approvers to add labels to ensure all tests are executed before merging
+# and avoid merging without realizing that required tests has not been run; complementary to bulletpoint in template: https://github.com/kubeflow/model-registry/blame/de5f225d96a4daeca77506d233082b1c4ea5afa3/.github/pull_request_template.md#L21
+name: Welcome first-time contributors (Beta)
+on:
+  pull_request_target:
+    types:
+      - opened
+permissions:
+  pull-requests: write
+
+# do NOT: add actions/checkout to this flow, add-third party scripts, or auto-trigger CI jobs
+jobs:
+  welcome:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check contributor status
+        id: check_1st_time_contrib
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const { data: pr } = await github.rest.pulls.get({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              pull_number: context.issue.number
+            });
+            const isFirstTimeContributor = pr.user.contributions === 0;
+            console.log(`First-time contributor status: ${isFirstTimeContributor}`);
+            core.setOutput('isFirstTimeContributor', isFirstTimeContributor.toString());
+
+      - name: Log contributor status (isFirstTimeContributor true)
+        if: steps.check_1st_time_contrib.outputs.isFirstTimeContributor == 'true'
+        run: echo "First-time contributor status is ${{ steps.check_1st_time_contrib.outputs.isFirstTimeContributor }}"
+    
+      - name: Log contributor status (isFirstTimeContributor false)
+        if: steps.check_1st_time_contrib.outputs.isFirstTimeContributor == 'false'
+        run: echo "First-time contributor status is ${{ steps.check_1st_time_contrib.outputs.isFirstTimeContributor }}"
+    
+      - name: Add a comment to the PR if first time contributor
+        if: steps.check_1st_time_contrib.outputs.isFirstTimeContributor == 'true'
+        uses: actions/github-script@v7
+        with:
+          script: |
+            github.rest.issues.createComment({
+              issue_number: context.issue.number,
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              body: "Maintainers: let's ensure the label `ok-to-test` has been maintained and all the tests have been executed before merging.<br/><br/>Thank you for your first Pull Request! 🎉🎉"
+            })
+# do NOT: add actions/checkout to this flow, add-third party scripts, or auto-trigger CI jobs

.github/workflows/fossa-license-scanning.yml

@@ -0,0 +1,28 @@
+name: FOSSA License Scanning
+
+on:
+    push:
+      branches:
+        - main
+    pull_request:
+
+permissions:
+  contents: read
+
+jobs:
+  fossa-scan:
+    if: github.repository_owner == 'kubeflow' # FOSSA is not intended to run on forks.
+    runs-on: ubuntu-latest
+    env:
+      # push-only token, intentional; see https://github.com/fossa-contrib/fossa-action?tab=readme-ov-file#push-only-api-token
+      # this also how other CNCF projects are doing e.g. https://github.com/cncf/foundation/issues/109
+      FOSSA_API_KEY: 80871bdd477c2c97f65e9822cae99d20 # This is a push-only token that is safe to be exposed.
+    steps:
+      - name: Checkout tree
+        uses: actions/checkout@v5
+
+      - name: Run FOSSA scan and upload build data
+        uses: fossas/fossa-action@v1.7.0
+        with:
+          api-key: ${{ env.FOSSA_API_KEY }}
+          project: "github.com/kubeflow/model-registry"

.github/workflows/labeler.yml

@@ -0,0 +1,12 @@
+name: "Pull Request Labeler"
+on:
+- pull_request_target
+
+jobs:
+  labeler:
+    permissions:
+      contents: read
+      pull-requests: write
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/labeler@v5

.github/workflows/prepare.yml

@@ -0,0 +1,27 @@
+on:
+  workflow_call
+
+permissions:
+  contents: read
+
+jobs:
+  prepare:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+      - name: Setup Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: "1.24"
+      - name: Prepare
+        run: make clean build/prepare
+      - name: Check if there are uncommitted file changes
+        run: |
+          clean=$(git status --porcelain)
+          if [[ -z "$clean" ]]; then
+              echo "Empty git status --porcelain: $clean"
+          else
+              echo "Uncommitted file changes detected: $clean"
+              git diff
+              exit 1
+          fi

.github/workflows/python-release.yml

@@ -14,13 +14,13 @@ jobs:
       FORCE_COLOR: "1"
     steps:
       - name: Check out the repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
         with:
           fetch-depth: 0
       - name: Set up Python
         uses: actions/setup-python@v5
         with:
-          python-version: "3.10"
+          python-version: "3.12"
       - name: Upgrade pip
         run: |
           pip install --constraint=.github/workflows/constraints.txt pip

.github/workflows/python-tests.yml

@@ -3,26 +3,251 @@ on:
   push:
     branches:
       - "main"
+  workflow_dispatch:
   pull_request:
+    paths-ignore:
+      - "LICENSE*"
+      - "**.gitignore"
+      - "**.md"
+      - "**.txt"
+      - ".github/ISSUE_TEMPLATE/**"
+      - ".github/dependabot.yml"
+      - "docs/**"
+
+permissions:
+  contents: read
+
 jobs:
-  tests:
-    name: ${{ matrix.session }} ${{ matrix.python }}
+  lint:
+    name: ${{ matrix.session }}
     runs-on: ubuntu-latest
     strategy:
       fail-fast: false
       matrix:
-        python: ["3.10"]
-        session: [lint, tests, mypy, docs-build]
-        include:
-          - python: "3.9"
-            session: tests
+        python: ["3.12"]
+        session: [lint, mypy]
     env:
       NOXSESSION: ${{ matrix.session }}
       FORCE_COLOR: "1"
-      PRE_COMMIT_COLOR: "always"
     steps:
       - name: Check out the repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
+      - name: Set up Python ${{ matrix.python }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python }}
+      - name: Upgrade pip
+        run: |
+          pip install --constraint=.github/workflows/constraints.txt pip
+          pip --version
+      - name: Upgrade pip in virtual environments
+        shell: python
+        run: |
+          import os
+          import pip
+
+          with open(os.environ["GITHUB_ENV"], mode="a") as io:
+              print(f"VIRTUALENV_PIP={pip.__version__}", file=io)
+      - name: Install Poetry
+        # use absolute path as recommended with: https://github.com/pypa/pipx/issues/1331
+        run: |
+          pipx install --pip-args=--constraint=${{ github.workspace }}/.github/workflows/constraints.txt poetry
+          poetry --version
+      - name: Install Nox
+        run: |
+          pipx install --pip-args=--constraint=${{ github.workspace }}/.github/workflows/constraints.txt nox
+          pipx inject --pip-args=--constraint=${{ github.workspace }}/.github/workflows/constraints.txt nox nox-poetry
+          nox --version
+      - name: Nox lint
+        working-directory: clients/python
+        run: |
+          if [[ ${{ matrix.session }} == "mypy" ]]; then
+            nox --python=${{ matrix.python }} ||\
+              echo "::error title='mypy failure'::Check the logs for more details"
+          else
+            nox --python=${{ matrix.python }}
+          fi
+
+  check-autogen:
+    name: Check autogenerated code is in sync
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python: ["3.12"]
+        nodejs: ["20"]
+    steps:
+      - name: Check out the repository
+        uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python }}
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.nodejs }}
+      - name: Upgrade pip
+        run: |
+          pip install --constraint=.github/workflows/constraints.txt pip
+          pip --version
+      - name: Install Poetry
+        run: |
+          pipx install --pip-args=--constraint=${{ github.workspace }}/.github/workflows/constraints.txt poetry
+          poetry --version
+      - name: Install openapi-generator-cli
+        run: |
+          make bin/openapi-generator-cli
+      - name: Generate Python client
+        working-directory: clients/python
+        run: |
+          make clean install tidy
+      - name: Check if there are uncommitted file changes
+        run: |
+          clean=$(git status --porcelain)
+          if [[ -z "$clean" ]]; then
+              echo "Empty git status --porcelain: $clean"
+          else
+              echo "Uncommitted file changes detected: $clean"
+              git diff
+              exit 1
+          fi
+
+  test:
+    name: Test against Py ${{ matrix.python }} and K8s ${{ matrix.kubernetes-version }}
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python: ["3.12"] # see below for versions 3.9-3.11
+        kubernetes-version:
+          ["v1.27.11", "v1.28.7", "v1.29.2", "v1.30.6", "v1.31.0"]
+        exclude: # on main merges (not PRs), use also different K8s versions for E2E testing
+          - kubernetes-version: ${{ github.event_name != 'push' && 'v1.28.7' }}
+          - kubernetes-version: ${{ github.event_name != 'push' && 'v1.29.2' }}
+          - kubernetes-version: ${{ github.event_name != 'push' && 'v1.30.6' }}
+          - kubernetes-version: ${{ github.event_name != 'push' && 'v1.31.0' }}
+        include: # test Py versions only with a reference K8s version, designated currently to kubernetes-version: v1.27.11
+          - python: "3.11"
+            kubernetes-version: "v1.27.11"
+          - python: "3.10"
+            kubernetes-version: "v1.27.11"
+          - python: "3.9"
+            kubernetes-version: "v1.27.11"
+    env:
+      FORCE_COLOR: "1"
+      IMG_REGISTRY: ghcr.io
+      IMG_ORG: kubeflow
+      IMG_REPO: model-registry
+    steps:
+      - name: Check out the repository
+        uses: actions/checkout@v5
+      - name: Set up Python ${{ matrix.python }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python }}
+      - name: Upgrade pip
+        run: |
+          pip install --constraint=.github/workflows/constraints.txt pip
+          pip --version
+      - name: Upgrade pip in virtual environments
+        shell: python
+        run: |
+          import os
+          import pip
+
+          with open(os.environ["GITHUB_ENV"], mode="a") as io:
+              print(f"VIRTUALENV_PIP={pip.__version__}", file=io)
+      - name: Install Poetry
+        # use absolute path as recommended with: https://github.com/pypa/pipx/issues/1331
+        run: |
+          pipx install --pip-args=--constraint=${{ github.workspace }}/.github/workflows/constraints.txt poetry
+          poetry --version
+      - name: Install Nox
+        run: |
+          pipx install --pip-args=--constraint=${{ github.workspace }}/.github/workflows/constraints.txt nox
+          pipx inject --pip-args=--constraint=${{ github.workspace }}/.github/workflows/constraints.txt nox nox-poetry
+          nox --version
+      - name: Install Storage Clients
+        # Oras should be available in the GH Action CI by default
+        # See: https://oras.land/docs/installation/#runner-machine-of-azure-devops-and-github-actions
+        run: |
+          sudo apt-get -y install skopeo
+      - name: Nox test
+        working-directory: clients/python
+        run: |
+          nox --python=${{ matrix.python }} --session=tests
+      - name: Generate Tag
+        shell: bash
+        id: tags
+        run: |
+          commit_sha=${{ github.event.after }}
+          tag=main-${commit_sha:0:7}
+          echo "tag=${tag}" >> $GITHUB_OUTPUT
+      - name: Build Image
+        shell: bash
+        env:
+          IMG_VERSION: ${{ steps.tags.outputs.tag }}
+        run: make image/build
+      - name: Start Kind Cluster
+        uses: helm/kind-action@v1.12.0
+        with:
+          node_image: kindest/node:${{ matrix.kubernetes-version }}
+          cluster_name: chart-testing-py-${{ matrix.python }}
+          kubectl_version: ${{ matrix.kubernetes-version }}
+      - name: Remove AppArmor profile for mysql in KinD on GHA # https://github.com/kubeflow/manifests/issues/2507
+        run: |
+          set -x
+          sudo apparmor_parser -R /etc/apparmor.d/usr.sbin.mysqld
+      - name: Load Local Registry Test Image
+        env:
+          IMG: "${{ env.IMG_REGISTRY }}/${{ env.IMG_ORG }}/${{ env.IMG_REPO }}:${{ steps.tags.outputs.tag }}"
+        run: |
+          kind load docker-image -n chart-testing-py-${{ matrix.python }} ${IMG}
+      - name: Deploy Model Registry using manifests
+        env:
+          IMG: "${{ env.IMG_REGISTRY }}/${{ env.IMG_ORG }}/${{ env.IMG_REPO }}:${{ steps.tags.outputs.tag }}"
+        run: ./scripts/deploy_on_kind.sh
+      - name: Deploy Minio using manifests
+        run: |
+          ./scripts/deploy_minio_on_kind.sh
+          cat ./scripts/manifests/minio/.env >> $GITHUB_ENV
+      - name: Deploy OCI Registry using manifests
+        run: ./scripts/deploy_local_kind_registry.sh
+      - name: Nox test end-to-end
+        working-directory: clients/python
+        run: |
+          kubectl port-forward -n kubeflow service/model-registry-service 8080:8080 &
+          kubectl port-forward -n minio svc/minio 9000:9000 &
+          kubectl port-forward service/distribution-registry-test-service 5001:5001 &
+          sleep 2
+          nox --python=${{ matrix.python }} --session=e2e -- --cov-report=xml
+      - name: Nox test fuzz (main only)
+        if: github.ref == 'refs/heads/main'
+        working-directory: clients/python
+        run: |
+          kubectl port-forward -n kubeflow service/model-registry-service 8080:8080 &
+          kubectl port-forward -n minio svc/minio 9000:9000 &
+          kubectl port-forward service/distribution-registry-test-service 5001:5001 &
+          sleep 2
+          nox --python=${{ matrix.python }} --session=fuzz
+
+  docs-build:
+    name: ${{ matrix.session }}
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python: ["3.12"]
+        session: [docs-build]
+    env:
+      NOXSESSION: ${{ matrix.session }}
+      FORCE_COLOR: "1"
+    steps:
+      - name: Check out the repository
+        uses: actions/checkout@v5
       - name: Set up Python ${{ matrix.python }}
         uses: actions/setup-python@v5
         with:
@@ -52,17 +277,15 @@ jobs:
       - name: Run Nox
         working-directory: clients/python
         run: |
-          if [[ ${{ matrix.session }} == "tests" ]]; then
-            nox --python=${{ matrix.python }} -- --cov-report=xml
-          elif [[ ${{ matrix.session }} == "mypy" ]]; then
-            nox --python=${{ matrix.python }} ||\
-              echo "::error title='mypy failure'::Check the logs for more details"
-          else
-            nox --python=${{ matrix.python }}
-          fi
-      - name: Upload documentation
-        if: matrix.session == 'docs-build'
+          nox --python=${{ matrix.python }}
+          poetry build
+      - name: Upload dist
         uses: actions/upload-artifact@v4
         with:
-          name: docs
+          name: py-dist
+          path: clients/python/dist
+      - name: Upload documentation
+        uses: actions/upload-artifact@v4
+        with:
+          name: py-docs
           path: clients/python/docs/_build

.github/workflows/run-robot-tests.yaml

@@ -1,65 +0,0 @@
-name: run-robot-tests
-run-name: Run Robot Framework tests
-# Run workflow
-on:
-  # For every push to repository
-  push:
-    # To any branch
-    branches:
-      - '*'
-  # For every pull request
-  pull_request:
-    # But ignore this paths
-    paths-ignore:
-      - 'LICENSE*'
-      - 'DOCKERFILE*'
-      - '**.gitignore'
-      - '**.md'
-      - '**.txt'
-      - '.github/ISSUE_TEMPLATE/**'
-      - '.github/dependabot.yml'
-      - 'docs/**'
-      - 'scripts/**'
-# Define workflow jobs
-jobs:
-  # Job runs Robot Framework tests against locally build image from current code
-  run-robot-tests:
-    # Ubuntu latest is sufficient system for run
-    runs-on: ubuntu-latest
-    # Define steps of job
-    steps:
-      # Get checkout action to get this repository
-      - uses: actions/checkout@v4
-      # Install defined Python version to run Robot Framework tests
-      - name: Install Python 3.9.x
-        # Get setup-python action to install Python
-        uses: actions/setup-python@v5
-        with:
-          # Set Python version to install
-          python-version: '3.9'
-          # Set architecture of Python to install
-          architecture: 'x64'
-      # Install required Python packages for running Robot Framework tests
-      - name: Install required Python packages
-        # Install required Python packages using pip
-        run: pip install -r test/robot/requirements.txt
-      # Install model_registry Python package from current code
-      - name: Install model_registry Python package
-        # Install model_registry package as editable using pip
-        run: pip install -e clients/python
-      # Start docker compose with locally build image from current code
-      - name: Start docker compose with local image
-        # Start docker compose in the background
-        run: docker compose -f docker-compose-local.yaml up --detach
-      # Run Robot Framework tests in REST mode against running docker compose
-      - name: Run Robot Framework tests (REST mode)
-        # Run Robot Framework tests in REST mode from test/robot directory
-        run: robot test/robot
-      # Run Robot Framework tests in Python mode against running docker compose
-      - name: Run Robot Framework tests (Python mode)
-        # Run Robot Framework tests in Python mode from test/robot directory
-        run: TEST_MODE=Python robot test/robot/MRandLogicalModel.robot
-      # Shutdown docker compose with locally build image from current code
-      - name: Shutdown docker compose with local image
-        # Shutdown docker compose running in the background
-        run: docker compose -f docker-compose-local.yaml down

.github/workflows/test-fuzz.yml

@@ -0,0 +1,69 @@
+name: Fuzz Test
+on:
+  workflow_dispatch:
+    inputs:
+      pr_number:
+        description: 'The pull request number to run fuzz tests on'
+        required: true
+        type: number
+
+permissions:
+  contents: read
+
+env:
+  IMG_REGISTRY: ghcr.io
+  IMG_ORG: kubeflow
+  IMG_REPO: model-registry/server
+  IMG_VERSION: latest
+  PUSH_IMAGE: false
+
+jobs:
+  test-fuzz:
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: clients/python
+    steps:
+      - name: Get PR details
+        id: pr
+        uses: actions/github-script@v7
+        with:
+          script: |
+            try {
+              const pr = await github.rest.pulls.get({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                pull_number: ${{ github.event.inputs.pr_number }}
+              });
+              return {
+                sha: pr.data.head.sha,
+                ref: pr.data.head.ref
+              };
+            } catch (error) {
+              console.log(`Error fetching PR #${{ github.event.inputs.pr_number }}: ${error.message}`);
+              throw error;
+            }
+
+      - name: Checkout PR
+        uses: actions/checkout@v5
+        with:
+          ref: ${{ fromJson(steps.pr.outputs.result).sha }}
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install Poetry
+        run: |
+          pipx install poetry
+
+      - name: Remove AppArmor profile for mysql in KinD on GHA # https://github.com/kubeflow/manifests/issues/2507
+        run: |
+          set -x
+          sudo apparmor_parser -R /etc/apparmor.d/usr.sbin.mysqld
+
+      - name: Run Fuzz Tests
+        run: |
+          echo "Starting fuzz tests..."
+          make test-fuzz

.github/workflows/ui-bff-build.yml

@@ -0,0 +1,60 @@
+name: UI - BFF - Build
+on:
+  push:
+    branches:
+      - "main"
+    paths:
+      - "clients/ui/**"
+      - "!LICENSE*"
+      - "!DOCKERFILE*"
+      - "!**.gitignore"
+      - "!**.md"
+
+  pull_request:
+    paths:
+      - "clients/ui/**"
+      - ".github/workflows/**"
+      - "!LICENSE*"
+      - "!DOCKERFILE*"
+      - "!**.gitignore"
+      - "!**.md"
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+
+      - name: Setup Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: "1.24.3"
+
+      - name: Clean
+        working-directory: clients/ui/bff
+        run: make clean
+
+      - name: Lint
+        uses: golangci/golangci-lint-action@v8
+        with:
+          version: v2.1.0
+          working-directory: clients/ui/bff/
+
+      - name: Build
+        working-directory: clients/ui/bff
+        run: make build
+
+      - name: Check if there are uncommitted file changes
+        working-directory: clients/ui/bff
+        run: |
+          clean=$(git status --porcelain)
+          if [[ -z "$clean" ]]; then
+              echo "Empty git status --porcelain: $clean"
+          else
+              echo "Uncommitted file changes detected: $clean"
+              git diff
+              exit 1
+          fi

.github/workflows/ui-frontend-build.yml

@@ -0,0 +1,62 @@
+name: UI - Frontend - Test and Build
+on:
+  push:
+    branches:
+      - "main"
+    paths:
+      - "clients/ui/**"
+      - "!LICENSE*"
+      - "!DOCKERFILE*"
+      - "!**.gitignore"
+      - "!**.md"
+  
+  pull_request:
+    paths:
+      - "clients/ui/**"
+      - ".github/workflows/**"
+      - "!LICENSE*"
+      - "!DOCKERFILE*"
+      - "!**.gitignore"
+      - "!**.md"
+
+permissions:
+  contents: read
+
+jobs:
+  test-and-build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "20"
+
+      - name: Install dependencies
+        working-directory: clients/ui/frontend
+        run: npm install
+
+      - name: Run tests
+        working-directory: clients/ui/frontend
+        run: npm run test
+
+      - name: Clean
+        working-directory: clients/ui/frontend
+        run: npm run build:clean
+
+      - name: Build
+        working-directory: clients/ui/frontend
+        run: npm run build
+
+      - name: Check if there are uncommitted file changes
+        working-directory: clients/ui/frontend
+        run: |
+          clean=$(git status --porcelain)
+          if [[ -z "$clean" ]]; then
+              echo "Empty git status --porcelain: $clean"
+          else
+              echo "Uncommitted file changes detected: $clean"
+              git diff
+              exit 1
+          fi

.gitignore

@@ -11,12 +11,11 @@
 # Test binary, built with `go test -c`
 *.test
 
+__debug*
+
 # Output of the go coverage tool, specifically when used with LiteIDE
 *.out
 
-# Go workspace file
-go.work
-
 # Idea files
 .idea
 
@@ -25,6 +24,9 @@ go.work
 model-registry
 metadata.sqlite.db
 
+# Temporary files for running the project
+.port-forwards.pid
+
 # Ignore go vendor and code coverage files
 vendor
 coverage.*
@@ -38,3 +40,19 @@ __pycache__
 # Protoc files
 include/
 readme.txt
+
+#OSX files
+**/.DS_Store
+
+# CSI executable
+mr-storage-initializer
+
+# KServe manifests
+istio-*
+
+# VSCode files
+.vscode/
+
+# Python
+venv/
+.python-version

.openapi-generator-ignore

@@ -29,7 +29,6 @@ pkg/openapi/git_push.sh
 pkg/openapi/.gitignore
 pkg/openapi/.travis.yml
 pkg/openapi/.openapi-generator-ignore
-
 pkg/openapi/README.md
 pkg/openapi/docs/**.md
 pkg/openapi/test

.readthedocs.yaml

@@ -0,0 +1,45 @@
+# Read the Docs configuration file for Sphinx projects
+# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
+
+# Required
+version: 2
+
+# Set the OS, Python version and other tools you might need
+build:
+  os: ubuntu-22.04
+  tools:
+    python: "3.9"
+    # You can also specify other tool versions:
+    # nodejs: "20"
+    # rust: "1.70"
+    # golang: "1.20"
+  jobs:
+    post_create_environment:
+      # Install poetry
+      # https://python-poetry.org/docs/#installing-manually
+      - python -m pip install poetry
+    post_install:
+      # Install dependencies with 'docs' dependency group
+      # https://python-poetry.org/docs/managing-dependencies/#dependency-groups
+      - VIRTUAL_ENV=$READTHEDOCS_VIRTUALENV_PATH poetry -C clients/python install --with docs
+
+# Build documentation in the "docs/" directory with Sphinx
+sphinx:
+  configuration: clients/python/docs/conf.py
+  # You can configure Sphinx to use a different builder, for instance use the dirhtml builder for simpler URLs
+  # builder: "dirhtml"
+  # Fail on all warnings to avoid broken references
+  # fail_on_warning: true
+# Optionally build your docs in additional formats such as PDF and ePub
+# formats:
+#   - pdf
+#   - epub
+
+# Optional but recommended, declare the Python requirements required
+# to build your documentation
+# See https://docs.readthedocs.io/en/stable/guides/reproducible-builds.html
+# python:
+#   install:
+#     - requirements: clients/python/docs/requirements.txt
+#     - method: pip
+#       path: clients/python

ADOPTERS.md

@@ -0,0 +1,13 @@
+# Adopters of Kubeflow Model Registry
+
+Below are the adopters of the Model Registry project. If you are using Model Registry in your organization, please add your name to the list by submitting a pull request: this will help foster the Kubeflow community. Kindly ensure the list remains in alphabetical order.
+If you are using other Kubeflow components, consider adding as well to the overall [Kubeflow Community Adopters file](https://github.com/kubeflow/community/blob/master/ADOPTERS.md).
+
+| Organization                  | Contact (GitHub User Name)                 | Environment                                | Description of Use                                                    |
+|-------------------------------|--------------------------------------------|--------------------------------------------|-----------------------------------------------------------------------|
+| [Pepsico](https://www.pepsico.com/) | [@milosjava](https://github.com/milosjava) | Experimenting  | Evaluating a transition from Azure Model Registry to Kubeflow Model Registry |
+| [Red Hat](https://www.redhat.com)          | [@rareddy](https://github.com/rareddy)| Production       |   Kubeflow Model Registry is part of [OpenShift AI](https://www.redhat.com/en/products/ai/openshift-ai) |
+| [INFN (National Institute for Nuclear Physics)](https://www.infn.it/en/) | [@mginfn](https://github.com/mginfn) | Experimenting  | Building a platform for running ML workflows |
+| [YIQISOFT](https://www.yiqisoft.com) | [@jiekechoo](https://github.com/jiekechoo) | Production | Model Registry is part of [YiAI](https://www.yiqisoft.cn/products/)|
+| [VMware](https://www.vmware.com) | [@tiansiyuan](https://github.com/tiansiyuan) | Testing | Model Registry is important for LLMs |
+| < company name here>           | < your github handle here >                  | <Production/Testing/Experimenting/etc>       | <any notes you'd like to share>                                       |

CONTRIBUTING.md

@@ -1,26 +1,37 @@
 # Kubeflow Contributor Guide
 
-Welcome to the Kubeflow project! We'd love to accept your patches and 
+Welcome to the Kubeflow Model Registry project! We'd love to accept your patches and 
 contributions to this project. Please read the 
 [contributor's guide in our docs](https://www.kubeflow.org/docs/about/contributing/).
 
-The contributor's guide
+The contributor's guide:
 
-* shows you where to find the Contributor License Agreement (CLA) that you need 
-  to sign,
-* helps you get started with your first contribution to Kubeflow,
-* and describes the pull request and review workflow in detail, including the
-  OWNERS files and automated workflow tool.
+* explains how to use the Developer Certificate of Origin (DCO) with git commit system
+  * like explained in [this guide](https://wiki.linuxfoundation.org/dco), or [this example](https://github.com/kubeflow/community/tree/master/dco-signoff-hook#signing-off-commits)
+* references the [Code of Conduct](https://www.kubeflow.org/docs/about/contributing/#follow-the-code-of-conduct)
+* helps you get started with your first contribution to Kubeflow
+  * like how to identify [good-first-issue](https://github.com/kubeflow/model-registry/labels/good%20first%20issue) tickets
+* and [describes](https://www.kubeflow.org/docs/about/contributing/#owners-files-and-pr-workflow) the pull request and review workflow in detail, including the
+  OWNERS files and automated workflow tool
+
+The [Kubeflow Community calendar](https://www.kubeflow.org/docs/about/community/#kubeflow-community-calendar) provides an overview of the community calls and specifically the bi-weekly Kubeflow Model Registry meeting.
 
 <hr/>
 
-This document focus on technical aspects while contributing to the Model Registry project
+The remainder of this document focuses on technical aspects while contributing to the Model Registry project specifically.
+
+The [Model Registry documentation](https://github.com/kubeflow/model-registry?tab=readme-ov-file#documentation-links) provides details about: what is a Model Registry, how to Install, logical model Concepts, how the MR python client works, Tutorials, FAQs and most importantly the [Technical References](https://github.com/kubeflow/model-registry?tab=readme-ov-file#documentation-links:~:text=FAQs-,Development,-introduction%20to%20local)!
 
 # Contributing to Model Registry using Apple-silicon/ARM-based computers
 
 Some limitations apply when developing on this project, specifically using Apple-silicon and Mac OSX.
 The content from this guide might also be applicable in part for general ARM-based developers/users, beyond Mac OSX.
 
+## Consider installing coreutils
+
+While we strived to keep the repository scripts cross-compatible with GNU and BSD utilities, you might want to consider installing the `coreutils` from Homebrew, [following these instructions](https://formulae.brew.sh/formula/coreutils).
+You will need to ensure the gnubin directory is added to your shell path. 
+
 ## Makefile
 
 The make command shipped with Mac OSX (at the time of writing) is a bit old:
@@ -28,11 +39,6 @@ The make command shipped with Mac OSX (at the time of writing) is a bit old:
 ```
 % make --version
 GNU Make 3.81
-Copyright (C) 2006  Free Software Foundation, Inc.
-This is free software; see the source for copying conditions.
-There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A
-PARTICULAR PURPOSE.
-
 This program built for i386-apple-darwin11.3.0
 ```
 
@@ -66,11 +72,70 @@ to your PATH from your bashrc like:
 
 and now you can substitute `gmake` every time the make command is mentioned in guides (or perform the path management per the caveat).
 
+## Local kubernetes deployment of Model Registry
+
+To test the Model Registry locally without mocking the k8s calls, the Model Registry backend can be deployed using Kind.
+
+### Prerequisites
+
+The following tools need to be installed in your local environment:
+
+- [Podman](https://podman.io/) (Docker should also work)
+- [kubectl](https://kubernetes.io/docs/tasks/tools/#kubectl)
+- [kind](https://kind.sigs.k8s.io/docs/user/quick-start/#installation)
+
+Choose the networking setup that fits your needs, either port-forwarding or Ingress.
+
+### Port-forwarding guide
+
+Create a Kind cluster with the following command:
+
+```sh
+kind create cluster
+```
+
+and then follow the steps from the [Installation guide](https://www.kubeflow.org/docs/components/model-registry/installation/#standalone-installation) on the Kubeflow website, to set up the port-forwarding and deploy the Model Registry on the cluster.
+
+### Ingress guide
+
+Follow the [Ingress guide](docs/mr_kind_deploy_ingress.md) to set up the Ingress controller and deploy the Model Registry on the cluster.
+
 ## Docker engine
 
 Several options of docker engines are available for Mac.
 Having Docker installed is also helpful for Testcontainers.
 
+### Podman
+
+[Podman](https://podman.io/) also supports Rosetta (Apple specific) emulation which is handy since the Google MLMD project dependency is x86 specific.
+
+We recommend setting up the Podman machine with root privileges,
+and setting the environment variable
+
+```sh
+export TESTCONTAINERS_RYUK_PRIVILEGED=true
+```
+
+when running TestContainer-based Model Registry Python tests (for more information, see [here](https://pypi.org/project/testcontainers/#:~:text=TESTCONTAINERS_RYUK_PRIVILEGED)).
+
+#### Fedora
+
+Fedora requires further setup to make testcontainers work with Podman, the following steps are required:
+
+- start the podman socket service
+
+```sh
+systemctl --user start podman.socket
+```
+
+- set the environment variable
+
+```sh
+export DOCKER_HOST=unix://$XDG_RUNTIME_DIR/podman/podman.sock
+```
+
+If you need more information, please refer to the [Testcontainers using Podman](https://golang.testcontainers.org/system_requirements/using_podman/).
+
 ### Colima
 
 Colima offers Rosetta (Apple specific) emulation which is handy since the Google MLMD project dependency is x86 specific.
@@ -95,17 +160,6 @@ This colima setups allows to:
 - launch Integration tests in Go (used in Core go layer) with Testcontainers for Go
 - launch DevContainer to be able to install MLMD python wheel dependency (which is x86 specific)
 
-## Remote-only MLMD Python library
-
-The Model Registry Python client wraps `ml-metadata` python dependency (which is [x86 specific](https://pypi.org/project/ml-metadata/#files)).
-
-When developing and contributing to the Model Registry Python client using Apple-silicon/ARM-based computers,
-it can be helpful to evaluate using locally this soft-fork of the upstream MLMD library supporting only remote gRPC connections:
-https://github.com/opendatahub-io/ml-metadata/releases/tag/v1.14.0%2Bremote.1
-
-This dependency can be substituted in the [clients/python/pyproject.toml](clients/python/pyproject.toml) and installed locally with `poetry lock`.
-It is recommended not to check-in this substitution, only helpful for local development while using Apple-silicon/ARM-based computers.
-
 ## DevContainer
 
 Using a [DevContainer](https://containers.dev) is helpful to develop with the Model Registry Python client, since it needs to wrap MLMD python dependency (which is [x86 specific](https://pypi.org/project/ml-metadata/#files)).
@@ -202,3 +256,31 @@ Then with the given setup MLMD is already installed inside the DevContainer:
 At this point Poetry is already installed as well and can be used to build and run test of the Model Registry Python client.
 
 <!-- to be continued with explanation of this "hack": https://github.com/tarilabs/ml-metadata-remote#readme -->
+
+# FAQ
+
+## Error `docker.errors.NotFound: 404 Client Error for http+docker://localhost/v1.41/containers ...`
+
+This happens on Mac OSX when running Testcontainers-based Python tests, and [Ryuk](https://github.com/testcontainers/moby-ryuk) does not have the correct access priviledges.
+
+```
+-------------------------------------------- Captured stderr setup ---------------------------------------------
+Pulling image testcontainers/ryuk:0.7.0
+Container started: 4af385c2d670
+---------------------------------------------- Captured log setup ----------------------------------------------
+WARNING  root:config.py:59 DOCKER_AUTH_CONFIG is experimental, see testcontainers/testcontainers-python#566
+INFO     testcontainers.core.container:container.py:88 Pulling image testcontainers/ryuk:0.7.0
+INFO     testcontainers.core.container:container.py:101 Container started: 4af385c2d670
+=========================================== short test summary info ============================================
+ERROR tests/store/test_wrapper.py::test_get_undefined_artifact_type_id - docker.errors.NotFound: 404 Client Error for http+docker://localhost/v1.41/containers/4af385c2d67067875f6f0...
+!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! stopping after 1 failures !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+=============================================== 1 error in 0.50s ===============================================
+```
+
+Solution:
+- Use `export TESTCONTAINERS_RYUK_PRIVILEGED=true` (we recommend this option)
+- Use `export TESTCONTAINERS_RYUK_DISABLED=true` to disable Ryuk entirely; the tests are configured to close all container resources, but we do not recommend this option
+
+For more information:
+- section [Docker engine](https://github.com/kubeflow/model-registry/blob/main/CONTRIBUTING.md#docker-engine) in this document
+- https://pypi.org/project/testcontainers/#:~:text=the%20database%20version.-,Configuration,-Env%20Variable

Dockerfile

@@ -1,44 +1,37 @@
 # Build the model-registry binary
-FROM registry.access.redhat.com/ubi8/go-toolset:1.19 as builder
+FROM --platform=$BUILDPLATFORM registry.access.redhat.com/ubi9/go-toolset:1.24 AS common
+ARG TARGETOS
+ARG TARGETARCH
 
 WORKDIR /workspace
-# Copy the Go Modules manifests
-COPY ["go.mod", "go.sum", "./"]
+# Copy the Go Modules manifests and workspace file
+COPY ["go.mod", "go.sum", "go.work", "go.work.sum", "./"]
+COPY ["pkg/openapi/go.mod", "pkg/openapi/"]
 # cache deps before building and copying source so that we don't need to re-download as much
 # and so that source changes don't invalidate our downloaded layer
 RUN go mod download
 
-USER root
-# default NodeJS 14 is not enough for openapi-generator-cli, switch to Node JS currently supported
-RUN yum remove -y nodejs npm
-RUN yum module -y reset nodejs
-RUN yum module -y enable nodejs:18
-# install npm and java for openapi-generator-cli
-RUN yum install -y nodejs npm java-11
-
-# Copy the go source
-COPY ["Makefile", "main.go", ".openapi-generator-ignore", "openapitools.json", "./"]
-
-# Copy rest of the source
-COPY .git/ .git/
+# Download tools
+COPY Makefile .
+COPY ["main.go", ".openapi-generator-ignore", "openapitools.json", "./"]
 COPY cmd/ cmd/
 COPY api/ api/
 COPY internal/ internal/
 COPY scripts/ scripts/
 COPY pkg/ pkg/
-COPY patches/ patches/
 COPY templates/ templates/
+COPY patches/ patches/
+COPY catalog/ catalog/
 
-# Download tools
-RUN make deps
+FROM common AS builder
 
-# Build
 USER root
-RUN CGO_ENABLED=1 GOOS=linux GOARCH=amd64 make clean model-registry
+
+RUN CGO_ENABLED=0 GOOS=${TARGETOS:-linux} GOARCH=${TARGETARCH} make build/compile
 
 # Use distroless as minimal base image to package the model-registry binary
 # Refer to https://github.com/GoogleContainerTools/distroless for more details
-FROM registry.access.redhat.com/ubi8/ubi-minimal:latest
+FROM registry.access.redhat.com/ubi9/ubi-minimal:latest
 WORKDIR /
 # copy the registry binary
 COPY --from=builder /workspace/model-registry .

Dockerfile.odh

@@ -1,9 +1,10 @@
 # Build the model-registry binary
-FROM registry.access.redhat.com/ubi8/go-toolset:1.19 as builder
+FROM registry.access.redhat.com/ubi9/go-toolset:1.24 AS builder
 
 WORKDIR /workspace
-# Copy the Go Modules manifests
-COPY ["go.mod", "go.sum", "./"]
+# Copy the Go Modules manifests and workspace file
+COPY ["go.mod", "go.sum", "go.work", "./"]
+COPY ["pkg/openapi/go.mod", "pkg/openapi/"]
 # cache deps before building and copying source so that we don't need to re-download as much
 # and so that source changes don't invalidate our downloaded layer
 RUN go mod download
@@ -25,7 +26,7 @@ RUN CGO_ENABLED=1 GOOS=linux GOARCH=amd64 make clean/odh build/odh
 
 # Use distroless as minimal base image to package the model-registry binary
 # Refer to https://github.com/GoogleContainerTools/distroless for more details
-FROM registry.access.redhat.com/ubi8/ubi-minimal:latest
+FROM registry.access.redhat.com/ubi9/ubi-minimal:latest
 WORKDIR /
 # copy the registry binary
 COPY --from=builder /workspace/model-registry .

Makefile

@@ -2,135 +2,194 @@
 MKFILE_PATH := $(abspath $(lastword $(MAKEFILE_LIST)))
 PROJECT_PATH := $(patsubst %/,%,$(dir $(MKFILE_PATH)))
 PROJECT_BIN := $(PROJECT_PATH)/bin
-GO := $(PROJECT_BIN)/go1.19
+GO ?= "$(shell which go)"
+UI_PATH := $(PROJECT_PATH)/clients/ui
+CSI_PATH := $(PROJECT_PATH)/cmd/csi
+CONTROLLER_PATH := $(PROJECT_PATH)/cmd/controller
+
+# ENVTEST_K8S_VERSION refers to the version of kubebuilder assets to be downloaded by envtest binary.
+ENVTEST_K8S_VERSION = 1.29
+ENVTEST ?= $(PROJECT_BIN)/setup-envtest
 
 # add tools bin directory
 PATH := $(PROJECT_BIN):$(PATH)
 
-MLMD_VERSION ?= 1.14.0
-
 # docker executable
 DOCKER ?= docker
 # default Dockerfile
 DOCKERFILE ?= Dockerfile
-# container registry, default to empty (dockerhub) if not explicitly set
-IMG_REGISTRY ?= 
+# container registry, default to github container registry
+IMG_REGISTRY ?= ghcr.io
 # container image organization
 IMG_ORG ?= kubeflow
 # container image version
 IMG_VERSION ?= main
 # container image repository
-IMG_REPO ?= model-registry
+IMG_REPO ?= model-registry/server
+# container image build path
+BUILD_PATH ?= .
 # container image
-ifdef IMG_REGISTRY
+ifdef IMG
+	IMG := ${IMG}
+else ifdef IMG_REGISTRY
     IMG := ${IMG_REGISTRY}/${IMG_ORG}/${IMG_REPO}
 else
     IMG := ${IMG_ORG}/${IMG_REPO}
 endif
 
+# Change Dockerfile path depending on IMG_REPO
+ifeq ($(IMG_REPO),model-registry/ui)
+    DOCKERFILE := $(UI_PATH)/Dockerfile
+	BUILD_PATH := $(UI_PATH)
+endif
+
+# The BUILD_PATH is still the root
+ifeq ($(IMG_REPO),model-registry/storage-initializer)
+    DOCKERFILE := $(CSI_PATH)/Dockerfile.csi
+endif
+
+# The BUILD_PATH is still the root
+ifeq ($(IMG_REPO),model-registry/controller)
+    DOCKERFILE := $(CONTROLLER_PATH)/Dockerfile.controller
+endif
+
 model-registry: build
 
-# clean the ml-metadata protos and trigger a fresh new build which downloads
-# ml-metadata protos based on specified MLMD_VERSION
-.PHONY: update/ml_metadata
-update/ml_metadata: clean/ml_metadata clean build
-
-clean/ml_metadata:
-	rm -rf api/grpc/ml_metadata/proto/*.proto
-
-api/grpc/ml_metadata/proto/metadata_source.proto:
-	mkdir -p api/grpc/ml_metadata/proto/
-	cd api/grpc/ml_metadata/proto/ && \
-		curl -LO "https://raw.githubusercontent.com/google/ml-metadata/v${MLMD_VERSION}/ml_metadata/proto/metadata_source.proto" && \
-		sed -i 's#syntax = "proto[23]";#&\noption go_package = "github.com/kubeflow/model-registry/internal/ml_metadata/proto";#' metadata_source.proto
-
-api/grpc/ml_metadata/proto/metadata_store.proto:
-	mkdir -p api/grpc/ml_metadata/proto/
-	cd api/grpc/ml_metadata/proto/ && \
-		curl -LO "https://raw.githubusercontent.com/google/ml-metadata/v${MLMD_VERSION}/ml_metadata/proto/metadata_store.proto" && \
-		sed -i 's#syntax = "proto[23]";#&\noption go_package = "github.com/kubeflow/model-registry/internal/ml_metadata/proto";#' metadata_store.proto
-
-api/grpc/ml_metadata/proto/metadata_store_service.proto:
-	mkdir -p api/grpc/ml_metadata/proto/
-	cd api/grpc/ml_metadata/proto/ && \
-		curl -LO "https://raw.githubusercontent.com/google/ml-metadata/v${MLMD_VERSION}/ml_metadata/proto/metadata_store_service.proto" && \
-		sed -i 's#syntax = "proto[23]";#&\noption go_package = "github.com/kubeflow/model-registry/internal/ml_metadata/proto";#' metadata_store_service.proto
-
-internal/ml_metadata/proto/%.pb.go: api/grpc/ml_metadata/proto/%.proto
-	bin/protoc -I./api/grpc --go_out=./internal --go_opt=paths=source_relative \
-		--go-grpc_out=./internal --go-grpc_opt=paths=source_relative $<
-
-.PHONY: gen/grpc
-gen/grpc: internal/ml_metadata/proto/metadata_store.pb.go internal/ml_metadata/proto/metadata_store_service.pb.go
-
 internal/converter/generated/converter.go: internal/converter/*.go
 	${GOVERTER} gen github.com/kubeflow/model-registry/internal/converter/
 
 .PHONY: gen/converter
-gen/converter: gen/grpc internal/converter/generated/converter.go
+gen/converter: internal/converter/generated/converter.go
+
+api/openapi/model-registry.yaml: api/openapi/src/model-registry.yaml api/openapi/src/lib/*.yaml bin/yq
+	scripts/merge_openapi.sh model-registry.yaml
+
+api/openapi/catalog.yaml: api/openapi/src/catalog.yaml api/openapi/src/lib/*.yaml bin/yq
+	scripts/merge_openapi.sh catalog.yaml
 
 # validate the openapi schema
 .PHONY: openapi/validate
-openapi/validate: bin/openapi-generator-cli
-	${OPENAPI_GENERATOR} validate -i api/openapi/model-registry.yaml
+openapi/validate: bin/openapi-generator-cli bin/yq
+	@scripts/merge_openapi.sh --check model-registry.yaml || (echo "api/openapi/model-registry.yaml is incorrectly formatted. Run 'make api/openapi/model-registry.yaml' to fix it."; exit 1)
+	@scripts/merge_openapi.sh --check catalog.yaml || (echo "$< is incorrectly formatted. Run 'make api/openapi/catalog.yaml' to fix it."; exit 1)
+	$(OPENAPI_GENERATOR) validate -i api/openapi/model-registry.yaml
+	$(OPENAPI_GENERATOR) validate -i api/openapi/catalog.yaml
 
 # generate the openapi server implementation
 .PHONY: gen/openapi-server
-gen/openapi-server: bin/openapi-generator-cli openapi/validate
-	@if git diff --exit-code --name-only | grep -q "api/openapi/model-registry.yaml" || \
-		git diff --exit-code --name-only | grep -q "api/openapi/model-registry.yaml" || \
-		[ -n "${FORCE_SERVER_GENERATION}" ]; then \
-		ROOT_FOLDER="." ./scripts/gen_openapi_server.sh; \
-	else \
-		echo "INFO api/openapi/model-registry.yaml is not staged or modified, will not re-generate server"; \
-	fi
+gen/openapi-server: bin/openapi-generator-cli api/openapi/model-registry.yaml api/openapi/catalog.yaml openapi/validate internal/server/openapi/api_model_registry_service.go
+	make -C catalog $@
+
+internal/server/openapi/api_model_registry_service.go: bin/openapi-generator-cli api/openapi/model-registry.yaml
+	./scripts/gen_openapi_server.sh
 
 # generate the openapi schema model and client
 .PHONY: gen/openapi
-gen/openapi: bin/openapi-generator-cli openapi/validate pkg/openapi/client.go
+gen/openapi: bin/openapi-generator-cli api/openapi/model-registry.yaml api/openapi/catalog.yaml openapi/validate pkg/openapi/client.go
+	make -C catalog $@
 
-pkg/openapi/client.go: bin/openapi-generator-cli api/openapi/model-registry.yaml
-	rm -rf pkg/openapi
+pkg/openapi/client.go: bin/openapi-generator-cli api/openapi/model-registry.yaml clean-pkg-openapi
 	${OPENAPI_GENERATOR} generate \
 		-i api/openapi/model-registry.yaml -g go -o pkg/openapi --package-name openapi \
 		--ignore-file-override ./.openapi-generator-ignore --additional-properties=isGoSubmodule=true,enumClassPrefix=true,useOneOfDiscriminatorLookup=true
 	gofmt -w pkg/openapi
 
+# Start the MySQL database
+.PHONY: start/mysql
+start/mysql:
+	./scripts/start_mysql_db.sh
+
+# Stop the MySQL database
+.PHONY: stop/mysql
+stop/mysql:
+	./scripts/teardown_mysql_db.sh
+
+# Start the PostgreSQL database
+.PHONY: start/postgres
+start/postgres:
+	./scripts/start_postgres_db.sh
+
+# Stop the PostgreSQL database
+.PHONY: stop/postgres
+stop/postgres:
+	./scripts/teardown_postgres_db.sh
+
+# generate the gorm structs for MySQL
+.PHONY: gen/gorm/mysql
+gen/gorm/mysql: bin/golang-migrate start/mysql
+	@(trap 'cd $(CURDIR) && $(MAKE) stop/mysql' EXIT; \
+	$(GOLANG_MIGRATE) -path './internal/datastore/embedmd/mysql/migrations' -database 'mysql://root:root@tcp(localhost:3306)/model-registry' up && \
+	cd gorm-gen && GOWORK=off go run main.go --db-type mysql --dsn 'root:root@tcp(localhost:3306)/model-registry?charset=utf8mb4&parseTime=True&loc=Local')
+
+# generate the gorm structs for PostgreSQL
+.PHONY: gen/gorm/postgres
+gen/gorm/postgres: bin/golang-migrate start/postgres
+	@(trap 'cd $(CURDIR) && $(MAKE) stop/postgres' EXIT; \
+	$(GOLANG_MIGRATE) -path './internal/datastore/embedmd/postgres/migrations' -database 'postgres://postgres:postgres@localhost:5432/model-registry?sslmode=disable' up && \
+	cd gorm-gen && GOWORK=off go run main.go --db-type postgres --dsn 'postgres://postgres:postgres@localhost:5432/model-registry?sslmode=disable' && \
+	cd $(CURDIR) && ./scripts/remove_gorm_defaults.sh)
+
+# generate the gorm structs (defaults to MySQL for backward compatibility)
+# Use GORM_DB_TYPE=postgres to generate for PostgreSQL instead
+.PHONY: gen/gorm
+gen/gorm: bin/golang-migrate
+ifeq ($(GORM_DB_TYPE),postgres)
+	$(MAKE) gen/gorm/postgres
+else
+	$(MAKE) gen/gorm/mysql
+endif
+
 .PHONY: vet
 vet:
-	${GO} vet ./...
+	@echo "Running go vet on all packages..."
+	@${GO} vet $$(${GO} list ./... | grep -vF github.com/kubeflow/model-registry/internal/db/filter) && \
+	echo "Checking filter package (parser.go excluded due to participle struct tags)..." && \
+	cd internal/db/filter && ${GO} build -o /dev/null . 2>&1 | grep -E "vet:|error:" || echo "✓ Filter package builds successfully"
+
+.PHONY: clean/csi
+clean/csi:
+	rm -Rf ./mr-storage-initializer
+
+.PHONY: clean-pkg-openapi
+clean-pkg-openapi:
+	while IFS= read -r file; do rm -f "pkg/openapi/$$file"; done < pkg/openapi/.openapi-generator/FILES
+	make -C catalog $@
+
+.PHONY: clean-internal-server-openapi
+clean-internal-server-openapi:
+	while IFS= read -r file; do rm -f "internal/server/openapi/$$file"; done < internal/server/openapi/.openapi-generator/FILES
+	make -C catalog $@
 
 .PHONY: clean
-clean:
-	rm -Rf ./model-registry internal/ml_metadata/proto/*.go internal/converter/generated/*.go pkg/openapi
+clean: clean-pkg-openapi clean-internal-server-openapi clean/csi
+	rm -Rf ./model-registry internal/converter/generated/*.go
 
 .PHONY: clean/odh
 clean/odh:
 	rm -Rf ./model-registry
 
-bin/go:
-	GOBIN=$(PROJECT_BIN) go install golang.org/dl/go1.19@latest
-	$(PROJECT_BIN)/go1.19 download
-
-bin/protoc:
-	./scripts/install_protoc.sh
-
-bin/go-enum:
-	GOBIN=$(PROJECT_BIN) ${GO} install github.com/searKing/golang/tools/go-enum@v1.2.97
-
-bin/protoc-gen-go:
-	GOBIN=$(PROJECT_BIN) ${GO} install google.golang.org/protobuf/cmd/protoc-gen-go@v1.31.0
-
-bin/protoc-gen-go-grpc:
-	GOBIN=$(PROJECT_BIN) ${GO} install google.golang.org/grpc/cmd/protoc-gen-go-grpc@v1.3.0
+bin/envtest:
+	GOBIN=$(PROJECT_BIN) ${GO} install sigs.k8s.io/controller-runtime/tools/setup-envtest@v0.0.0-20240320141353-395cfc7486e6
 
 GOLANGCI_LINT ?= ${PROJECT_BIN}/golangci-lint
 bin/golangci-lint:
-	curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s -- -b $(PROJECT_BIN) v1.54.2
+	curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s -- -b $(PROJECT_BIN) v2.0.2
 
 GOVERTER ?= ${PROJECT_BIN}/goverter
 bin/goverter:
-	GOBIN=$(PROJECT_PATH)/bin ${GO} install github.com/jmattheis/goverter/cmd/goverter@v1.1.1
+	GOBIN=$(PROJECT_PATH)/bin ${GO} install github.com/jmattheis/goverter/cmd/goverter@v1.8.1
+
+YQ ?= ${PROJECT_BIN}/yq
+bin/yq:
+	GOBIN=$(PROJECT_PATH)/bin ${GO} install github.com/mikefarah/yq/v4@v4.45.1
+
+GOLANG_MIGRATE ?= ${PROJECT_BIN}/migrate
+bin/golang-migrate:
+	GOBIN=$(PROJECT_PATH)/bin ${GO} install -tags 'mysql,postgres' github.com/golang-migrate/migrate/v4/cmd/migrate@v4.18.3
+
+GENQLIENT ?= ${PROJECT_BIN}/genqlient
+bin/genqlient:
+	GOBIN=$(PROJECT_PATH)/bin ${GO} install github.com/Khan/genqlient@v0.7.0
 
 OPENAPI_GENERATOR ?= ${PROJECT_BIN}/openapi-generator-cli
 NPM ?= "$(shell which npm)"
@@ -155,40 +214,67 @@ clean/deps:
 	rm -Rf bin/*
 
 .PHONY: deps
-deps: bin/go bin/protoc bin/go-enum bin/protoc-gen-go bin/protoc-gen-go-grpc bin/golangci-lint bin/goverter bin/openapi-generator-cli
+deps: bin/golangci-lint bin/goverter bin/openapi-generator-cli bin/envtest
 
 .PHONY: vendor
 vendor:
 	${GO} mod vendor
 
-.PHONY: build
-build: gen vet lint
+# WARNING: DO NOT DELETE THIS TARGET, USED BY Dockerfile!!!
+.PHONY: build/prepare
+build/prepare: gen vet lint
+
+# WARNING: DO NOT DELETE THIS TARGET, USED BY Dockerfile!!!
+.PHONY: build/compile
+build/compile:
 	${GO} build -buildvcs=false
 
+# WARNING: DO NOT EDIT THIS TARGET DIRECTLY!!!
+# Use build/prepare to add build prerequisites
+# Use build/compile to add/edit go source compilation
+# WARNING: Editing this target directly WILL affect the Dockerfile image build!!!
+.PHONY: build
+build: build/prepare build/compile
+
 .PHONY: build/odh
 build/odh: vet
 	${GO} build -buildvcs=false
 
+.PHONY: build/prepare/csi
+build/prepare/csi: build/prepare lint/csi
+
+.PHONY: build/compile/csi
+build/compile/csi:
+	${GO} build -buildvcs=false -o mr-storage-initializer ${CSI_PATH}/main.go
+
+.PHONY: build/csi
+build/csi: build/prepare/csi build/compile/csi
+
 .PHONY: gen
-gen: deps gen/grpc gen/openapi gen/openapi-server gen/converter
+gen: deps gen/openapi gen/openapi-server gen/converter
 	${GO} generate ./...
 
 .PHONY: lint
-lint:
-	${GOLANGCI_LINT} run main.go
-	${GOLANGCI_LINT} run cmd/... internal/... ./pkg/...
+lint: bin/golangci-lint
+	${GOLANGCI_LINT} run main.go  --timeout 3m
+	${GOLANGCI_LINT} run cmd/... internal/... ./pkg/...  --timeout 3m
+
+.PHONY: lint/csi
+lint/csi: bin/golangci-lint
+	${GOLANGCI_LINT} run ${CSI_PATH}/main.go
+	${GOLANGCI_LINT} run internal/csi/...
 
 .PHONY: test
-test: gen
-	${GO} test ./internal/... ./pkg/...
+test: bin/envtest
+	KUBEBUILDER_ASSETS="$(shell $(ENVTEST) use $(ENVTEST_K8S_VERSION) -p path)" ${GO} test ./internal/... ./pkg/...
 
 .PHONY: test-nocache
-test-nocache: gen
-	${GO} test ./internal/... ./pkg/... -count=1
+test-nocache: bin/envtest
+	KUBEBUILDER_ASSETS="$(shell $(ENVTEST) use $(ENVTEST_K8S_VERSION) -p path)" ${GO} test ./internal/... ./pkg/... -count=1
 
 .PHONY: test-cover
-test-cover: gen
-	${GO} test ./internal/... ./pkg/... -coverprofile=coverage.txt
+test-cover: bin/envtest
+	KUBEBUILDER_ASSETS="$(shell $(ENVTEST) use $(ENVTEST_K8S_VERSION) -p path)" ${GO} test ./internal/... ./pkg/... -coverprofile=coverage.txt
 	${GO} tool cover -html=coverage.txt -o coverage.html
 
 .PHONY: run/proxy
@@ -208,11 +294,36 @@ else
 	$(DOCKER) login -u "${DOCKER_USER}" -p "${DOCKER_PWD}"
 endif
 
-
 # build docker image
 .PHONY: image/build
 image/build:
-	${DOCKER} build . -f ${DOCKERFILE} -t ${IMG}:$(IMG_VERSION)
+	${DOCKER} build ${BUILD_PATH} -f ${DOCKERFILE} -t ${IMG}:$(IMG_VERSION) $(ARGS)
+
+# build docker image using buildx
+# PLATFORMS defines the target platforms for the model registry image be built to provide support to multiple
+# architectures. (i.e. make docker-buildx). To use this option you need to:
+# - be able to use docker buildx. More info: https://docs.docker.com/build/buildx/
+# - have enabled BuildKit. More info: https://docs.docker.com/develop/develop-images/build_enhancements/
+# - be able to push the image to your registry (i.e. if you do not set a valid value via IMG=<myregistry/image:<tag>> then the export will fail)
+# To adequately provide solutions that are compatible with multiple platforms, you should consider using this option.
+PLATFORMS ?= linux/arm64,linux/amd64,linux/s390x,linux/ppc64le
+.PHONY: image/buildx
+image/buildx:
+ifeq ($(DOCKER),docker)
+	# docker uses builder containers
+	- $(DOCKER) buildx rm model-registry-builder
+	$(DOCKER) buildx create --use --name model-registry-builder --platform=$(PLATFORMS)
+	$(DOCKER) buildx build --push --platform=$(PLATFORMS) --tag ${IMG}:$(IMG_VERSION) -f ${DOCKERFILE} .
+	$(DOCKER) buildx rm model-registry-builder
+else ifeq ($(DOCKER),podman)
+	# podman uses image manifests
+	$(DOCKER) manifest create -a ${IMG}
+	$(DOCKER) buildx build --platform=$(PLATFORMS) --manifest ${IMG}:$(IMG_VERSION) -f ${DOCKERFILE} .
+	$(DOCKER) manifest push ${IMG}
+	$(DOCKER) manifest rm ${IMG}
+else
+	$(error Unsupported container tool $(DOCKER))
+endif
 
 # push docker image
 .PHONY: image/push
@@ -220,3 +331,130 @@ image/push:
 	${DOCKER} push ${IMG}:$(IMG_VERSION)
 
 all: model-registry
+
+##  ------------------------------- ##
+##  ----  Controller Targets   ---- ##
+##  ------------------------------- ##
+
+##@ Development
+
+.PHONY: controller/manifests
+controller/manifests: bin/controller-gen ## Generate WebhookConfiguration, ClusterRole and CustomResourceDefinition objects.
+	$(CONTROLLER_GEN) rbac:roleName=model-registry-manager-role crd webhook paths="{./cmd/controller/..., ./internal/controller/...}" output:crd:artifacts:config=manifests/options/controller/crd/bases output:rbac:dir=manifests/kustomize/options/controller/rbac
+
+.PHONY: controller/generate
+controller/generate: bin/controller-gen ## Generate code containing DeepCopy, DeepCopyInto, and DeepCopyObject method implementations.
+	$(CONTROLLER_GEN) object:headerFile="./cmd/controller/hack/boilerplate.go.txt" paths="{./cmd/controller/..., ./internal/controller/...}"
+
+.PHONY: controller/fmt
+controller/fmt: ## Run go fmt against code.
+	go fmt ./cmd/controller/... ./internal/controller/...
+
+.PHONY: controller/vet
+controller/vet: ## Run go vet against code.
+	go vet ./cmd/controller/... ./internal/controller/...
+
+.PHONY: controller/test
+controller/test: controller/manifests controller/generate controller/fmt controller/vet bin/envtest ## Run tests.
+	KUBEBUILDER_ASSETS="$(shell $(ENVTEST) use $(ENVTEST_K8S_VERSION) --bin-dir $(PROJECT_BIN) -p path)" go test $$(go list ./internal/controller/... | grep -vF /e2e) -coverprofile cover.out
+
+##@ Build
+
+.PHONY: controller/build
+controller/build: controller/manifests controller/generate controller/fmt controller/vet ## Build manager binary.
+	go build -o bin/manager cmd/controller/main.go
+
+.PHONY: controller/run
+controller/run: controller/manifests controller/generate controller/fmt controller/vet ## Run a controller from your host.
+	go run ./cmd/controller/main.go
+
+# If you wish to build the manager image targeting other platforms you can use the --platform flag.
+# (i.e. docker build --platform linux/arm64). However, you must enable docker buildKit for it.
+# More info: https://docs.docker.com/develop/develop-images/build_enhancements/
+.PHONY: controller/docker-build
+controller/docker-build: ## Build docker image with the manager.
+	$(DOCKER) build -t ${IMG} -f ./cmd/controller/Dockerfile.controller .
+
+.PHONY: controller/docker-push
+controller/docker-push: ## Push docker image with the manager.
+	$(DOCKER) push ${IMG}
+
+# PLATFORMS defines the target platforms for the manager image be built to provide support to multiple
+# architectures. (i.e. make docker-buildx IMG=myregistry/mypoperator:0.0.1). To use this option you need to:
+# - be able to use docker buildx. More info: https://docs.docker.com/build/buildx/
+# - have enabled BuildKit. More info: https://docs.docker.com/develop/develop-images/build_enhancements/
+# - be able to push the image to your registry (i.e. if you do not set a valid value via IMG=<myregistry/image:<tag>> then the export will fail)
+# To adequately provide solutions that are compatible with multiple platforms, you should consider using this option.
+PLATFORMS ?= linux/arm64,linux/amd64,linux/s390x,linux/ppc64le
+.PHONY: controller/docker-buildx
+controller/docker-buildx: ## Build and push docker image for the manager for cross-platform support
+	# copy existing Dockerfile and insert --platform=${BUILDPLATFORM} into Dockerfile.cross, and preserve the original Dockerfile
+	sed -e '1 s/\(^FROM\)/FROM --platform=\$$\{BUILDPLATFORM\}/; t' -e ' 1,// s//FROM --platform=\$$\{BUILDPLATFORM\}/' ./cmd/controller/Dockerfile.controller > Dockerfile.cross
+	- $(DOCKER) buildx create --name controller-builder
+	$(DOCKER) buildx use controller-builder
+	- $(DOCKER) buildx build --push --platform=$(PLATFORMS) --tag ${IMG} -f Dockerfile.cross .
+	- $(DOCKER) buildx rm controller-builder
+	rm Dockerfile.cross
+
+.PHONY: controller/build-installer
+controller/build-installer: controller/manifests controller/generate bin/kustomize ## Generate a consolidated YAML with CRDs and deployment.
+	mkdir -p dist
+	cd manifests/kustomize/options/controller/manager && $(KUSTOMIZE) edit set image controller=${IMG}
+	$(KUSTOMIZE) build manifests/kustomize/options/controller/default > dist/install.yaml
+
+##@ Deployment
+
+ifndef ignore-not-found
+  ignore-not-found = false
+endif
+
+.PHONY: controller/install
+controller/install: controller/manifests bin/kustomize ## Install CRDs into the K8s cluster specified in ~/.kube/config.
+	$(KUSTOMIZE) build manifests/kustomize/options/controller/crd | $(KUBECTL) apply -f -
+
+.PHONY: controller/uninstall
+controller/uninstall: controller/manifests bin/kustomize ## Uninstall CRDs from the K8s cluster specified in ~/.kube/config. Call with ignore-not-found=true to ignore resource not found errors during deletion.
+	$(KUSTOMIZE) build manifests/kustomize/options/controller/crd | $(KUBECTL) delete --ignore-not-found=$(ignore-not-found) -f -
+
+.PHONY: controller/deploy
+controller/deploy: controller/manifests bin/kustomize ## Deploy controller to the K8s cluster specified in ~/.kube/config.
+	cd manifests/kustomize/options/controller/manager && $(KUSTOMIZE) edit set image ghcr.io/kubeflow/model-registry/controller=${IMG}:${IMG_VERSION}
+	$(KUSTOMIZE) build manifests/kustomize/options/controller/overlays/base | $(KUBECTL) apply -f -
+
+.PHONY: controller/undeploy
+controller/undeploy: bin/kustomize ## Undeploy controller from the K8s cluster specified in ~/.kube/config. Call with ignore-not-found=true to ignore resource not found errors during deletion.
+	$(KUSTOMIZE) build manifests/kustomize/options/controller/overlays/base | $(KUBECTL) delete --ignore-not-found=$(ignore-not-found) -f -
+
+##@ Tools
+
+KUBECTL ?= kubectl
+CONTROLLER_GEN ?= $(PROJECT_BIN)/controller-gen
+KUSTOMIZE ?= $(PROJECT_BIN)/kustomize
+CONTROLLER_TOOLS_VERSION ?= v0.16.4
+KUSTOMIZE_VERSION ?= v5.5.0
+
+.PHONY: bin/kustomize
+bin/kustomize: $(KUSTOMIZE) ## Download kustomize locally if necessary.
+$(KUSTOMIZE): $(PROJECT_BIN)
+	$(call go-install-tool,$(KUSTOMIZE),sigs.k8s.io/kustomize/kustomize/v5,$(KUSTOMIZE_VERSION))
+
+.PHONY: bin/controller-gen
+bin/controller-gen: $(CONTROLLER_GEN) ## Download controller-gen locally if necessary.
+$(CONTROLLER_GEN): $(PROJECT_BIN)
+	$(call go-install-tool,$(CONTROLLER_GEN),sigs.k8s.io/controller-tools/cmd/controller-gen,$(CONTROLLER_TOOLS_VERSION))
+
+# go-install-tool will 'go install' any package with custom target and name of binary, if it doesn't exist
+# $1 - target path with name of binary
+# $2 - package url which can be installed
+# $3 - specific version of package
+define go-install-tool
+@[ -f "$(1)-$(3)" ] || { \
+set -e; \
+package=$(2)@$(3) ;\
+echo "Downloading $${package}" ;\
+rm -f $(1) || true ;\
+GOBIN=$(PROJECT_BIN) go install $${package} ;\
+mv $(1) $(1)-$(3) ;\
+} ;\
+ln -sf $(1)-$(3) $(1)
+endef

OWNERS

@@ -1,9 +1,13 @@
 approvers:
+  - Al-Pragliola
   - andreyvelich
   - ckadner
+  - ederign
   - tarilabs
   - rareddy
   - Tomcli
   - zijianjoy
 reviewers:
   - andreyvelich
+  - Al-Pragliola
+  - pboyd

README.md

@@ -1,15 +1,51 @@
 # Model Registry
-Model registry provides a central repository for model developers to store and manage models, versions, and artifacts metadata. A Go-based application that leverages [ml_metadata](https://github.com/google/ml-metadata/) project under the hood.
+
+![build checks status](https://github.com/kubeflow/model-registry/actions/workflows/build.yml/badge.svg?branch=main)
+[![codecov](https://codecov.io/github/kubeflow/model-registry/graph/badge.svg?token=61URLQA3VS)](https://codecov.io/github/kubeflow/model-registry)
+[![FOSSA Status](https://app.fossa.com/api/projects/custom%2B162%2Fgithub.com%2Fkubeflow%2Fmodel-registry.svg?type=shield&issueType=license)](https://app.fossa.com/projects/custom%2B162%2Fgithub.com%2Fkubeflow%2Fmodel-registry?ref=badge_shield&issueType=license)
+[![OpenSSF Best Practices](https://www.bestpractices.dev/projects/9937/badge)](https://www.bestpractices.dev/projects/9937)
+
+Model registry provides a central repository for model developers to store and manage models, versions, and artifacts metadata.
 
 ## Red Hat's Pledge
 - Red Hat drives the project's development through Open Source principles, ensuring transparency, sustainability, and community ownership.
 - Red Hat values the Kubeflow community and commits to providing a minimum of 12 months' notice before ending project maintenance after the initial release.
 
-![build checks status](https://github.com/kubeflow/model-registry/actions/workflows/build.yml/badge.svg?branch=main)
-[![codecov](https://codecov.io/github/kubeflow/model-registry/graph/badge.svg?token=61URLQA3VS)](https://codecov.io/github/kubeflow/model-registry)
+> **Alpha**
+>
+> This Kubeflow component has alpha status with limited support. See the [Kubeflow versioning policies](https://www.kubeflow.org/docs/started/support/#application-status). The Kubeflow team is interested in your [feedback](https://github.com/kubeflow/model-registry) about the usability of the feature.
+
+## Documentation links:
+
+1. Introduction
+ - [What is Kubeflow Model Registry](https://www.kubeflow.org/docs/components/model-registry/overview/)
+ - [Blog KF 1.9 introducing Model Registry](https://blog.kubeflow.org/kubeflow-1.9-release/#model-registry)
+ - [Blog KF 1.10 introducing UI for Model Registry, CSI, and other features](https://blog.kubeflow.org/kubeflow-1.10-release/#model-registry)
+2. Installation
+ - [installing Model Registry standalone](https://www.kubeflow.org/docs/components/model-registry/installation/#standalone-installation)
+ - [installing Model Registry with Kubeflow manifests](https://github.com/kubeflow/manifests/tree/master/applications/model-registry/upstream#readme)
+ - [installing Model Registry using ODH Operator](https://github.com/opendatahub-io/model-registry-operator/tree/main/docs#readme)
+3. Concepts
+ - [Logical Model](./docs/logical_model.md)
+4. Python client
+ - [installing and using the Model Registry Python client](https://model-registry.readthedocs.io/en/latest/)
+5. Tutorials
+ - [end-to-end tutorial](https://www.kubeflow.org/docs/components/model-registry/getting-started/)
+ - [demonstration video](https://www.youtube.com/watch?v=JVxUTkAKsMU)
+6. [FAQs](#faq)
+7. Development
+ - [introduction to local build and development](#pre-requisites)
+ - [contributing](./CONTRIBUTING.md)
+ - [Kubeflow community and the Model Registry working group](https://www.kubeflow.org/docs/about/community/)
+ - REST API
+   - [OpenAPI definition](https://editor.swagger.io/?url=https://raw.githubusercontent.com/kubeflow/model-registry/main/api/openapi/model-registry.yaml) 
+   - [playground](https://petstore.swagger.io/?url=https://raw.githubusercontent.com/kubeflow/model-registry/main/api/openapi/model-registry.yaml)
+ - [license scanning](https://github.com/kubeflow/model-registry/issues/323)
+ - [monitoring image quality](https://github.com/kubeflow/model-registry/issues/327)
+8. [UI](clients/ui/README.md)
 
 ## Pre-requisites:
-- go >= 1.19
+- go >= 1.24
 - protoc v24.3 - [Protocol Buffers v24.3 Release](https://github.com/protocolbuffers/protobuf/releases/tag/v24.3)
 - npm >= 10.2.0 - [Installing Node.js and npm](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm)
 - Java >= 11.0
@@ -26,9 +62,7 @@ Run the following command to start the OpenAPI proxy server from source:
 ```shell
 make run/proxy
 ```
-The proxy service implements the OpenAPI defined in [model-registry.yaml](api/openapi/model-registry.yaml) to create a Model Registry specific REST API on top of the existing ml-metadata server.
-
-> **NOTE** The ml-metadata server must be running and accessible from the environment where model-registry starts up.
+The proxy service implements the OpenAPI defined in [model-registry.yaml](api/openapi/model-registry.yaml) to create a Model Registry specific REST API.
 
 ### Model registry logical model
 
@@ -36,8 +70,8 @@ For a high-level documentation of the Model Registry _logical model_, please che
 
 ## Model Registry Core
 
-The model registry core is the layer which implements the core/business logic by interacting with the underlying ml-metadata server.
-It provides a model registry domain-specific [api](internal/core/api.go) that is in charge to proxy all, appropriately transformed, requests to ml-metadata using gRPC calls.
+The model registry core is the layer which implements the core/business logic by interacting with the underlying datastore internal service.
+It provides a model registry domain-specific [api](pkg/api/api.go) that is in charge to proxy all, appropriately transformed, requests to the datastore internal service.
 
 ### Model registry library
 
@@ -45,6 +79,22 @@ For more background on Model Registry Go core library and instructions on using
 
 ## Development
 
+### Database Schema Changes
+
+When making changes to the database schema, you need to regenerate the GORM structs. This is done using the `gen/gorm` target:
+
+```bash
+make gen/gorm
+```
+
+This target will:
+1. Start a temporary database
+2. Run migrations
+3. Generate GORM structs based on the schema
+4. Clean up the temporary database
+
+> **NOTE:** The target requires Docker to be running.
+
 ### Building
 Run the following command to build the server binary:
 
@@ -91,8 +141,6 @@ Subsequent builds will re-use the cached tools layer.
 
 #### Running the proxy server
 
-> **NOTE:** ml-metadata server must be running and accessible, see more info on how to start the gRPC server in the official ml-metadata [documentation](https://github.com/google/ml-metadata).
-
 The following command starts the proxy server:
 
 ```shell
@@ -103,11 +151,11 @@ Where, `<uid>`, `<gid>`, and `<host-path>` are the same as in the migrate comman
 And `<hostname>` and `<port>` are the local ip and port to use to expose the container's default `8080` listening port.
 The server listens on `localhost` by default, hence the `-n 0.0.0.0` option allows the server port to be exposed.
 
-#### Running model registry & ml-metadata
+#### Running model registry
 
 > **NOTE:** Docker compose must be installed in your environment.
 
-There are two `docker-compose` files that make the startup of both model registry and ml-metadara easier, by simply running:
+There are two `docker-compose` files that make the startup of both model registry and a MySQL database easier, by simply running:
 
 ```shell
 docker compose -f docker-compose[-local].yaml up
@@ -115,20 +163,58 @@ docker compose -f docker-compose[-local].yaml up
 
 The main difference between the two docker compose files is that `-local` one build the model registry from source, the other one, instead, download the `latest` pushed [quay.io](https://quay.io/repository/opendatahub/model-registry?tab=tags) image.
 
-When shutting down the docker compose, you might want to clean-up the SQLite db file generated by ML Metadata, for example `./test/config/ml-metadata/metadata.sqlite.db`
-
 ### Testing architecture
 
-The following diagram illustrate testing strategy for the several components in Model Registry project:
+The following diagram illustrates testing strategy for the several components in Model Registry project:
 
-![](/docs/Model%20Registry%20Testing%20areas.png)
+![](/docs/Model%20Registry%20Testing%20areas.drawio.png)
 
 Go layers components are tested with Unit Tests written in Go, as well as Integration Tests leveraging Testcontainers.
-This allows to verify the expected "Core layer" of logical data mapping developed implemented in Go, matches technical expectations.
+This allows to verify the expected "Core layer" of logical data mapping developed and implemented in Go, matches technical expectations.
 
 Python client is also tested with Unit Tests and Integration Tests written in Python.
 
-End-to-end testing is developed with Robot Framework; this higher-lever layer of testing is used to:
-- demonstrate *User Stories* from high level perspective
-- demonstrate coherent logical data mapping by performing the same high level capabilities, using REST API flow Vs Python client flow,
-directly checking the end results in the backend gRPC MLMD server.
+End-to-end testing is developed with KinD and Pytest; this higher-lever layer of testing is used to demonstrate *User Stories* from high level perspective.
+
+## Related Components
+
+### Model Catalog Service
+- [Model Catalog Service](catalog/README.md) - Federated model discovery across external catalogs
+
+### Kubernetes Components
+- [Controller](cmd/controller/README.md) - Kubernetes controller for model registry CRDs
+- [CSI Driver](cmd/csi/README.md) - Container Storage Interface for model artifacts
+
+### Client Components
+- [UI Backend for Frontend (BFF)](clients/ui/bff/README.md) - Go-based BFF service for the React UI
+- [UI Frontend](clients/ui/frontend/README.md) - React-based frontend application
+
+### Job Components
+- [Async Upload Job](jobs/async-upload/README.md) - Background job for handling asynchronous model uploads
+
+### Development & Deployment
+- [Development Environment](devenv/README.md) - Local development setup and tools
+- [Kubernetes Manifests](manifests/kustomize/README.md) - Kustomize-based Kubernetes deployment manifests
+
+## FAQ
+
+### How do I delete metadata resources using the Model Registry API?
+
+MR utilizes a common `ARCHIVED` status for all types.
+To delete something, simply update its status.
+
+## Tips
+### Pull image rate limiting
+
+Occasionally you may encounter an 'ImagePullBackOff' error when deploying the Model Registry manifests. See example below for the `model-registry-db` container.
+
+```
+Failed to pull image “mysql:8.3.0”: rpc error: code = Unknown desc = fetching target platform image selected from image index: reading manifest sha256:f9097d95a4ba5451fff79f4110ea6d750ac17ca08840f1190a73320b84ca4c62 in docker.io/library/mysql: toomanyrequests: You have reached your pull rate limit. You may increase the limit by authenticating and upgrading: https://www.docker.com/increase-rate-limit
+```
+
+This error is triggered by the rate limits from docker.io; in this example specifically about the image `mysql:8.3.0` (the expanded reference is `docker.io/library/mysql:8.3.0`). To mitigate this error you could [authenticate using image pull secrets](https://kubernetes.io/docs/tasks/configure-pod-container/pull-image-private-registry/) for _local development_; or replace the image used with alternative mirrored images, for instance with the following example:
+```
+manifests/kustomize/overlays/db/model-registry-db-deployment.yaml file.
+
+spec.template.spec.containers.image: public.ecr.aws/docker/library/mysql:8.3.0
+```

RELEASE.md

@@ -0,0 +1,137 @@
+# Release Process
+
+This document describes the Release process followed by this Kubeflow Model Registry component project, enacted by its Maintainers.
+
+# Principles
+
+The Kubeflow Model Registry follows the [Github Release Workflow](https://github.com/kubeflow/model-registry/releases), and performs periodic releases in accordance with the Kubeflow Platform WG recommendations.
+
+The Kubeflow Model Registry follows [Semantic Versioning](https://semver.org/): `MAJOR.MINOR.PATCH`.
+
+The Kubeflow Model Registry per governance of the Kubeflow Community, Kubeflow Platform WG, and KSC, releases as Alpha version, including the following statement:
+
+```md
+> **Alpha**
+> This Kubeflow component has alpha status with limited support. See the [Kubeflow versioning policies](https://www.kubeflow.org/docs/started/support/#application-status). The Kubeflow team is interested in your [feedback](https://github.com/kubeflow/model-registry/issues/new/choose) about the usability of the feature.
+```
+
+The Release of the Kubeflow Model Registry provides:
+- a container image for the Backend; known as the "KF MR Go REST server"
+- a Python client to be used in a Jupyter notebook, programmatically, or that can be integrated in the Kubeflow SDK; known as the "MR py client"
+- an optional Model Registry Custom Storage Initializer container image for KServe; the "Model Registry CSI"
+- a collection of Kubernetes Manifests, which get synchronized to the `kubeflow/manifests` repository
+- an update to the Kubeflow website
+
+# Instructions
+
+These instructions can be followed by the Maintainers with write access on the repository.
+
+Assuming the following remotes are setup locally:
+
+```
+origin	git@github.com:<your username>/model-registry.git (fetch)
+origin	git@github.com:<your username>/model-registry.git (push)
+upstream	git@github.com:kubeflow/model-registry.git (fetch)
+upstream	git@github.com:kubeflow/model-registry.git (push)
+```
+
+and for the rest of this instructions, the `<your username>` will be referred as `mr_maintainer`.
+
+Prerequisites:
+- on main branch, the version indicated by the [pyproject.toml](https://github.com/kubeflow/model-registry/blob/d2312907025adbe83d3faafbecf1474824d055ed/clients/python/pyproject.toml#L3) and [metadadata](https://github.com/kubeflow/model-registry/blob/d2312907025adbe83d3faafbecf1474824d055ed/clients/python/src/model_registry/__init__.py#L3) of the Model Registry Python client is current (that is, is already valorized to the _target_ release number).
+- the main branch is up-to-date, all the required work has been already merged.
+
+```
+git checkout main
+git pull upstream main
+```
+
+Example for `0.2.10` release:
+
+```sh
+VVERSION=v0.2.10
+TDATE=$(date "+%Y%m%d")
+```
+
+> [!NOTE]
+> We no longer explicits the `-alpha` suffix (see [here](https://github.com/kubeflow/model-registry/issues/435#issuecomment-2384745910)).
+
+- create the release branch upstream
+
+```
+git checkout -b release/$VVERSION
+git push upstream release/$VVERSION
+```
+
+this creates the release branch upstream.
+
+Create a PR to update what's needed on the release branch, i.e. to update the manifest images.
+
+```
+git checkout -b mr_maintainer-$TDATE-upstreamSync
+pushd manifests/kustomize/base && kustomize edit set image ghcr.io/kubeflow/model-registry/server=ghcr.io/kubeflow/model-registry/server:$VVERSION && popd
+pushd manifests/kustomize/options/csi && kustomize edit set image ghcr.io/kubeflow/model-registry/storage-initializer=ghcr.io/kubeflow/model-registry/storage-initializer:$VVERSION && popd
+pushd manifests/kustomize/options/ui/base && kustomize edit set image model-registry-ui=ghcr.io/kubeflow/model-registry/ui:$VVERSION && popd
+pushd manifests/kustomize/options/catalog && kustomize edit set image ghcr.io/kubeflow/model-registry/server=ghcr.io/kubeflow/model-registry/server:$VVERSION && popd
+git add .
+git commit -s
+
+# suggested commit msg: "chore: align manifest for 0.2.10"
+
+# using `git push origin`
+# will give back convenient command on the screen for copy/paste:
+# eg: git push --set-upstream origin mr_maintainer-20241108-upstreamSync
+git push --set-upstream origin mr_maintainer-$TDATE-upstreamSync
+```
+
+- create PR ⚠️ targeting the _release branch_ ⚠️ specifically (title ~like: `chore: align manifest for 0.2.10`)
+- merge the PR (you can manually add the approved, lgtm labels)
+
+- optional. if you create the tag from local git (see point below); await GHA complete that push Container images to docker.io or any other KF registry: https://github.com/kubeflow/model-registry/actions
+- create [the Release from GitHub](https://github.com/kubeflow/model-registry/releases/new), ⚠️ select the _release branch_ ⚠️ , input the _new tag_<br/>(in this example the tag is created from GitHub; alternatively, you could just do the tag manually by checking out the release branch locally--remember to pull!!--and issuing the tag from local machine).
+Encouraging in upstream to mark it as a non-production release (in the github screen).
+Encouraging to use the "alpha" version policy of KF in the beginning of the release markdown (see previous pre-releases).
+
+It is helpful to prefix this in the release notes:
+
+```md
+> **Alpha**
+> This Kubeflow component has alpha status with limited support. See the [Kubeflow versioning policies](https://www.kubeflow.org/docs/started/support/#application-status). The Kubeflow team is interested in your [feedback](https://github.com/kubeflow/model-registry/issues/new/choose) about the usability of the feature.
+```
+
+- release the MR Python client
+
+```
+git checkout release/$VVERSION
+git pull upstream release/$VVERSION
+git tag py-$VVERSION
+git push upstream py-$VVERSION
+```
+
+At this point, a release as been created, both the container images and the Python client on pypi.
+
+## KF/manifests
+
+The KF/model-registry manifests need to be sync'd to KF/manifests repository using the Manifest/Platform WG provided script (in the KF/manifests repo).
+
+Example PR:
+- https://github.com/kubeflow/manifests/pull/3053
+
+It is supposed to work by leveraging sync script in KF/manifests repo:
+- https://github.com/kubeflow/manifests/blob/13a72b79e6f107118bfaeeba2bb26fc21e9244b6/scripts/synchronize-model-registry-manifests.sh#L18
+
+## KF/website
+
+Update latest MR release version number in the KF/website repo.
+
+Example PR:
+- https://github.com/kubeflow/website/pull/4046
+
+Please notice the OpenAPI spec in the Reference section is automatically updated, since it is sourced from the repo: https://github.com/kubeflow/website/blob/23d50fea25adbb4883ab21ca64d19db9100390bf/content/en/docs/components/model-registry/reference/rest-api.md#L44-L47
+
+## Anticipate prerequisites
+
+See at the beginning "Prerequisites", to facilitate the next round, now it's the best time:
+- bump already MR py client to the next version, example PR
+https://github.com/kubeflow/model-registry/pull/871
+

ROADMAP.md

@@ -0,0 +1,23 @@
+# Kubeflow Model Registry Roadmap
+
+## Overview
+
+The Kubeflow Model Registry project roadmap is tracked using [GitHub Milestones](https://github.com/kubeflow/model-registry/milestones), following the Kubeflow Release Team's request: this approach has been recommended in order to maintain a detailed view of all the items intended for upcoming Kubeflow releases, organized by "themes". The roadmap is continuously updated as we make progress towards a Kubeflow Release.
+
+## Current Roadmap
+
+The current roadmap and upcoming features are tracked in our [GitHub Milestones](https://github.com/kubeflow/model-registry/milestones). Each milestone tracks specific or future Kubeflow release and contains the planned features, enhancements, and bug fixes. For each milestone, a GitHub Issue is typically attached serving as a Tracker record to provide additional details.
+
+## Past Roadmaps
+
+- Model Registry in Kubeflow 1.10
+    - [Milestone](https://github.com/kubeflow/model-registry/milestone/1)
+    - [Tracker for details](https://github.com/kubeflow/model-registry/issues/175)
+- Model Registry in Kubeflow 1.9
+    - [Tracker for details](https://github.com/kubeflow/model-registry/issues/3)
+
+## See also
+
+For more information about contributing to this project including the roadmap, refer to our [CONTRIBUTING.md](./CONTRIBUTING.md) file.
+
+For more information about the release process, refer to our [RELEASE.md](./RELEASE.md) file.

SECURITY.md

@@ -0,0 +1,64 @@
+# Security Policy
+
+## Supported Versions
+
+Kubeflow Model Registry versions are expressed as `vX.Y.Z`, where X is the major version,
+Y is the minor version, and Z is the patch version, following the
+[Semantic Versioning](https://semver.org/) terminology.
+
+The Kubeflow Model Registry project maintains release branches for the most recent two minor releases.
+Applicable fixes, including security fixes, may be backported to those two release branches,
+depending on severity and feasibility.
+
+Users are encouraged to stay updated with the latest releases to benefit from security patches and
+improvements.
+
+## Reporting a Vulnerability
+
+We're extremely grateful for security researchers and users that report vulnerabilities to the
+Kubeflow Open Source Community. All reports are thoroughly investigated by Kubeflow projects owners.
+
+You can use the following ways to report security vulnerabilities privately:
+
+- Using the Kubeflow Model Registry repository [GitHub Security Advisory](https://github.com/kubeflow/model-registry/security/advisories/new).
+- Using our private Kubeflow Steering Committee mailing list: ksc@kubeflow.org.
+
+Please provide detailed information to help us understand and address the issue promptly.
+
+## Disclosure Process
+
+**Acknowledgment**: We will acknowledge receipt of your report within 10 business days.
+
+**Assessment**: The Kubeflow projects owners will investigate the reported issue to determine its
+validity and severity.
+
+**Resolution**: If the issue is confirmed, we will work on a fix and prepare a release.
+
+**Notification**: Once a fix is available, we will notify the reporter and coordinate a public
+disclosure.
+
+**Public Disclosure**: Details of the vulnerability and the fix will be published in the project's
+release notes and communicated through appropriate channels.
+
+## Prevention Mechanisms
+
+Kubeflow Model Registry employs several measures to prevent security issues:
+
+**Code Reviews**: All code changes are reviewed by maintainers to ensure code quality and security.
+
+**Dependency Management**: Regular updates and monitoring of dependencies (e.g. Dependabot) to
+address known vulnerabilities.
+
+**Continuous Integration**: Automated testing and security checks are integrated into the CI/CD pipeline.
+
+**Image Scanning**: Container images are scanned for vulnerabilities.
+
+## Communication Channels
+
+For the general questions please join the following resources:
+
+- Kubeflow [Slack channels](https://www.kubeflow.org/docs/about/community/#kubeflow-slack-channels).
+
+- Kubeflow discuss [mailing list](https://www.kubeflow.org/docs/about/community/#kubeflow-mailing-list).
+
+Please **do not report** security vulnerabilities through public channels.

api/openapi/catalog.yaml

@@ -0,0 +1,679 @@
+openapi: 3.0.3
+info:
+  title: Model Catalog REST API
+  version: v1alpha1
+  description: REST API for Model Registry to create and manage ML model metadata
+  license:
+    name: Apache 2.0
+    url: "https://www.apache.org/licenses/LICENSE-2.0"
+servers:
+  - url: "https://localhost:8080"
+  - url: "http://localhost:8080"
+paths:
+  /api/model_catalog/v1alpha1/models:
+    description: >-
+      The REST endpoint/path used to list zero or more `CatalogModel` entities from all `CatalogSources`.
+    get:
+      summary: Search catalog models across sources.
+      tags:
+        - ModelCatalogService
+      parameters:
+        - name: source
+          description: |-
+            Filter models by source. This parameter is currently required and
+            may only be specified once.
+          schema:
+            type: string
+          in: query
+          required: true
+        - name: q
+          description: Free-form keyword search used to filter the response.
+          schema:
+            type: string
+          in: query
+          required: false
+        - $ref: "#/components/parameters/pageSize"
+        - $ref: "#/components/parameters/orderBy"
+        - $ref: "#/components/parameters/sortOrder"
+        - $ref: "#/components/parameters/nextPageToken"
+      responses:
+        "200":
+          $ref: "#/components/responses/CatalogModelListResponse"
+        "400":
+          $ref: "#/components/responses/BadRequest"
+        "401":
+          $ref: "#/components/responses/Unauthorized"
+        "404":
+          $ref: "#/components/responses/NotFound"
+        "500":
+          $ref: "#/components/responses/InternalServerError"
+      operationId: findModels
+  /api/model_catalog/v1alpha1/sources:
+    summary: Path used to get the list of catalog sources.
+    description: >-
+      The REST endpoint/path used to list zero or more `CatalogSource` entities.
+    get:
+      summary: List All CatalogSources
+      tags:
+        - ModelCatalogService
+      parameters:
+        - $ref: "#/components/parameters/name"
+        - $ref: "#/components/parameters/pageSize"
+        - $ref: "#/components/parameters/orderBy"
+        - $ref: "#/components/parameters/sortOrder"
+        - $ref: "#/components/parameters/nextPageToken"
+      responses:
+        "200":
+          $ref: "#/components/responses/CatalogSourceListResponse"
+        "400":
+          $ref: "#/components/responses/BadRequest"
+        "401":
+          $ref: "#/components/responses/Unauthorized"
+        "404":
+          $ref: "#/components/responses/NotFound"
+        "500":
+          $ref: "#/components/responses/InternalServerError"
+      operationId: findSources
+      description: Gets a list of all `CatalogSource` entities.
+  /api/model_catalog/v1alpha1/sources/{source_id}/models/{model_name+}:
+    description: >-
+      The REST endpoint/path used to get a `CatalogModel`.
+    get:
+      summary: Get a `CatalogModel`.
+      tags:
+        - ModelCatalogService
+      responses:
+        "200":
+          $ref: "#/components/responses/CatalogModelResponse"
+        "401":
+          $ref: "#/components/responses/Unauthorized"
+        "404":
+          $ref: "#/components/responses/NotFound"
+        "500":
+          $ref: "#/components/responses/InternalServerError"
+      operationId: getModel
+    parameters:
+      - name: source_id
+        description: A unique identifier for a `CatalogSource`.
+        schema:
+          type: string
+        in: path
+        required: true
+      - name: model_name+
+        description: A unique identifier for the model.
+        schema:
+          type: string
+        in: path
+        required: true
+  /api/model_catalog/v1alpha1/sources/{source_id}/models/{model_name}/artifacts:
+    description: >-
+      The REST endpoint/path used to list `CatalogModelArtifacts`.
+    get:
+      summary: List CatalogModelArtifacts.
+      tags:
+        - ModelCatalogService
+      responses:
+        "200":
+          $ref: "#/components/responses/CatalogModelArtifactListResponse"
+        "401":
+          $ref: "#/components/responses/Unauthorized"
+        "404":
+          $ref: "#/components/responses/NotFound"
+        "500":
+          $ref: "#/components/responses/InternalServerError"
+      operationId: getAllModelArtifacts
+    parameters:
+      - name: source_id
+        description: A unique identifier for a `CatalogSource`.
+        schema:
+          type: string
+        in: path
+        required: true
+      - name: model_name
+        description: A unique identifier for the model.
+        schema:
+          type: string
+        in: path
+        required: true
+components:
+  schemas:
+    ArtifactTypeQueryParam:
+      description: Supported artifact types for querying.
+      enum:
+        - model-artifact
+        - doc-artifact
+        - dataset-artifact
+        - metric
+        - parameter
+      type: string
+    BaseModel:
+      type: object
+      properties:
+        description:
+          type: string
+          description: Human-readable description of the model.
+        readme:
+          type: string
+          description: Model documentation in Markdown.
+        maturity:
+          type: string
+          description: Maturity level of the model.
+          example: Generally Available
+        language:
+          type: array
+          description: List of supported languages (https://en.wikipedia.org/wiki/List_of_ISO_639_language_codes).
+          items:
+            type: string
+          example:
+            - en
+            - es
+            - cz
+        tasks:
+          type: array
+          description: List of tasks the model is designed for.
+          items:
+            type: string
+          example:
+            - text-generation
+        provider:
+          type: string
+          description: Name of the organization or entity that provides the model.
+          example: IBM
+        logo:
+          type: string
+          format: uri
+          description: |-
+            URL to the model's logo. A [data
+            URL](https://developer.mozilla.org/en-US/docs/Web/URI/Schemes/data)
+            is recommended.
+        license:
+          type: string
+          description: Short name of the model's license.
+          example: apache-2.0
+        licenseLink:
+          type: string
+          format: uri
+          description: URL to the license text.
+        libraryName:
+          type: string
+          example: transformers
+        customProperties:
+          description: User provided custom properties which are not defined by its type.
+          type: object
+          additionalProperties:
+            $ref: "#/components/schemas/MetadataValue"
+    BaseResourceDates:
+      description: Common timestamp fields for resources
+      type: object
+      properties:
+        createTimeSinceEpoch:
+          format: int64
+          description: Output only. Create time of the resource in millisecond since epoch.
+          type: string
+          readOnly: true
+        lastUpdateTimeSinceEpoch:
+          format: int64
+          description: Output only. Last update time of the resource since epoch in millisecond since epoch.
+          type: string
+          readOnly: true
+    BaseResourceList:
+      required:
+        - nextPageToken
+        - pageSize
+        - size
+      type: object
+      properties:
+        nextPageToken:
+          description: Token to use to retrieve next page of results.
+          type: string
+        pageSize:
+          format: int32
+          description: Maximum number of resources to return in the result.
+          type: integer
+        size:
+          format: int32
+          description: Number of items in result list.
+          type: integer
+    CatalogModel:
+      description: A model in the model catalog.
+      allOf:
+        - type: object
+          required:
+            - name
+          properties:
+            name:
+              type: string
+              description: Name of the model. Must be unique within a source.
+              example: ibm-granite/granite-3.1-8b-base
+            source_id:
+              type: string
+              description: ID of the source this model belongs to.
+        - $ref: "#/components/schemas/BaseResourceDates"
+        - $ref: "#/components/schemas/BaseModel"
+    CatalogModelArtifact:
+      description: A single artifact for a catalog model.
+      allOf:
+        - type: object
+          required:
+            - uri
+          properties:
+            uri:
+              type: string
+              format: uri
+              description: URI where the artifact can be retrieved.
+            customProperties:
+              description: User provided custom properties which are not defined by its type.
+              type: object
+              additionalProperties:
+                $ref: "#/components/schemas/MetadataValue"
+        - $ref: "#/components/schemas/BaseResourceDates"
+    CatalogModelArtifactList:
+      description: List of CatalogModel entities.
+      allOf:
+        - type: object
+          properties:
+            items:
+              description: Array of `CatalogModelArtifact` entities.
+              type: array
+              items:
+                $ref: "#/components/schemas/CatalogModelArtifact"
+          required:
+            - items
+        - $ref: "#/components/schemas/BaseResourceList"
+    CatalogModelList:
+      description: List of CatalogModel entities.
+      allOf:
+        - type: object
+          properties:
+            items:
+              description: Array of `CatalogModel` entities.
+              type: array
+              items:
+                $ref: "#/components/schemas/CatalogModel"
+          required:
+            - items
+        - $ref: "#/components/schemas/BaseResourceList"
+    CatalogSource:
+      description: A catalog source. A catalog source has CatalogModel children.
+      required:
+        - id
+        - name
+      type: object
+      properties:
+        id:
+          description: A unique identifier for a `CatalogSource`.
+          type: string
+        name:
+          description: The name of the catalog source.
+          type: string
+        enabled:
+          description: Whether the catalog source is enabled.
+          type: boolean
+          default: true
+    CatalogSourceList:
+      description: List of CatalogSource entities.
+      allOf:
+        - type: object
+          properties:
+            items:
+              description: Array of `CatalogSource` entities.
+              type: array
+              items:
+                $ref: "#/components/schemas/CatalogSource"
+        - $ref: "#/components/schemas/BaseResourceList"
+    Error:
+      description: Error code and message.
+      required:
+        - code
+        - message
+      type: object
+      properties:
+        code:
+          description: Error code
+          type: string
+        message:
+          description: Error message
+          type: string
+    MetadataBoolValue:
+      description: A bool property value.
+      type: object
+      required:
+        - metadataType
+        - bool_value
+      properties:
+        bool_value:
+          type: boolean
+        metadataType:
+          type: string
+          example: MetadataBoolValue
+          default: MetadataBoolValue
+    MetadataDoubleValue:
+      description: A double property value.
+      type: object
+      required:
+        - metadataType
+        - double_value
+      properties:
+        double_value:
+          format: double
+          type: number
+        metadataType:
+          type: string
+          example: MetadataDoubleValue
+          default: MetadataDoubleValue
+    MetadataIntValue:
+      description: An integer (int64) property value.
+      type: object
+      required:
+        - metadataType
+        - int_value
+      properties:
+        int_value:
+          format: int64
+          type: string
+        metadataType:
+          type: string
+          example: MetadataIntValue
+          default: MetadataIntValue
+    MetadataProtoValue:
+      description: A proto property value.
+      type: object
+      required:
+        - metadataType
+        - type
+        - proto_value
+      properties:
+        type:
+          description: url describing proto value
+          type: string
+        proto_value:
+          description: Base64 encoded bytes for proto value
+          type: string
+        metadataType:
+          type: string
+          example: MetadataProtoValue
+          default: MetadataProtoValue
+    MetadataStringValue:
+      description: A string property value.
+      type: object
+      required:
+        - metadataType
+        - string_value
+      properties:
+        string_value:
+          type: string
+        metadataType:
+          type: string
+          example: MetadataStringValue
+          default: MetadataStringValue
+    MetadataStructValue:
+      description: A struct property value.
+      type: object
+      required:
+        - metadataType
+        - struct_value
+      properties:
+        struct_value:
+          description: Base64 encoded bytes for struct value
+          type: string
+        metadataType:
+          type: string
+          example: MetadataStructValue
+          default: MetadataStructValue
+    MetadataValue:
+      oneOf:
+        - $ref: "#/components/schemas/MetadataIntValue"
+        - $ref: "#/components/schemas/MetadataDoubleValue"
+        - $ref: "#/components/schemas/MetadataStringValue"
+        - $ref: "#/components/schemas/MetadataStructValue"
+        - $ref: "#/components/schemas/MetadataProtoValue"
+        - $ref: "#/components/schemas/MetadataBoolValue"
+      discriminator:
+        propertyName: metadataType
+        mapping:
+          MetadataBoolValue: "#/components/schemas/MetadataBoolValue"
+          MetadataDoubleValue: "#/components/schemas/MetadataDoubleValue"
+          MetadataIntValue: "#/components/schemas/MetadataIntValue"
+          MetadataProtoValue: "#/components/schemas/MetadataProtoValue"
+          MetadataStringValue: "#/components/schemas/MetadataStringValue"
+          MetadataStructValue: "#/components/schemas/MetadataStructValue"
+      description: A value in properties.
+      example:
+        string_value: my_value
+        metadataType: MetadataStringValue
+    OrderByField:
+      description: Supported fields for ordering result entities.
+      enum:
+        - CREATE_TIME
+        - LAST_UPDATE_TIME
+        - ID
+        - NAME
+      type: string
+    SortOrder:
+      description: Supported sort direction for ordering result entities.
+      enum:
+        - ASC
+        - DESC
+      type: string
+  responses:
+    BadRequest:
+      content:
+        application/json:
+          schema:
+            $ref: "#/components/schemas/Error"
+      description: Bad Request parameters
+    CatalogModelArtifactListResponse:
+      content:
+        application/json:
+          schema:
+            $ref: "#/components/schemas/CatalogModelArtifactList"
+      description: A response containing a list of CatalogModelArtifact entities.
+    CatalogModelListResponse:
+      content:
+        application/json:
+          schema:
+            $ref: "#/components/schemas/CatalogModelList"
+      description: A response containing a list of CatalogModel entities.
+    CatalogModelResponse:
+      content:
+        application/json:
+          schema:
+            $ref: "#/components/schemas/CatalogModel"
+      description: A response containing a `CatalogModel` entity.
+    CatalogSourceListResponse:
+      content:
+        application/json:
+          schema:
+            $ref: "#/components/schemas/CatalogSourceList"
+      description: A response containing a list of CatalogSource entities.
+    CatalogSourceResponse:
+      content:
+        application/json:
+          schema:
+            $ref: "#/components/schemas/CatalogSource"
+      description: A response containing a `CatalogSource` entity.
+    Conflict:
+      content:
+        application/json:
+          schema:
+            $ref: "#/components/schemas/Error"
+      description: Conflict with current state of target resource
+    InternalServerError:
+      content:
+        application/json:
+          schema:
+            $ref: "#/components/schemas/Error"
+      description: Unexpected internal server error
+    NotFound:
+      content:
+        application/json:
+          schema:
+            $ref: "#/components/schemas/Error"
+      description: The specified resource was not found
+    ServiceUnavailable:
+      content:
+        application/json:
+          schema:
+            $ref: "#/components/schemas/Error"
+      description: Service is unavailable
+    Unauthorized:
+      content:
+        application/json:
+          schema:
+            $ref: "#/components/schemas/Error"
+      description: Unauthorized
+    UnprocessableEntity:
+      content:
+        application/json:
+          schema:
+            $ref: "#/components/schemas/Error"
+      description: Unprocessable Entity error
+  parameters:
+    orderBy:
+      style: form
+      explode: true
+      examples:
+        orderBy:
+          value: ID
+      name: orderBy
+      description: Specifies the order by criteria for listing entities.
+      schema:
+        $ref: "#/components/schemas/OrderByField"
+      in: query
+      required: false
+    id:
+      name: id
+      description: The ID of resource.
+      schema:
+        type: string
+      in: path
+      required: true
+    name:
+      examples:
+        name:
+          value: entity-name
+      name: name
+      description: Name of entity to search.
+      schema:
+        type: string
+      in: query
+      required: false
+    externalId:
+      examples:
+        externalId:
+          value: "10"
+      name: externalId
+      description: External ID of entity to search.
+      schema:
+        type: string
+      in: query
+      required: false
+    parentResourceId:
+      examples:
+        parentResourceId:
+          value: "10"
+      name: parentResourceId
+      description: ID of the parent resource to use for search.
+      schema:
+        type: string
+      in: query
+      required: false
+    filterQuery:
+      examples:
+        filterQuery:
+          value: "name='my-model' AND state='LIVE'"
+      name: filterQuery
+      description: |
+        A SQL-like query string to filter the list of entities. The query supports rich filtering capabilities with automatic type inference.
+
+        **Supported Operators:**
+        - Comparison: `=`, `!=`, `<>`, `>`, `<`, `>=`, `<=`
+        - Pattern matching: `LIKE`, `ILIKE` (case-insensitive)
+        - Set membership: `IN`
+        - Logical: `AND`, `OR`
+        - Grouping: `()` for complex expressions
+
+        **Data Types:**
+        - Strings: `"value"` or `'value'`
+        - Numbers: `42`, `3.14`, `1e-5`
+        - Booleans: `true`, `false` (case-insensitive)
+
+        **Property Access:**
+        - Standard properties: `name`, `id`, `state`, `createTimeSinceEpoch`
+        - Custom properties: Any user-defined property name
+        - Escaped properties: Use backticks for special characters: `` `custom-property` ``
+        - Type-specific access: `property.string_value`, `property.double_value`, `property.int_value`, `property.bool_value`
+
+        **Examples:**
+        - Basic: `name = "my-model"`
+        - Comparison: `accuracy > 0.95`
+        - Pattern: `name LIKE "%tensorflow%"`
+        - Complex: `(name = "model-a" OR name = "model-b") AND state = "LIVE"`
+        - Custom property: `framework.string_value = "pytorch"`
+        - Escaped property: `` `mlflow.source.type` = "notebook" ``
+      schema:
+        type: string
+      in: query
+      required: false
+    pageSize:
+      examples:
+        pageSize:
+          value: "100"
+      name: pageSize
+      description: Number of entities in each page.
+      schema:
+        type: string
+      in: query
+      required: false
+    nextPageToken:
+      name: nextPageToken
+      description: Token to use to retrieve next page of results.
+      schema:
+        type: string
+      in: query
+      required: false
+    sortOrder:
+      style: form
+      explode: true
+      examples:
+        sortOrder:
+          value: DESC
+      name: sortOrder
+      description: "Specifies the sort order for listing entities, defaults to ASC."
+      schema:
+        $ref: "#/components/schemas/SortOrder"
+      in: query
+      required: false
+    artifactType:
+      style: form
+      explode: true
+      examples:
+        artifactType:
+          value: model-artifact
+      name: artifactType
+      description: "Specifies the artifact type for listing artifacts."
+      schema:
+        $ref: "#/components/schemas/ArtifactTypeQueryParam"
+      in: query
+      required: false
+    stepIds:
+      style: form
+      explode: true
+      examples:
+        stepIds:
+          value: "1,2,3"
+      name: stepIds
+      description: "Comma-separated list of step IDs to filter metrics by."
+      schema:
+        type: string
+      in: query
+      required: false
+  securitySchemes:
+    Bearer:
+      scheme: bearer
+      bearerFormat: JWT
+      type: http
+      description: Bearer JWT scheme
+security:
+  - Bearer: []
+tags: []

api/openapi/src/catalog.yaml

@@ -0,0 +1,281 @@
+openapi: 3.0.3
+info:
+  title: Model Catalog REST API
+  version: v1alpha1
+  description: REST API for Model Registry to create and manage ML model metadata
+  license:
+    name: Apache 2.0
+    url: "https://www.apache.org/licenses/LICENSE-2.0"
+servers:
+  - url: "https://localhost:8080"
+  - url: "http://localhost:8080"
+paths:
+  /api/model_catalog/v1alpha1/models:
+    description: >-
+      The REST endpoint/path used to list zero or more `CatalogModel` entities from all `CatalogSources`.
+    get:
+      summary: Search catalog models across sources.
+      tags:
+        - ModelCatalogService
+      parameters:
+        - name: source
+          description: |-
+            Filter models by source. This parameter is currently required and
+            may only be specified once.
+          schema:
+            type: string
+          in: query
+          required: true
+        - name: q
+          description: Free-form keyword search used to filter the response.
+          schema:
+            type: string
+          in: query
+          required: false
+        - $ref: "#/components/parameters/pageSize"
+        - $ref: "#/components/parameters/orderBy"
+        - $ref: "#/components/parameters/sortOrder"
+        - $ref: "#/components/parameters/nextPageToken"
+      responses:
+        "200":
+          $ref: "#/components/responses/CatalogModelListResponse"
+        "400":
+          $ref: "#/components/responses/BadRequest"
+        "401":
+          $ref: "#/components/responses/Unauthorized"
+        "404":
+          $ref: "#/components/responses/NotFound"
+        "500":
+          $ref: "#/components/responses/InternalServerError"
+      operationId: findModels
+  /api/model_catalog/v1alpha1/sources:
+    summary: Path used to get the list of catalog sources.
+    description: >-
+      The REST endpoint/path used to list zero or more `CatalogSource` entities.
+    get:
+      summary: List All CatalogSources
+      tags:
+        - ModelCatalogService
+      parameters:
+        - $ref: "#/components/parameters/name"
+        - $ref: "#/components/parameters/pageSize"
+        - $ref: "#/components/parameters/orderBy"
+        - $ref: "#/components/parameters/sortOrder"
+        - $ref: "#/components/parameters/nextPageToken"
+      responses:
+        "200":
+          $ref: "#/components/responses/CatalogSourceListResponse"
+        "400":
+          $ref: "#/components/responses/BadRequest"
+        "401":
+          $ref: "#/components/responses/Unauthorized"
+        "404":
+          $ref: "#/components/responses/NotFound"
+        "500":
+          $ref: "#/components/responses/InternalServerError"
+      operationId: findSources
+      description: Gets a list of all `CatalogSource` entities.
+  /api/model_catalog/v1alpha1/sources/{source_id}/models/{model_name+}:
+    description: >-
+      The REST endpoint/path used to get a `CatalogModel`.
+    get:
+      summary: Get a `CatalogModel`.
+      tags:
+        - ModelCatalogService
+      responses:
+        "200":
+          $ref: "#/components/responses/CatalogModelResponse"
+        "401":
+          $ref: "#/components/responses/Unauthorized"
+        "404":
+          $ref: "#/components/responses/NotFound"
+        "500":
+          $ref: "#/components/responses/InternalServerError"
+      operationId: getModel
+    parameters:
+      - name: source_id
+        description: A unique identifier for a `CatalogSource`.
+        schema:
+          type: string
+        in: path
+        required: true
+      - name: model_name+
+        description: A unique identifier for the model.
+        schema:
+          type: string
+        in: path
+        required: true
+  /api/model_catalog/v1alpha1/sources/{source_id}/models/{model_name}/artifacts:
+    description: >-
+      The REST endpoint/path used to list `CatalogModelArtifacts`.
+    get:
+      summary: List CatalogModelArtifacts.
+      tags:
+        - ModelCatalogService
+      responses:
+        "200":
+          $ref: "#/components/responses/CatalogModelArtifactListResponse"
+        "401":
+          $ref: "#/components/responses/Unauthorized"
+        "404":
+          $ref: "#/components/responses/NotFound"
+        "500":
+          $ref: "#/components/responses/InternalServerError"
+      operationId: getAllModelArtifacts
+    parameters:
+      - name: source_id
+        description: A unique identifier for a `CatalogSource`.
+        schema:
+          type: string
+        in: path
+        required: true
+      - name: model_name
+        description: A unique identifier for the model.
+        schema:
+          type: string
+        in: path
+        required: true
+components:
+  schemas:
+    CatalogModel:
+      description: A model in the model catalog.
+      allOf:
+        - type: object
+          required:
+            - name
+          properties:
+            name:
+              type: string
+              description: Name of the model. Must be unique within a source.
+              example: ibm-granite/granite-3.1-8b-base
+            source_id:
+              type: string
+              description: ID of the source this model belongs to.
+        - $ref: "#/components/schemas/BaseResourceDates"
+        - $ref: "#/components/schemas/BaseModel"
+    CatalogModelArtifact:
+      description: A single artifact for a catalog model.
+      allOf:
+        - type: object
+          required:
+            - uri
+          properties:
+            uri:
+              type: string
+              format: uri
+              description: URI where the artifact can be retrieved.
+            customProperties:
+              description: User provided custom properties which are not defined by its type.
+              type: object
+              additionalProperties:
+                $ref: "#/components/schemas/MetadataValue"
+        - $ref: "#/components/schemas/BaseResourceDates"
+    CatalogModelArtifactList:
+      description: List of CatalogModel entities.
+      allOf:
+        - type: object
+          properties:
+            items:
+              description: Array of `CatalogModelArtifact` entities.
+              type: array
+              items:
+                $ref: "#/components/schemas/CatalogModelArtifact"
+          required:
+            - items
+        - $ref: "#/components/schemas/BaseResourceList"
+    CatalogModelList:
+      description: List of CatalogModel entities.
+      allOf:
+        - type: object
+          properties:
+            items:
+              description: Array of `CatalogModel` entities.
+              type: array
+              items:
+                $ref: "#/components/schemas/CatalogModel"
+          required:
+            - items
+        - $ref: "#/components/schemas/BaseResourceList"
+    CatalogSource:
+      description: A catalog source. A catalog source has CatalogModel children.
+      required:
+        - id
+        - name
+      type: object
+      properties:
+        id:
+          description: A unique identifier for a `CatalogSource`.
+          type: string
+        name:
+          description: The name of the catalog source.
+          type: string
+        enabled:
+          description: Whether the catalog source is enabled.
+          type: boolean
+          default: true
+    CatalogSourceList:
+      description: List of CatalogSource entities.
+      allOf:
+        - type: object
+          properties:
+            items:
+              description: Array of `CatalogSource` entities.
+              type: array
+              items:
+                $ref: "#/components/schemas/CatalogSource"
+        - $ref: "#/components/schemas/BaseResourceList"
+    OrderByField:
+      description: Supported fields for ordering result entities.
+      enum:
+        - CREATE_TIME
+        - LAST_UPDATE_TIME
+        - ID
+        - NAME
+      type: string
+
+  responses:
+    CatalogModelArtifactListResponse:
+      content:
+        application/json:
+          schema:
+            $ref: "#/components/schemas/CatalogModelArtifactList"
+      description: A response containing a list of CatalogModelArtifact entities.
+    CatalogModelListResponse:
+      content:
+        application/json:
+          schema:
+            $ref: "#/components/schemas/CatalogModelList"
+      description: A response containing a list of CatalogModel entities.
+    CatalogModelResponse:
+      content:
+        application/json:
+          schema:
+            $ref: "#/components/schemas/CatalogModel"
+      description: A response containing a `CatalogModel` entity.
+    CatalogSourceListResponse:
+      content:
+        application/json:
+          schema:
+            $ref: "#/components/schemas/CatalogSourceList"
+      description: A response containing a list of CatalogSource entities.
+    CatalogSourceResponse:
+      content:
+        application/json:
+          schema:
+            $ref: "#/components/schemas/CatalogSource"
+      description: A response containing a `CatalogSource` entity.
+
+  parameters:
+    orderBy:
+      style: form
+      explode: true
+      examples:
+        orderBy:
+          value: ID
+      name: orderBy
+      description: Specifies the order by criteria for listing entities.
+      schema:
+        $ref: "#/components/schemas/OrderByField"
+      in: query
+      required: false
+tags: []

api/openapi/src/lib/common.yaml

@@ -0,0 +1,404 @@
+components:
+  schemas:
+    ArtifactTypeQueryParam:
+      description: Supported artifact types for querying.
+      enum:
+        - model-artifact
+        - doc-artifact
+        - dataset-artifact
+        - metric
+        - parameter
+      type: string
+    BaseModel:
+      type: object
+      properties:
+        description:
+          type: string
+          description: Human-readable description of the model.
+        readme:
+          type: string
+          description: Model documentation in Markdown.
+        maturity:
+          type: string
+          description: Maturity level of the model.
+          example: Generally Available
+        language:
+          type: array
+          description: List of supported languages (https://en.wikipedia.org/wiki/List_of_ISO_639_language_codes).
+          items:
+            type: string
+          example:
+            - en
+            - es
+            - cz
+        tasks:
+          type: array
+          description: List of tasks the model is designed for.
+          items:
+            type: string
+          example:
+            - text-generation
+        provider:
+          type: string
+          description: Name of the organization or entity that provides the model.
+          example: IBM
+        logo:
+          type: string
+          format: uri
+          description: |-
+            URL to the model's logo. A [data
+            URL](https://developer.mozilla.org/en-US/docs/Web/URI/Schemes/data)
+            is recommended.
+        license:
+          type: string
+          description: Short name of the model's license.
+          example: apache-2.0
+        licenseLink:
+          type: string
+          format: uri
+          description: URL to the license text.
+        libraryName:
+          type: string
+          example: transformers
+        customProperties:
+          description: User provided custom properties which are not defined by its type.
+          type: object
+          additionalProperties:
+            $ref: "#/components/schemas/MetadataValue"
+    BaseResourceDates:
+      description: Common timestamp fields for resources
+      type: object
+      properties:
+        createTimeSinceEpoch:
+          format: int64
+          description: Output only. Create time of the resource in millisecond since epoch.
+          type: string
+          readOnly: true
+        lastUpdateTimeSinceEpoch:
+          format: int64
+          description: Output only. Last update time of the resource since epoch in millisecond since epoch.
+          type: string
+          readOnly: true
+    BaseResourceList:
+      required:
+        - nextPageToken
+        - pageSize
+        - size
+      type: object
+      properties:
+        nextPageToken:
+          description: Token to use to retrieve next page of results.
+          type: string
+        pageSize:
+          format: int32
+          description: Maximum number of resources to return in the result.
+          type: integer
+        size:
+          format: int32
+          description: Number of items in result list.
+          type: integer
+    Error:
+      description: Error code and message.
+      required:
+        - code
+        - message
+      type: object
+      properties:
+        code:
+          description: Error code
+          type: string
+        message:
+          description: Error message
+          type: string
+    MetadataBoolValue:
+      description: A bool property value.
+      type: object
+      required:
+        - metadataType
+        - bool_value
+      properties:
+        bool_value:
+          type: boolean
+        metadataType:
+          type: string
+          example: MetadataBoolValue
+          default: MetadataBoolValue
+    MetadataDoubleValue:
+      description: A double property value.
+      type: object
+      required:
+        - metadataType
+        - double_value
+      properties:
+        double_value:
+          format: double
+          type: number
+        metadataType:
+          type: string
+          example: MetadataDoubleValue
+          default: MetadataDoubleValue
+    MetadataIntValue:
+      description: An integer (int64) property value.
+      type: object
+      required:
+        - metadataType
+        - int_value
+      properties:
+        int_value:
+          format: int64
+          type: string
+        metadataType:
+          type: string
+          example: MetadataIntValue
+          default: MetadataIntValue
+    MetadataProtoValue:
+      description: A proto property value.
+      type: object
+      required:
+        - metadataType
+        - type
+        - proto_value
+      properties:
+        type:
+          description: url describing proto value
+          type: string
+        proto_value:
+          description: Base64 encoded bytes for proto value
+          type: string
+        metadataType:
+          type: string
+          example: MetadataProtoValue
+          default: MetadataProtoValue
+    MetadataStringValue:
+      description: A string property value.
+      type: object
+      required:
+        - metadataType
+        - string_value
+      properties:
+        string_value:
+          type: string
+        metadataType:
+          type: string
+          example: MetadataStringValue
+          default: MetadataStringValue
+    MetadataStructValue:
+      description: A struct property value.
+      type: object
+      required:
+        - metadataType
+        - struct_value
+      properties:
+        struct_value:
+          description: Base64 encoded bytes for struct value
+          type: string
+        metadataType:
+          type: string
+          example: MetadataStructValue
+          default: MetadataStructValue
+    MetadataValue:
+      oneOf:
+        - $ref: "#/components/schemas/MetadataIntValue"
+        - $ref: "#/components/schemas/MetadataDoubleValue"
+        - $ref: "#/components/schemas/MetadataStringValue"
+        - $ref: "#/components/schemas/MetadataStructValue"
+        - $ref: "#/components/schemas/MetadataProtoValue"
+        - $ref: "#/components/schemas/MetadataBoolValue"
+      discriminator:
+        propertyName: metadataType
+        mapping:
+          MetadataBoolValue: "#/components/schemas/MetadataBoolValue"
+          MetadataDoubleValue: "#/components/schemas/MetadataDoubleValue"
+          MetadataIntValue: "#/components/schemas/MetadataIntValue"
+          MetadataProtoValue: "#/components/schemas/MetadataProtoValue"
+          MetadataStringValue: "#/components/schemas/MetadataStringValue"
+          MetadataStructValue: "#/components/schemas/MetadataStructValue"
+      description: A value in properties.
+      example:
+        string_value: my_value
+        metadataType: MetadataStringValue
+    SortOrder:
+      description: Supported sort direction for ordering result entities.
+      enum:
+        - ASC
+        - DESC
+      type: string
+  responses:
+    BadRequest:
+      content:
+        application/json:
+          schema:
+            $ref: "#/components/schemas/Error"
+      description: Bad Request parameters
+    Conflict:
+      content:
+        application/json:
+          schema:
+            $ref: "#/components/schemas/Error"
+      description: Conflict with current state of target resource
+    InternalServerError:
+      content:
+        application/json:
+          schema:
+            $ref: "#/components/schemas/Error"
+      description: Unexpected internal server error
+    NotFound:
+      content:
+        application/json:
+          schema:
+            $ref: "#/components/schemas/Error"
+      description: The specified resource was not found
+    ServiceUnavailable:
+      content:
+        application/json:
+          schema:
+            $ref: "#/components/schemas/Error"
+      description: Service is unavailable
+    Unauthorized:
+      content:
+        application/json:
+          schema:
+            $ref: "#/components/schemas/Error"
+      description: Unauthorized
+    UnprocessableEntity:
+      content:
+        application/json:
+          schema:
+            $ref: "#/components/schemas/Error"
+      description: Unprocessable Entity error
+  parameters:
+    id:
+      name: id
+      description: The ID of resource.
+      schema:
+        type: string
+      in: path
+      required: true
+    name:
+      examples:
+        name:
+          value: entity-name
+      name: name
+      description: Name of entity to search.
+      schema:
+        type: string
+      in: query
+      required: false
+    externalId:
+      examples:
+        externalId:
+          value: "10"
+      name: externalId
+      description: External ID of entity to search.
+      schema:
+        type: string
+      in: query
+      required: false
+    parentResourceId:
+      examples:
+        parentResourceId:
+          value: "10"
+      name: parentResourceId
+      description: ID of the parent resource to use for search.
+      schema:
+        type: string
+      in: query
+      required: false
+    filterQuery:
+      examples:
+        filterQuery:
+          value: "name='my-model' AND state='LIVE'"
+      name: filterQuery
+      description: |
+        A SQL-like query string to filter the list of entities. The query supports rich filtering capabilities with automatic type inference.
+
+        **Supported Operators:**
+        - Comparison: `=`, `!=`, `<>`, `>`, `<`, `>=`, `<=`
+        - Pattern matching: `LIKE`, `ILIKE` (case-insensitive)
+        - Set membership: `IN`
+        - Logical: `AND`, `OR`
+        - Grouping: `()` for complex expressions
+
+        **Data Types:**
+        - Strings: `"value"` or `'value'`
+        - Numbers: `42`, `3.14`, `1e-5`
+        - Booleans: `true`, `false` (case-insensitive)
+
+        **Property Access:**
+        - Standard properties: `name`, `id`, `state`, `createTimeSinceEpoch`
+        - Custom properties: Any user-defined property name
+        - Escaped properties: Use backticks for special characters: `` `custom-property` ``
+        - Type-specific access: `property.string_value`, `property.double_value`, `property.int_value`, `property.bool_value`
+
+        **Examples:**
+        - Basic: `name = "my-model"`
+        - Comparison: `accuracy > 0.95`
+        - Pattern: `name LIKE "%tensorflow%"`
+        - Complex: `(name = "model-a" OR name = "model-b") AND state = "LIVE"`
+        - Custom property: `framework.string_value = "pytorch"`
+        - Escaped property: `` `mlflow.source.type` = "notebook" ``
+      schema:
+        type: string
+      in: query
+      required: false
+    pageSize:
+      examples:
+        pageSize:
+          value: "100"
+      name: pageSize
+      description: Number of entities in each page.
+      schema:
+        type: string
+      in: query
+      required: false
+    nextPageToken:
+      name: nextPageToken
+      description: Token to use to retrieve next page of results.
+      schema:
+        type: string
+      in: query
+      required: false
+    sortOrder:
+      style: form
+      explode: true
+      examples:
+        sortOrder:
+          value: DESC
+      name: sortOrder
+      description: "Specifies the sort order for listing entities, defaults to ASC."
+      schema:
+        $ref: "#/components/schemas/SortOrder"
+      in: query
+      required: false
+    artifactType:
+      style: form
+      explode: true
+      examples:
+        artifactType:
+          value: model-artifact
+      name: artifactType
+      description: "Specifies the artifact type for listing artifacts."
+      schema:
+        $ref: "#/components/schemas/ArtifactTypeQueryParam"
+      in: query
+      required: false
+    stepIds:
+      style: form
+      explode: true
+      examples:
+        stepIds:
+          value: "1,2,3"
+      name: stepIds
+      description: "Comma-separated list of step IDs to filter metrics by."
+      schema:
+        type: string
+      in: query
+      required: false
+  securitySchemes:
+    Bearer:
+      scheme: bearer
+      bearerFormat: JWT
+      type: http
+      description: Bearer JWT scheme
+security:
+  - Bearer: []

catalog/.openapi-generator-ignore

@@ -0,0 +1,44 @@
+# OpenAPI Generator Ignore
+# Generated by openapi-generator https://github.com/openapitools/openapi-generator
+
+# Use this file to prevent files from being overwritten by the generator.
+# The patterns follow closely to .gitignore or .dockerignore.
+
+# As an example, the C# client generator defines ApiClient.cs.
+# You can make changes and tell OpenAPI Generator to ignore just this file by uncommenting the following line:
+#ApiClient.cs
+
+# You can match any string of characters against a directory, file or extension with a single asterisk (*):
+#foo/*/qux
+# The above matches foo/bar/qux and foo/baz/qux, but not foo/bar/baz/qux
+
+# You can recursively match patterns against a directory, file or extension with a double asterisk (**):
+#foo/**/qux
+# This matches foo/bar/qux, foo/baz/qux, and foo/bar/baz/qux
+
+# You can also negate patterns with an exclamation (!).
+# For example, you can ignore all files in a docs folder with the file extension .md:
+#docs/*.md
+# Then explicitly reverse the ignore rule for a single file:
+#!docs/README.md
+
+# model and client files
+pkg/openapi/api
+pkg/openapi/api/**
+pkg/openapi/git_push.sh
+pkg/openapi/.gitignore
+pkg/openapi/.travis.yml
+pkg/openapi/.openapi-generator-ignore
+pkg/openapi/README.md
+pkg/openapi/docs/**.md
+pkg/openapi/test
+pkg/openapi/test/**
+pkg/openapi/**all_of.go
+pkg/openapi/go.mod
+pkg/openapi/go.sum
+
+# server files to ignore
+internal/server/openapi/api
+internal/server/openapi/api/**
+internal/server/openapi/.openapi-generator-ignore
+internal/server/openapi/README.md

catalog/Makefile

@@ -0,0 +1,44 @@
+PROJECT_BIN := $(CURDIR)/../bin
+OPENAPI_GENERATOR := $(PROJECT_BIN)/openapi-generator-cli
+GENQLIENT_BIN ?= $(PROJECT_BIN)/genqlient
+GENQLIENT_CONFIG := internal/catalog/genqlient/genqlient.yaml
+GENQLIENT_OUTPUT := internal/catalog/genqlient/generated.go
+GENQLIENT_SOURCES := $(wildcard internal/catalog/genqlient/queries/*.graphql)
+GRAPHQL_SCHEMA := internal/catalog/genqlient/queries/schema.graphql
+
+.PHONY: gen/openapi-server
+gen/openapi-server: internal/server/openapi/api_model_catalog_service.go
+
+internal/server/openapi/api_model_catalog_service.go: ../api/openapi/catalog.yaml
+	OPENAPI_GENERATOR="$(OPENAPI_GENERATOR)" ./scripts/gen_openapi_server.sh
+
+.PHONY: gen/openapi
+gen/openapi: pkg/openapi/client.go
+
+pkg/openapi/client.go: ../api/openapi/catalog.yaml
+	${OPENAPI_GENERATOR} generate \
+		-i ../api/openapi/catalog.yaml -g go -o pkg/openapi --package-name openapi \
+		--ignore-file-override ./.openapi-generator-ignore --additional-properties=isGoSubmodule=true,enumClassPrefix=true,useOneOfDiscriminatorLookup=true
+	gofmt -w pkg/openapi
+
+.PHONY: gen/graphql
+gen/graphql: $(GENQLIENT_OUTPUT)
+
+$(GENQLIENT_OUTPUT): $(GENQLIENT_CONFIG) $(GENQLIENT_SOURCES) $(PROJECT_BIN)/genqlient
+	$(GENQLIENT_BIN) --config $(GENQLIENT_CONFIG)
+
+.PHONY: download/graphql-schema
+download/graphql-schema:
+	npx get-graphql-schema https://catalog.redhat.com/api/containers/graphql/ > $(GRAPHQL_SCHEMA)
+
+.PHONY: clean-pkg-openapi
+clean-pkg-openapi:
+	while IFS= read -r file; do rm -f "pkg/openapi/$$file"; done < pkg/openapi/.openapi-generator/FILES
+
+.PHONY: clean-graphql
+clean-graphql:
+	rm -f $(GENQLIENT_OUTPUT)
+
+.PHONY: clean-internal-server-openapi
+clean-internal-server-openapi:
+	while IFS= read -r file; do rm -f "internal/server/openapi/$$file"; done < internal/server/openapi/.openapi-generator/FILES

catalog/README.md

@@ -0,0 +1,159 @@
+# Model Catalog Service
+
+The Model Catalog Service provides a **read-only discovery service** for ML models across multiple catalog sources. It acts as a federated metadata aggregation layer, allowing users to search and discover models from various external catalogs through a unified REST API.
+
+## Architecture Overview
+
+The catalog service operates as a **metadata aggregation layer** that:
+- Federates model discovery across different external catalogs
+- Provides a unified REST API for model search and discovery
+- Uses pluggable source providers for extensibility
+- Operates without traditional database storage (file-based configuration)
+
+### Supported Catalog Sources
+
+- **YAML Catalog** - Static YAML files containing model metadata
+- **Red Hat Ecosystem Catalog (RHEC)** - GraphQL API integration for container and model discovery. Can be used as a reference implementation of how one could extend with their own graphql providers.
+
+## REST API
+
+### Base URL
+`/api/model_catalog/v1alpha1`
+
+### Endpoints
+
+| Method | Path | Description |
+|--------|------|-------------|
+| `GET` | `/sources` | List all catalog sources with pagination |
+| `GET` | `/models` | Search models across sources (requires `source` parameter) |
+| `GET` | `/sources/{source_id}/models/{model_name+}` | Get specific model details |
+| `GET` | `/sources/{source_id}/models/{model_name}/artifacts` | List model artifacts |
+
+### OpenAPI Specification
+
+View the complete API specification:
+- [Swagger UI](https://www.kubeflow.org/docs/components/model-registry/reference/model-catalog-rest-api/#swagger-ui)
+- [Swagger Playground](https://petstore.swagger.io/?url=https://raw.githubusercontent.com/kubeflow/model-registry/main/api/openapi/catalog.yaml)
+
+## Data Models
+
+### CatalogSource
+Simple source metadata:
+```json
+{
+  "id": "string",
+  "name": "string"
+}
+```
+
+### CatalogModel
+Rich model metadata including:
+- Basic info: `name`, `description`, `readme`, `maturity`
+- Technical: `language[]`, `tasks[]`, `libraryName`
+- Legal: `license`, `licenseLink`, `provider`
+- Extensible: `customProperties` (key-value metadata)
+
+### CatalogModelArtifact
+Artifact references:
+```json
+{
+  "uri": "string",
+  "customProperties": {}
+}
+```
+
+## Configuration
+
+The catalog service uses **file-based configuration** instead of traditional databases:
+
+```yaml
+# catalog-sources.yaml
+catalogs:
+  - id: "yaml-catalog"
+    name: "Local YAML Catalog"
+    type: "yaml"
+    properties:
+      path: "./models"
+  - id: "rhec-catalog"
+    name: "Red Hat Ecosystem Catalog"
+    type: "rhec"
+    properties:
+      # RHEC-specific configuration
+```
+
+## Development
+
+### Prerequisites
+- Go >= 1.24
+- Java >= 11.0 (for OpenAPI generation)
+- Node.js >= 20.0.0 (for GraphQL schema downloads)
+
+### Building
+
+Generate OpenAPI server code:
+```bash
+make gen/openapi-server
+```
+
+Generate OpenAPI client code:
+```bash
+make gen/openapi
+```
+
+Generate GraphQL client (for RHEC integration):
+```bash
+make gen/graphql
+```
+
+### Project Structure
+
+```
+catalog/
+├── cmd/                    # Main application entry point
+├── internal/
+│   ├── catalog/           # Core catalog logic and providers
+│   │   ├── genqlient/     # GraphQL client generation
+│   │   └── testdata/      # Test fixtures
+│   └── server/openapi/    # REST API implementation
+├── pkg/openapi/           # Generated OpenAPI client
+├── scripts/               # Build and generation scripts
+└── Makefile              # Build targets
+```
+
+### Adding New Catalog Providers
+
+1. Implement the `CatalogSourceProvider` interface:
+```go
+type CatalogSourceProvider interface {
+    GetModel(ctx context.Context, name string) (*model.CatalogModel, error)
+    ListModels(ctx context.Context, params ListModelsParams) (model.CatalogModelList, error)
+    GetArtifacts(ctx context.Context, name string) (*model.CatalogModelArtifactList, error)
+}
+```
+
+2. Register your provider:
+```go
+catalog.RegisterCatalogType("my-catalog", func(source *CatalogSourceConfig) (CatalogSourceProvider, error) {
+    return NewMyCatalogProvider(source)
+})
+```
+
+### Testing
+
+The catalog service includes comprehensive testing:
+- Unit tests for core catalog logic
+- Integration tests for provider implementations
+- OpenAPI contract validation
+
+### Configuration Hot Reloading
+
+The service automatically reloads configuration when the catalog sources file changes, enabling dynamic catalog updates without service restarts.
+
+## Integration
+
+The catalog service is designed to complement the main Model Registry service by providing:
+- External model discovery capabilities
+- Unified metadata aggregation
+- Read-only access to distributed model catalogs
+
+For complete Model Registry documentation, see the [main README](../README.md).

catalog/cmd/catalog.go

@@ -0,0 +1,44 @@
+package cmd
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/golang/glog"
+	"github.com/kubeflow/model-registry/catalog/internal/catalog"
+	"github.com/kubeflow/model-registry/catalog/internal/server/openapi"
+	"github.com/spf13/cobra"
+)
+
+var catalogCfg = struct {
+	ListenAddress string
+	ConfigPath    string
+}{
+	ListenAddress: "0.0.0.0:8080",
+	ConfigPath:    "sources.yaml",
+}
+
+var CatalogCmd = &cobra.Command{
+	Use:   "catalog",
+	Short: "Catalog API server",
+	Long:  `Launch the API server for the model catalog`,
+	RunE:  runCatalogServer,
+}
+
+func init() {
+	CatalogCmd.Flags().StringVarP(&catalogCfg.ListenAddress, "listen", "l", catalogCfg.ListenAddress, "Address to listen on")
+	CatalogCmd.Flags().StringVar(&catalogCfg.ConfigPath, "catalogs-path", catalogCfg.ConfigPath, "Path to catalog source configuration file")
+}
+
+func runCatalogServer(cmd *cobra.Command, args []string) error {
+	sources, err := catalog.LoadCatalogSources(catalogCfg.ConfigPath)
+	if err != nil {
+		return fmt.Errorf("error loading catalog sources: %v", err)
+	}
+
+	svc := openapi.NewModelCatalogServiceAPIService(sources)
+	ctrl := openapi.NewModelCatalogServiceAPIController(svc)
+
+	glog.Infof("Catalog API server listening on %s", catalogCfg.ListenAddress)
+	return http.ListenAndServe(catalogCfg.ListenAddress, openapi.NewRouter(ctrl))
+}

catalog/internal/catalog/catalog.go

@@ -0,0 +1,205 @@
+package catalog
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+	"sync"
+
+	"github.com/golang/glog"
+	"k8s.io/apimachinery/pkg/util/yaml"
+
+	model "github.com/kubeflow/model-registry/catalog/pkg/openapi"
+)
+
+type ListModelsParams struct {
+	Query     string
+	OrderBy   model.OrderByField
+	SortOrder model.SortOrder
+}
+
+// CatalogSourceProvider is implemented by catalog source types, e.g. YamlCatalog
+type CatalogSourceProvider interface {
+	// GetModel returns model metadata for a single model by its name. If
+	// nothing is found with the name provided it returns nil, without an
+	// error.
+	GetModel(ctx context.Context, name string) (*model.CatalogModel, error)
+
+	// ListModels returns all models according to the parameters. If
+	// nothing suitable is found, it returns an empty list.
+	ListModels(ctx context.Context, params ListModelsParams) (model.CatalogModelList, error)
+
+	// GetArtifacts returns all artifacts for a particular model. If no
+	// model is found with that name, it returns nil. If the model is
+	// found, but has no artifacts, an empty list is returned.
+	GetArtifacts(ctx context.Context, name string) (*model.CatalogModelArtifactList, error)
+}
+
+// CatalogSourceConfig is a single entry from the catalog sources YAML file.
+type CatalogSourceConfig struct {
+	model.CatalogSource `json:",inline"`
+
+	// Catalog type to use, must match one of the registered types
+	Type string `json:"type"`
+
+	// Properties used for configuring the catalog connection based on catalog implementation
+	Properties map[string]any `json:"properties,omitempty"`
+}
+
+// sourceConfig is the structure for the catalog sources YAML file.
+type sourceConfig struct {
+	Catalogs []CatalogSourceConfig `json:"catalogs"`
+}
+
+type CatalogTypeRegisterFunc func(source *CatalogSourceConfig) (CatalogSourceProvider, error)
+
+var registeredCatalogTypes = make(map[string]CatalogTypeRegisterFunc, 0)
+
+func RegisterCatalogType(catalogType string, callback CatalogTypeRegisterFunc) error {
+	if _, exists := registeredCatalogTypes[catalogType]; exists {
+		return fmt.Errorf("catalog type %s already exists", catalogType)
+	}
+	registeredCatalogTypes[catalogType] = callback
+	return nil
+}
+
+type CatalogSource struct {
+	Provider CatalogSourceProvider
+	Metadata model.CatalogSource
+}
+
+type SourceCollection struct {
+	sourcesMu sync.RWMutex
+	sources   map[string]CatalogSource
+}
+
+func NewSourceCollection(sources map[string]CatalogSource) *SourceCollection {
+	return &SourceCollection{sources: sources}
+}
+
+func (sc *SourceCollection) All() map[string]CatalogSource {
+	sc.sourcesMu.RLock()
+	defer sc.sourcesMu.RUnlock()
+
+	return sc.sources
+}
+
+func (sc *SourceCollection) Get(name string) (src CatalogSource, ok bool) {
+	sc.sourcesMu.RLock()
+	defer sc.sourcesMu.RUnlock()
+
+	src, ok = sc.sources[name]
+	return
+}
+
+func (sc *SourceCollection) load(path string) error {
+	// Get absolute path of the catalog config file
+	absConfigPath, err := filepath.Abs(path)
+	if err != nil {
+		return fmt.Errorf("failed to get absolute path for %s: %v", path, err)
+	}
+
+	// Get the directory of the config file to resolve relative paths
+	configDir := filepath.Dir(absConfigPath)
+
+	// Save current working directory
+	originalWd, err := os.Getwd()
+	if err != nil {
+		return fmt.Errorf("failed to get current working directory: %v", err)
+	}
+
+	// Change to the config directory to make relative paths work
+	if err := os.Chdir(configDir); err != nil {
+		return fmt.Errorf("failed to change to config directory %s: %v", configDir, err)
+	}
+
+	// Ensure we restore the original working directory when we're done
+	defer func() {
+		if err := os.Chdir(originalWd); err != nil {
+			glog.Errorf("failed to restore original working directory %s: %v", originalWd, err)
+		}
+	}()
+
+	config := sourceConfig{}
+	bytes, err := os.ReadFile(absConfigPath)
+	if err != nil {
+		return err
+	}
+
+	if err = yaml.UnmarshalStrict(bytes, &config); err != nil {
+		return err
+	}
+
+	sources := make(map[string]CatalogSource, len(config.Catalogs))
+	for _, catalogConfig := range config.Catalogs {
+		// If enabled is explicitly set to false, skip
+		hasEnabled := catalogConfig.HasEnabled()
+		if hasEnabled && *catalogConfig.Enabled == false {
+			continue
+		}
+		// If not explicitly set, default to enabled
+		if !hasEnabled {
+			t := true
+			catalogConfig.CatalogSource.Enabled = &t
+		}
+
+		catalogType := catalogConfig.Type
+		glog.Infof("reading config type %s...", catalogType)
+		registerFunc, ok := registeredCatalogTypes[catalogType]
+		if !ok {
+			return fmt.Errorf("catalog type %s not registered", catalogType)
+		}
+		id := catalogConfig.GetId()
+		if len(id) == 0 {
+			return fmt.Errorf("invalid catalog id %s", id)
+		}
+		if _, exists := sources[id]; exists {
+			return fmt.Errorf("duplicate catalog id %s", id)
+		}
+		provider, err := registerFunc(&catalogConfig)
+		if err != nil {
+			return fmt.Errorf("error reading catalog type %s with id %s: %v", catalogType, id, err)
+		}
+
+		sources[id] = CatalogSource{
+			Provider: provider,
+			Metadata: catalogConfig.CatalogSource,
+		}
+
+		glog.Infof("loaded config %s of type %s", id, catalogType)
+	}
+
+	sc.sourcesMu.Lock()
+	defer sc.sourcesMu.Unlock()
+	sc.sources = sources
+
+	return nil
+}
+
+func LoadCatalogSources(path string) (*SourceCollection, error) {
+	sc := &SourceCollection{}
+	err := sc.load(path)
+	if err != nil {
+		return nil, err
+	}
+
+	go func() {
+		changes, err := getMonitor().Path(path)
+		if err != nil {
+			glog.Errorf("unable to watch sources file: %v", err)
+			// Not fatal, we just won't get automatic updates.
+		}
+
+		for range changes {
+			glog.Infof("Reloading sources %s", path)
+
+			err = sc.load(path)
+			if err != nil {
+				glog.Errorf("unable to load sources: %v", err)
+			}
+		}
+	}()
+
+	return sc, nil
+}

catalog/internal/catalog/catalog_test.go

@@ -0,0 +1,102 @@
+package catalog
+
+import (
+	"reflect"
+	"sort"
+	"testing"
+
+	model "github.com/kubeflow/model-registry/catalog/pkg/openapi"
+)
+
+func TestLoadCatalogSources(t *testing.T) {
+	type args struct {
+		catalogsPath string
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    []string
+		wantErr bool
+	}{
+		{
+			name:    "test-catalog-sources",
+			args:    args{catalogsPath: "testdata/test-catalog-sources.yaml"},
+			want:    []string{"catalog1", "catalog3", "catalog4"},
+			wantErr: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := LoadCatalogSources(tt.args.catalogsPath)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("LoadCatalogSources() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			gotKeys := make([]string, 0, len(got.All()))
+			for k := range got.All() {
+				gotKeys = append(gotKeys, k)
+			}
+			sort.Strings(gotKeys)
+			if !reflect.DeepEqual(gotKeys, tt.want) {
+				t.Errorf("LoadCatalogSources() got = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestLoadCatalogSourcesEnabledDisabled(t *testing.T) {
+	trueValue := true
+	type args struct {
+		catalogsPath string
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    map[string]model.CatalogSource
+		wantErr bool
+	}{
+		{
+			name: "test-catalog-sources-enabled-and-disabled",
+			args: args{catalogsPath: "testdata/test-catalog-sources.yaml"},
+			want: map[string]model.CatalogSource{
+				"catalog1": {
+					Id:      "catalog1",
+					Name:    "Catalog 1",
+					Enabled: &trueValue,
+				},
+				"catalog3": {
+					Id:      "catalog3",
+					Name:    "Catalog 3",
+					Enabled: &trueValue,
+				},
+				"catalog4": {
+					Id:      "catalog4",
+					Name:    "Catalog 4",
+					Enabled: &trueValue,
+				},
+			},
+			wantErr: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := LoadCatalogSources(tt.args.catalogsPath)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("LoadCatalogSources() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if err != nil {
+				return
+			}
+
+			gotMetadata := make(map[string]model.CatalogSource)
+			for id, source := range got.All() {
+				gotMetadata[id] = source.Metadata
+			}
+
+			if !reflect.DeepEqual(gotMetadata, tt.want) {
+				t.Errorf("LoadCatalogSources() got metadata = %#v, want %#v", gotMetadata, tt.want)
+			}
+		})
+	}
+}

catalog/internal/catalog/genqlient/README.md

@@ -0,0 +1,32 @@
+## Using Genqlient with the Red Hat Ecosystem Catalog
+
+The Genqlient is used to retrieve metadata from a CatalogSource, in this case the Red Hat Ecosystem Catalog (RHEC), for the Model Catalog based on GraphQL queries to the RHEC API.
+
+This directory contains the necessary files to generate a type-safe Go GraphQL client for the RHEC using [genqlient](https://github.com/Khan/genqlient).
+
+### File Structure
+
+-   `genqlient.yaml`: The configuration file for `genqlient`. It specifies the location of the GraphQL schema, the directory containing the GraphQL queries, and the output file for the generated code.
+-   `queries/`: This directory contains the GraphQL schema and query files.
+    -   `schema.graphql`: The GraphQL schema for the RHEC API.
+    -   `*.graphql`: Files containing the GraphQL queries.
+
+### Generating the Client
+
+To regenerate the client, you will first need to ensure the required tools are installed by running `make deps` from the project root. Once the tools are installed, you can generate the client by running the following command from the `catalog` directory:
+
+```bash
+make gen/graphql
+```
+
+This will generate the `generated.go` file in the current directory.
+
+### Downloading the Schema
+
+The `schema.graphql` file can be updated by downloading the latest version from the RHEC API. You can do this by running the following command from the `catalog` directory:
+
+```bash
+make download/graphql-schema
+```
+
+This will download the schema and save it to the correct location. After updating the schema, you should regenerate the client to ensure it is up to date. 

catalog/internal/catalog/genqlient/generated.go

@@ -0,0 +1,389 @@
+// Code generated by github.com/Khan/genqlient, DO NOT EDIT.
+
+package genqlient
+
+import (
+	"context"
+	"time"
+
+	"github.com/Khan/genqlient/graphql"
+)
+
+// FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponse includes the requested fields of the GraphQL type ContainerImagePaginatedResponse.
+type FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponse struct {
+	Error FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponseError                `json:"error"`
+	Total int                                                                                                            `json:"total"`
+	Data  []FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponseDataContainerImage `json:"data"`
+}
+
+// GetError returns FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponse.Error, and is useful for accessing the field via an interface.
+func (v *FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponse) GetError() FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponseError {
+	return v.Error
+}
+
+// GetTotal returns FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponse.Total, and is useful for accessing the field via an interface.
+func (v *FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponse) GetTotal() int {
+	return v.Total
+}
+
+// GetData returns FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponse.Data, and is useful for accessing the field via an interface.
+func (v *FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponse) GetData() []FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponseDataContainerImage {
+	return v.Data
+}
+
+// FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponseDataContainerImage includes the requested fields of the GraphQL type ContainerImage.
+// The GraphQL type's documentation follows.
+//
+// Metadata about images contained in RedHat and ISV repositories
+type FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponseDataContainerImage struct {
+	// The date when the entry was created. Value is created automatically on creation.
+	Creation_date time.Time `json:"creation_date"`
+	// The date when the entry was last updated.
+	Last_update_date time.Time `json:"last_update_date"`
+	// Published repositories associated with the container image.
+	Repositories []FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponseDataContainerImageRepositoriesContainerImageRepo `json:"repositories"`
+	// Data parsed from image metadata.
+	// These fields are not computed from any other source.
+	Parsed_data FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponseDataContainerImageParsed_dataParsedData `json:"parsed_data"`
+}
+
+// GetCreation_date returns FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponseDataContainerImage.Creation_date, and is useful for accessing the field via an interface.
+func (v *FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponseDataContainerImage) GetCreation_date() time.Time {
+	return v.Creation_date
+}
+
+// GetLast_update_date returns FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponseDataContainerImage.Last_update_date, and is useful for accessing the field via an interface.
+func (v *FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponseDataContainerImage) GetLast_update_date() time.Time {
+	return v.Last_update_date
+}
+
+// GetRepositories returns FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponseDataContainerImage.Repositories, and is useful for accessing the field via an interface.
+func (v *FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponseDataContainerImage) GetRepositories() []FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponseDataContainerImageRepositoriesContainerImageRepo {
+	return v.Repositories
+}
+
+// GetParsed_data returns FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponseDataContainerImage.Parsed_data, and is useful for accessing the field via an interface.
+func (v *FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponseDataContainerImage) GetParsed_data() FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponseDataContainerImageParsed_dataParsedData {
+	return v.Parsed_data
+}
+
+// FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponseDataContainerImageParsed_dataParsedData includes the requested fields of the GraphQL type ParsedData.
+type FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponseDataContainerImageParsed_dataParsedData struct {
+	Labels []FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponseDataContainerImageParsed_dataParsedDataLabelsLabel `json:"labels"`
+}
+
+// GetLabels returns FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponseDataContainerImageParsed_dataParsedData.Labels, and is useful for accessing the field via an interface.
+func (v *FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponseDataContainerImageParsed_dataParsedData) GetLabels() []FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponseDataContainerImageParsed_dataParsedDataLabelsLabel {
+	return v.Labels
+}
+
+// FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponseDataContainerImageParsed_dataParsedDataLabelsLabel includes the requested fields of the GraphQL type Label.
+// The GraphQL type's documentation follows.
+//
+// Image label.
+type FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponseDataContainerImageParsed_dataParsedDataLabelsLabel struct {
+	// The name of the label
+	Name string `json:"name"`
+	// Value of the label.
+	Value string `json:"value"`
+}
+
+// GetName returns FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponseDataContainerImageParsed_dataParsedDataLabelsLabel.Name, and is useful for accessing the field via an interface.
+func (v *FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponseDataContainerImageParsed_dataParsedDataLabelsLabel) GetName() string {
+	return v.Name
+}
+
+// GetValue returns FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponseDataContainerImageParsed_dataParsedDataLabelsLabel.Value, and is useful for accessing the field via an interface.
+func (v *FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponseDataContainerImageParsed_dataParsedDataLabelsLabel) GetValue() string {
+	return v.Value
+}
+
+// FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponseDataContainerImageRepositoriesContainerImageRepo includes the requested fields of the GraphQL type ContainerImageRepo.
+type FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponseDataContainerImageRepositoriesContainerImageRepo struct {
+	// Hostname of the registry where the repository can be accessed.
+	Registry string `json:"registry"`
+	// List of container tags assigned to this layer.
+	Tags []FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponseDataContainerImageRepositoriesContainerImageRepoTagsContainerImageRepoTag `json:"tags"`
+}
+
+// GetRegistry returns FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponseDataContainerImageRepositoriesContainerImageRepo.Registry, and is useful for accessing the field via an interface.
+func (v *FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponseDataContainerImageRepositoriesContainerImageRepo) GetRegistry() string {
+	return v.Registry
+}
+
+// GetTags returns FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponseDataContainerImageRepositoriesContainerImageRepo.Tags, and is useful for accessing the field via an interface.
+func (v *FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponseDataContainerImageRepositoriesContainerImageRepo) GetTags() []FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponseDataContainerImageRepositoriesContainerImageRepoTagsContainerImageRepoTag {
+	return v.Tags
+}
+
+// FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponseDataContainerImageRepositoriesContainerImageRepoTagsContainerImageRepoTag includes the requested fields of the GraphQL type ContainerImageRepoTag.
+type FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponseDataContainerImageRepositoriesContainerImageRepoTagsContainerImageRepoTag struct {
+	// The name of the tag.
+	Name string `json:"name"`
+}
+
+// GetName returns FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponseDataContainerImageRepositoriesContainerImageRepoTagsContainerImageRepoTag.Name, and is useful for accessing the field via an interface.
+func (v *FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponseDataContainerImageRepositoriesContainerImageRepoTagsContainerImageRepoTag) GetName() string {
+	return v.Name
+}
+
+// FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponseError includes the requested fields of the GraphQL type ResponseError.
+type FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponseError struct {
+	Detail string `json:"detail"`
+	Status int    `json:"status"`
+}
+
+// GetDetail returns FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponseError.Detail, and is useful for accessing the field via an interface.
+func (v *FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponseError) GetDetail() string {
+	return v.Detail
+}
+
+// GetStatus returns FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponseError.Status, and is useful for accessing the field via an interface.
+func (v *FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponseError) GetStatus() int {
+	return v.Status
+}
+
+// FindRepositoryImagesResponse is returned by FindRepositoryImages on success.
+type FindRepositoryImagesResponse struct {
+	// List images for a repository. Exclude total for improved performance.
+	Find_repository_images_by_registry_path FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponse `json:"find_repository_images_by_registry_path"`
+}
+
+// GetFind_repository_images_by_registry_path returns FindRepositoryImagesResponse.Find_repository_images_by_registry_path, and is useful for accessing the field via an interface.
+func (v *FindRepositoryImagesResponse) GetFind_repository_images_by_registry_path() FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponse {
+	return v.Find_repository_images_by_registry_path
+}
+
+// GetRepositoryGet_repository_by_registry_pathContainerRepositoryResponse includes the requested fields of the GraphQL type ContainerRepositoryResponse.
+type GetRepositoryGet_repository_by_registry_pathContainerRepositoryResponse struct {
+	Error GetRepositoryGet_repository_by_registry_pathContainerRepositoryResponseError                   `json:"error"`
+	Data  GetRepositoryGet_repository_by_registry_pathContainerRepositoryResponseDataContainerRepository `json:"data"`
+}
+
+// GetError returns GetRepositoryGet_repository_by_registry_pathContainerRepositoryResponse.Error, and is useful for accessing the field via an interface.
+func (v *GetRepositoryGet_repository_by_registry_pathContainerRepositoryResponse) GetError() GetRepositoryGet_repository_by_registry_pathContainerRepositoryResponseError {
+	return v.Error
+}
+
+// GetData returns GetRepositoryGet_repository_by_registry_pathContainerRepositoryResponse.Data, and is useful for accessing the field via an interface.
+func (v *GetRepositoryGet_repository_by_registry_pathContainerRepositoryResponse) GetData() GetRepositoryGet_repository_by_registry_pathContainerRepositoryResponseDataContainerRepository {
+	return v.Data
+}
+
+// GetRepositoryGet_repository_by_registry_pathContainerRepositoryResponseDataContainerRepository includes the requested fields of the GraphQL type ContainerRepository.
+// The GraphQL type's documentation follows.
+//
+// Contains metadata associated with Red Hat and ISV repositories
+type GetRepositoryGet_repository_by_registry_pathContainerRepositoryResponseDataContainerRepository struct {
+	// The date when the entry was created. Value is created automatically on creation.
+	Creation_date time.Time `json:"creation_date"`
+	// The date when the entry was last updated.
+	Last_update_date time.Time `json:"last_update_date"`
+	// The release categories of a repository.
+	Release_categories []string `json:"release_categories"`
+	// Label of the vendor that owns this repository.
+	Vendor_label string                                                                                                                          `json:"vendor_label"`
+	Display_data GetRepositoryGet_repository_by_registry_pathContainerRepositoryResponseDataContainerRepositoryDisplay_dataRepositoryDisplayData `json:"display_data"`
+}
+
+// GetCreation_date returns GetRepositoryGet_repository_by_registry_pathContainerRepositoryResponseDataContainerRepository.Creation_date, and is useful for accessing the field via an interface.
+func (v *GetRepositoryGet_repository_by_registry_pathContainerRepositoryResponseDataContainerRepository) GetCreation_date() time.Time {
+	return v.Creation_date
+}
+
+// GetLast_update_date returns GetRepositoryGet_repository_by_registry_pathContainerRepositoryResponseDataContainerRepository.Last_update_date, and is useful for accessing the field via an interface.
+func (v *GetRepositoryGet_repository_by_registry_pathContainerRepositoryResponseDataContainerRepository) GetLast_update_date() time.Time {
+	return v.Last_update_date
+}
+
+// GetRelease_categories returns GetRepositoryGet_repository_by_registry_pathContainerRepositoryResponseDataContainerRepository.Release_categories, and is useful for accessing the field via an interface.
+func (v *GetRepositoryGet_repository_by_registry_pathContainerRepositoryResponseDataContainerRepository) GetRelease_categories() []string {
+	return v.Release_categories
+}
+
+// GetVendor_label returns GetRepositoryGet_repository_by_registry_pathContainerRepositoryResponseDataContainerRepository.Vendor_label, and is useful for accessing the field via an interface.
+func (v *GetRepositoryGet_repository_by_registry_pathContainerRepositoryResponseDataContainerRepository) GetVendor_label() string {
+	return v.Vendor_label
+}
+
+// GetDisplay_data returns GetRepositoryGet_repository_by_registry_pathContainerRepositoryResponseDataContainerRepository.Display_data, and is useful for accessing the field via an interface.
+func (v *GetRepositoryGet_repository_by_registry_pathContainerRepositoryResponseDataContainerRepository) GetDisplay_data() GetRepositoryGet_repository_by_registry_pathContainerRepositoryResponseDataContainerRepositoryDisplay_dataRepositoryDisplayData {
+	return v.Display_data
+}
+
+// GetRepositoryGet_repository_by_registry_pathContainerRepositoryResponseDataContainerRepositoryDisplay_dataRepositoryDisplayData includes the requested fields of the GraphQL type RepositoryDisplayData.
+// The GraphQL type's documentation follows.
+//
+// Display data for Catalog.
+type GetRepositoryGet_repository_by_registry_pathContainerRepositoryResponseDataContainerRepositoryDisplay_dataRepositoryDisplayData struct {
+	// The short description of the repository.
+	Short_description string `json:"short_description"`
+	// The long description of the repository.
+	Long_description string `json:"long_description"`
+}
+
+// GetShort_description returns GetRepositoryGet_repository_by_registry_pathContainerRepositoryResponseDataContainerRepositoryDisplay_dataRepositoryDisplayData.Short_description, and is useful for accessing the field via an interface.
+func (v *GetRepositoryGet_repository_by_registry_pathContainerRepositoryResponseDataContainerRepositoryDisplay_dataRepositoryDisplayData) GetShort_description() string {
+	return v.Short_description
+}
+
+// GetLong_description returns GetRepositoryGet_repository_by_registry_pathContainerRepositoryResponseDataContainerRepositoryDisplay_dataRepositoryDisplayData.Long_description, and is useful for accessing the field via an interface.
+func (v *GetRepositoryGet_repository_by_registry_pathContainerRepositoryResponseDataContainerRepositoryDisplay_dataRepositoryDisplayData) GetLong_description() string {
+	return v.Long_description
+}
+
+// GetRepositoryGet_repository_by_registry_pathContainerRepositoryResponseError includes the requested fields of the GraphQL type ResponseError.
+type GetRepositoryGet_repository_by_registry_pathContainerRepositoryResponseError struct {
+	Detail string `json:"detail"`
+	Status int    `json:"status"`
+}
+
+// GetDetail returns GetRepositoryGet_repository_by_registry_pathContainerRepositoryResponseError.Detail, and is useful for accessing the field via an interface.
+func (v *GetRepositoryGet_repository_by_registry_pathContainerRepositoryResponseError) GetDetail() string {
+	return v.Detail
+}
+
+// GetStatus returns GetRepositoryGet_repository_by_registry_pathContainerRepositoryResponseError.Status, and is useful for accessing the field via an interface.
+func (v *GetRepositoryGet_repository_by_registry_pathContainerRepositoryResponseError) GetStatus() int {
+	return v.Status
+}
+
+// GetRepositoryResponse is returned by GetRepository on success.
+type GetRepositoryResponse struct {
+	// Get a repository by registry and path (product line/image name).
+	Get_repository_by_registry_path GetRepositoryGet_repository_by_registry_pathContainerRepositoryResponse `json:"get_repository_by_registry_path"`
+}
+
+// GetGet_repository_by_registry_path returns GetRepositoryResponse.Get_repository_by_registry_path, and is useful for accessing the field via an interface.
+func (v *GetRepositoryResponse) GetGet_repository_by_registry_path() GetRepositoryGet_repository_by_registry_pathContainerRepositoryResponse {
+	return v.Get_repository_by_registry_path
+}
+
+// __FindRepositoryImagesInput is used internally by genqlient
+type __FindRepositoryImagesInput struct {
+	Registry   string `json:"registry"`
+	Repository string `json:"repository"`
+}
+
+// GetRegistry returns __FindRepositoryImagesInput.Registry, and is useful for accessing the field via an interface.
+func (v *__FindRepositoryImagesInput) GetRegistry() string { return v.Registry }
+
+// GetRepository returns __FindRepositoryImagesInput.Repository, and is useful for accessing the field via an interface.
+func (v *__FindRepositoryImagesInput) GetRepository() string { return v.Repository }
+
+// __GetRepositoryInput is used internally by genqlient
+type __GetRepositoryInput struct {
+	Registry   string `json:"registry"`
+	Repository string `json:"repository"`
+}
+
+// GetRegistry returns __GetRepositoryInput.Registry, and is useful for accessing the field via an interface.
+func (v *__GetRepositoryInput) GetRegistry() string { return v.Registry }
+
+// GetRepository returns __GetRepositoryInput.Repository, and is useful for accessing the field via an interface.
+func (v *__GetRepositoryInput) GetRepository() string { return v.Repository }
+
+// The query executed by FindRepositoryImages.
+const FindRepositoryImages_Operation = `
+query FindRepositoryImages ($registry: String!, $repository: String!) {
+	find_repository_images_by_registry_path(registry: $registry, repository: $repository, sort_by: [{field:"creation_date",order:DESC}]) {
+		error {
+			detail
+			status
+		}
+		total
+		data {
+			creation_date
+			last_update_date
+			repositories {
+				registry
+				tags {
+					name
+				}
+			}
+			parsed_data {
+				labels {
+					name
+					value
+				}
+			}
+		}
+	}
+}
+`
+
+func FindRepositoryImages(
+	ctx_ context.Context,
+	client_ graphql.Client,
+	registry string,
+	repository string,
+) (data_ *FindRepositoryImagesResponse, err_ error) {
+	req_ := &graphql.Request{
+		OpName: "FindRepositoryImages",
+		Query:  FindRepositoryImages_Operation,
+		Variables: &__FindRepositoryImagesInput{
+			Registry:   registry,
+			Repository: repository,
+		},
+	}
+
+	data_ = &FindRepositoryImagesResponse{}
+	resp_ := &graphql.Response{Data: data_}
+
+	err_ = client_.MakeRequest(
+		ctx_,
+		req_,
+		resp_,
+	)
+
+	return data_, err_
+}
+
+// The query executed by GetRepository.
+const GetRepository_Operation = `
+query GetRepository ($registry: String!, $repository: String!) {
+	get_repository_by_registry_path(registry: $registry, repository: $repository) {
+		error {
+			detail
+			status
+		}
+		data {
+			creation_date
+			last_update_date
+			release_categories
+			vendor_label
+			display_data {
+				short_description
+				long_description
+			}
+		}
+	}
+}
+`
+
+func GetRepository(
+	ctx_ context.Context,
+	client_ graphql.Client,
+	registry string,
+	repository string,
+) (data_ *GetRepositoryResponse, err_ error) {
+	req_ := &graphql.Request{
+		OpName: "GetRepository",
+		Query:  GetRepository_Operation,
+		Variables: &__GetRepositoryInput{
+			Registry:   registry,
+			Repository: repository,
+		},
+	}
+
+	data_ = &GetRepositoryResponse{}
+	resp_ := &graphql.Response{Data: data_}
+
+	err_ = client_.MakeRequest(
+		ctx_,
+		req_,
+		resp_,
+	)
+
+	return data_, err_
+}

catalog/internal/catalog/genqlient/genqlient.yaml

@@ -0,0 +1,10 @@
+# genqlient.yaml
+schema: queries/schema.graphql
+operations:
+  - "queries/find_repository_images.graphql"
+  - "queries/get_repository.graphql"
+generated: generated.go
+package: genqlient
+bindings:
+  DateTime:
+    type: time.Time 

catalog/internal/catalog/genqlient/queries/find_repository_images.graphql

@@ -0,0 +1,29 @@
+query FindRepositoryImages($registry: String!, $repository: String!) {
+  find_repository_images_by_registry_path(
+    registry: $registry
+    repository: $repository
+    sort_by: [{ field: "creation_date", order: DESC }]
+  ) {
+    error {
+      detail
+      status
+    }
+    total
+    data {
+      creation_date
+      last_update_date
+      repositories {
+        registry
+        tags {
+          name
+        }
+      }
+      parsed_data {
+        labels {
+          name
+          value
+        }
+      }
+    }
+  }
+}

catalog/internal/catalog/genqlient/queries/get_repository.graphql

@@ -0,0 +1,21 @@
+query GetRepository($registry: String!, $repository: String!) {
+  get_repository_by_registry_path(
+    registry: $registry
+    repository: $repository
+  ) {
+    error {
+      detail
+      status
+    }
+    data {
+      creation_date
+      last_update_date
+      release_categories
+      vendor_label
+      display_data {
+        short_description
+        long_description
+      }
+    }
+  }
+}

catalog/internal/catalog/hf_catalog.go

@@ -0,0 +1,125 @@
+package catalog
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/golang/glog"
+	"github.com/kubeflow/model-registry/catalog/pkg/openapi"
+	model "github.com/kubeflow/model-registry/catalog/pkg/openapi"
+)
+
+type hfCatalogImpl struct {
+	client  *http.Client
+	apiKey  string
+	baseURL string
+}
+
+var _ CatalogSourceProvider = &hfCatalogImpl{}
+
+const (
+	defaultHuggingFaceURL = "https://huggingface.co"
+)
+
+func (h *hfCatalogImpl) GetModel(ctx context.Context, name string) (*openapi.CatalogModel, error) {
+	// TODO: Implement HuggingFace model retrieval
+	return nil, fmt.Errorf("HuggingFace model retrieval not yet implemented")
+}
+
+func (h *hfCatalogImpl) ListModels(ctx context.Context, params ListModelsParams) (model.CatalogModelList, error) {
+	// TODO: Implement HuggingFace model listing
+	// For now, return empty list to satisfy interface
+	return model.CatalogModelList{
+		Items:    []model.CatalogModel{},
+		PageSize: 0,
+		Size:     0,
+	}, nil
+}
+
+func (h *hfCatalogImpl) GetArtifacts(ctx context.Context, name string) (*openapi.CatalogModelArtifactList, error) {
+	// TODO: Implement HuggingFace model artifacts retrieval
+	// For now, return empty list to satisfy interface
+	return &openapi.CatalogModelArtifactList{
+		Items:    []openapi.CatalogModelArtifact{},
+		PageSize: 0,
+		Size:     0,
+	}, nil
+}
+
+// validateCredentials checks if the HuggingFace API credentials are valid
+func (h *hfCatalogImpl) validateCredentials(ctx context.Context) error {
+	glog.Infof("Validating HuggingFace API credentials")
+
+	// Make a simple API call to validate credentials
+	apiURL := h.baseURL + "/api/whoami-v2"
+	req, err := http.NewRequestWithContext(ctx, "GET", apiURL, nil)
+	if err != nil {
+		return fmt.Errorf("failed to create validation request: %w", err)
+	}
+
+	if h.apiKey != "" {
+		req.Header.Set("Authorization", "Bearer "+h.apiKey)
+	}
+
+	resp, err := h.client.Do(req)
+	if err != nil {
+		return fmt.Errorf("failed to validate HuggingFace credentials: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode == http.StatusUnauthorized {
+		return fmt.Errorf("invalid HuggingFace API credentials")
+	}
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("HuggingFace API validation failed with status: %d", resp.StatusCode)
+	}
+
+	glog.Infof("HuggingFace credentials validated successfully")
+	return nil
+}
+
+// newHfCatalog creates a new HuggingFace catalog source
+func newHfCatalog(source *CatalogSourceConfig) (CatalogSourceProvider, error) {
+	apiKey, ok := source.Properties["apiKey"].(string)
+	if !ok || apiKey == "" {
+		return nil, fmt.Errorf("missing or invalid 'apiKey' property for HuggingFace catalog")
+	}
+
+	baseURL := defaultHuggingFaceURL
+	if url, ok := source.Properties["url"].(string); ok && url != "" {
+		baseURL = strings.TrimSuffix(url, "/")
+	}
+
+	// Optional model limit for future implementation
+	modelLimit := 100
+	if limit, ok := source.Properties["modelLimit"].(int); ok && limit > 0 {
+		modelLimit = limit
+	}
+
+	glog.Infof("Configuring HuggingFace catalog with URL: %s, modelLimit: %d", baseURL, modelLimit)
+
+	h := &hfCatalogImpl{
+		client:  &http.Client{Timeout: 30 * time.Second},
+		apiKey:  apiKey,
+		baseURL: baseURL,
+	}
+
+	// Validate credentials during initialization (as required by Jira ticket)
+	ctx := context.Background()
+	if err := h.validateCredentials(ctx); err != nil {
+		glog.Errorf("HuggingFace catalog credential validation failed: %v", err)
+		return nil, fmt.Errorf("failed to validate HuggingFace catalog credentials: %w", err)
+	}
+
+	glog.Infof("HuggingFace catalog source configured successfully")
+	return h, nil
+}
+
+func init() {
+	if err := RegisterCatalogType("hf", newHfCatalog); err != nil {
+		panic(err)
+	}
+}

catalog/internal/catalog/hf_catalog_test.go

@@ -0,0 +1,174 @@
+package catalog
+
+import (
+	"context"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"github.com/kubeflow/model-registry/catalog/pkg/openapi"
+)
+
+func TestNewHfCatalog_MissingAPIKey(t *testing.T) {
+	source := &CatalogSourceConfig{
+		CatalogSource: openapi.CatalogSource{
+			Id:   "test_hf",
+			Name: "Test HF",
+		},
+		Type: "hf",
+		Properties: map[string]any{
+			"url": "https://huggingface.co",
+		},
+	}
+
+	_, err := newHfCatalog(source)
+	if err == nil {
+		t.Fatal("Expected error for missing API key, got nil")
+	}
+	if err.Error() != "missing or invalid 'apiKey' property for HuggingFace catalog" {
+		t.Fatalf("Expected specific error message, got: %s", err.Error())
+	}
+}
+
+func TestNewHfCatalog_WithValidCredentials(t *testing.T) {
+	// Create mock server that returns valid response for credential validation
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		// Check for authorization header
+		auth := r.Header.Get("Authorization")
+		if auth != "Bearer test-api-key" {
+			w.WriteHeader(http.StatusUnauthorized)
+			return
+		}
+
+		switch r.URL.Path {
+		case "/api/whoami-v2":
+			w.Header().Set("Content-Type", "application/json")
+			w.WriteHeader(http.StatusOK)
+			w.Write([]byte(`{"name": "test-user", "type": "user"}`))
+		default:
+			w.WriteHeader(http.StatusNotFound)
+		}
+	}))
+	defer server.Close()
+
+	source := &CatalogSourceConfig{
+		CatalogSource: openapi.CatalogSource{
+			Id:   "test_hf",
+			Name: "Test HF",
+		},
+		Type: "hf",
+		Properties: map[string]any{
+			"apiKey":     "test-api-key",
+			"url":        server.URL,
+			"modelLimit": 10,
+		},
+	}
+
+	catalog, err := newHfCatalog(source)
+	if err != nil {
+		t.Fatalf("Failed to create HF catalog: %v", err)
+	}
+
+	hfCatalog := catalog.(*hfCatalogImpl)
+
+	// Test that methods return appropriate responses for stub implementation
+	ctx := context.Background()
+
+	// Test GetModel - should return not implemented error
+	model, err := hfCatalog.GetModel(ctx, "test-model")
+	if err == nil {
+		t.Fatal("Expected not implemented error, got nil")
+	}
+	if model != nil {
+		t.Fatal("Expected nil model, got non-nil")
+	}
+
+	// Test ListModels - should return empty list
+	listParams := ListModelsParams{
+		Query:     "",
+		OrderBy:   openapi.ORDERBYFIELD_NAME,
+		SortOrder: openapi.SORTORDER_ASC,
+	}
+	modelList, err := hfCatalog.ListModels(ctx, listParams)
+	if err != nil {
+		t.Fatalf("Failed to list models: %v", err)
+	}
+	if len(modelList.Items) != 0 {
+		t.Fatalf("Expected 0 models, got %d", len(modelList.Items))
+	}
+
+	// Test GetArtifacts - should return empty list
+	artifacts, err := hfCatalog.GetArtifacts(ctx, "test-model")
+	if err != nil {
+		t.Fatalf("Failed to get artifacts: %v", err)
+	}
+	if artifacts == nil {
+		t.Fatal("Expected artifacts list, got nil")
+	}
+	if len(artifacts.Items) != 0 {
+		t.Fatalf("Expected 0 artifacts, got %d", len(artifacts.Items))
+	}
+}
+
+func TestNewHfCatalog_InvalidCredentials(t *testing.T) {
+	// Create mock server that returns 401
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusUnauthorized)
+	}))
+	defer server.Close()
+
+	source := &CatalogSourceConfig{
+		CatalogSource: openapi.CatalogSource{
+			Id:   "test_hf",
+			Name: "Test HF",
+		},
+		Type: "hf",
+		Properties: map[string]any{
+			"apiKey": "invalid-key",
+			"url":    server.URL,
+		},
+	}
+
+	_, err := newHfCatalog(source)
+	if err == nil {
+		t.Fatal("Expected error for invalid credentials, got nil")
+	}
+	if !strings.Contains(err.Error(), "invalid HuggingFace API credentials") {
+		t.Fatalf("Expected credential validation error, got: %s", err.Error())
+	}
+}
+
+func TestNewHfCatalog_DefaultConfiguration(t *testing.T) {
+	// Create mock server for default HuggingFace URL
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusOK)
+		w.Write([]byte(`{"name": "test-user"}`))
+	}))
+	defer server.Close()
+
+	source := &CatalogSourceConfig{
+		CatalogSource: openapi.CatalogSource{
+			Id:   "test_hf",
+			Name: "Test HF",
+		},
+		Type: "hf",
+		Properties: map[string]any{
+			"apiKey": "test-key",
+			"url":    server.URL, // Override default for testing
+		},
+	}
+
+	catalog, err := newHfCatalog(source)
+	if err != nil {
+		t.Fatalf("Failed to create HF catalog with defaults: %v", err)
+	}
+
+	hfCatalog := catalog.(*hfCatalogImpl)
+	if hfCatalog.apiKey != "test-key" {
+		t.Fatalf("Expected apiKey 'test-key', got '%s'", hfCatalog.apiKey)
+	}
+	if hfCatalog.baseURL != server.URL {
+		t.Fatalf("Expected baseURL '%s', got '%s'", server.URL, hfCatalog.baseURL)
+	}
+}

catalog/internal/catalog/monitor.go

@@ -0,0 +1,238 @@
+package catalog
+
+import (
+	"fmt"
+	"hash/crc32"
+	"io"
+	"os"
+	"path/filepath"
+	"sync"
+	"sync/atomic"
+
+	"github.com/fsnotify/fsnotify"
+	"github.com/golang/glog"
+)
+
+// monitor sends events when the contents of a file have changed.
+//
+// Unfortunately, simply watching the file misses events for our primary case
+// of k8s mounted configmaps because the files we're watching are actually
+// symlinks which aren't modified:
+//
+//	drwxrwxrwx    1 root     root           138 Jul  2 15:45 .
+//	drwxr-xr-x    1 root     root           116 Jul  2 15:52 ..
+//	drwxr-xr-x    1 root     root            62 Jul  2 15:45 ..2025_07_02_15_45_09.2837733502
+//	lrwxrwxrwx    1 root     root            32 Jul  2 15:45 ..data -> ..2025_07_02_15_45_09.2837733502
+//	lrwxrwxrwx    1 root     root            26 Jul  2 13:18 sample-catalog.yaml -> ..data/sample-catalog.yaml
+//	lrwxrwxrwx    1 root     root            19 Jul  2 13:18 sources.yaml -> ..data/sources.yaml
+//
+// Updates are written to a new directory and the ..data symlink is updated. No
+// fsnotify events will ever be triggered for the YAML files.
+//
+// The approach taken here is to watch the directory containing the file for
+// any change and then hash the contents of the file to avoid false-positives.
+type monitor struct {
+	watcher *fsnotify.Watcher
+	closed  <-chan struct{}
+
+	recordsMu sync.RWMutex
+	records   map[string]map[string]*monitorRecord
+}
+
+var _monitor *monitor
+var initMonitor sync.Once
+
+// getMonitor returns a singleton monitor instance. Panics on failure.
+func getMonitor() *monitor {
+	initMonitor.Do(func() {
+		var err error
+		_monitor, err = newMonitor()
+		if err != nil {
+			panic(fmt.Sprintf("Unable to create file monitor: %v", err))
+		}
+	})
+	if _monitor == nil {
+		// Panic in case someone traps the panic that occurred during
+		// initialization and tries to call this again.
+		panic("Unable to get file monitor")
+	}
+
+	return _monitor
+}
+
+func newMonitor() (*monitor, error) {
+	watcher, err := fsnotify.NewWatcher()
+	if err != nil {
+		return nil, err
+	}
+
+	m := &monitor{
+		watcher: watcher,
+		records: map[string]map[string]*monitorRecord{},
+	}
+
+	go m.monitor()
+	return m, nil
+}
+
+// Close stops the monitor and waits for the background goroutine to exit.
+//
+// All channels returned by Path() will be closed.
+func (m *monitor) Close() {
+	select {
+	case <-m.closed:
+		// Already closed, nothing to do.
+		return
+	default:
+		// Fallthrough
+	}
+
+	m.watcher.Close()
+	<-m.closed
+
+	m.recordsMu.Lock()
+	defer m.recordsMu.Unlock()
+
+	uniqCh := make(map[chan<- struct{}]struct{})
+	for dir := range m.records {
+		for file := range m.records[dir] {
+			record, ok := m.records[dir][file]
+			if !ok {
+				continue
+			}
+			for _, ch := range record.channels {
+				uniqCh[ch] = struct{}{}
+			}
+		}
+	}
+	for ch := range uniqCh {
+		close(ch)
+	}
+	m.records = nil
+}
+
+// Path returns a channel that receives an event when the contents of a file
+// change. The file does not need to exist before calling this method, however
+// the provided path should only be a file or a symlink (not a directory,
+// device, etc.). The returned channel will be closed when the monitor is
+// closed.
+func (m *monitor) Path(p string) (<-chan struct{}, error) {
+	absPath, err := filepath.Abs(p)
+	if err != nil {
+		return nil, fmt.Errorf("abs: %w", err)
+	}
+
+	m.recordsMu.Lock()
+	defer m.recordsMu.Unlock()
+
+	dir, base := filepath.Split(absPath)
+	dir = filepath.Clean(dir)
+
+	err = m.watcher.Add(dir)
+	if err != nil {
+		return nil, fmt.Errorf("unable to watch directory %q: %w", dir, err)
+	}
+
+	if _, exists := m.records[dir]; !exists {
+		m.records[dir] = make(map[string]*monitorRecord, 1)
+	}
+
+	ch := make(chan struct{}, 1)
+
+	if _, exists := m.records[dir][base]; !exists {
+		m.records[dir][base] = &monitorRecord{
+			channels: []chan<- struct{}{ch},
+		}
+	} else {
+		r := m.records[dir][base]
+		r.channels = append(r.channels, ch)
+	}
+	m.records[dir][base].updateHash(filepath.Join(dir, base))
+
+	return ch, nil
+}
+
+func (m *monitor) monitor() {
+	closed := make(chan struct{})
+	m.closed = closed
+	defer close(closed)
+
+	for {
+		select {
+		case err, ok := <-m.watcher.Errors:
+			if !ok {
+				return
+			}
+
+			glog.Errorf("fsnotify error: %v", err)
+		case e, ok := <-m.watcher.Events:
+			if !ok {
+				return
+			}
+
+			glog.V(2).Infof("fsnotify.Event: %v", e)
+
+			switch e.Op {
+			case fsnotify.Create, fsnotify.Write:
+				// Fallthrough
+			default:
+				// Ignore fsnotify.Remove, fsnotify.Rename and fsnotify.Chmod
+				continue
+			}
+
+			func() {
+				m.recordsMu.RLock()
+				defer m.recordsMu.RUnlock()
+
+				dir := filepath.Dir(e.Name)
+
+				dc := m.records[dir]
+				if dc == nil {
+					return
+				}
+
+				for base, record := range dc {
+					path := filepath.Join(dir, base)
+					if !record.updateHash(path) {
+						continue
+					}
+					for _, ch := range record.channels {
+						// Send the event, ignore any that would block.
+						select {
+						case ch <- struct{}{}:
+						default:
+							glog.Errorf("monitor: missed event for path %s", path)
+						}
+					}
+				}
+			}()
+		}
+	}
+}
+
+type monitorRecord struct {
+	channels []chan<- struct{}
+	hash     uint32
+}
+
+// updateHash recalculates the hash and returns true if it has changed.
+func (mr *monitorRecord) updateHash(path string) bool {
+	newHash := mr.calculateHash(path)
+	oldHash := atomic.SwapUint32(&mr.hash, newHash)
+	return oldHash != newHash
+}
+
+func (monitorRecord) calculateHash(path string) uint32 {
+	fh, err := os.Open(path)
+	if err != nil {
+		return 0
+	}
+	defer fh.Close()
+
+	h := crc32.NewIEEE()
+	_, err = io.Copy(h, fh)
+	if err != nil {
+		return 0
+	}
+	return h.Sum32()
+}

catalog/internal/catalog/monitor_test.go

@@ -0,0 +1,179 @@
+package catalog
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestMonitor(t *testing.T) {
+	assert := assert.New(t)
+
+	mon, err := newMonitor()
+	if !assert.NoError(err) {
+		return
+	}
+
+	tmpDir := t.TempDir()
+	fileA := filepath.Join(tmpDir, "a")
+	fileB := filepath.Join(tmpDir, "b")
+	fileC := filepath.Join(tmpDir, "c")
+
+	_watchMonitor := func(ch <-chan struct{}, err error) *monitorWatcher {
+		if err != nil {
+			t.Fatalf("watchMonitor passed error %v", err)
+		}
+		return watchMonitor(ch)
+	}
+
+	a := _watchMonitor(mon.Path(fileA))
+	b := _watchMonitor(mon.Path(fileB))
+
+	updateFile(t, fileA)
+	a.AssertCount(t, 1)
+	b.AssertCount(t, 0, "unchanged file should not have any events")
+
+	a.Reset()
+	updateFile(t, fileB)
+	b.AssertCount(t, 1)
+	updateFile(t, fileB)
+	b.AssertCount(t, 2)
+	a.AssertCount(t, 0, "unchanged file should not have any events")
+
+	b.Reset()
+	updateFile(t, fileC)
+	a.AssertCount(t, 0, "unchanged file should not have an event")
+	b.AssertCount(t, 0, "unchanged file should not have an event")
+
+	// Ensure that Close doesn't hang.
+	finished := make(chan struct{})
+	go func() {
+		defer close(finished)
+		mon.Close()
+	}()
+	assert.Eventually(func() bool {
+		select {
+		case <-finished:
+			return true
+		default:
+			return false
+		}
+	}, time.Second, 50*time.Millisecond)
+
+	// Verify that the monitor channels closed.
+	assert.True(a.Done())
+	assert.True(b.Done())
+}
+
+func TestMonitorSymlinks(t *testing.T) {
+	assert := assert.New(t)
+
+	tmpDir := t.TempDir()
+	mon, err := newMonitor()
+	if !assert.NoError(err) {
+		return
+	}
+	defer mon.Close()
+
+	// Watch the files on the published path.
+	_watchMonitor := func(ch <-chan struct{}, err error) *monitorWatcher {
+		if err != nil {
+			t.Fatalf("watchMonitor passed error %v", err)
+		}
+		return watchMonitor(ch)
+	}
+
+	a := _watchMonitor(mon.Path(filepath.Join(tmpDir, "a")))
+	b := _watchMonitor(mon.Path(filepath.Join(tmpDir, "b")))
+
+	// Set up a directory structure with symlinks like k8s does for mounted
+	// configmaps.
+	// a -> latest/a, b -> latest/b, latest -> v1
+	assert.NoError(os.Mkdir(filepath.Join(tmpDir, "v1"), 0777))
+	updateFile(t, filepath.Join(tmpDir, "v1", "a"), "foo")
+	updateFile(t, filepath.Join(tmpDir, "v1", "b"), "bar")
+	assert.NoError(os.Symlink("v1", filepath.Join(tmpDir, "latest")))
+	assert.NoError(os.Symlink(filepath.Join("latest", "a"), filepath.Join(tmpDir, "a")))
+	assert.NoError(os.Symlink(filepath.Join("latest", "b"), filepath.Join(tmpDir, "b")))
+
+	a.AssertCount(t, 1)
+	b.AssertCount(t, 1)
+	a.Reset()
+	b.Reset()
+
+	// Make a new version directory
+	os.Mkdir(filepath.Join(tmpDir, "v2"), 0777)
+	updateFile(t, filepath.Join(tmpDir, "v2", "a"), "UPDATED")
+	updateFile(t, filepath.Join(tmpDir, "v2", "b"), "bar")
+
+	a.AssertCount(t, 0)
+	b.AssertCount(t, 0)
+	a.Reset()
+	b.Reset()
+
+	// Update the symlink to point to the new version:
+	assert.NoError(os.Rename(filepath.Join(tmpDir, "latest"), filepath.Join(tmpDir, "latest_tmp")))
+	assert.NoError(os.Symlink(filepath.Join("v2"), filepath.Join(tmpDir, "latest")))
+	assert.NoError(os.Remove(filepath.Join(tmpDir, "latest_tmp")))
+	assert.NoError(os.RemoveAll(filepath.Join(tmpDir, "v1")))
+
+	a.AssertCount(t, 1)
+	b.AssertCount(t, 0)
+}
+
+type monitorWatcher struct {
+	count int32
+	done  int32
+}
+
+func (mw *monitorWatcher) Reset() {
+	atomic.StoreInt32(&mw.count, 0)
+}
+
+func (mw *monitorWatcher) AssertCount(t *testing.T, expected int, args ...any) bool {
+	t.Helper()
+	return assert.Eventually(t, func() bool {
+		return int(atomic.LoadInt32(&mw.count)) == expected
+	}, time.Second, 10*time.Millisecond, args...)
+}
+
+func (mw *monitorWatcher) Count() int {
+	return int(atomic.LoadInt32(&mw.count))
+}
+
+func (mw *monitorWatcher) Done() bool {
+	return atomic.LoadInt32(&mw.done) != 0
+}
+
+func watchMonitor(ch <-chan struct{}) *monitorWatcher {
+	mw := &monitorWatcher{}
+
+	go func() {
+		defer atomic.StoreInt32(&mw.done, 1)
+		for range ch {
+			atomic.AddInt32(&mw.count, 1)
+		}
+	}()
+
+	return mw
+}
+
+func updateFile(t *testing.T, path string, contents ...string) {
+	fh, err := os.Create(path)
+	if err != nil {
+		t.Fatalf("unable to open %q: %v", path, err)
+	}
+	if len(contents) == 0 {
+		fmt.Fprintf(fh, "%s\n", time.Now())
+	} else {
+		for _, line := range contents {
+			fmt.Fprintf(fh, "%s\n", line)
+		}
+	}
+	fh.Close()
+}

catalog/internal/catalog/rhec_catalog.go

@@ -0,0 +1,334 @@
+package catalog
+
+import (
+	"context"
+	"fmt"
+	"math"
+	"net/http"
+	"sort"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/Khan/genqlient/graphql"
+	"github.com/kubeflow/model-registry/catalog/internal/catalog/genqlient"
+	"github.com/kubeflow/model-registry/catalog/pkg/openapi"
+	model "github.com/kubeflow/model-registry/catalog/pkg/openapi"
+	models "github.com/kubeflow/model-registry/catalog/pkg/openapi"
+)
+
+type rhecModel struct {
+	models.CatalogModel `yaml:",inline"`
+	Artifacts           []*openapi.CatalogModelArtifact `yaml:"artifacts"`
+}
+
+// rhecCatalogConfig defines the structure of the RHEC catalog configuration.
+type rhecCatalogConfig struct {
+	Models         []string `yaml:"models"`
+	ExcludedModels []string `yaml:"excludedModels"`
+}
+
+type rhecCatalogImpl struct {
+	modelsLock sync.RWMutex
+	models     map[string]*rhecModel
+}
+
+var _ CatalogSourceProvider = &rhecCatalogImpl{}
+
+func (r *rhecCatalogImpl) GetModel(ctx context.Context, name string) (*openapi.CatalogModel, error) {
+	r.modelsLock.RLock()
+	defer r.modelsLock.RUnlock()
+
+	rm := r.models[name]
+	if rm == nil {
+		return nil, nil
+	}
+	cp := rm.CatalogModel
+	return &cp, nil
+}
+
+func (r *rhecCatalogImpl) ListModels(ctx context.Context, params ListModelsParams) (openapi.CatalogModelList, error) {
+	r.modelsLock.RLock()
+	defer r.modelsLock.RUnlock()
+
+	var filteredModels []*model.CatalogModel
+	for _, rm := range r.models {
+		cm := rm.CatalogModel
+		if params.Query != "" {
+			query := strings.ToLower(params.Query)
+			// Check if query matches name, description, tasks, provider, or libraryName
+			if !strings.Contains(strings.ToLower(cm.Name), query) &&
+				!strings.Contains(strings.ToLower(cm.GetDescription()), query) &&
+				!strings.Contains(strings.ToLower(cm.GetProvider()), query) &&
+				!strings.Contains(strings.ToLower(cm.GetLibraryName()), query) {
+
+				// Check tasks
+				foundInTasks := false
+				for _, task := range cm.GetTasks() { // Use GetTasks() for nil safety
+					if strings.Contains(strings.ToLower(task), query) {
+						foundInTasks = true
+						break
+					}
+				}
+				if !foundInTasks {
+					continue // Skip if no match in any searchable field
+				}
+			}
+		}
+		filteredModels = append(filteredModels, &cm)
+	}
+
+	// Sort the filtered models
+	sort.Slice(filteredModels, func(i, j int) bool {
+		a := filteredModels[i]
+		b := filteredModels[j]
+
+		var less bool
+		switch params.OrderBy {
+		case model.ORDERBYFIELD_CREATE_TIME:
+			// Convert CreateTimeSinceEpoch (string) to int64 for comparison
+			// Handle potential nil or conversion errors by treating as 0
+			aTime, _ := strconv.ParseInt(a.GetCreateTimeSinceEpoch(), 10, 64)
+			bTime, _ := strconv.ParseInt(b.GetCreateTimeSinceEpoch(), 10, 64)
+			less = aTime < bTime
+		case model.ORDERBYFIELD_LAST_UPDATE_TIME:
+			// Convert LastUpdateTimeSinceEpoch (string) to int64 for comparison
+			// Handle potential nil or conversion errors by treating as 0
+			aTime, _ := strconv.ParseInt(a.GetLastUpdateTimeSinceEpoch(), 10, 64)
+			bTime, _ := strconv.ParseInt(b.GetLastUpdateTimeSinceEpoch(), 10, 64)
+			less = aTime < bTime
+		case model.ORDERBYFIELD_NAME:
+			fallthrough
+		default:
+			// Fallback to name sort if an unknown sort field is provided
+			less = strings.Compare(a.Name, b.Name) < 0
+		}
+
+		if params.SortOrder == model.SORTORDER_DESC {
+			return !less
+		}
+		return less
+	})
+
+	count := len(filteredModels)
+	if count > math.MaxInt32 {
+		count = math.MaxInt32
+	}
+
+	list := model.CatalogModelList{
+		Items:    make([]model.CatalogModel, count),
+		PageSize: int32(count),
+		Size:     int32(count),
+	}
+	for i := range list.Items {
+		list.Items[i] = *filteredModels[i]
+	}
+	return list, nil // Return the struct value directly
+}
+
+func (r *rhecCatalogImpl) GetArtifacts(ctx context.Context, name string) (*openapi.CatalogModelArtifactList, error) {
+	r.modelsLock.RLock()
+	defer r.modelsLock.RUnlock()
+
+	rm := r.models[name]
+	if rm == nil {
+		return nil, nil
+	}
+
+	count := len(rm.Artifacts)
+	if count > math.MaxInt32 {
+		count = math.MaxInt32
+	}
+
+	list := openapi.CatalogModelArtifactList{
+		Items:    make([]openapi.CatalogModelArtifact, count),
+		PageSize: int32(count),
+		Size:     int32(count),
+	}
+	for i := range list.Items {
+		list.Items[i] = *rm.Artifacts[i]
+	}
+	return &list, nil
+}
+
+func fetchRepository(ctx context.Context, client graphql.Client, repository string) (*genqlient.GetRepositoryResponse, error) {
+	resp, err := genqlient.GetRepository(ctx, client, "registry.access.redhat.com", repository)
+	if err != nil {
+		return nil, fmt.Errorf("failed to query rhec repository: %w", err)
+	}
+
+	if err := resp.Get_repository_by_registry_path.Error; err.Detail != "" || err.Status != 0 {
+		return nil, fmt.Errorf("rhec repository query error: detail: %s, status: %d", err.Detail, err.Status)
+	}
+	return resp, nil
+}
+
+func fetchRepositoryImages(ctx context.Context, client graphql.Client, repository string) ([]genqlient.FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponseDataContainerImage, error) {
+	resp, err := genqlient.FindRepositoryImages(ctx, client, "registry.access.redhat.com", repository)
+	if err != nil {
+		return nil, fmt.Errorf("failed to query rhec images: %w", err)
+	}
+
+	if err := resp.Find_repository_images_by_registry_path.Error; err.Detail != "" || err.Status != 0 {
+		return nil, fmt.Errorf("rhec images query error: detail: %s, status: %d", err.Detail, err.Status)
+	}
+	return resp.Find_repository_images_by_registry_path.Data, nil
+}
+
+func newRhecModel(repoData *genqlient.GetRepositoryResponse, imageData genqlient.FindRepositoryImagesFind_repository_images_by_registry_pathContainerImagePaginatedResponseDataContainerImage, imageTagName, repositoryName string) *rhecModel {
+
+	sourceId := "rhec"
+	createTime := repoData.Get_repository_by_registry_path.Data.Creation_date.Format(time.RFC3339)
+	lastUpdateTime := repoData.Get_repository_by_registry_path.Data.Last_update_date.Format(time.RFC3339)
+	description := repoData.Get_repository_by_registry_path.Data.Display_data.Short_description
+	readme := repoData.Get_repository_by_registry_path.Data.Display_data.Long_description
+	provider := repoData.Get_repository_by_registry_path.Data.Vendor_label
+
+	var maturity *string
+	if len(repoData.Get_repository_by_registry_path.Data.Release_categories) > 0 {
+		maturityStr := repoData.Get_repository_by_registry_path.Data.Release_categories[0]
+		maturity = &maturityStr
+	}
+
+	var tasks []string
+	for _, label := range imageData.Parsed_data.Labels {
+		tasks = append(tasks, label.Value)
+	}
+	imageCreationDate := imageData.Creation_date.Format(time.RFC3339)
+	imageLastUpdateDate := imageData.Last_update_date.Format(time.RFC3339)
+
+	modelName := repositoryName + ":" + imageTagName
+
+	return &rhecModel{
+		CatalogModel: openapi.CatalogModel{
+			Name:                     modelName,
+			CreateTimeSinceEpoch:     &createTime,
+			LastUpdateTimeSinceEpoch: &lastUpdateTime,
+			Description:              &description,
+			Readme:                   &readme,
+			Maturity:                 maturity,
+			Language:                 []string{},
+			Tasks:                    tasks,
+			Provider:                 &provider,
+			Logo:                     nil,
+			License:                  nil,
+			LicenseLink:              nil,
+			LibraryName:              nil,
+			SourceId:                 &sourceId,
+		},
+		Artifacts: []*openapi.CatalogModelArtifact{
+			{
+				Uri:                      "oci://registry.redhat.io/" + repositoryName + ":" + imageTagName,
+				CreateTimeSinceEpoch:     &imageCreationDate,
+				LastUpdateTimeSinceEpoch: &imageLastUpdateDate,
+			},
+		},
+	}
+}
+
+func (r *rhecCatalogImpl) load(modelsList []string, excludedModelsList []string) error {
+	graphqlClient := graphql.NewClient("https://catalog.redhat.com/api/containers/graphql/", http.DefaultClient)
+	ctx := context.Background()
+
+	models := make(map[string]*rhecModel)
+	for _, repo := range modelsList {
+		repoData, err := fetchRepository(ctx, graphqlClient, repo)
+		if err != nil {
+			return err
+		}
+
+		imagesData, err := fetchRepositoryImages(ctx, graphqlClient, repo)
+		if err != nil {
+			return err
+		}
+
+		for _, image := range imagesData {
+			for _, imageRepository := range image.Repositories {
+				for _, imageTag := range imageRepository.Tags {
+					tagName := imageTag.Name
+					fullModelName := repo + ":" + tagName
+
+					if isModelExcluded(fullModelName, excludedModelsList) {
+						continue
+					}
+
+					model := newRhecModel(repoData, image, tagName, repo)
+					models[fullModelName] = model
+				}
+			}
+		}
+	}
+
+	r.modelsLock.Lock()
+	defer r.modelsLock.Unlock()
+	r.models = models
+
+	return nil
+}
+
+func isModelExcluded(modelName string, patterns []string) bool {
+	for _, pattern := range patterns {
+		if strings.HasSuffix(pattern, "*") {
+			if strings.HasPrefix(modelName, strings.TrimSuffix(pattern, "*")) {
+				return true
+			}
+		} else if modelName == pattern {
+			return true
+		}
+	}
+	return false
+}
+
+func newRhecCatalog(source *CatalogSourceConfig) (CatalogSourceProvider, error) {
+	modelsData, ok := source.Properties["models"]
+	if !ok {
+		return nil, fmt.Errorf("missing 'models' property for rhec catalog")
+	}
+
+	modelsList, ok := modelsData.([]any)
+	if !ok {
+		return nil, fmt.Errorf("'models' property should be a list")
+	}
+
+	models := make([]string, len(modelsList))
+	for i, v := range modelsList {
+		models[i], ok = v.(string)
+		if !ok {
+			return nil, fmt.Errorf("invalid entry in 'models' list, expected a string")
+		}
+	}
+
+	// Excluded models is an optional source property.
+	var excludedModels []string
+	if excludedModelsData, ok := source.Properties["excludedModels"]; ok {
+		excludedModelsList, ok := excludedModelsData.([]any)
+		if !ok {
+			return nil, fmt.Errorf("'excludedModels' property should be a list")
+		}
+		excludedModels = make([]string, len(excludedModelsList))
+		for i, v := range excludedModelsList {
+			excludedModels[i], ok = v.(string)
+			if !ok {
+				return nil, fmt.Errorf("invalid entry in 'excludedModels' list, expected a string")
+			}
+		}
+	}
+
+	r := &rhecCatalogImpl{
+		models: make(map[string]*rhecModel),
+	}
+
+	err := r.load(models, excludedModels)
+	if err != nil {
+		return nil, fmt.Errorf("error loading rhec catalog: %w", err)
+	}
+
+	return r, nil
+}
+
+func init() {
+	if err := RegisterCatalogType("rhec", newRhecCatalog); err != nil {
+		panic(err)
+	}
+}

catalog/internal/catalog/rhec_catalog_test.go

@@ -0,0 +1,393 @@
+package catalog
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/google/go-cmp/cmp"
+	"github.com/kubeflow/model-registry/catalog/pkg/openapi"
+	model "github.com/kubeflow/model-registry/catalog/pkg/openapi"
+)
+
+func TestRhecCatalogImpl_GetModel(t *testing.T) {
+	modelTime := time.Now()
+	createTime := modelTime.Format(time.RFC3339)
+	lastUpdateTime := modelTime.Add(5 * time.Minute).Format(time.RFC3339)
+	sourceId := "rhec"
+	provider := "redhat"
+
+	testModels := map[string]*rhecModel{
+		"model1": {
+			CatalogModel: openapi.CatalogModel{
+				Name:                     "model1",
+				CreateTimeSinceEpoch:     &createTime,
+				LastUpdateTimeSinceEpoch: &lastUpdateTime,
+				Provider:                 &provider,
+				SourceId:                 &sourceId,
+			},
+			Artifacts: []*openapi.CatalogModelArtifact{},
+		},
+	}
+
+	r := &rhecCatalogImpl{
+		models: testModels,
+	}
+
+	tests := []struct {
+		name      string
+		modelName string
+		want      *openapi.CatalogModel
+		wantErr   bool
+	}{
+		{
+			name:      "get existing model",
+			modelName: "model1",
+			want: &openapi.CatalogModel{
+				Name:                     "model1",
+				CreateTimeSinceEpoch:     &createTime,
+				LastUpdateTimeSinceEpoch: &lastUpdateTime,
+				Provider:                 &provider,
+				SourceId:                 &sourceId,
+			},
+			wantErr: false,
+		},
+		{
+			name:      "get non-existent model",
+			modelName: "not-exist",
+			want:      nil,
+			wantErr:   false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := r.GetModel(context.Background(), tt.modelName)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("GetModel() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if diff := cmp.Diff(tt.want, got); diff != "" {
+				t.Errorf("GetModel() mismatch (-want +got):\n%s", diff)
+			}
+		})
+	}
+}
+
+func TestRhecCatalogImpl_GetArtifacts(t *testing.T) {
+	modelTime := time.Now()
+	createTime := modelTime.Format(time.RFC3339)
+	lastUpdateTime := modelTime.Add(5 * time.Minute).Format(time.RFC3339)
+	sourceId := "rhec"
+	provider := "redhat"
+	artifactCreateTime := modelTime.Add(10 * time.Minute).Format(time.RFC3339)
+	artifactLastUpdateTime := modelTime.Add(15 * time.Minute).Format(time.RFC3339)
+
+	testModels := map[string]*rhecModel{
+		"model1": {
+			CatalogModel: openapi.CatalogModel{
+				Name:                     "model1",
+				CreateTimeSinceEpoch:     &createTime,
+				LastUpdateTimeSinceEpoch: &lastUpdateTime,
+				Provider:                 &provider,
+				SourceId:                 &sourceId,
+			},
+			Artifacts: []*openapi.CatalogModelArtifact{
+				{
+					Uri:                      "test-uri",
+					CreateTimeSinceEpoch:     &artifactCreateTime,
+					LastUpdateTimeSinceEpoch: &artifactLastUpdateTime,
+				},
+			},
+		},
+		"model2-no-artifacts": {
+			CatalogModel: openapi.CatalogModel{
+				Name:                     "model2-no-artifacts",
+				CreateTimeSinceEpoch:     &createTime,
+				LastUpdateTimeSinceEpoch: &lastUpdateTime,
+				Provider:                 &provider,
+				SourceId:                 &sourceId,
+			},
+			Artifacts: []*openapi.CatalogModelArtifact{},
+		},
+	}
+
+	r := &rhecCatalogImpl{
+		models: testModels,
+	}
+
+	tests := []struct {
+		name      string
+		modelName string
+		want      *openapi.CatalogModelArtifactList
+		wantErr   bool
+	}{
+		{
+			name:      "get artifacts for existing model",
+			modelName: "model1",
+			want: &openapi.CatalogModelArtifactList{
+				Items: []openapi.CatalogModelArtifact{
+					{
+						Uri:                      "test-uri",
+						CreateTimeSinceEpoch:     &artifactCreateTime,
+						LastUpdateTimeSinceEpoch: &artifactLastUpdateTime,
+					},
+				},
+				PageSize: 1,
+				Size:     1,
+			},
+			wantErr: false,
+		},
+		{
+			name:      "get artifacts for model with no artifacts",
+			modelName: "model2-no-artifacts",
+			want: &openapi.CatalogModelArtifactList{
+				Items:    []openapi.CatalogModelArtifact{},
+				PageSize: 0,
+				Size:     0,
+			},
+			wantErr: false,
+		},
+		{
+			name:      "get artifacts for non-existent model",
+			modelName: "not-exist",
+			want:      nil,
+			wantErr:   false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := r.GetArtifacts(context.Background(), tt.modelName)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("GetArtifacts() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if diff := cmp.Diff(tt.want, got); diff != "" {
+				t.Errorf("GetArtifacts() mismatch (-want +got):\n%s", diff)
+			}
+		})
+	}
+}
+
+func TestRhecCatalogListModels(t *testing.T) {
+	modelTime := time.Now()
+	createTime := modelTime.Format(time.RFC3339)
+	lastUpdateTime := modelTime.Add(5 * time.Minute).Format(time.RFC3339)
+	sourceId := "rhec"
+	provider := "redhat"
+	artifactCreateTime := modelTime.Add(10 * time.Minute).Format(time.RFC3339)
+	artifactLastUpdateTime := modelTime.Add(15 * time.Minute).Format(time.RFC3339)
+
+	testModels := map[string]*rhecModel{
+		"model3": {
+			CatalogModel: openapi.CatalogModel{
+				Name:                     "model3",
+				CreateTimeSinceEpoch:     &createTime,
+				LastUpdateTimeSinceEpoch: &lastUpdateTime,
+				Provider:                 &provider,
+				SourceId:                 &sourceId,
+			},
+			Artifacts: []*openapi.CatalogModelArtifact{
+				{
+					Uri:                      "test-uri",
+					CreateTimeSinceEpoch:     &artifactCreateTime,
+					LastUpdateTimeSinceEpoch: &artifactLastUpdateTime,
+				},
+			},
+		},
+		"model1": {
+			CatalogModel: openapi.CatalogModel{
+				Name:                     "model1",
+				CreateTimeSinceEpoch:     &createTime,
+				LastUpdateTimeSinceEpoch: &lastUpdateTime,
+				Provider:                 &provider,
+				SourceId:                 &sourceId,
+			},
+			Artifacts: []*openapi.CatalogModelArtifact{
+				{
+					Uri:                      "test-uri",
+					CreateTimeSinceEpoch:     &artifactCreateTime,
+					LastUpdateTimeSinceEpoch: &artifactLastUpdateTime,
+				},
+			},
+		},
+		"model1:v2": {
+			CatalogModel: openapi.CatalogModel{
+				Name:                     "model1:v2",
+				CreateTimeSinceEpoch:     &createTime,
+				LastUpdateTimeSinceEpoch: &lastUpdateTime,
+				Provider:                 &provider,
+				SourceId:                 &sourceId,
+			},
+			Artifacts: []*openapi.CatalogModelArtifact{
+				{
+					Uri:                      "test-uri",
+					CreateTimeSinceEpoch:     &artifactCreateTime,
+					LastUpdateTimeSinceEpoch: &artifactLastUpdateTime,
+				},
+			},
+		},
+		"model2": {
+			CatalogModel: openapi.CatalogModel{
+				Name:                     "model2",
+				CreateTimeSinceEpoch:     &createTime,
+				LastUpdateTimeSinceEpoch: &lastUpdateTime,
+				Provider:                 &provider,
+				SourceId:                 &sourceId,
+			},
+			Artifacts: []*openapi.CatalogModelArtifact{},
+		},
+	}
+
+	r := &rhecCatalogImpl{
+		models: testModels,
+	}
+
+	tests := []struct {
+		name      string
+		modelName string
+		params    ListModelsParams
+		want      openapi.CatalogModelList
+		wantErr   bool
+	}{
+		{
+			name: "list models and sort order",
+			want: openapi.CatalogModelList{
+				Items: []openapi.CatalogModel{
+					{
+						Name:                     "model1",
+						CreateTimeSinceEpoch:     &createTime,
+						LastUpdateTimeSinceEpoch: &lastUpdateTime,
+						Provider:                 &provider,
+						SourceId:                 &sourceId,
+					},
+					{
+						Name:                     "model1:v2",
+						CreateTimeSinceEpoch:     &createTime,
+						LastUpdateTimeSinceEpoch: &lastUpdateTime,
+						Provider:                 &provider,
+						SourceId:                 &sourceId,
+					},
+					{
+						Name:                     "model2",
+						CreateTimeSinceEpoch:     &createTime,
+						LastUpdateTimeSinceEpoch: &lastUpdateTime,
+						Provider:                 &provider,
+						SourceId:                 &sourceId,
+					},
+					{
+						Name:                     "model3",
+						CreateTimeSinceEpoch:     &createTime,
+						LastUpdateTimeSinceEpoch: &lastUpdateTime,
+						Provider:                 &provider,
+						SourceId:                 &sourceId,
+					},
+				},
+				PageSize: 4,
+				Size:     4,
+			},
+			wantErr: false,
+		},
+		{
+			name:      "list models with query and sort order",
+			modelName: "model1",
+			params: ListModelsParams{
+				Query:     "model1",
+				OrderBy:   model.ORDERBYFIELD_NAME,
+				SortOrder: model.SORTORDER_ASC,
+			},
+			want: openapi.CatalogModelList{
+				Items: []openapi.CatalogModel{
+					{
+						Name:                     "model1",
+						CreateTimeSinceEpoch:     &createTime,
+						LastUpdateTimeSinceEpoch: &lastUpdateTime,
+						Provider:                 &provider,
+						SourceId:                 &sourceId,
+					},
+					{
+						Name:                     "model1:v2",
+						CreateTimeSinceEpoch:     &createTime,
+						LastUpdateTimeSinceEpoch: &lastUpdateTime,
+						Provider:                 &provider,
+						SourceId:                 &sourceId,
+					},
+				},
+				PageSize: 2,
+				Size:     2,
+			},
+			wantErr: false,
+		},
+		{
+			name:      "get non-existent model",
+			modelName: "not-exist",
+			params: ListModelsParams{
+				Query:     "not-exist",
+				OrderBy:   model.ORDERBYFIELD_NAME,
+				SortOrder: model.SORTORDER_ASC,
+			},
+			want:    openapi.CatalogModelList{Items: []openapi.CatalogModel{}},
+			wantErr: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := r.ListModels(context.Background(), tt.params)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("ListModels() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if diff := cmp.Diff(tt.want, got); diff != "" {
+				t.Errorf("ListModels() mismatch (-want +got):\n%s", diff)
+			}
+		})
+	}
+}
+
+func TestIsModelExcluded(t *testing.T) {
+	tests := []struct {
+		name      string
+		modelName string
+		patterns  []string
+		want      bool
+	}{
+		{
+			name:      "exact match",
+			modelName: "model1:v1",
+			patterns:  []string{"model1:v1"},
+			want:      true,
+		},
+		{
+			name:      "wildcard match",
+			modelName: "model1:v2",
+			patterns:  []string{"model1:*"},
+			want:      true,
+		},
+		{
+			name:      "no match",
+			modelName: "model2:v1",
+			patterns:  []string{"model1:*"},
+			want:      false,
+		},
+		{
+			name:      "multiple patterns with match",
+			modelName: "model3:v1",
+			patterns:  []string{"model2:*", "model3:v1"},
+			want:      true,
+		},
+		{
+			name:      "empty patterns",
+			modelName: "model1:v1",
+			patterns:  []string{},
+			want:      false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := isModelExcluded(tt.modelName, tt.patterns)
+			if got != tt.want {
+				t.Errorf("isModelExcluded() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

catalog/internal/catalog/testdata/empty-catalog.yaml

@@ -0,0 +1,4 @@
+
+source: empty-catalog
+models: []
+

catalog/internal/catalog/testdata/test-catalog-sources.yaml

@@ -0,0 +1,33 @@
+catalogs:
+  - name: "Catalog 1"
+    id: catalog1
+    type: yaml
+    enabled: true
+    properties:
+      privateProp11: 54321
+      privateProp12: privateStringValue
+      yamlCatalogPath: test-yaml-catalog.yaml
+  - name: "Catalog 2"
+    id: catalog2
+    type: yaml
+    enabled: false
+    properties:
+      privateProp21: 12345
+      privateProp22: privateStringValue2
+      yamlCatalogPath: test-yaml-catalog.yaml
+  - name: "Catalog 3"
+    id: catalog3
+    type: rhec
+    enabled: true
+    properties:
+      models:
+      - rhelai1/modelcar-granite-7b-starter
+  - name: "Catalog 4"
+    id: catalog4
+    type: rhec
+    enabled: true
+    properties:
+      models:
+      - rhelai1/modelcar-granite-7b-starter
+      excludedModels:
+      - rhelai1/modelcar-granite-7b-starter:latest

catalog/internal/catalog/testdata/test-hf-catalog-sources.yaml

@@ -0,0 +1,17 @@
+catalogs:
+  - name: "HuggingFace Test Catalog"
+    id: hf_test
+    type: hf
+    enabled: true
+    properties:
+      apiKey: "hf_test_api_key_here"
+      url: "https://huggingface.co"
+      modelLimit: 50
+  - name: "HuggingFace Invalid Credentials"
+    id: hf_invalid
+    type: hf
+    enabled: false # disabled so it doesn't cause startup failures in tests
+    properties:
+      apiKey: "invalid_key"
+      url: "https://huggingface.co"
+      modelLimit: 10

catalog/internal/catalog/testdata/test-list-models-catalog.yaml

@@ -0,0 +1,40 @@
+
+source: test-list-models
+models:
+  - name: model-alpha
+    description: A model for text generation.
+    tasks: ["text-generation", "nlp"]
+    provider: IBM
+    libraryName: transformers
+    createTimeSinceEpoch: "1678886400000" # March 15, 2023 00:00:00 GMT
+  - name: model-beta
+    description: Another model for image recognition.
+    tasks: ["image-recognition"]
+    provider: Google
+    libraryName: tensorflow
+    createTimeSinceEpoch: "1681564800000" # April 15, 2023 00:00:00 GMT
+  - name: model-gamma
+    description: A specialized model for natural language processing.
+    tasks: ["nlp"]
+    provider: IBM
+    libraryName: pytorch
+    createTimeSinceEpoch: "1675209600000" # February 1, 2023 00:00:00 GMT
+  - name: another-model-alpha
+    description: A different model for text summarization.
+    tasks: ["text-summarization", "nlp"]
+    provider: Microsoft
+    libraryName: huggingface
+    createTimeSinceEpoch: "1684243200000" # May 16, 2023 00:00:00 GMT
+  - name: model-with-no-tasks
+    description: This model has no specific tasks.
+    tasks: []
+    provider: None
+    libraryName: custom
+    createTimeSinceEpoch: "1672531200000" # January 1, 2023 00:00:00 GMT
+  - name: Z-model
+    description: The last model in alphabetical order.
+    tasks: ["optimization"]
+    provider: Oracle
+    libraryName: scikit-learn
+    createTimeSinceEpoch: "1690934400000" # August 2, 2023 00:00:00 GMT
+

catalog/internal/catalog/testdata/test-yaml-catalog.yaml

@@ -0,0 +1,693 @@
+source: Red Hat
+models:
+  - name: rhelai1/granite-8b-code-base
+    provider: IBM
+    description: |-
+      Granite-8B-Code-Base is a decoder-only code model designed for code
+      generative tasks (e.g., code generation, code explanation, code fixing,
+      etc.). It is trained from scratch with a two-phase training strategy. In
+      phase 1, our model is trained on 4 trillion tokens sourced from 116
+      programming languages, ensuring a comprehensive understanding of
+      programming languages and syntax. In phase 2, our model is trained on 500
+      billion tokens with a carefully designed mixture of high-quality data from
+      code and natural language domains to improve the models’ ability to reason
+      and follow instructions.
+    readme: |-
+      # Granite-3.1-8B-Base
+
+      **Model Summary:**
+      Granite-3.1-8B-Base extends the context length of Granite-3.0-8B-Base from 4K to 128K using a progressive training strategy by increasing the supported context length in increments while adjusting RoPE theta until the model has successfully adapted to desired length of 128K. This long-context pre-training stage was performed using approximately 500B tokens.
+
+      - **Developers:** Granite Team, IBM
+      - **GitHub Repository:** [ibm-granite/granite-3.1-language-models](https://github.com/ibm-granite/granite-3.1-language-models)
+      - **Website**: [Granite Docs](https://www.ibm.com/granite/docs/)
+      - **Paper:** [Granite 3.1 Language Models (coming soon)](https://huggingface.co/collections/ibm-granite/granite-31-language-models-6751dbbf2f3389bec5c6f02d)
+      - **Release Date**: December 18th, 2024
+      - **License:** [Apache 2.0](https://www.apache.org/licenses/LICENSE-2.0)
+
+      **Supported Languages:**
+      English, German, Spanish, French, Japanese, Portuguese, Arabic, Czech, Italian, Korean, Dutch, and Chinese. Users may finetune Granite 3.1 models for languages beyond these 12 languages.
+
+      **Intended Use:**
+      Prominent use cases of LLMs in text-to-text generation include summarization, text classification, extraction, question-answering, and other long-context tasks. All Granite Base models are able to handle these tasks as they were trained on a large amount of data from various domains. Moreover, they can serve as baseline to create specialized models for specific application scenarios.
+
+      **Generation:**
+      This is a simple example of how to use Granite-3.1-8B-Base model.
+
+      Install the following libraries:
+
+      ```shell
+      pip install torch torchvision torchaudio
+      pip install accelerate
+      pip install transformers
+      ```
+      Then, copy the code snippet below to run the example.
+
+      ```python
+      from transformers import AutoModelForCausalLM, AutoTokenizer
+      device = "auto"
+      model_path = "ibm-granite/granite-3.1-8B-base"
+      tokenizer = AutoTokenizer.from_pretrained(model_path)
+      # drop device_map if running on CPU
+      model = AutoModelForCausalLM.from_pretrained(model_path, device_map=device)
+      model.eval()
+      # change input text as desired
+      input_text = "Where is the Thomas J. Watson Research Center located?"
+      # tokenize the text
+      input_tokens = tokenizer(input_text, return_tensors="pt").to(device)
+      # generate output tokens
+      output = model.generate(**input_tokens,
+                              max_length=4000)
+      # decode output tokens into text
+      output = tokenizer.batch_decode(output)
+      # print output
+      print(output)
+      ```
+
+      **Evaluation Results:**
+      <table>
+        <caption><b>HuggingFace Open LLM Leaderboard V1</b></caption>
+      <thead>
+        <tr>
+          <th style="text-align:left; background-color: #001d6c; color: white;">Models</th>
+          <th style="text-align:center; background-color: #001d6c; color: white;">ARC-Challenge</th>
+          <th style="text-align:center; background-color: #001d6c; color: white;">Hellaswag</th>
+          <th style="text-align:center; background-color: #001d6c; color: white;">MMLU</th>
+          <th style="text-align:center; background-color: #001d6c; color: white;">TruthfulQA</th>
+          <th style="text-align:center; background-color: #001d6c; color: white;">Winogrande</th>
+          <th style="text-align:center; background-color: #001d6c; color: white;">GSM8K</th>
+          <th style="text-align:center; background-color: #001d6c; color: white;">Avg</th>
+        </tr></thead>
+        <tbody>
+        <tr>
+          <td style="text-align:left; background-color: #DAE8FF; color: black;">Granite-3.1-8B-Base</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">63.99</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">83.27</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">63.45</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">51.29</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">78.92</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">60.19</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">66.85</td>
+        </tr>
+        <tr>
+          <td style="text-align:left; background-color: #FFFFFF; color: #2D2D2D;">Granite-3.1-2B-Base</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">53.58</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">77.67</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">52.86</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">39.02</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">72.84</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">47.99</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">57.32</td>
+        </tr>
+        <tr>
+          <td style="text-align:left; background-color: #FFFFFF; color: #2D2D2D;">Granite-3.1-3B-A800M-Base</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">50.76</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">74.45</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">48.31</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">39.91</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">69.29</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">40.56</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">53.88</td>
+        </tr>
+        <tr>
+          <td style="text-align:left; background-color: #FFFFFF; color: #2D2D2D;">Granite-3.1-1B-A400M-Base</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">39.42</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">66.13</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">26.53</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">37.67</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">2.03</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">18.87</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">31.78</td>
+        </tr>
+      </tbody></table>
+
+      <table>
+        <caption><b>HuggingFace Open LLM Leaderboard V2</b></caption>
+        <thead>
+        <tr>
+          <th style="text-align:left; background-color: #001d6c; color: white;">Models</th>
+          <th style="text-align:center; background-color: #001d6c; color: white;">IFEval</th>
+          <th style="text-align:center; background-color: #001d6c; color: white;">BBH</th>
+          <th style="text-align:center; background-color: #001d6c; color: white;">MATH Lvl 5</th>
+          <th style="text-align:center; background-color: #001d6c; color: white;">GPQA</th>
+          <th style="text-align:center; background-color: #001d6c; color: white;">MUSR</th>
+          <th style="text-align:center; background-color: #001d6c; color: white;">MMLU-Pro</th>
+          <th style="text-align:center; background-color: #001d6c; color: white;">Avg</th>
+        </tr></thead>
+        <tbody>
+        <tr>
+          <td style="text-align:left; background-color: #DAE8FF; color: black;">Granite-3.1-8B-Base</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">42.21</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">26.02</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">9.52</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">9.51</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">8.36</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">24.8</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">20.07</td>
+        </tr>
+        <tr>
+          <td style="text-align:left; background-color: #FFFFFF; color: #2D2D2D;">Granite-3.1-2B-Base</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">35.22</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">16.84</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">5.59</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">3.69</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">3.9</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">13.9</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">13.19</td>
+        </tr>
+        <tr>
+          <td style="text-align:left; background-color: #FFFFFF; color: #2D2D2D;">Granite-3.1-3B-A800M-Base</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">29.96</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">11.91</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">4</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">3.69</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">1.11</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">8.81</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">9.91</td>
+        </tr>
+        <tr>
+          <td style="text-align:left; background-color: #FFFFFF; color: #2D2D2D;">Granite-3.1-1B-A400M-Base</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">25.19</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">6.43</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">2.19</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">0.22</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">1.76</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">1.55</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">6.22</td>
+        </tr>
+      </tbody></table>
+
+      **Model Architecture:**
+      Granite-3.1-8B-Base is based on a decoder-only dense transformer architecture. Core components of this architecture are: GQA and RoPE, MLP with SwiGLU, RMSNorm, and shared input/output embeddings.
+      <table>
+      <thead>
+        <tr>
+          <th style="text-align:left; background-color: #001d6c; color: white;">Model</th>
+          <th style="text-align:center; background-color: #001d6c; color: white;">2B Dense</th>
+          <th style="text-align:center; background-color: #001d6c; color: white;">8B Dense</th>
+          <th style="text-align:center; background-color: #001d6c; color: white;">1B MoE</th>
+          <th style="text-align:center; background-color: #001d6c; color: white;">3B MoE</th>
+        </tr></thead>
+      <tbody>
+        <tr>
+          <td style="text-align:left; background-color: #FFFFFF; color: black;">Embedding size</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">2048</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">4096</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">1024</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">1536</td>
+        </tr>
+        <tr>
+          <td style="text-align:left; background-color: #FFFFFF; color: black;">Number of layers</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">40</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">40</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">24</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">32</td>
+        </tr>
+        <tr>
+          <td style="text-align:left; background-color: #FFFFFF; color: black;">Attention head size</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">64</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">128</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">64</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">64</td>
+        </tr>
+        <tr>
+          <td style="text-align:left; background-color: #FFFFFF; color: black;">Number of attention heads</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">32</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">32</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">16</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">24</td>
+        </tr>
+        <tr>
+          <td style="text-align:left; background-color: #FFFFFF; color: black;">Number of KV heads</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">8</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">8</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">8</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">8</td>
+        </tr>
+        <tr>
+          <td style="text-align:left; background-color: #FFFFFF; color: black;">MLP hidden size</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">8192</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">12800</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">512</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">512</td>
+        </tr>
+        <tr>
+          <td style="text-align:left; background-color: #FFFFFF; color: black;">MLP activation</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">SwiGLU</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">SwiGLU</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">SwiGLU</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">SwiGLU</td>
+        </tr>
+        <tr>
+          <td style="text-align:left; background-color: #FFFFFF; color: black;">Number of experts</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">—</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">—</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">32</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">40</td>
+        </tr>
+        <tr>
+          <td style="text-align:left; background-color: #FFFFFF; color: black;">MoE TopK</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">—</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">—</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">8</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">8</td>
+        </tr>
+        <tr>
+          <td style="text-align:left; background-color: #FFFFFF; color: black;">Initialization std</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">0.1</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">0.1</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">0.1</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">0.1</td>
+        </tr>
+        <tr>
+          <td style="text-align:left; background-color: #FFFFFF; color: black;">Sequence length</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">128K</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">128K</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">128K</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">128K</td>
+        </tr>
+        <tr>
+          <td style="text-align:left; background-color: #FFFFFF; color: black;">Position embedding</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">RoPE</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">RoPE</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">RoPE</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">RoPE</td>
+        </tr>
+        <tr>
+          <td style="text-align:left; background-color: #FFFFFF; color: black;"># Parameters</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">2.5B</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">8.1B</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">1.3B</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">3.3B</td>
+        </tr>
+        <tr>
+          <td style="text-align:left; background-color: #FFFFFF; color: black;"># Active parameters</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">2.5B</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">8.1B</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">400M</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">800M</td>
+        </tr>
+        <tr>
+          <td style="text-align:left; background-color: #FFFFFF; color: black;"># Training tokens</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">12T</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">12T</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">10T</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">10T</td>
+        </tr>
+      </tbody></table>
+      **Training Data:**
+      This model is trained on a mix of open source and proprietary data following a three-stage training strategy.
+      * Stage 1 data: The data for stage 1 is sourced from diverse domains, such as: web, code, academic sources, books, and math data.
+      * Stage 2 data: The data for stage 2 comprises a curated mix of high-quality data from the same domains, plus multilingual and instruction data. The goal of this second training phase is to enhance the model’s performance on specific tasks.
+      * Stage 3 data: The data for stage 3 consists of original stage-2 pretraining data with additional synthetic long-context data in form of QA/summary pairs where the answer
+      contains a recitation of the related paragraph before the answer.
+
+      A detailed attribution of datasets can be found in the [Granite 3.0 Technical Report](https://github.com/ibm-granite/granite-3.0-language-models/blob/main/paper.pdf), [Granite 3.1 Technical Report (coming soon)](https://huggingface.co/collections/ibm-granite/granite-31-language-models-6751dbbf2f3389bec5c6f02d), and [Accompanying Author List](https://github.com/ibm-granite/granite-3.0-language-models/blob/main/author-ack.pdf).
+
+      **Infrastructure:**
+      We train Granite 3.1 Language Models using IBM's super computing cluster, Blue Vela, which is outfitted with NVIDIA H100 GPUs. This cluster provides a scalable and efficient infrastructure for training our models over thousands of GPUs.
+
+      **Ethical Considerations and Limitations:**
+      The use of Large Language Models involves risks and ethical considerations people must be aware of, including but not limited to: bias and fairness, misinformation, and autonomous decision-making. Granite-3.1-8B-Base model is not the exception in this regard. Even though this model is suited for multiple generative AI tasks, it has not undergone any safety alignment, there it may produce problematic outputs. Additionally, it remains uncertain whether smaller models might exhibit increased susceptibility to hallucination in generation scenarios by copying text verbatim from the training dataset due to their reduced sizes and memorization capacities. This aspect is currently an active area of research, and we anticipate more rigorous exploration, comprehension, and mitigations in this domain. Regarding ethics, a latent risk associated with all Large Language Models is their malicious utilization. We urge the community to use Granite-3.1-8B-Base model with ethical intentions and in a responsible way.
+
+      **Resources**
+      - ⭐️ Learn about the latest updates with Granite: https://www.ibm.com/granite
+      - 📄 Get started with tutorials, best practices, and prompt engineering advice: https://www.ibm.com/granite/docs/
+      - 💡 Learn about the latest Granite learning resources: https://ibm.biz/granite-learning-resources
+    language: ["ar", "cs", "de", "en", "es", "fr", "it", "ja", "ko", "nl", "pt", "zh"]
+    license: apache-2.0
+    licenseLink: https://www.apache.org/licenses/LICENSE-2.0.txt
+    maturity: Generally Available
+    libraryName: transformers
+    tasks:
+      - text-generation
+    createTimeSinceEpoch: "1733514949000"
+    lastUpdateTimeSinceEpoch: "1734637721000"
+    artifacts:
+      - uri: oci://registry.redhat.io/rhelai1/granite-8b-code-base:1.3-1732870892
+  - name: rhelai1/granite-8b-code-instruct
+    provider: IBM
+    description: |-
+      Granite-8B-Code-Instruct is a 8B parameter model fine tuned from
+      Granite-8B-Code-Base on a combination of permissively licensed instruction
+      data to enhance instruction following capabilities including logical
+      reasoning and problem-solving skills.
+    readme: |-
+      # Granite-3.1-8B-Instruct
+
+      **Model Summary:**
+      Granite-3.1-8B-Instruct is a 8B parameter long-context instruct model finetuned from Granite-3.1-8B-Base using a combination of open source instruction datasets with permissive license and internally collected synthetic datasets tailored for solving long context problems. This model is developed using a diverse set of techniques with a structured chat format, including supervised finetuning, model alignment using reinforcement learning, and model merging.
+
+      - **Developers:** Granite Team, IBM
+      - **GitHub Repository:** [ibm-granite/granite-3.1-language-models](https://github.com/ibm-granite/granite-3.1-language-models)
+      - **Website**: [Granite Docs](https://www.ibm.com/granite/docs/)
+      - **Paper:** [Granite 3.1 Language Models (coming soon)](https://huggingface.co/collections/ibm-granite/granite-31-language-models-6751dbbf2f3389bec5c6f02d)
+      - **Release Date**: December 18th, 2024
+      - **License:** [Apache 2.0](https://www.apache.org/licenses/LICENSE-2.0)
+
+      **Supported Languages:**
+      English, German, Spanish, French, Japanese, Portuguese, Arabic, Czech, Italian, Korean, Dutch, and Chinese. Users may finetune Granite 3.1 models for languages beyond these 12 languages.
+
+      **Intended Use:**
+      The model is designed to respond to general instructions and can be used to build AI assistants for multiple domains, including business applications.
+
+      *Capabilities*
+      * Summarization
+      * Text classification
+      * Text extraction
+      * Question-answering
+      * Retrieval Augmented Generation (RAG)
+      * Code related tasks
+      * Function-calling tasks
+      * Multilingual dialog use cases
+      * Long-context tasks including long document/meeting summarization, long document QA, etc.
+
+      **Generation:**
+      This is a simple example of how to use Granite-3.1-8B-Instruct model.
+
+      Install the following libraries:
+
+      ```shell
+      pip install torch torchvision torchaudio
+      pip install accelerate
+      pip install transformers
+      ```
+      Then, copy the snippet from the section that is relevant for your use case.
+
+      ```python
+      import torch
+      from transformers import AutoModelForCausalLM, AutoTokenizer
+
+      device = "auto"
+      model_path = "ibm-granite/granite-3.1-8b-instruct"
+      tokenizer = AutoTokenizer.from_pretrained(model_path)
+      # drop device_map if running on CPU
+      model = AutoModelForCausalLM.from_pretrained(model_path, device_map=device)
+      model.eval()
+      # change input text as desired
+      chat = [
+          { "role": "user", "content": "Please list one IBM Research laboratory located in the United States. You should only output its name and location." },
+      ]
+      chat = tokenizer.apply_chat_template(chat, tokenize=False, add_generation_prompt=True)
+      # tokenize the text
+      input_tokens = tokenizer(chat, return_tensors="pt").to(device)
+      # generate output tokens
+      output = model.generate(**input_tokens,
+                              max_new_tokens=100)
+      # decode output tokens into text
+      output = tokenizer.batch_decode(output)
+      # print output
+      print(output)
+      ```
+      **Evaluation Results:**
+      <table>
+        <caption><b>HuggingFace Open LLM Leaderboard V1</b></caption>
+      <thead>
+        <tr>
+          <th style="text-align:left; background-color: #001d6c; color: white;">Models</th>
+          <th style="text-align:center; background-color: #001d6c; color: white;">ARC-Challenge</th>
+          <th style="text-align:center; background-color: #001d6c; color: white;">Hellaswag</th>
+          <th style="text-align:center; background-color: #001d6c; color: white;">MMLU</th>
+          <th style="text-align:center; background-color: #001d6c; color: white;">TruthfulQA</th>
+          <th style="text-align:center; background-color: #001d6c; color: white;">Winogrande</th>
+          <th style="text-align:center; background-color: #001d6c; color: white;">GSM8K</th>
+          <th style="text-align:center; background-color: #001d6c; color: white;">Avg</th>
+        </tr></thead>
+        <tbody>
+        <tr>
+          <td style="text-align:left; background-color: #DAE8FF; color: black;">Granite-3.1-8B-Instruct</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">62.62</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">84.48</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">65.34</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">66.23</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">75.37</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">73.84</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">71.31</td>
+        </tr>
+        <tr>
+          <td style="text-align:left; background-color: #FFFFFF; color: #2D2D2D;">Granite-3.1-2B-Instruct</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">54.61</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">75.14</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">55.31</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">59.42</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">67.48</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">52.76</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">60.79</td>
+        </tr>
+        <tr>
+          <td style="text-align:left; background-color: #FFFFFF; color: #2D2D2D;">Granite-3.1-3B-A800M-Instruct</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">50.42</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">73.01</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">52.19</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">49.71</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">64.87</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">48.97</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">56.53</td>
+        </tr>
+        <tr>
+          <td style="text-align:left; background-color: #FFFFFF; color: #2D2D2D;">Granite-3.1-1B-A400M-Instruct</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">42.66</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">65.97</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">26.13</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">46.77</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">62.35</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">33.88</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">46.29</td>
+        </tr>
+      </tbody></table>
+
+      <table>
+        <caption><b>HuggingFace Open LLM Leaderboard V2</b></caption>
+      <thead>
+        <tr>
+          <th style="text-align:left; background-color: #001d6c; color: white;">Models</th>
+          <th style="text-align:center; background-color: #001d6c; color: white;">IFEval</th>
+          <th style="text-align:center; background-color: #001d6c; color: white;">BBH</th>
+          <th style="text-align:center; background-color: #001d6c; color: white;">MATH Lvl 5</th>
+          <th style="text-align:center; background-color: #001d6c; color: white;">GPQA</th>
+          <th style="text-align:center; background-color: #001d6c; color: white;">MUSR</th>
+          <th style="text-align:center; background-color: #001d6c; color: white;">MMLU-Pro</th>
+          <th style="text-align:center; background-color: #001d6c; color: white;">Avg</th>
+        </tr></thead>
+        <tbody>
+        <tr>
+          <td style="text-align:left; background-color: #DAE8FF; color: black;">Granite-3.1-8B-Instruct</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">72.08</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">34.09</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">21.68</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">8.28</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">19.01</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">28.19</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">30.55</td>
+        </tr>
+        <tr>
+          <td style="text-align:left; background-color: #FFFFFF; color: #2D2D2D;">Granite-3.1-2B-Instruct</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">62.86</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">21.82</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">11.33</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">5.26</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">4.87</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">20.21</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">21.06</td>
+        </tr>
+        <tr>
+          <td style="text-align:left; background-color: #FFFFFF; color: #2D2D2D;">Granite-3.1-3B-A800M-Instruct</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">55.16</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">16.69</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">10.35</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">5.15</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">2.51</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">12.75</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">17.1</td>
+        </tr>
+        <tr>
+          <td style="text-align:left; background-color: #FFFFFF; color: #2D2D2D;">Granite-3.1-1B-A400M-Instruct</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">46.86</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">6.18</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">4.08</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">0</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">0.78</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">2.41</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: #2D2D2D;">10.05</td>
+        </tr>
+      </tbody></table>
+
+      **Model Architecture:**
+      Granite-3.1-8B-Instruct is based on a decoder-only dense transformer architecture. Core components of this architecture are: GQA and RoPE, MLP with SwiGLU, RMSNorm, and shared input/output embeddings.
+
+      <table>
+      <thead>
+        <tr>
+          <th style="text-align:left; background-color: #001d6c; color: white;">Model</th>
+          <th style="text-align:center; background-color: #001d6c; color: white;">2B Dense</th>
+          <th style="text-align:center; background-color: #001d6c; color: white;">8B Dense</th>
+          <th style="text-align:center; background-color: #001d6c; color: white;">1B MoE</th>
+          <th style="text-align:center; background-color: #001d6c; color: white;">3B MoE</th>
+        </tr></thead>
+      <tbody>
+        <tr>
+          <td style="text-align:left; background-color: #FFFFFF; color: black;">Embedding size</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">2048</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">4096</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">1024</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">1536</td>
+        </tr>
+        <tr>
+          <td style="text-align:left; background-color: #FFFFFF; color: black;">Number of layers</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">40</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">40</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">24</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">32</td>
+        </tr>
+        <tr>
+          <td style="text-align:left; background-color: #FFFFFF; color: black;">Attention head size</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">64</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">128</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">64</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">64</td>
+        </tr>
+        <tr>
+          <td style="text-align:left; background-color: #FFFFFF; color: black;">Number of attention heads</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">32</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">32</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">16</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">24</td>
+        </tr>
+        <tr>
+          <td style="text-align:left; background-color: #FFFFFF; color: black;">Number of KV heads</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">8</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">8</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">8</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">8</td>
+        </tr>
+        <tr>
+          <td style="text-align:left; background-color: #FFFFFF; color: black;">MLP hidden size</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">8192</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">12800</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">512</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">512</td>
+        </tr>
+        <tr>
+          <td style="text-align:left; background-color: #FFFFFF; color: black;">MLP activation</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">SwiGLU</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">SwiGLU</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">SwiGLU</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">SwiGLU</td>
+        </tr>
+        <tr>
+          <td style="text-align:left; background-color: #FFFFFF; color: black;">Number of experts</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">—</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">—</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">32</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">40</td>
+        </tr>
+        <tr>
+          <td style="text-align:left; background-color: #FFFFFF; color: black;">MoE TopK</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">—</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">—</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">8</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">8</td>
+        </tr>
+        <tr>
+          <td style="text-align:left; background-color: #FFFFFF; color: black;">Initialization std</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">0.1</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">0.1</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">0.1</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">0.1</td>
+        </tr>
+        <tr>
+          <td style="text-align:left; background-color: #FFFFFF; color: black;">Sequence length</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">128K</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">128K</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">128K</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">128K</td>
+        </tr>
+        <tr>
+          <td style="text-align:left; background-color: #FFFFFF; color: black;">Position embedding</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">RoPE</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">RoPE</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">RoPE</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">RoPE</td>
+        </tr>
+        <tr>
+          <td style="text-align:left; background-color: #FFFFFF; color: black;"># Parameters</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">2.5B</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">8.1B</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">1.3B</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">3.3B</td>
+        </tr>
+        <tr>
+          <td style="text-align:left; background-color: #FFFFFF; color: black;"># Active parameters</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">2.5B</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">8.1B</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">400M</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">800M</td>
+        </tr>
+        <tr>
+          <td style="text-align:left; background-color: #FFFFFF; color: black;"># Training tokens</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">12T</td>
+          <td style="text-align:center; background-color: #DAE8FF; color: black;">12T</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">10T</td>
+          <td style="text-align:center; background-color: #FFFFFF; color: black;">10T</td>
+        </tr>
+      </tbody></table>
+
+      **Training Data:**
+      Overall, our SFT data is largely comprised of three key sources: (1) publicly available datasets with permissive license, (2) internal synthetic data targeting specific capabilities including long-context tasks, and (3) very small amounts of human-curated data. A detailed attribution of datasets can be found in the [Granite 3.0 Technical Report](https://github.com/ibm-granite/granite-3.0-language-models/blob/main/paper.pdf), [Granite 3.1 Technical Report (coming soon)](https://huggingface.co/collections/ibm-granite/granite-31-language-models-6751dbbf2f3389bec5c6f02d), and [Accompanying Author List](https://github.com/ibm-granite/granite-3.0-language-models/blob/main/author-ack.pdf).
+
+      **Infrastructure:**
+      We train Granite 3.1 Language Models using IBM's super computing cluster, Blue Vela, which is outfitted with NVIDIA H100 GPUs. This cluster provides a scalable and efficient infrastructure for training our models over thousands of GPUs.
+
+      **Ethical Considerations and Limitations:**
+      Granite 3.1 Instruct Models are primarily finetuned using instruction-response pairs mostly in English, but also multilingual data covering eleven languages. Although this model can handle multilingual dialog use cases, its performance might not be similar to English tasks. In such case, introducing a small number of examples (few-shot) can help the model in generating more accurate outputs. While this model has been aligned by keeping safety in consideration, the model may in some cases produce inaccurate, biased, or unsafe responses to user prompts. So we urge the community to use this model with proper safety testing and tuning tailored for their specific tasks.
+
+      **Resources**
+      - ⭐️ Learn about the latest updates with Granite: https://www.ibm.com/granite
+      - 📄 Get started with tutorials, best practices, and prompt engineering advice: https://www.ibm.com/granite/docs/
+      - 💡 Learn about the latest Granite learning resources: https://ibm.biz/granite-learning-resources
+
+      <!-- ## Citation
+      ```
+      @misc{granite-models,
+        author = {author 1, author2, ...},
+        title = {},
+        journal = {},
+        volume = {},
+        year = {2024},
+        url = {https://arxiv.org/abs/0000.00000},
+      }
+      ``` -->
+    language: ["ar", "cs", "de", "en", "es", "fr", "it", "ja", "ko", "nl", "pt", "zh"]
+    license: apache-2.0
+    licenseLink: https://www.apache.org/licenses/LICENSE-2.0.txt
+    maturity: Generally Available
+    libraryName: transformers
+    tasks:
+      - text-generation
+    createTimeSinceEpoch: "1733514949000"
+    lastUpdateTimeSinceEpoch: "1734637721000"
+    artifacts:
+      - uri: oci://registry.redhat.io/rhelai1/granite-8b-code-instruct:1.3-1732870892
+        createTimeSinceEpoch: "1733514949000"
+        lastUpdateTimeSinceEpoch: "1734637721000"
+        customProperties:
+          foo:
+            string_value: bar
+          baz:
+            string_value: qux
+  - name: model-with-no-artifacts
+    provider: Test
+    description: A model used for testing the GetArtifacts method when no artifacts are present.
+    readme: |
+      # Model with No Artifacts
+      This is a test model.
+    language: ["en"]
+    license: apache-2.0
+    licenseLink: https://www.apache.org/licenses/LICENSE-2.0.txt
+    maturity: Development
+    libraryName: testlib
+    tasks:
+      - test-task
+    createTimeSinceEpoch: "1700000000000"
+    lastUpdateTimeSinceEpoch: "1700000000000"
+    artifacts: []

catalog/internal/catalog/yaml_catalog.go

@@ -0,0 +1,241 @@
+package catalog
+
+import (
+	"context"
+	"fmt"
+	"math"
+	"os"
+	"path/filepath"
+	"sort"
+	"strconv"
+	"strings"
+	"sync"
+
+	"k8s.io/apimachinery/pkg/util/yaml"
+
+	"github.com/golang/glog"
+	model "github.com/kubeflow/model-registry/catalog/pkg/openapi"
+)
+
+type yamlModel struct {
+	model.CatalogModel `yaml:",inline"`
+	Artifacts          []*model.CatalogModelArtifact `yaml:"artifacts"`
+}
+
+type yamlCatalog struct {
+	Source string      `yaml:"source"`
+	Models []yamlModel `yaml:"models"`
+}
+
+type yamlCatalogImpl struct {
+	modelsLock sync.RWMutex
+	models     map[string]*yamlModel
+}
+
+var _ CatalogSourceProvider = &yamlCatalogImpl{}
+
+func (y *yamlCatalogImpl) GetModel(ctx context.Context, name string) (*model.CatalogModel, error) {
+	y.modelsLock.RLock()
+	defer y.modelsLock.RUnlock()
+
+	ym := y.models[name]
+	if ym == nil {
+		return nil, nil
+	}
+	cp := ym.CatalogModel
+	return &cp, nil
+}
+
+func (y *yamlCatalogImpl) ListModels(ctx context.Context, params ListModelsParams) (model.CatalogModelList, error) {
+	y.modelsLock.RLock()
+	defer y.modelsLock.RUnlock()
+
+	var filteredModels []*model.CatalogModel
+	for _, ym := range y.models {
+		cm := ym.CatalogModel
+		if params.Query != "" {
+			query := strings.ToLower(params.Query)
+			// Check if query matches name, description, tasks, provider, or libraryName
+			if !strings.Contains(strings.ToLower(cm.Name), query) &&
+				!strings.Contains(strings.ToLower(cm.GetDescription()), query) &&
+				!strings.Contains(strings.ToLower(cm.GetProvider()), query) &&
+				!strings.Contains(strings.ToLower(cm.GetLibraryName()), query) {
+
+				// Check tasks
+				foundInTasks := false
+				for _, task := range cm.GetTasks() { // Use GetTasks() for nil safety
+					if strings.Contains(strings.ToLower(task), query) {
+						foundInTasks = true
+						break
+					}
+				}
+				if !foundInTasks {
+					continue // Skip if no match in any searchable field
+				}
+			}
+		}
+		filteredModels = append(filteredModels, &cm)
+	}
+
+	// Sort the filtered models
+	sort.Slice(filteredModels, func(i, j int) bool {
+		a := filteredModels[i]
+		b := filteredModels[j]
+
+		var less bool
+		switch params.OrderBy {
+		case model.ORDERBYFIELD_CREATE_TIME:
+			// Convert CreateTimeSinceEpoch (string) to int64 for comparison
+			// Handle potential nil or conversion errors by treating as 0
+			aTime, _ := strconv.ParseInt(a.GetCreateTimeSinceEpoch(), 10, 64)
+			bTime, _ := strconv.ParseInt(b.GetCreateTimeSinceEpoch(), 10, 64)
+			less = aTime < bTime
+		case model.ORDERBYFIELD_LAST_UPDATE_TIME:
+			// Convert LastUpdateTimeSinceEpoch (string) to int64 for comparison
+			// Handle potential nil or conversion errors by treating as 0
+			aTime, _ := strconv.ParseInt(a.GetLastUpdateTimeSinceEpoch(), 10, 64)
+			bTime, _ := strconv.ParseInt(b.GetLastUpdateTimeSinceEpoch(), 10, 64)
+			less = aTime < bTime
+		case model.ORDERBYFIELD_NAME:
+			fallthrough
+		default:
+			// Fallback to name sort if an unknown sort field is provided
+			less = strings.Compare(a.Name, b.Name) < 0
+		}
+
+		if params.SortOrder == model.SORTORDER_DESC {
+			return !less
+		}
+		return less
+	})
+
+	count := len(filteredModels)
+	if count > math.MaxInt32 {
+		count = math.MaxInt32
+	}
+
+	list := model.CatalogModelList{
+		Items:    make([]model.CatalogModel, count),
+		PageSize: int32(count),
+		Size:     int32(count),
+	}
+	for i := range list.Items {
+		list.Items[i] = *filteredModels[i]
+	}
+	return list, nil // Return the struct value directly
+}
+
+func (y *yamlCatalogImpl) GetArtifacts(ctx context.Context, name string) (*model.CatalogModelArtifactList, error) {
+	y.modelsLock.RLock()
+	defer y.modelsLock.RUnlock()
+
+	ym := y.models[name]
+	if ym == nil {
+		return nil, nil
+	}
+
+	count := len(ym.Artifacts)
+	if count > math.MaxInt32 {
+		count = math.MaxInt32
+	}
+
+	list := model.CatalogModelArtifactList{
+		Items:    make([]model.CatalogModelArtifact, count),
+		PageSize: int32(count),
+		Size:     int32(count),
+	}
+	for i := range list.Items {
+		list.Items[i] = *ym.Artifacts[i]
+	}
+	return &list, nil
+}
+
+func (y *yamlCatalogImpl) load(path string, excludedModelsList []string) error {
+	bytes, err := os.ReadFile(path)
+	if err != nil {
+		return fmt.Errorf("failed to read %s file: %v", yamlCatalogPath, err)
+	}
+
+	var contents yamlCatalog
+	if err = yaml.UnmarshalStrict(bytes, &contents); err != nil {
+		return fmt.Errorf("failed to parse %s file: %v", yamlCatalogPath, err)
+	}
+
+	models := make(map[string]*yamlModel)
+	for i := range contents.Models {
+		modelName := contents.Models[i].Name
+		if isModelExcluded(modelName, excludedModelsList) {
+			continue
+		}
+		models[modelName] = &contents.Models[i]
+	}
+
+	y.modelsLock.Lock()
+	defer y.modelsLock.Unlock()
+	y.models = models
+
+	return nil
+}
+
+const yamlCatalogPath = "yamlCatalogPath"
+
+func newYamlCatalog(source *CatalogSourceConfig) (CatalogSourceProvider, error) {
+	yamlModelFile, exists := source.Properties[yamlCatalogPath].(string)
+	if !exists || yamlModelFile == "" {
+		return nil, fmt.Errorf("missing %s string property", yamlCatalogPath)
+	}
+
+	yamlModelFile, err := filepath.Abs(yamlModelFile)
+	if err != nil {
+		return nil, fmt.Errorf("abs: %w", err)
+	}
+
+	// Excluded models is an optional source property.
+	var excludedModels []string
+	if excludedModelsData, ok := source.Properties["excludedModels"]; ok {
+		excludedModelsList, ok := excludedModelsData.([]any)
+		if !ok {
+			return nil, fmt.Errorf("'excludedModels' property should be a list")
+		}
+		excludedModels = make([]string, len(excludedModelsList))
+		for i, v := range excludedModelsList {
+			excludedModels[i], ok = v.(string)
+			if !ok {
+				return nil, fmt.Errorf("invalid entry in 'excludedModels' list, expected a string")
+			}
+		}
+	}
+
+	p := &yamlCatalogImpl{
+		models: make(map[string]*yamlModel),
+	}
+	err = p.load(yamlModelFile, excludedModels)
+	if err != nil {
+		return nil, err
+	}
+
+	go func() {
+		changes, err := getMonitor().Path(yamlModelFile)
+		if err != nil {
+			glog.Errorf("unable to watch YAML catalog file: %v", err)
+			// Not fatal, we just won't get automatic updates.
+		}
+
+		for range changes {
+			glog.Infof("Reloading YAML catalog %s", yamlModelFile)
+
+			err = p.load(yamlModelFile, excludedModels)
+			if err != nil {
+				glog.Errorf("unable to load YAML catalog: %v", err)
+			}
+		}
+	}()
+
+	return p, nil
+}
+
+func init() {
+	if err := RegisterCatalogType("yaml", newYamlCatalog); err != nil {
+		panic(err)
+	}
+}

catalog/internal/catalog/yaml_catalog_test.go

@@ -0,0 +1,207 @@
+package catalog
+
+import (
+	"context"
+	"testing"
+
+	model "github.com/kubeflow/model-registry/catalog/pkg/openapi"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestYAMLCatalogGetModel(t *testing.T) {
+	assert := assert.New(t)
+	provider := testYAMLProvider(t, "testdata/test-yaml-catalog.yaml")
+
+	model, err := provider.GetModel(context.Background(), "rhelai1/granite-8b-code-base")
+	if assert.NoError(err) {
+		assert.Equal("rhelai1/granite-8b-code-base", model.Name)
+
+		newLogo := "foobar"
+		model.Logo = &newLogo
+
+		model2, err := provider.GetModel(context.Background(), "rhelai1/granite-8b-code-base")
+		if assert.NoError(err) {
+			assert.NotEqual(model2.Logo, model.Logo, "changes to one returned object should not affect other return values")
+		}
+	}
+
+	notFound, err := provider.GetModel(context.Background(), "foo")
+	assert.NoError(err)
+	assert.Nil(notFound)
+}
+
+func TestYAMLCatalogGetArtifacts(t *testing.T) {
+	assert := assert.New(t)
+	provider := testYAMLProvider(t, "testdata/test-yaml-catalog.yaml")
+
+	// Test case 1: Model with artifacts
+	artifacts, err := provider.GetArtifacts(context.Background(), "rhelai1/granite-8b-code-base")
+	if assert.NoError(err) {
+		assert.NotNil(artifacts)
+		assert.Equal(int32(1), artifacts.Size)
+		assert.Equal(int32(1), artifacts.PageSize)
+		assert.Len(artifacts.Items, 1)
+		assert.Equal("oci://registry.redhat.io/rhelai1/granite-8b-code-base:1.3-1732870892", artifacts.Items[0].Uri)
+	}
+
+	// Test case 2: Model with no artifacts
+	noArtifactsModel, err := provider.GetArtifacts(context.Background(), "model-with-no-artifacts")
+	if assert.NoError(err) {
+		assert.NotNil(noArtifactsModel)
+		assert.Equal(int32(0), noArtifactsModel.Size)
+		assert.Equal(int32(0), noArtifactsModel.PageSize)
+		assert.Len(noArtifactsModel.Items, 0)
+	}
+
+	// Test case 3: Model not found
+	notFoundArtifacts, err := provider.GetArtifacts(context.Background(), "non-existent-model")
+	assert.NoError(err)
+	assert.Nil(notFoundArtifacts)
+}
+
+func TestYAMLCatalogListModels(t *testing.T) {
+	assert := assert.New(t)
+	provider := testYAMLProvider(t, "testdata/test-list-models-catalog.yaml")
+	ctx := context.Background()
+
+	// Test case 1: List all models, default sort (by name ascending)
+	models, err := provider.ListModels(ctx, ListModelsParams{})
+	if assert.NoError(err) {
+		assert.NotNil(models)
+		assert.Equal(int32(6), models.Size)
+		assert.Equal(int32(6), models.PageSize)
+		assert.Len(models.Items, 6)
+		assert.Equal("Z-model", models.Items[0].Name) // Z-model should be first due to string comparison for alphabetical sort
+		assert.Equal("another-model-alpha", models.Items[1].Name)
+		assert.Equal("model-alpha", models.Items[2].Name)
+		assert.Equal("model-beta", models.Items[3].Name)
+		assert.Equal("model-gamma", models.Items[4].Name)
+		assert.Equal("model-with-no-tasks", models.Items[5].Name)
+	}
+
+	// Test case 2: List all models, sort by name ascending
+	models, err = provider.ListModels(ctx, ListModelsParams{OrderBy: model.ORDERBYFIELD_NAME, SortOrder: model.SORTORDER_ASC})
+	if assert.NoError(err) {
+		assert.Equal(int32(6), models.Size)
+		assert.Equal("Z-model", models.Items[0].Name)
+		assert.Equal("another-model-alpha", models.Items[1].Name)
+	}
+
+	// Test case 3: List all models, sort by name descending
+	models, err = provider.ListModels(ctx, ListModelsParams{OrderBy: model.ORDERBYFIELD_NAME, SortOrder: model.SORTORDER_DESC})
+	if assert.NoError(err) {
+		assert.Equal(int32(6), models.Size)
+		assert.Equal("model-with-no-tasks", models.Items[0].Name)
+		assert.Equal("model-gamma", models.Items[1].Name)
+	}
+
+	// Test case 4: List all models, sort by created (CreateTimeSinceEpoch) ascending
+	models, err = provider.ListModels(ctx, ListModelsParams{OrderBy: model.ORDERBYFIELD_CREATE_TIME, SortOrder: model.SORTORDER_ASC})
+	if assert.NoError(err) {
+		assert.Equal(int32(6), models.Size)
+		assert.Equal("model-with-no-tasks", models.Items[0].Name) // Jan 1, 2023
+		assert.Equal("model-gamma", models.Items[1].Name)         // Feb 1, 2023
+	}
+
+	// Test case 5: List all models, sort by published (CreateTimeSinceEpoch) descending
+	models, err = provider.ListModels(ctx, ListModelsParams{OrderBy: model.ORDERBYFIELD_CREATE_TIME, SortOrder: model.SORTORDER_DESC})
+	if assert.NoError(err) {
+		assert.Equal(int32(6), models.Size)
+		assert.Equal("Z-model", models.Items[0].Name)             // Aug 2, 2023
+		assert.Equal("another-model-alpha", models.Items[1].Name) // May 16, 2023
+	}
+
+	// Test case 6: Filter by query "model" (should match all 6 models)
+	models, err = provider.ListModels(ctx, ListModelsParams{Query: "model"})
+	if assert.NoError(err) {
+		assert.Equal(int32(6), models.Size)
+		assert.Equal("Z-model", models.Items[0].Name)
+		assert.Equal("another-model-alpha", models.Items[1].Name)
+		assert.Equal("model-alpha", models.Items[2].Name)
+		assert.Equal("model-beta", models.Items[3].Name)
+		assert.Equal("model-gamma", models.Items[4].Name)
+		assert.Equal("model-with-no-tasks", models.Items[5].Name)
+	}
+
+	// Test case 7: Filter by query "text" (should match model-alpha, another-model-alpha)
+	models, err = provider.ListModels(ctx, ListModelsParams{Query: "text"})
+	if assert.NoError(err) {
+		assert.Equal(int32(2), models.Size)
+		assert.Equal("another-model-alpha", models.Items[0].Name) // Alphabetical order
+		assert.Equal("model-alpha", models.Items[1].Name)
+	}
+
+	// Test case 8: Filter by query "nlp" (should match model-alpha, model-gamma, another-model-alpha)
+	models, err = provider.ListModels(ctx, ListModelsParams{Query: "nlp"})
+	if assert.NoError(err) {
+		assert.Equal(int32(3), models.Size)
+		assert.Equal("another-model-alpha", models.Items[0].Name)
+		assert.Equal("model-alpha", models.Items[1].Name)
+		assert.Equal("model-gamma", models.Items[2].Name)
+	}
+
+	// Test case 9: Filter by query "IBM" (should match model-alpha, model-gamma)
+	models, err = provider.ListModels(ctx, ListModelsParams{Query: "IBM"})
+	if assert.NoError(err) {
+		assert.Equal(int32(2), models.Size)
+		assert.Equal("model-alpha", models.Items[0].Name)
+		assert.Equal("model-gamma", models.Items[1].Name)
+	}
+
+	// Test case 10: Filter by query "transformers" (should match model-alpha)
+	models, err = provider.ListModels(ctx, ListModelsParams{Query: "transformers"})
+	if assert.NoError(err) {
+		assert.Equal(int32(1), models.Size)
+		assert.Equal("model-alpha", models.Items[0].Name)
+	}
+
+	// Test case 11: Filter by query "nonexistent" (should return empty list)
+	models, err = provider.ListModels(ctx, ListModelsParams{Query: "nonexistent"})
+	assert.NoError(err)
+	assert.NotNil(models)
+	assert.Equal(int32(0), models.Size)
+	assert.Equal(int32(0), models.PageSize)
+	assert.Len(models.Items, 0)
+
+	// Test case 12: Empty catalog
+	emptyProvider := testYAMLProvider(t, "testdata/empty-catalog.yaml") // Assuming an empty-catalog.yaml exists or will be created
+	emptyModels, err := emptyProvider.ListModels(ctx, ListModelsParams{})
+	assert.NoError(err)
+	assert.NotNil(emptyModels)
+	assert.Equal(int32(0), emptyModels.Size)
+	assert.Equal(int32(0), emptyModels.PageSize)
+	assert.Len(emptyModels.Items, 0)
+
+	// Test case 13: Test with excluded models
+	excludedProvider := testYAMLProviderWithExclusions(t, "testdata/test-list-models-catalog.yaml", []any{
+		"model-alpha",
+	})
+	excludedModels, err := excludedProvider.ListModels(ctx, ListModelsParams{})
+	if assert.NoError(err) {
+		assert.NotNil(excludedModels)
+		assert.Equal(int32(5), excludedModels.Size)
+		for _, m := range excludedModels.Items {
+			assert.NotEqual("model-alpha", m.Name)
+		}
+	}
+}
+
+func testYAMLProvider(t *testing.T, path string) CatalogSourceProvider {
+	return testYAMLProviderWithExclusions(t, path, nil)
+}
+
+func testYAMLProviderWithExclusions(t *testing.T, path string, excludedModels []any) CatalogSourceProvider {
+	properties := map[string]any{
+		yamlCatalogPath: path,
+	}
+	if excludedModels != nil {
+		properties["excludedModels"] = excludedModels
+	}
+	provider, err := newYamlCatalog(&CatalogSourceConfig{
+		Properties: properties,
+	})
+	if err != nil {
+		t.Fatalf("newYamlCatalog(%s) with exclusions failed: %v", path, err)
+	}
+	return provider
+}

catalog/internal/server/openapi/.openapi-generator/FILES

@@ -0,0 +1,27 @@
+api.go
+api_model_catalog_service.go
+error.go
+helpers.go
+impl.go
+logger.go
+model_artifact_type_query_param.go
+model_base_model.go
+model_base_resource_dates.go
+model_base_resource_list.go
+model_catalog_model.go
+model_catalog_model_artifact.go
+model_catalog_model_artifact_list.go
+model_catalog_model_list.go
+model_catalog_source.go
+model_catalog_source_list.go
+model_error.go
+model_metadata_bool_value.go
+model_metadata_double_value.go
+model_metadata_int_value.go
+model_metadata_proto_value.go
+model_metadata_string_value.go
+model_metadata_struct_value.go
+model_metadata_value.go
+model_order_by_field.go
+model_sort_order.go
+routers.go

catalog/internal/server/openapi/.openapi-generator/VERSION

@@ -0,0 +1 @@
+7.13.0

catalog/internal/server/openapi/api.go

@@ -0,0 +1,39 @@
+/*
+ * Model Catalog REST API
+ *
+ * REST API for Model Registry to create and manage ML model metadata
+ *
+ * API version: v1alpha1
+ */
+
+// Generated by: OpenAPI Generator (https://openapi-generator.tech). DO NOT EDIT.
+
+package openapi
+
+import (
+	"context"
+	"net/http"
+
+	model "github.com/kubeflow/model-registry/catalog/pkg/openapi"
+)
+
+// ModelCatalogServiceAPIRouter defines the required methods for binding the api requests to a responses for the ModelCatalogServiceAPI
+// The ModelCatalogServiceAPIRouter implementation should parse necessary information from the http request,
+// pass the data to a ModelCatalogServiceAPIServicer to perform the required actions, then write the service results to the http response.
+type ModelCatalogServiceAPIRouter interface {
+	FindModels(http.ResponseWriter, *http.Request)
+	FindSources(http.ResponseWriter, *http.Request)
+	GetModel(http.ResponseWriter, *http.Request)
+	GetAllModelArtifacts(http.ResponseWriter, *http.Request)
+}
+
+// ModelCatalogServiceAPIServicer defines the api actions for the ModelCatalogServiceAPI service
+// This interface intended to stay up to date with the openapi yaml used to generate it,
+// while the service implementation can be ignored with the .openapi-generator-ignore file
+// and updated with the logic required for the API.
+type ModelCatalogServiceAPIServicer interface {
+	FindModels(context.Context, string, string, string, model.OrderByField, model.SortOrder, string) (ImplResponse, error)
+	FindSources(context.Context, string, string, model.OrderByField, model.SortOrder, string) (ImplResponse, error)
+	GetModel(context.Context, string, string) (ImplResponse, error)
+	GetAllModelArtifacts(context.Context, string, string) (ImplResponse, error)
+}

catalog/internal/server/openapi/api_model_catalog_service.go

@@ -0,0 +1,141 @@
+/*
+ * Model Catalog REST API
+ *
+ * REST API for Model Registry to create and manage ML model metadata
+ *
+ * API version: v1alpha1
+ */
+
+// Generated by: OpenAPI Generator (https://openapi-generator.tech). DO NOT EDIT.
+
+package openapi
+
+import (
+	"net/http"
+	"strings"
+
+	"github.com/go-chi/chi/v5"
+
+	model "github.com/kubeflow/model-registry/catalog/pkg/openapi"
+)
+
+// ModelCatalogServiceAPIController binds http requests to an api service and writes the service results to the http response
+type ModelCatalogServiceAPIController struct {
+	service      ModelCatalogServiceAPIServicer
+	errorHandler ErrorHandler
+}
+
+// ModelCatalogServiceAPIOption for how the controller is set up.
+type ModelCatalogServiceAPIOption func(*ModelCatalogServiceAPIController)
+
+// WithModelCatalogServiceAPIErrorHandler inject ErrorHandler into controller
+func WithModelCatalogServiceAPIErrorHandler(h ErrorHandler) ModelCatalogServiceAPIOption {
+	return func(c *ModelCatalogServiceAPIController) {
+		c.errorHandler = h
+	}
+}
+
+// NewModelCatalogServiceAPIController creates a default api controller
+func NewModelCatalogServiceAPIController(s ModelCatalogServiceAPIServicer, opts ...ModelCatalogServiceAPIOption) Router {
+	controller := &ModelCatalogServiceAPIController{
+		service:      s,
+		errorHandler: DefaultErrorHandler,
+	}
+
+	for _, opt := range opts {
+		opt(controller)
+	}
+
+	return controller
+}
+
+// Routes returns all the api routes for the ModelCatalogServiceAPIController
+func (c *ModelCatalogServiceAPIController) Routes() Routes {
+	return Routes{
+		"FindModels": Route{
+			strings.ToUpper("Get"),
+			"/api/model_catalog/v1alpha1/models",
+			c.FindModels,
+		},
+		"FindSources": Route{
+			strings.ToUpper("Get"),
+			"/api/model_catalog/v1alpha1/sources",
+			c.FindSources,
+		},
+		"GetModel": Route{
+			strings.ToUpper("Get"),
+			"/api/model_catalog/v1alpha1/sources/{source_id}/models/*",
+			c.GetModel,
+		},
+		"GetAllModelArtifacts": Route{
+			strings.ToUpper("Get"),
+			"/api/model_catalog/v1alpha1/sources/{source_id}/models/{model_name}/artifacts",
+			c.GetAllModelArtifacts,
+		},
+	}
+}
+
+// FindModels - Search catalog models across sources.
+func (c *ModelCatalogServiceAPIController) FindModels(w http.ResponseWriter, r *http.Request) {
+	query := r.URL.Query()
+	sourceParam := query.Get("source")
+	qParam := query.Get("q")
+	pageSizeParam := query.Get("pageSize")
+	orderByParam := query.Get("orderBy")
+	sortOrderParam := query.Get("sortOrder")
+	nextPageTokenParam := query.Get("nextPageToken")
+	result, err := c.service.FindModels(r.Context(), sourceParam, qParam, pageSizeParam, model.OrderByField(orderByParam), model.SortOrder(sortOrderParam), nextPageTokenParam)
+	// If an error occurred, encode the error with the status code
+	if err != nil {
+		c.errorHandler(w, r, err, &result)
+		return
+	}
+	// If no error, encode the body and the result code
+	EncodeJSONResponse(result.Body, &result.Code, w)
+}
+
+// FindSources - List All CatalogSources
+func (c *ModelCatalogServiceAPIController) FindSources(w http.ResponseWriter, r *http.Request) {
+	query := r.URL.Query()
+	nameParam := query.Get("name")
+	pageSizeParam := query.Get("pageSize")
+	orderByParam := query.Get("orderBy")
+	sortOrderParam := query.Get("sortOrder")
+	nextPageTokenParam := query.Get("nextPageToken")
+	result, err := c.service.FindSources(r.Context(), nameParam, pageSizeParam, model.OrderByField(orderByParam), model.SortOrder(sortOrderParam), nextPageTokenParam)
+	// If an error occurred, encode the error with the status code
+	if err != nil {
+		c.errorHandler(w, r, err, &result)
+		return
+	}
+	// If no error, encode the body and the result code
+	EncodeJSONResponse(result.Body, &result.Code, w)
+}
+
+// GetModel - Get a `CatalogModel`.
+func (c *ModelCatalogServiceAPIController) GetModel(w http.ResponseWriter, r *http.Request) {
+	sourceIdParam := chi.URLParam(r, "source_id")
+	modelNameParam := chi.URLParam(r, "*")
+	result, err := c.service.GetModel(r.Context(), sourceIdParam, modelNameParam)
+	// If an error occurred, encode the error with the status code
+	if err != nil {
+		c.errorHandler(w, r, err, &result)
+		return
+	}
+	// If no error, encode the body and the result code
+	EncodeJSONResponse(result.Body, &result.Code, w)
+}
+
+// GetAllModelArtifacts - List CatalogModelArtifacts.
+func (c *ModelCatalogServiceAPIController) GetAllModelArtifacts(w http.ResponseWriter, r *http.Request) {
+	sourceIdParam := chi.URLParam(r, "source_id")
+	modelNameParam := chi.URLParam(r, "model_name")
+	result, err := c.service.GetAllModelArtifacts(r.Context(), sourceIdParam, modelNameParam)
+	// If an error occurred, encode the error with the status code
+	if err != nil {
+		c.errorHandler(w, r, err, &result)
+		return
+	}
+	// If no error, encode the body and the result code
+	EncodeJSONResponse(result.Body, &result.Code, w)
+}

catalog/internal/server/openapi/api_model_catalog_service_service.go

@@ -0,0 +1,172 @@
+package openapi
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"math"
+	"net/http"
+	"slices"
+	"strings"
+
+	"github.com/kubeflow/model-registry/catalog/internal/catalog"
+	model "github.com/kubeflow/model-registry/catalog/pkg/openapi"
+)
+
+// ModelCatalogServiceAPIService is a service that implements the logic for the ModelCatalogServiceAPIServicer
+// This service should implement the business logic for every endpoint for the ModelCatalogServiceAPI s.coreApi.
+// Include any external packages or services that will be required by this service.
+type ModelCatalogServiceAPIService struct {
+	sources *catalog.SourceCollection
+}
+
+// GetAllModelArtifacts retrieves all model artifacts for a given model from the specified source.
+func (m *ModelCatalogServiceAPIService) GetAllModelArtifacts(ctx context.Context, sourceID string, name string) (ImplResponse, error) {
+	source, ok := m.sources.Get(sourceID)
+	if !ok {
+		return notFound("Unknown source"), nil
+	}
+
+	artifacts, err := source.Provider.GetArtifacts(ctx, name)
+	if err != nil {
+		return Response(http.StatusInternalServerError, err), err
+	}
+
+	return Response(http.StatusOK, artifacts), nil
+}
+
+func (m *ModelCatalogServiceAPIService) FindModels(ctx context.Context, sourceID string, q string, pageSize string, orderBy model.OrderByField, sortOrder model.SortOrder, nextPageToken string) (ImplResponse, error) {
+	source, ok := m.sources.Get(sourceID)
+	if !ok {
+		return notFound("Unknown source"), errors.New("Unknown source")
+	}
+
+	p, err := newPaginator[model.CatalogModel](pageSize, orderBy, sortOrder, nextPageToken)
+	if err != nil {
+		return ErrorResponse(http.StatusBadRequest, err), err
+	}
+
+	listModelsParams := catalog.ListModelsParams{
+		Query:     q,
+		OrderBy:   p.OrderBy,
+		SortOrder: p.SortOrder,
+	}
+
+	models, err := source.Provider.ListModels(ctx, listModelsParams)
+	if err != nil {
+		return ErrorResponse(http.StatusInternalServerError, err), err
+	}
+
+	page, next := p.Paginate(models.Items)
+
+	models.Items = page
+	models.PageSize = p.PageSize
+	models.NextPageToken = next.Token()
+
+	return Response(http.StatusOK, models), nil
+}
+
+func (m *ModelCatalogServiceAPIService) GetModel(ctx context.Context, sourceID string, name string) (ImplResponse, error) {
+	if name, ok := strings.CutSuffix(name, "/artifacts"); ok {
+		return m.GetAllModelArtifacts(ctx, sourceID, name)
+	}
+
+	source, ok := m.sources.Get(sourceID)
+	if !ok {
+		return notFound("Unknown source"), nil
+	}
+
+	model, err := source.Provider.GetModel(ctx, name)
+	if err != nil {
+		return Response(http.StatusInternalServerError, err), err
+	}
+	if model == nil {
+		return notFound("Unknown model"), nil
+	}
+
+	return Response(http.StatusOK, model), nil
+}
+
+func (m *ModelCatalogServiceAPIService) FindSources(ctx context.Context, name string, strPageSize string, orderBy model.OrderByField, sortOrder model.SortOrder, nextPageToken string) (ImplResponse, error) {
+	sources := m.sources.All()
+	if len(sources) > math.MaxInt32 {
+		err := errors.New("too many registered models")
+		return ErrorResponse(http.StatusInternalServerError, err), err
+	}
+
+	paginator, err := newPaginator[model.CatalogSource](strPageSize, orderBy, sortOrder, nextPageToken)
+	if err != nil {
+		return ErrorResponse(http.StatusBadRequest, err), err
+	}
+
+	items := make([]model.CatalogSource, 0, len(sources))
+
+	name = strings.ToLower(name)
+
+	for _, v := range sources {
+		if !strings.Contains(strings.ToLower(v.Metadata.Name), name) {
+			continue
+		}
+
+		items = append(items, v.Metadata)
+	}
+
+	cmpFunc, err := genCatalogCmpFunc(orderBy, sortOrder)
+	if err != nil {
+		return ErrorResponse(http.StatusBadRequest, err), err
+	}
+	slices.SortStableFunc(items, cmpFunc)
+
+	total := int32(len(items))
+
+	pagedItems, next := paginator.Paginate(items)
+
+	res := model.CatalogSourceList{
+		PageSize:      paginator.PageSize,
+		Items:         pagedItems,
+		Size:          total,
+		NextPageToken: next.Token(),
+	}
+	return Response(http.StatusOK, res), nil
+}
+
+func genCatalogCmpFunc(orderBy model.OrderByField, sortOrder model.SortOrder) (func(model.CatalogSource, model.CatalogSource) int, error) {
+	multiplier := 1
+	switch model.SortOrder(strings.ToUpper(string(sortOrder))) {
+	case model.SORTORDER_DESC:
+		multiplier = -1
+	case model.SORTORDER_ASC, "":
+		multiplier = 1
+	default:
+		return nil, fmt.Errorf("unsupported sort order field")
+	}
+
+	switch model.OrderByField(strings.ToUpper(string(orderBy))) {
+	case model.ORDERBYFIELD_ID, "":
+		return func(a, b model.CatalogSource) int {
+			return multiplier * strings.Compare(a.Id, b.Id)
+		}, nil
+	case model.ORDERBYFIELD_NAME:
+		return func(a, b model.CatalogSource) int {
+			return multiplier * strings.Compare(a.Name, b.Name)
+		}, nil
+	default:
+		return nil, fmt.Errorf("unsupported order by field")
+	}
+}
+
+var _ ModelCatalogServiceAPIServicer = &ModelCatalogServiceAPIService{}
+
+// NewModelCatalogServiceAPIService creates a default api service
+func NewModelCatalogServiceAPIService(sources *catalog.SourceCollection) ModelCatalogServiceAPIServicer {
+	return &ModelCatalogServiceAPIService{
+		sources: sources,
+	}
+}
+
+func notFound(msg string) ImplResponse {
+	if msg == "" {
+		msg = "Resource not found"
+	}
+	return ErrorResponse(http.StatusNotFound, errors.New(msg))
+}

catalog/internal/server/openapi/api_model_catalog_service_service_test.go

@@ -0,0 +1,968 @@
+package openapi
+
+import (
+	"context"
+	"net/http"
+	"sort"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/kubeflow/model-registry/catalog/internal/catalog"
+	model "github.com/kubeflow/model-registry/catalog/pkg/openapi"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// timeToMillisStringPointer converts time.Time to *string representing milliseconds since epoch.
+func timeToMillisStringPointer(t time.Time) *string {
+	s := strconv.FormatInt(t.UnixMilli(), 10)
+	return &s
+}
+
+// pointerOrDefault returns the value pointed to by p, or def if p is nil.
+func pointerOrDefault(p *string, def string) string {
+	if p == nil {
+		return def
+	}
+	return *p
+}
+
+func TestFindModels(t *testing.T) {
+	// Define common models for testing
+	time1 := time.Date(2023, 1, 1, 0, 0, 0, 0, time.UTC)
+	time2 := time.Date(2023, 1, 2, 0, 0, 0, 0, time.UTC)
+	time3 := time.Date(2023, 1, 3, 0, 0, 0, 0, time.UTC)
+	time4 := time.Date(2023, 1, 4, 0, 0, 0, 0, time.UTC)
+
+	// Updated model definitions to match OpenAPI schema (no direct Id or Published, use Name, CreateTime, LastUpdateTime)
+	modelA := &model.CatalogModel{Name: "Model A", CreateTimeSinceEpoch: timeToMillisStringPointer(time1), LastUpdateTimeSinceEpoch: timeToMillisStringPointer(time4)}
+	modelB := &model.CatalogModel{Name: "Model B", CreateTimeSinceEpoch: timeToMillisStringPointer(time2), LastUpdateTimeSinceEpoch: timeToMillisStringPointer(time3)}
+	modelC := &model.CatalogModel{Name: "Another Model C", CreateTimeSinceEpoch: timeToMillisStringPointer(time3), LastUpdateTimeSinceEpoch: timeToMillisStringPointer(time2)}
+	modelD := &model.CatalogModel{Name: "My Model D", CreateTimeSinceEpoch: timeToMillisStringPointer(time4), LastUpdateTimeSinceEpoch: timeToMillisStringPointer(time1)}
+
+	testCases := []struct {
+		name              string
+		sourceID          string
+		mockModels        map[string]*model.CatalogModel
+		q                 string
+		pageSize          string
+		orderBy           model.OrderByField
+		sortOrder         model.SortOrder
+		nextPageToken     string
+		expectedStatus    int
+		expectedModelList *model.CatalogModelList
+	}{
+		{
+			name:     "Successful query with no filters",
+			sourceID: "source1",
+			mockModels: map[string]*model.CatalogModel{
+				"modelA": modelA, "modelB": modelB, "modelC": modelC, "modelD": modelD,
+			},
+			q:              "",
+			pageSize:       "10",
+			orderBy:        model.ORDERBYFIELD_NAME,
+			sortOrder:      model.SORTORDER_ASC,
+			expectedStatus: http.StatusOK,
+			expectedModelList: &model.CatalogModelList{
+				Items:         []model.CatalogModel{*modelC, *modelA, *modelB, *modelD}, // Sorted by Name ASC: Another Model C, Model A, Model B, My Model D
+				Size:          4,
+				PageSize:      10, // Default page size
+				NextPageToken: "",
+			},
+		},
+		{
+			name:     "Filter by query 'Model'",
+			sourceID: "source1",
+			mockModels: map[string]*model.CatalogModel{
+				"modelA": modelA, "modelB": modelB, "modelC": modelC, "modelD": modelD,
+			},
+			q:              "Model",
+			pageSize:       "10",
+			orderBy:        model.ORDERBYFIELD_NAME,
+			sortOrder:      model.SORTORDER_ASC,
+			expectedStatus: http.StatusOK,
+			expectedModelList: &model.CatalogModelList{
+				Items:         []model.CatalogModel{*modelC, *modelA, *modelB, *modelD}, // Corrected to include modelC and sorted by name ASC
+				Size:          4,                                                        // Corrected from 3 to 4
+				PageSize:      10,
+				NextPageToken: "",
+			},
+		},
+		{
+			name:     "Filter by query 'model' (case insensitive)",
+			sourceID: "source1",
+			mockModels: map[string]*model.CatalogModel{
+				"modelA": modelA, "modelB": modelB, "modelC": modelC, "modelD": modelD,
+			},
+			q:              "model",
+			pageSize:       "10",
+			orderBy:        model.ORDERBYFIELD_NAME,
+			sortOrder:      model.SORTORDER_ASC,
+			expectedStatus: http.StatusOK,
+			expectedModelList: &model.CatalogModelList{
+				Items:         []model.CatalogModel{*modelC, *modelA, *modelB, *modelD}, // Corrected to include modelC and sorted by name ASC
+				Size:          4,                                                        // Corrected from 3 to 4
+				PageSize:      10,
+				NextPageToken: "",
+			},
+		},
+		{
+			name:     "Page size limit",
+			sourceID: "source1",
+			mockModels: map[string]*model.CatalogModel{
+				"modelA": modelA, "modelB": modelB, "modelC": modelC, "modelD": modelD,
+			},
+			q:              "",
+			pageSize:       "2",
+			orderBy:        model.ORDERBYFIELD_NAME,
+			sortOrder:      model.SORTORDER_ASC,
+			expectedStatus: http.StatusOK,
+			expectedModelList: &model.CatalogModelList{
+				Items:         []model.CatalogModel{*modelC, *modelA}, // First 2 after sorting by Name ASC
+				Size:          4,                                      // Total size remains 4
+				PageSize:      2,
+				NextPageToken: (&stringCursor{Value: "Model A", ID: "Model A"}).String(),
+			},
+		},
+		{
+			name:     "Sort by ID Descending (mocked as Name Descending)",
+			sourceID: "source1",
+			mockModels: map[string]*model.CatalogModel{
+				"modelA": modelA, "modelB": modelB, "modelC": modelC, "modelD": modelD,
+			},
+			q:              "",
+			pageSize:       "10",
+			orderBy:        model.ORDERBYFIELD_ID,
+			sortOrder:      model.SORTORDER_DESC,
+			expectedStatus: http.StatusOK,
+			expectedModelList: &model.CatalogModelList{
+				Items:         []model.CatalogModel{*modelD, *modelB, *modelA, *modelC}, // Sorted by Name DESC
+				Size:          4,
+				PageSize:      10,
+				NextPageToken: "",
+			},
+		},
+		{
+			name:     "Sort by CreateTime Ascending",
+			sourceID: "source1",
+			mockModels: map[string]*model.CatalogModel{
+				"modelA": modelA, "modelB": modelB, "modelC": modelC, "modelD": modelD,
+			},
+			q:              "",
+			pageSize:       "10",
+			orderBy:        model.ORDERBYFIELD_CREATE_TIME,
+			sortOrder:      model.SORTORDER_ASC,
+			expectedStatus: http.StatusOK,
+			expectedModelList: &model.CatalogModelList{
+				Items:         []model.CatalogModel{*modelA, *modelB, *modelC, *modelD}, // Sorted by CreateTime ASC
+				Size:          4,
+				PageSize:      10,
+				NextPageToken: "",
+			},
+		},
+		{
+			name:     "Sort by LastUpdateTime Descending",
+			sourceID: "source1",
+			mockModels: map[string]*model.CatalogModel{
+				"modelA": modelA, "modelB": modelB, "modelC": modelC, "modelD": modelD,
+			},
+			q:              "",
+			pageSize:       "10",
+			orderBy:        model.ORDERBYFIELD_LAST_UPDATE_TIME,
+			sortOrder:      model.SORTORDER_DESC,
+			expectedStatus: http.StatusOK,
+			expectedModelList: &model.CatalogModelList{
+				Items:         []model.CatalogModel{*modelA, *modelB, *modelC, *modelD}, // Corrected to be sorted by LastUpdateTime DESC (modelA has latest time4, modelD has earliest time1)
+				Size:          4,
+				PageSize:      10,
+				NextPageToken: "",
+			},
+		},
+		{
+			name:              "Invalid source ID",
+			sourceID:          "unknown-source",
+			mockModels:        map[string]*model.CatalogModel{},
+			q:                 "",
+			pageSize:          "10",
+			orderBy:           model.ORDERBYFIELD_ID,
+			sortOrder:         model.SORTORDER_ASC,
+			expectedStatus:    http.StatusNotFound,
+			expectedModelList: nil,
+		},
+		{
+			name:     "Invalid pageSize string",
+			sourceID: "source1",
+			mockModels: map[string]*model.CatalogModel{
+				"modelA": modelA,
+			},
+			q:                 "",
+			pageSize:          "abc",
+			orderBy:           model.ORDERBYFIELD_ID,
+			sortOrder:         model.SORTORDER_ASC,
+			expectedStatus:    http.StatusBadRequest,
+			expectedModelList: nil,
+		},
+		{
+			name:     "Unsupported orderBy field",
+			sourceID: "source1",
+			mockModels: map[string]*model.CatalogModel{
+				"modelA": modelA,
+			},
+			q:                 "",
+			pageSize:          "10",
+			orderBy:           "UNSUPPORTED_FIELD",
+			sortOrder:         model.SORTORDER_ASC,
+			expectedStatus:    http.StatusBadRequest,
+			expectedModelList: nil,
+		},
+		{
+			name:     "Unsupported sortOrder field",
+			sourceID: "source1",
+			mockModels: map[string]*model.CatalogModel{
+				"modelA": modelA,
+			},
+			q:                 "",
+			pageSize:          "10",
+			orderBy:           model.ORDERBYFIELD_ID,
+			sortOrder:         "UNSUPPORTED_ORDER",
+			expectedStatus:    http.StatusBadRequest,
+			expectedModelList: nil,
+		},
+		{
+			name:           "Empty models in source",
+			sourceID:       "source1",
+			mockModels:     map[string]*model.CatalogModel{},
+			q:              "",
+			pageSize:       "10",
+			orderBy:        model.ORDERBYFIELD_ID,
+			sortOrder:      model.SORTORDER_ASC,
+			expectedStatus: http.StatusOK,
+			expectedModelList: &model.CatalogModelList{
+				Items:         []model.CatalogModel{},
+				Size:          0,
+				PageSize:      10,
+				NextPageToken: "",
+			},
+		},
+		{
+			name:     "Default sort (ID ascending) and default page size",
+			sourceID: "source1",
+			mockModels: map[string]*model.CatalogModel{
+				"modelB": modelB, "modelA": modelA, "modelD": modelD, "modelC": modelC,
+			},
+			q:              "",
+			pageSize:       "", // Default page size
+			orderBy:        "", // Default order by ID
+			sortOrder:      "", // Default sort order ASC
+			expectedStatus: http.StatusOK,
+			expectedModelList: &model.CatalogModelList{
+				Items:         []model.CatalogModel{*modelC, *modelA, *modelB, *modelD}, // Sorted by Name ASC (as ID is mocked to use Name)
+				Size:          4,
+				PageSize:      10, // Default page size
+				NextPageToken: "",
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			// Create mock source collection
+			sources := catalog.NewSourceCollection(map[string]catalog.CatalogSource{
+				"source1": {
+					Metadata: model.CatalogSource{Id: "source1", Name: "Test Source 1"},
+					Provider: &mockModelProvider{
+						models: tc.mockModels,
+					},
+				},
+			})
+			service := NewModelCatalogServiceAPIService(sources)
+
+			resp, err := service.FindModels(
+				context.Background(),
+				tc.sourceID,
+				tc.q,
+				tc.pageSize,
+				tc.orderBy,
+				tc.sortOrder,
+				tc.nextPageToken,
+			)
+
+			assert.Equal(t, tc.expectedStatus, resp.Code)
+
+			if tc.expectedStatus != http.StatusOK {
+				assert.NotNil(t, err)
+				return
+			}
+
+			require.NotNil(t, resp.Body)
+			modelList, ok := resp.Body.(model.CatalogModelList)
+			require.True(t, ok, "Response body should be a CatalogModelList")
+
+			assert.Equal(t, tc.expectedModelList.Size, modelList.Size)
+			assert.Equal(t, tc.expectedModelList.PageSize, modelList.PageSize)
+			if !assert.Equal(t, tc.expectedModelList.NextPageToken, modelList.NextPageToken) && tc.expectedModelList.NextPageToken != "" {
+				assert.Equal(t, decodeStringCursor(tc.expectedModelList.NextPageToken), decodeStringCursor(modelList.NextPageToken))
+			}
+
+			// Deep equality check for items
+			assert.Equal(t, tc.expectedModelList.Items, modelList.Items)
+		})
+	}
+}
+
+func TestFindSources(t *testing.T) {
+	// Setup test cases
+	trueValue := true
+	testCases := []struct {
+		name           string
+		catalogs       map[string]catalog.CatalogSource
+		nameFilter     string
+		pageSize       string
+		orderBy        model.OrderByField
+		sortOrder      model.SortOrder
+		nextPageToken  string
+		expectedStatus int
+		expectedSize   int32
+		expectedItems  int
+		checkSorting   bool
+	}{
+		{
+			name:           "Empty catalog list",
+			catalogs:       map[string]catalog.CatalogSource{},
+			nameFilter:     "",
+			pageSize:       "10",
+			orderBy:        model.ORDERBYFIELD_ID,
+			sortOrder:      model.SORTORDER_ASC,
+			expectedStatus: http.StatusOK,
+			expectedSize:   0,
+			expectedItems:  0,
+		},
+		{
+			name: "Single catalog",
+			catalogs: map[string]catalog.CatalogSource{
+				"catalog1": {
+					Metadata: model.CatalogSource{Id: "catalog1", Name: "Test Catalog 1", Enabled: &trueValue},
+				},
+			},
+			nameFilter:     "",
+			pageSize:       "10",
+			orderBy:        model.ORDERBYFIELD_ID,
+			sortOrder:      model.SORTORDER_ASC,
+			expectedStatus: http.StatusOK,
+			expectedSize:   1,
+			expectedItems:  1,
+		},
+		{
+			name: "Multiple catalogs with no filter",
+			catalogs: map[string]catalog.CatalogSource{
+				"catalog1": {
+					Metadata: model.CatalogSource{Id: "catalog1", Name: "Test Catalog 1", Enabled: &trueValue},
+				},
+				"catalog2": {
+					Metadata: model.CatalogSource{Id: "catalog2", Name: "Test Catalog 2", Enabled: &trueValue},
+				},
+				"catalog3": {
+					Metadata: model.CatalogSource{Id: "catalog3", Name: "Another Catalog", Enabled: &trueValue},
+				},
+			},
+			nameFilter:     "",
+			pageSize:       "10",
+			orderBy:        model.ORDERBYFIELD_ID,
+			sortOrder:      model.SORTORDER_ASC,
+			expectedStatus: http.StatusOK,
+			expectedSize:   3,
+			expectedItems:  3,
+		},
+		{
+			name: "Filter by name",
+			catalogs: map[string]catalog.CatalogSource{
+				"catalog1": {
+					Metadata: model.CatalogSource{Id: "catalog1", Name: "Test Catalog 1", Enabled: &trueValue},
+				},
+				"catalog2": {
+					Metadata: model.CatalogSource{Id: "catalog2", Name: "Test Catalog 2", Enabled: &trueValue},
+				},
+				"catalog3": {
+					Metadata: model.CatalogSource{Id: "catalog3", Name: "Another Catalog", Enabled: &trueValue},
+				},
+			},
+			nameFilter:     "Test",
+			pageSize:       "10",
+			orderBy:        model.ORDERBYFIELD_ID,
+			sortOrder:      model.SORTORDER_ASC,
+			expectedStatus: http.StatusOK,
+			expectedSize:   2,
+			expectedItems:  2,
+		},
+		{
+			name: "Filter by name case insensitive",
+			catalogs: map[string]catalog.CatalogSource{
+				"catalog1": {
+					Metadata: model.CatalogSource{Id: "catalog1", Name: "Test Catalog 1", Enabled: &trueValue},
+				},
+				"catalog2": {
+					Metadata: model.CatalogSource{Id: "catalog2", Name: "Test Catalog 2", Enabled: &trueValue},
+				},
+				"catalog3": {
+					Metadata: model.CatalogSource{Id: "catalog3", Name: "Another Catalog", Enabled: &trueValue},
+				},
+			},
+			nameFilter:     "test",
+			pageSize:       "10",
+			orderBy:        model.ORDERBYFIELD_ID,
+			sortOrder:      model.SORTORDER_ASC,
+			expectedStatus: http.StatusOK,
+			expectedSize:   2,
+			expectedItems:  2,
+		},
+		{
+			name: "Pagination - limit results",
+			catalogs: map[string]catalog.CatalogSource{
+				"catalog1": {
+					Metadata: model.CatalogSource{Id: "catalog1", Name: "Test Catalog 1", Enabled: &trueValue},
+				},
+				"catalog2": {
+					Metadata: model.CatalogSource{Id: "catalog2", Name: "Test Catalog 2", Enabled: &trueValue},
+				},
+				"catalog3": {
+					Metadata: model.CatalogSource{Id: "catalog3", Name: "Another Catalog", Enabled: &trueValue},
+				},
+			},
+			nameFilter:     "",
+			pageSize:       "2",
+			orderBy:        model.ORDERBYFIELD_ID,
+			sortOrder:      model.SORTORDER_ASC,
+			expectedStatus: http.StatusOK,
+			expectedSize:   3, // Total size should be 3
+			expectedItems:  2, // But only 2 items returned due to page size
+		},
+		{
+			name: "Default page size",
+			catalogs: map[string]catalog.CatalogSource{
+				"catalog1": {
+					Metadata: model.CatalogSource{Id: "catalog1", Name: "Test Catalog 1", Enabled: &trueValue},
+				},
+				"catalog2": {
+					Metadata: model.CatalogSource{Id: "catalog2", Name: "Test Catalog 2", Enabled: &trueValue},
+				},
+			},
+			nameFilter:     "",
+			pageSize:       "", // Empty to test default
+			orderBy:        model.ORDERBYFIELD_ID,
+			sortOrder:      model.SORTORDER_ASC,
+			expectedStatus: http.StatusOK,
+			expectedSize:   2,
+			expectedItems:  2,
+		},
+		{
+			name: "Invalid page size",
+			catalogs: map[string]catalog.CatalogSource{
+				"catalog1": {
+					Metadata: model.CatalogSource{Id: "catalog1", Name: "Test Catalog 1", Enabled: &trueValue},
+				},
+			},
+			nameFilter:     "",
+			pageSize:       "invalid",
+			orderBy:        model.ORDERBYFIELD_ID,
+			sortOrder:      model.SORTORDER_ASC,
+			expectedStatus: http.StatusBadRequest,
+		},
+		{
+			name: "Sort by ID ascending",
+			catalogs: map[string]catalog.CatalogSource{
+				"catalog2": {
+					Metadata: model.CatalogSource{Id: "catalog2", Name: "B Catalog", Enabled: &trueValue},
+				},
+				"catalog1": {
+					Metadata: model.CatalogSource{Id: "catalog1", Name: "A Catalog", Enabled: &trueValue},
+				},
+				"catalog3": {
+					Metadata: model.CatalogSource{Id: "catalog3", Name: "C Catalog", Enabled: &trueValue},
+				},
+			},
+			nameFilter:     "",
+			pageSize:       "10",
+			orderBy:        model.ORDERBYFIELD_ID,
+			sortOrder:      model.SORTORDER_ASC,
+			expectedStatus: http.StatusOK,
+			expectedSize:   3,
+			expectedItems:  3,
+			checkSorting:   true,
+		},
+		{
+			name: "Sort by ID descending",
+			catalogs: map[string]catalog.CatalogSource{
+				"catalog2": {
+					Metadata: model.CatalogSource{Id: "catalog2", Name: "B Catalog", Enabled: &trueValue},
+				},
+				"catalog1": {
+					Metadata: model.CatalogSource{Id: "catalog1", Name: "A Catalog", Enabled: &trueValue},
+				},
+				"catalog3": {
+					Metadata: model.CatalogSource{Id: "catalog3", Name: "C Catalog", Enabled: &trueValue},
+				},
+			},
+			nameFilter:     "",
+			pageSize:       "10",
+			orderBy:        model.ORDERBYFIELD_ID,
+			sortOrder:      model.SORTORDER_DESC,
+			expectedStatus: http.StatusOK,
+			expectedSize:   3,
+			expectedItems:  3,
+			checkSorting:   true,
+		},
+		{
+			name: "Sort by name ascending",
+			catalogs: map[string]catalog.CatalogSource{
+				"catalog2": {
+					Metadata: model.CatalogSource{Id: "catalog2", Name: "B Catalog", Enabled: &trueValue},
+				},
+				"catalog1": {
+					Metadata: model.CatalogSource{Id: "catalog1", Name: "A Catalog", Enabled: &trueValue},
+				},
+				"catalog3": {
+					Metadata: model.CatalogSource{Id: "catalog3", Name: "C Catalog", Enabled: &trueValue},
+				},
+			},
+			nameFilter:     "",
+			pageSize:       "10",
+			orderBy:        model.ORDERBYFIELD_NAME,
+			sortOrder:      model.SORTORDER_ASC,
+			expectedStatus: http.StatusOK,
+			expectedSize:   3,
+			expectedItems:  3,
+			checkSorting:   true,
+		},
+		{
+			name: "Sort by name descending",
+			catalogs: map[string]catalog.CatalogSource{
+				"catalog2": {
+					Metadata: model.CatalogSource{Id: "catalog2", Name: "B Catalog", Enabled: &trueValue},
+				},
+				"catalog1": {
+					Metadata: model.CatalogSource{Id: "catalog1", Name: "A Catalog", Enabled: &trueValue},
+				},
+				"catalog3": {
+					Metadata: model.CatalogSource{Id: "catalog3", Name: "C Catalog"},
+				},
+			},
+			nameFilter:     "",
+			pageSize:       "10",
+			orderBy:        model.ORDERBYFIELD_NAME,
+			sortOrder:      model.SORTORDER_DESC,
+			expectedStatus: http.StatusOK,
+			expectedSize:   3,
+			expectedItems:  3,
+			checkSorting:   true,
+		},
+		{
+			name: "Invalid sort order",
+			catalogs: map[string]catalog.CatalogSource{
+				"catalog1": {
+					Metadata: model.CatalogSource{Id: "catalog1", Name: "Test Catalog 1"},
+				},
+			},
+			nameFilter:     "",
+			pageSize:       "10",
+			orderBy:        model.ORDERBYFIELD_ID,
+			sortOrder:      "INVALID",
+			expectedStatus: http.StatusBadRequest,
+		},
+		{
+			name: "Invalid order by field",
+			catalogs: map[string]catalog.CatalogSource{
+				"catalog1": {
+					Metadata: model.CatalogSource{Id: "catalog1", Name: "Test Catalog 1"},
+				},
+			},
+			nameFilter:     "",
+			pageSize:       "10",
+			orderBy:        "INVALID",
+			sortOrder:      model.SORTORDER_ASC,
+			expectedStatus: http.StatusBadRequest,
+		},
+		{
+			name: "Default sort order (ID ascending)",
+			catalogs: map[string]catalog.CatalogSource{
+				"catalog2": {
+					Metadata: model.CatalogSource{Id: "catalog2", Name: "B Catalog"},
+				},
+				"catalog1": {
+					Metadata: model.CatalogSource{Id: "catalog1", Name: "A Catalog"},
+				},
+				"catalog3": {
+					Metadata: model.CatalogSource{Id: "catalog3", Name: "C Catalog"},
+				},
+			},
+			nameFilter:     "",
+			pageSize:       "10",
+			orderBy:        "", // Empty to test default
+			sortOrder:      "", // Empty to test default
+			expectedStatus: http.StatusOK,
+			expectedSize:   3,
+			expectedItems:  3,
+			checkSorting:   true,
+		},
+	}
+
+	// Run test cases
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			// Create service with test catalogs
+			service := NewModelCatalogServiceAPIService(catalog.NewSourceCollection(tc.catalogs))
+
+			// Call FindSources
+			resp, err := service.FindSources(
+				context.Background(),
+				tc.nameFilter,
+				tc.pageSize,
+				tc.orderBy,
+				tc.sortOrder,
+				tc.nextPageToken,
+			)
+
+			// Check response status
+			assert.Equal(t, tc.expectedStatus, resp.Code)
+
+			// If we expect an error, we don't need to check the response body
+			if tc.expectedStatus != http.StatusOK {
+				assert.NotNil(t, err)
+				return
+			}
+
+			// For successful responses, check the response body
+			require.NotNil(t, resp.Body)
+
+			// Type assertion to access the CatalogSourceList
+			sourceList, ok := resp.Body.(model.CatalogSourceList)
+			require.True(t, ok, "Response body should be a CatalogSourceList")
+
+			// Check the size matches expected
+			assert.Equal(t, tc.expectedSize, sourceList.Size)
+
+			// Check the number of items matches expected
+			assert.Equal(t, tc.expectedItems, len(sourceList.Items))
+
+			// Check that page size is set correctly
+			if tc.pageSize == "" {
+				// Default page size should be 10
+				assert.Equal(t, int32(10), sourceList.PageSize)
+			} else if pageSizeInt, err := strconv.ParseInt(tc.pageSize, 10, 32); err == nil {
+				assert.Equal(t, int32(pageSizeInt), sourceList.PageSize)
+			}
+
+			// Check sorting if required
+			if tc.checkSorting && len(sourceList.Items) > 1 {
+				switch tc.orderBy {
+				case model.ORDERBYFIELD_ID, "":
+					// Check ID sorting
+					for i := 0; i < len(sourceList.Items)-1; i++ {
+						if tc.sortOrder == "" || tc.sortOrder == model.SORTORDER_ASC {
+							assert.LessOrEqual(t,
+								sourceList.Items[i].Id,
+								sourceList.Items[i+1].Id,
+								"Items should be sorted by ID in ascending order")
+						} else {
+							assert.GreaterOrEqual(t,
+								sourceList.Items[i].Id,
+								sourceList.Items[i+1].Id,
+								"Items should be sorted by ID in descending order")
+						}
+					}
+				case model.ORDERBYFIELD_NAME:
+					// Check name sorting
+					for i := 0; i < len(sourceList.Items)-1; i++ {
+						if tc.sortOrder == "" || tc.sortOrder == model.SORTORDER_ASC {
+							assert.LessOrEqual(t,
+								sourceList.Items[i].Name,
+								sourceList.Items[i+1].Name,
+								"Items should be sorted by name in ascending order")
+						} else {
+							assert.GreaterOrEqual(t,
+								sourceList.Items[i].Name,
+								sourceList.Items[i+1].Name,
+								"Items should be sorted by name in descending order")
+						}
+					}
+				}
+			}
+		})
+	}
+}
+
+// Define a mock model provider
+type mockModelProvider struct {
+	models    map[string]*model.CatalogModel
+	artifacts map[string][]model.CatalogModelArtifact
+}
+
+// Implement GetModel method for the mock provider
+func (m *mockModelProvider) GetModel(ctx context.Context, name string) (*model.CatalogModel, error) {
+	model, exists := m.models[name]
+	if !exists {
+		return nil, nil
+	}
+	return model, nil
+}
+
+func (m *mockModelProvider) ListModels(ctx context.Context, params catalog.ListModelsParams) (model.CatalogModelList, error) {
+	var filteredModels []*model.CatalogModel
+	for _, mdl := range m.models {
+		if params.Query == "" || strings.Contains(strings.ToLower(mdl.Name), strings.ToLower(params.Query)) {
+			filteredModels = append(filteredModels, mdl)
+		}
+	}
+
+	// Sort the filtered models
+	sort.SliceStable(filteredModels, func(i, j int) bool {
+		cmp := 0
+		switch params.OrderBy {
+		case model.ORDERBYFIELD_CREATE_TIME:
+			// Parse CreateTimeSinceEpoch strings to int64 for comparison
+			t1, _ := strconv.ParseInt(pointerOrDefault(filteredModels[i].CreateTimeSinceEpoch, "0"), 10, 64)
+			t2, _ := strconv.ParseInt(pointerOrDefault(filteredModels[j].CreateTimeSinceEpoch, "0"), 10, 64)
+			cmp = int(t1 - t2)
+		case model.ORDERBYFIELD_LAST_UPDATE_TIME:
+			// Parse LastUpdateTimeSinceEpoch strings to int64 for comparison
+			t1, _ := strconv.ParseInt(pointerOrDefault(filteredModels[i].LastUpdateTimeSinceEpoch, "0"), 10, 64)
+			t2, _ := strconv.ParseInt(pointerOrDefault(filteredModels[j].LastUpdateTimeSinceEpoch, "0"), 10, 64)
+			cmp = int(t1 - t2)
+		case model.ORDERBYFIELD_NAME:
+			fallthrough
+		default:
+			cmp = strings.Compare(filteredModels[i].Name, filteredModels[j].Name)
+		}
+
+		if params.SortOrder == model.SORTORDER_DESC {
+			return cmp > 0
+		}
+		return cmp < 0
+	})
+
+	items := make([]model.CatalogModel, len(filteredModels))
+	for i, mdl := range filteredModels {
+		items[i] = *mdl
+	}
+
+	return model.CatalogModelList{
+		Items:         items,
+		Size:          int32(len(items)),
+		PageSize:      int32(len(items)), // Mock returns all filtered items as one "page"
+		NextPageToken: "",
+	}, nil
+}
+
+func (m *mockModelProvider) GetArtifacts(ctx context.Context, name string) (*model.CatalogModelArtifactList, error) {
+	artifacts, exists := m.artifacts[name]
+	if !exists {
+		return &model.CatalogModelArtifactList{
+			Items:         []model.CatalogModelArtifact{},
+			Size:          0,
+			PageSize:      0, // Or a default page size if applicable
+			NextPageToken: "",
+		}, nil
+	}
+	return &model.CatalogModelArtifactList{
+		Items:         artifacts,
+		Size:          int32(len(artifacts)),
+		PageSize:      int32(len(artifacts)),
+		NextPageToken: "",
+	}, nil
+}
+
+func TestGetModel(t *testing.T) {
+	testCases := []struct {
+		name           string
+		sources        map[string]catalog.CatalogSource
+		sourceID       string
+		modelName      string
+		expectedStatus int
+		expectedModel  *model.CatalogModel
+	}{
+		{
+			name: "Existing model in source",
+			sources: map[string]catalog.CatalogSource{
+				"source1": {
+					Metadata: model.CatalogSource{Id: "source1", Name: "Test Source"},
+					Provider: &mockModelProvider{
+						models: map[string]*model.CatalogModel{
+							"test-model": {
+								Name: "test-model",
+							},
+						},
+					},
+				},
+			},
+			sourceID:       "source1",
+			modelName:      "test-model",
+			expectedStatus: http.StatusOK,
+			expectedModel: &model.CatalogModel{
+				Name: "test-model",
+			},
+		},
+		{
+			name: "Non-existing source",
+			sources: map[string]catalog.CatalogSource{
+				"source1": {
+					Metadata: model.CatalogSource{Id: "source1", Name: "Test Source"},
+				},
+			},
+			sourceID:       "source2",
+			modelName:      "test-model",
+			expectedStatus: http.StatusNotFound,
+			expectedModel:  nil,
+		},
+		{
+			name: "Existing source, non-existing model",
+			sources: map[string]catalog.CatalogSource{
+				"source1": {
+					Metadata: model.CatalogSource{Id: "source1", Name: "Test Source"},
+					Provider: &mockModelProvider{
+						models: map[string]*model.CatalogModel{},
+					},
+				},
+			},
+			sourceID:       "source1",
+			modelName:      "test-model",
+			expectedStatus: http.StatusNotFound,
+			expectedModel:  nil,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			// Create service with test sources
+			service := NewModelCatalogServiceAPIService(catalog.NewSourceCollection(tc.sources))
+
+			// Call GetModel
+			resp, _ := service.GetModel(
+				context.Background(),
+				tc.sourceID,
+				tc.modelName,
+			)
+
+			// Check response status
+			assert.Equal(t, tc.expectedStatus, resp.Code)
+
+			// If we expect an error or not found, we don't need to check the response body
+			if tc.expectedStatus != http.StatusOK {
+				return
+			}
+
+			// For successful responses, check the response body
+			require.NotNil(t, resp.Body)
+
+			// Type assertion to access the Model
+			model, ok := resp.Body.(*model.CatalogModel)
+			require.True(t, ok, "Response body should be a Model")
+
+			// Check the model details
+			assert.Equal(t, tc.expectedModel.Name, model.Name)
+		})
+	}
+}
+
+func TestGetAllModelArtifacts(t *testing.T) {
+	testCases := []struct {
+		name              string
+		sources           map[string]catalog.CatalogSource
+		sourceID          string
+		modelName         string
+		expectedStatus    int
+		expectedArtifacts []model.CatalogModelArtifact
+	}{
+		{
+			name: "Existing artifacts for model in source",
+			sources: map[string]catalog.CatalogSource{
+				"source1": {
+					Metadata: model.CatalogSource{Id: "source1", Name: "Test Source"},
+					Provider: &mockModelProvider{
+						artifacts: map[string][]model.CatalogModelArtifact{
+							"test-model": {
+								{
+									Uri: "s3://bucket/artifact1",
+								},
+								{
+									Uri: "s3://bucket/artifact2",
+								},
+							},
+						},
+					},
+				},
+			},
+			sourceID:       "source1",
+			modelName:      "test-model",
+			expectedStatus: http.StatusOK,
+			expectedArtifacts: []model.CatalogModelArtifact{
+				{
+					Uri: "s3://bucket/artifact1",
+				},
+				{
+					Uri: "s3://bucket/artifact2",
+				},
+			},
+		},
+		{
+			name: "Non-existing source",
+			sources: map[string]catalog.CatalogSource{
+				"source1": {
+					Metadata: model.CatalogSource{Id: "source1", Name: "Test Source"},
+				},
+			},
+			sourceID:          "source2",
+			modelName:         "test-model",
+			expectedStatus:    http.StatusNotFound,
+			expectedArtifacts: nil,
+		},
+		{
+			name: "Existing source, no artifacts for model",
+			sources: map[string]catalog.CatalogSource{
+				"source1": {
+					Metadata: model.CatalogSource{Id: "source1", Name: "Test Source"},
+					Provider: &mockModelProvider{
+						artifacts: map[string][]model.CatalogModelArtifact{},
+					},
+				},
+			},
+			sourceID:          "source1",
+			modelName:         "test-model",
+			expectedStatus:    http.StatusOK,
+			expectedArtifacts: []model.CatalogModelArtifact{}, // Should be an empty slice, not nil
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			// Create service with test sources
+			service := NewModelCatalogServiceAPIService(catalog.NewSourceCollection(tc.sources))
+
+			// Call GetAllModelArtifacts
+			resp, _ := service.GetAllModelArtifacts(
+				context.Background(),
+				tc.sourceID,
+				tc.modelName,
+			)
+
+			// Check response status
+			assert.Equal(t, tc.expectedStatus, resp.Code)
+
+			// If we expect an error or not found, we don't need to check the response body
+			if tc.expectedStatus != http.StatusOK {
+				return
+			}
+
+			// For successful responses, check the response body
+			require.NotNil(t, resp.Body)
+
+			// Type assertion to access the list of artifacts
+			artifactList, ok := resp.Body.(*model.CatalogModelArtifactList)
+			require.True(t, ok, "Response body should be a CatalogModelArtifactList")
+
+			// Check the artifacts
+			assert.Equal(t, tc.expectedArtifacts, artifactList.Items)
+			assert.Equal(t, int32(len(tc.expectedArtifacts)), artifactList.Size)
+		})
+	}
+}

catalog/internal/server/openapi/error.go

@@ -0,0 +1,61 @@
+/*
+ * Model Catalog REST API
+ *
+ * REST API for Model Registry to create and manage ML model metadata
+ *
+ * API version: v1alpha1
+ */
+
+// Generated by: OpenAPI Generator (https://openapi-generator.tech). DO NOT EDIT.
+
+package openapi
+
+import (
+	"errors"
+	"fmt"
+	"net/http"
+)
+
+// ErrTypeAssertionError is thrown when type an interface does not match the asserted type
+var ErrTypeAssertionError = errors.New("unable to assert type")
+
+// ParsingError indicates that an error has occurred when parsing request parameters
+type ParsingError struct {
+	Err error
+}
+
+func (e *ParsingError) Unwrap() error {
+	return e.Err
+}
+
+func (e *ParsingError) Error() string {
+	return e.Err.Error()
+}
+
+// RequiredError indicates that an error has occurred when parsing request parameters
+type RequiredError struct {
+	Field string
+}
+
+func (e *RequiredError) Error() string {
+	return fmt.Sprintf("required field '%s' is zero value.", e.Field)
+}
+
+// ErrorHandler defines the required method for handling error. You may implement it and inject this into a controller if
+// you would like errors to be handled differently from the DefaultErrorHandler
+type ErrorHandler func(w http.ResponseWriter, r *http.Request, err error, result *ImplResponse)
+
+// DefaultErrorHandler defines the default logic on how to handle errors from the controller. Any errors from parsing
+// request params will return a StatusBadRequest. Otherwise, the error code originating from the servicer will be used.
+func DefaultErrorHandler(w http.ResponseWriter, r *http.Request, err error, result *ImplResponse) {
+	if _, ok := err.(*ParsingError); ok {
+		// Handle parsing errors
+		EncodeJSONResponse(ErrorResponse(http.StatusBadRequest, err).Body, func(i int) *int { return &i }(http.StatusBadRequest), w)
+	} else if _, ok := err.(*RequiredError); ok {
+		// Handle missing required errors
+		EncodeJSONResponse(ErrorResponse(http.StatusBadRequest, err).Body, func(i int) *int { return &i }(http.StatusUnprocessableEntity), w)
+	} else {
+		// Handle all other errors
+		EncodeJSONResponse(result.Body, &result.Code, w)
+	}
+}

catalog/internal/server/openapi/helpers.go

@@ -0,0 +1,74 @@
+/*
+ * Model Catalog REST API
+ *
+ * REST API for Model Registry to create and manage ML model metadata
+ *
+ * API version: v1alpha1
+ */
+
+// Generated by: OpenAPI Generator (https://openapi-generator.tech). DO NOT EDIT.
+
+package openapi
+
+import (
+	"net/http"
+	"reflect"
+
+	model "github.com/kubeflow/model-registry/pkg/openapi"
+)
+
+// Response return a ImplResponse struct filled
+func Response(code int, body interface{}) ImplResponse {
+	return ImplResponse{
+		Code: code,
+		Body: body,
+	}
+}
+
+func ErrorResponse(code int, err error) ImplResponse {
+	return ImplResponse{
+		Code: code,
+		Body: model.Error{
+			Code:    http.StatusText(code),
+			Message: err.Error(),
+		},
+	}
+}
+
+// IsZeroValue checks if the val is the zero-ed value.
+func IsZeroValue(val interface{}) bool {
+	return val == nil || reflect.DeepEqual(val, reflect.Zero(reflect.TypeOf(val)).Interface())
+}
+
+// AssertRecurseInterfaceRequired recursively checks each struct in a slice against the callback.
+// This method traverse nested slices in a preorder fashion.
+func AssertRecurseInterfaceRequired[T any](obj interface{}, callback func(T) error) error {
+	return AssertRecurseValueRequired(reflect.ValueOf(obj), callback)
+}
+
+// AssertRecurseValueRequired checks each struct in the nested slice against the callback.
+// This method traverse nested slices in a preorder fashion. ErrTypeAssertionError is thrown if
+// the underlying struct does not match type T.
+func AssertRecurseValueRequired[T any](value reflect.Value, callback func(T) error) error {
+	switch value.Kind() {
+	// If it is a struct we check using callback
+	case reflect.Struct:
+		obj, ok := value.Interface().(T)
+		if !ok {
+			return ErrTypeAssertionError
+		}
+
+		if err := callback(obj); err != nil {
+			return err
+		}
+
+	// If it is a slice we continue recursion
+	case reflect.Slice:
+		for i := 0; i < value.Len(); i += 1 {
+			if err := AssertRecurseValueRequired(value.Index(i), callback); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}

catalog/internal/server/openapi/impl.go

@@ -0,0 +1,17 @@
+/*
+ * Model Catalog REST API
+ *
+ * REST API for Model Registry to create and manage ML model metadata
+ *
+ * API version: v1alpha1
+ */
+
+// Generated by: OpenAPI Generator (https://openapi-generator.tech). DO NOT EDIT.
+
+package openapi
+
+// ImplResponse defines an implementation response with error code and the associated body
+type ImplResponse struct {
+	Code int
+	Body interface{}
+}

catalog/internal/server/openapi/logger.go

@@ -0,0 +1,20 @@
+/*
+ * Model Catalog REST API
+ *
+ * REST API for Model Registry to create and manage ML model metadata
+ *
+ * API version: v1alpha1
+ */
+
+// Generated by: OpenAPI Generator (https://openapi-generator.tech). DO NOT EDIT.
+
+package openapi
+
+import (
+	"github.com/go-chi/chi/v5/middleware"
+	"net/http"
+)
+
+func Logger(inner http.Handler) http.Handler {
+	return middleware.Logger(inner)
+}

catalog/internal/server/openapi/pagination.go

@@ -0,0 +1,123 @@
+package openapi
+
+import (
+	"encoding/base64"
+	"fmt"
+	"strconv"
+	"strings"
+
+	model "github.com/kubeflow/model-registry/catalog/pkg/openapi"
+)
+
+type paginator[T model.Sortable] struct {
+	PageSize  int32
+	OrderBy   model.OrderByField
+	SortOrder model.SortOrder
+	cursor    *stringCursor
+}
+
+func newPaginator[T model.Sortable](pageSize string, orderBy model.OrderByField, sortOrder model.SortOrder, nextPageToken string) (*paginator[T], error) {
+	if orderBy != "" && !orderBy.IsValid() {
+		return nil, fmt.Errorf("unsupported order by field: %s", orderBy)
+	}
+	if sortOrder != "" && !sortOrder.IsValid() {
+		return nil, fmt.Errorf("unsupported sort order field: %s", sortOrder)
+	}
+
+	p := &paginator[T]{
+		PageSize:  10, // Default page size
+		OrderBy:   orderBy,
+		SortOrder: sortOrder,
+	}
+
+	if pageSize != "" {
+		pageSize64, err := strconv.ParseInt(pageSize, 10, 32)
+		if err != nil {
+			return nil, fmt.Errorf("error converting page size to int32: %w", err)
+		}
+		p.PageSize = int32(pageSize64)
+	}
+
+	if nextPageToken != "" {
+		p.cursor = decodeStringCursor(nextPageToken)
+	}
+
+	return p, nil
+}
+
+func (p *paginator[T]) Token() string {
+	if p == nil || p.cursor == nil {
+		return ""
+	}
+	return p.cursor.String()
+}
+
+func (p *paginator[T]) Paginate(items []T) ([]T, *paginator[T]) {
+	startIndex := 0
+	if p.cursor != nil {
+		for i, item := range items {
+			itemValue := item.SortValue(p.OrderBy)
+			id := item.SortValue(model.ORDERBYFIELD_ID)
+			if id != "" && id == p.cursor.ID && itemValue == p.cursor.Value {
+				startIndex = i + 1
+				break
+			}
+		}
+	}
+
+	if startIndex >= len(items) {
+		return []T{}, nil
+	}
+
+	var pagedItems []T
+	var next *paginator[T]
+
+	endIndex := startIndex + int(p.PageSize)
+	if endIndex > len(items) {
+		endIndex = len(items)
+	}
+	pagedItems = items[startIndex:endIndex]
+
+	if endIndex < len(items) {
+		lastItem := pagedItems[len(pagedItems)-1]
+		lastItemID := lastItem.SortValue(model.ORDERBYFIELD_ID)
+		if lastItemID != "" {
+			next = &paginator[T]{
+				PageSize:  p.PageSize,
+				OrderBy:   p.OrderBy,
+				SortOrder: p.SortOrder,
+				cursor: &stringCursor{
+					Value: lastItem.SortValue(p.OrderBy),
+					ID:    lastItemID,
+				},
+			}
+		}
+	}
+
+	return pagedItems, next
+}
+
+type stringCursor struct {
+	Value string
+	ID    string
+}
+
+func (c *stringCursor) String() string {
+	return base64.StdEncoding.EncodeToString([]byte(fmt.Sprintf("%s:%s", c.Value, c.ID)))
+}
+
+func decodeStringCursor(encoded string) *stringCursor {
+	decoded, err := base64.StdEncoding.DecodeString(encoded)
+	if err != nil {
+		// Show the first page on a bad token.
+		return nil
+	}
+	parts := strings.SplitN(string(decoded), ":", 2)
+	if len(parts) != 2 {
+		return nil
+	}
+	return &stringCursor{
+		Value: parts[0],
+		ID:    parts[1],
+	}
+}

catalog/internal/server/openapi/pagination_test.go

@@ -0,0 +1,180 @@
+package openapi
+
+import (
+	"strconv"
+	"testing"
+
+	model "github.com/kubeflow/model-registry/catalog/pkg/openapi"
+	"github.com/stretchr/testify/assert"
+)
+
+func createCatalogSource(id int) model.CatalogSource {
+	return model.CatalogSource{
+		Id:   "source" + strconv.Itoa(id),
+		Name: "Source " + strconv.Itoa(id),
+	}
+}
+
+func createCatalogSources(count int) []model.CatalogSource {
+	sources := make([]model.CatalogSource, count)
+	for i := 0; i < count; i++ {
+		sources[i] = createCatalogSource(i)
+	}
+	return sources
+}
+
+func TestPaginateSources(t *testing.T) {
+	allSources := createCatalogSources(25)
+
+	testCases := []struct {
+		name               string
+		items              []model.CatalogSource
+		pageSize           string
+		orderBy            model.OrderByField
+		nextPageToken      string
+		expectedItemsCount int
+		expectedNextToken  bool
+		expectedFirstID    string
+		expectedLastID     string
+	}{
+		{
+			name:               "First page, full page",
+			items:              allSources,
+			pageSize:           "10",
+			orderBy:            "ID",
+			nextPageToken:      "",
+			expectedItemsCount: 10,
+			expectedNextToken:  true,
+			expectedFirstID:    "source0",
+			expectedLastID:     "source9",
+		},
+		{
+			name:               "Second page, full page",
+			items:              allSources,
+			pageSize:           "10",
+			orderBy:            "ID",
+			nextPageToken:      (&stringCursor{Value: "source9", ID: "source9"}).String(),
+			expectedItemsCount: 10,
+			expectedNextToken:  true,
+			expectedFirstID:    "source10",
+			expectedLastID:     "source19",
+		},
+		{
+			name:               "Last page, partial page",
+			items:              allSources,
+			pageSize:           "10",
+			orderBy:            "ID",
+			nextPageToken:      (&stringCursor{Value: "source19", ID: "source19"}).String(),
+			expectedItemsCount: 5,
+			expectedNextToken:  false,
+			expectedFirstID:    "source20",
+			expectedLastID:     "source24",
+		},
+		{
+			name:               "Page size larger than items",
+			items:              allSources,
+			pageSize:           "30",
+			orderBy:            "ID",
+			nextPageToken:      "",
+			expectedItemsCount: 25,
+			expectedNextToken:  false,
+			expectedFirstID:    "source0",
+			expectedLastID:     "source24",
+		},
+		{
+			name:               "Empty items",
+			items:              []model.CatalogSource{},
+			pageSize:           "10",
+			orderBy:            "ID",
+			nextPageToken:      "",
+			expectedItemsCount: 0,
+			expectedNextToken:  false,
+		},
+		{
+			name:               "Order by Name, first page",
+			items:              allSources,
+			pageSize:           "5",
+			orderBy:            "NAME",
+			nextPageToken:      "",
+			expectedItemsCount: 5,
+			expectedNextToken:  true,
+			expectedFirstID:    "source0",
+			expectedLastID:     "source4",
+		},
+		{
+			name:               "Order by Name, second page",
+			items:              allSources,
+			pageSize:           "5",
+			orderBy:            "NAME",
+			nextPageToken:      (&stringCursor{Value: "Source 4", ID: "source4"}).String(),
+			expectedItemsCount: 5,
+			expectedNextToken:  true,
+			expectedFirstID:    "source5",
+			expectedLastID:     "source9",
+		},
+		{
+			name:               "Invalid token",
+			items:              allSources,
+			pageSize:           "10",
+			orderBy:            "ID",
+			nextPageToken:      "invalid-token",
+			expectedItemsCount: 10,
+			expectedNextToken:  true,
+			expectedFirstID:    "source0",
+			expectedLastID:     "source9",
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			paginator, err := newPaginator[model.CatalogSource](tc.pageSize, tc.orderBy, "", tc.nextPageToken)
+			if !assert.NoError(t, err) {
+				return
+			}
+
+			pagedItems, newNextPageToken := paginator.Paginate(tc.items)
+
+			assert.Equal(t, tc.expectedItemsCount, len(pagedItems))
+			if tc.expectedNextToken {
+				assert.NotEmpty(t, newNextPageToken)
+			} else {
+				assert.Empty(t, newNextPageToken)
+			}
+
+			if tc.expectedItemsCount > 0 {
+				assert.Equal(t, tc.expectedFirstID, pagedItems[0].Id)
+				assert.Equal(t, tc.expectedLastID, pagedItems[len(pagedItems)-1].Id)
+			}
+		})
+	}
+}
+
+func TestPaginateSources_NoDuplicates(t *testing.T) {
+	allSources := createCatalogSources(100)
+	pageSize := "10"
+	orderBy := "ID"
+
+	seenItems := make(map[string]struct{}, len(allSources))
+	totalSeen := 0
+
+	paginator, err := newPaginator[model.CatalogSource](pageSize, model.OrderByField(orderBy), "", "")
+	if !assert.NoError(t, err) {
+		return
+	}
+
+	for paginator != nil {
+		var pagedItems []model.CatalogSource
+		pagedItems, paginator = paginator.Paginate(allSources)
+
+		for _, item := range pagedItems {
+			if _, ok := seenItems[item.Id]; ok {
+				t.Errorf("Duplicate item found: %s", item.Id)
+			}
+			seenItems[item.Id] = struct{}{}
+		}
+
+		totalSeen += len(pagedItems)
+	}
+
+	assert.Equal(t, len(allSources), totalSeen, "Total number of items seen should match the original slice")
+}

catalog/internal/server/openapi/routers.go

@@ -0,0 +1,310 @@
+/*
+ * Model Catalog REST API
+ *
+ * REST API for Model Registry to create and manage ML model metadata
+ *
+ * API version: v1alpha1
+ */
+
+// Generated by: OpenAPI Generator (https://openapi-generator.tech). DO NOT EDIT.
+
+package openapi
+
+import (
+	"encoding/json"
+	"errors"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"os"
+	"strconv"
+	"strings"
+
+	"github.com/go-chi/chi/v5"
+	"github.com/go-chi/chi/v5/middleware"
+	"github.com/go-chi/cors"
+	"github.com/golang/glog"
+)
+
+//lint:file-ignore U1000 Ignore all unused code, it's generated
+
+// A Route defines the parameters for an api endpoint
+type Route struct {
+	Method      string
+	Pattern     string
+	HandlerFunc http.HandlerFunc
+}
+
+// Routes is a map of defined api endpoints
+type Routes map[string]Route
+
+// Router defines the required methods for retrieving api routes
+type Router interface {
+	Routes() Routes
+}
+
+const errMsgRequiredMissing = "required parameter is missing"
+const errMsgMinValueConstraint = "provided parameter is not respecting minimum value constraint"
+const errMsgMaxValueConstraint = "provided parameter is not respecting maximum value constraint"
+
+// NewRouter creates a new router for any number of api routers
+func NewRouter(routers ...Router) chi.Router {
+	router := chi.NewRouter()
+	router.Use(middleware.Logger)
+	router.Use(cors.Handler(cors.Options{
+		AllowedOrigins:   []string{"https://*", "http://*"},
+		AllowedMethods:   []string{"GET", "POST", "PUT", "DELETE", "OPTIONS"},
+		AllowedHeaders:   []string{"Accept", "Authorization", "Content-Type", "X-CSRF-Token", "X-PINGOTHER"},
+		ExposedHeaders:   []string{"Link"},
+		AllowCredentials: false,
+		MaxAge:           300, // Maximum value not ignored by any of major browsers
+	}))
+	for _, api := range routers {
+		for _, route := range api.Routes() {
+			handler := route.HandlerFunc
+			router.Method(route.Method, route.Pattern, handler)
+		}
+	}
+
+	return router
+}
+
+// EncodeJSONResponse uses the json encoder to write an interface to the http response with an optional status code
+func EncodeJSONResponse(i interface{}, status *int, w http.ResponseWriter) {
+	w.Header().Set("Content-Type", "application/json; charset=UTF-8")
+	if status != nil {
+		w.WriteHeader(*status)
+	} else {
+		w.WriteHeader(http.StatusOK)
+	}
+
+	if i != nil {
+		if err := json.NewEncoder(w).Encode(i); err != nil {
+			// FIXME: is it too late to inform the client of an error at this point??
+			glog.Errorf("error encoding JSON response: %v", err)
+		}
+	}
+}
+
+// ReadFormFileToTempFile reads file data from a request form and writes it to a temporary file
+func ReadFormFileToTempFile(r *http.Request, key string) (*os.File, error) {
+	_, fileHeader, err := r.FormFile(key)
+	if err != nil {
+		return nil, err
+	}
+
+	return readFileHeaderToTempFile(fileHeader)
+}
+
+// ReadFormFilesToTempFiles reads files array data from a request form and writes it to a temporary files
+func ReadFormFilesToTempFiles(r *http.Request, key string) ([]*os.File, error) {
+	if err := r.ParseMultipartForm(32 << 20); err != nil {
+		return nil, err
+	}
+
+	files := make([]*os.File, 0, len(r.MultipartForm.File[key]))
+
+	for _, fileHeader := range r.MultipartForm.File[key] {
+		file, err := readFileHeaderToTempFile(fileHeader)
+		if err != nil {
+			return nil, err
+		}
+
+		files = append(files, file)
+	}
+
+	return files, nil
+}
+
+// readFileHeaderToTempFile reads multipart.FileHeader and writes it to a temporary file
+func readFileHeaderToTempFile(fileHeader *multipart.FileHeader) (*os.File, error) {
+	formFile, err := fileHeader.Open()
+	if err != nil {
+		return nil, err
+	}
+
+	//nolint:errcheck
+	defer formFile.Close()
+
+	fileBytes, err := io.ReadAll(formFile)
+	if err != nil {
+		return nil, err
+	}
+
+	file, err := os.CreateTemp("", fileHeader.Filename)
+	if err != nil {
+		return nil, err
+	}
+
+	//nolint:errcheck
+	defer file.Close()
+
+	// FIXME: return values are ignored!!!
+	_, _ = file.Write(fileBytes)
+
+	return file, nil
+}
+
+type Number interface {
+	~int32 | ~int64 | ~float32 | ~float64
+}
+
+type ParseString[T Number | string | bool] func(v string) (T, error)
+
+// parseFloat64 parses a string parameter to an float64.
+func parseFloat64(param string) (float64, error) {
+	if param == "" {
+		return 0, nil
+	}
+
+	return strconv.ParseFloat(param, 64)
+}
+
+// parseFloat32 parses a string parameter to an float32.
+func parseFloat32(param string) (float32, error) {
+	if param == "" {
+		return 0, nil
+	}
+
+	v, err := strconv.ParseFloat(param, 32)
+	return float32(v), err
+}
+
+// parseInt64 parses a string parameter to an int64.
+func parseInt64(param string) (int64, error) {
+	if param == "" {
+		return 0, nil
+	}
+
+	return strconv.ParseInt(param, 10, 64)
+}
+
+// parseInt32 parses a string parameter to an int32.
+func parseInt32(param string) (int32, error) {
+	if param == "" {
+		return 0, nil
+	}
+
+	val, err := strconv.ParseInt(param, 10, 32)
+	return int32(val), err
+}
+
+// parseBool parses a string parameter to an bool.
+func parseBool(param string) (bool, error) {
+	if param == "" {
+		return false, nil
+	}
+
+	return strconv.ParseBool(param)
+}
+
+type Operation[T Number | string | bool] func(actual string) (T, bool, error)
+
+func WithRequire[T Number | string | bool](parse ParseString[T]) Operation[T] {
+	var empty T
+	return func(actual string) (T, bool, error) {
+		if actual == "" {
+			return empty, false, errors.New(errMsgRequiredMissing)
+		}
+
+		v, err := parse(actual)
+		return v, false, err
+	}
+}
+
+func WithDefaultOrParse[T Number | string | bool](def T, parse ParseString[T]) Operation[T] {
+	return func(actual string) (T, bool, error) {
+		if actual == "" {
+			return def, true, nil
+		}
+
+		v, err := parse(actual)
+		return v, false, err
+	}
+}
+
+func WithParse[T Number | string | bool](parse ParseString[T]) Operation[T] {
+	return func(actual string) (T, bool, error) {
+		v, err := parse(actual)
+		return v, false, err
+	}
+}
+
+type Constraint[T Number | string | bool] func(actual T) error
+
+func WithMinimum[T Number](expected T) Constraint[T] {
+	return func(actual T) error {
+		if actual < expected {
+			return errors.New(errMsgMinValueConstraint)
+		}
+
+		return nil
+	}
+}
+
+func WithMaximum[T Number](expected T) Constraint[T] {
+	return func(actual T) error {
+		if actual > expected {
+			return errors.New(errMsgMaxValueConstraint)
+		}
+
+		return nil
+	}
+}
+
+// parseNumericParameter parses a numeric parameter to its respective type.
+func parseNumericParameter[T Number](param string, fn Operation[T], checks ...Constraint[T]) (T, error) {
+	v, ok, err := fn(param)
+	if err != nil {
+		return 0, err
+	}
+
+	if !ok {
+		for _, check := range checks {
+			if err := check(v); err != nil {
+				return 0, err
+			}
+		}
+	}
+
+	return v, nil
+}
+
+// parseBoolParameter parses a string parameter to a bool
+func parseBoolParameter(param string, fn Operation[bool]) (bool, error) {
+	v, _, err := fn(param)
+	return v, err
+}
+
+// parseNumericArrayParameter parses a string parameter containing array of values to its respective type.
+func parseNumericArrayParameter[T Number](param, delim string, required bool, fn Operation[T], checks ...Constraint[T]) ([]T, error) {
+	if param == "" {
+		if required {
+			return nil, errors.New(errMsgRequiredMissing)
+		}
+
+		return nil, nil
+	}
+
+	str := strings.Split(param, delim)
+	values := make([]T, len(str))
+
+	for i, s := range str {
+		v, ok, err := fn(s)
+		if err != nil {
+			return nil, err
+		}
+
+		if !ok {
+			for _, check := range checks {
+				if err := check(v); err != nil {
+					return nil, err
+				}
+			}
+		}
+
+		values[i] = v
+	}
+
+	return values, nil
+}

catalog/internal/server/openapi/type_asserts.go

@@ -0,0 +1,367 @@
+/*
+ * Model Registry REST API
+ *
+ * REST API for Model Registry to create and manage ML model metadata
+ *
+ * API version: 1.0.0
+ * Generated by: OpenAPI Generator (https://openapi-generator.tech)
+ *
+ */
+
+// File generated by scripts/gen_type_assert.sh - DO NOT EDIT
+
+package openapi
+
+import (
+	model "github.com/kubeflow/model-registry/catalog/pkg/openapi"
+)
+
+// AssertArtifactTypeQueryParamConstraints checks if the values respects the defined constraints
+func AssertArtifactTypeQueryParamConstraints(obj model.ArtifactTypeQueryParam) error {
+	return nil
+}
+
+// AssertArtifactTypeQueryParamRequired checks if the required fields are not zero-ed
+func AssertArtifactTypeQueryParamRequired(obj model.ArtifactTypeQueryParam) error {
+	return nil
+}
+
+// AssertBaseModelConstraints checks if the values respects the defined constraints
+func AssertBaseModelConstraints(obj model.BaseModel) error {
+	return nil
+}
+
+// AssertBaseModelRequired checks if the required fields are not zero-ed
+func AssertBaseModelRequired(obj model.BaseModel) error {
+	return nil
+}
+
+// AssertBaseResourceDatesConstraints checks if the values respects the defined constraints
+func AssertBaseResourceDatesConstraints(obj model.BaseResourceDates) error {
+	return nil
+}
+
+// AssertBaseResourceDatesRequired checks if the required fields are not zero-ed
+func AssertBaseResourceDatesRequired(obj model.BaseResourceDates) error {
+	return nil
+}
+
+// AssertBaseResourceListConstraints checks if the values respects the defined constraints
+func AssertBaseResourceListConstraints(obj model.BaseResourceList) error {
+	return nil
+}
+
+// AssertBaseResourceListRequired checks if the required fields are not zero-ed
+func AssertBaseResourceListRequired(obj model.BaseResourceList) error {
+	elements := map[string]interface{}{
+		"nextPageToken": obj.NextPageToken,
+		"pageSize":      obj.PageSize,
+		"size":          obj.Size,
+	}
+	for name, el := range elements {
+		if isZero := IsZeroValue(el); isZero {
+			return &RequiredError{Field: name}
+		}
+	}
+
+	return nil
+}
+
+// AssertCatalogModelArtifactConstraints checks if the values respects the defined constraints
+func AssertCatalogModelArtifactConstraints(obj model.CatalogModelArtifact) error {
+	return nil
+}
+
+// AssertCatalogModelArtifactListConstraints checks if the values respects the defined constraints
+func AssertCatalogModelArtifactListConstraints(obj model.CatalogModelArtifactList) error {
+	return nil
+}
+
+// AssertCatalogModelArtifactListRequired checks if the required fields are not zero-ed
+func AssertCatalogModelArtifactListRequired(obj model.CatalogModelArtifactList) error {
+	elements := map[string]interface{}{
+		"nextPageToken": obj.NextPageToken,
+		"pageSize":      obj.PageSize,
+		"size":          obj.Size,
+		"items":         obj.Items,
+	}
+	for name, el := range elements {
+		if isZero := IsZeroValue(el); isZero {
+			return &RequiredError{Field: name}
+		}
+	}
+
+	for _, el := range obj.Items {
+		if err := AssertCatalogModelArtifactRequired(el); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// AssertCatalogModelArtifactRequired checks if the required fields are not zero-ed
+func AssertCatalogModelArtifactRequired(obj model.CatalogModelArtifact) error {
+	elements := map[string]interface{}{
+		"uri": obj.Uri,
+	}
+	for name, el := range elements {
+		if isZero := IsZeroValue(el); isZero {
+			return &RequiredError{Field: name}
+		}
+	}
+
+	return nil
+}
+
+// AssertCatalogModelConstraints checks if the values respects the defined constraints
+func AssertCatalogModelConstraints(obj model.CatalogModel) error {
+	return nil
+}
+
+// AssertCatalogModelListConstraints checks if the values respects the defined constraints
+func AssertCatalogModelListConstraints(obj model.CatalogModelList) error {
+	return nil
+}
+
+// AssertCatalogModelListRequired checks if the required fields are not zero-ed
+func AssertCatalogModelListRequired(obj model.CatalogModelList) error {
+	elements := map[string]interface{}{
+		"nextPageToken": obj.NextPageToken,
+		"pageSize":      obj.PageSize,
+		"size":          obj.Size,
+		"items":         obj.Items,
+	}
+	for name, el := range elements {
+		if isZero := IsZeroValue(el); isZero {
+			return &RequiredError{Field: name}
+		}
+	}
+
+	for _, el := range obj.Items {
+		if err := AssertCatalogModelRequired(el); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// AssertCatalogModelRequired checks if the required fields are not zero-ed
+func AssertCatalogModelRequired(obj model.CatalogModel) error {
+	elements := map[string]interface{}{
+		"name": obj.Name,
+	}
+	for name, el := range elements {
+		if isZero := IsZeroValue(el); isZero {
+			return &RequiredError{Field: name}
+		}
+	}
+
+	return nil
+}
+
+// AssertCatalogSourceConstraints checks if the values respects the defined constraints
+func AssertCatalogSourceConstraints(obj model.CatalogSource) error {
+	return nil
+}
+
+// AssertCatalogSourceListConstraints checks if the values respects the defined constraints
+func AssertCatalogSourceListConstraints(obj model.CatalogSourceList) error {
+	return nil
+}
+
+// AssertCatalogSourceListRequired checks if the required fields are not zero-ed
+func AssertCatalogSourceListRequired(obj model.CatalogSourceList) error {
+	elements := map[string]interface{}{
+		"nextPageToken": obj.NextPageToken,
+		"pageSize":      obj.PageSize,
+		"size":          obj.Size,
+	}
+	for name, el := range elements {
+		if isZero := IsZeroValue(el); isZero {
+			return &RequiredError{Field: name}
+		}
+	}
+
+	for _, el := range obj.Items {
+		if err := AssertCatalogSourceRequired(el); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// AssertCatalogSourceRequired checks if the required fields are not zero-ed
+func AssertCatalogSourceRequired(obj model.CatalogSource) error {
+	elements := map[string]interface{}{
+		"id":   obj.Id,
+		"name": obj.Name,
+	}
+	for name, el := range elements {
+		if isZero := IsZeroValue(el); isZero {
+			return &RequiredError{Field: name}
+		}
+	}
+
+	return nil
+}
+
+// AssertErrorConstraints checks if the values respects the defined constraints
+func AssertErrorConstraints(obj model.Error) error {
+	return nil
+}
+
+// AssertErrorRequired checks if the required fields are not zero-ed
+func AssertErrorRequired(obj model.Error) error {
+	elements := map[string]interface{}{
+		"code":    obj.Code,
+		"message": obj.Message,
+	}
+	for name, el := range elements {
+		if isZero := IsZeroValue(el); isZero {
+			return &RequiredError{Field: name}
+		}
+	}
+
+	return nil
+}
+
+// AssertMetadataBoolValueConstraints checks if the values respects the defined constraints
+func AssertMetadataBoolValueConstraints(obj model.MetadataBoolValue) error {
+	return nil
+}
+
+// AssertMetadataBoolValueRequired checks if the required fields are not zero-ed
+func AssertMetadataBoolValueRequired(obj model.MetadataBoolValue) error {
+	elements := map[string]interface{}{
+		"bool_value":   obj.BoolValue,
+		"metadataType": obj.MetadataType,
+	}
+	for name, el := range elements {
+		if isZero := IsZeroValue(el); isZero {
+			return &RequiredError{Field: name}
+		}
+	}
+
+	return nil
+}
+
+// AssertMetadataDoubleValueConstraints checks if the values respects the defined constraints
+func AssertMetadataDoubleValueConstraints(obj model.MetadataDoubleValue) error {
+	return nil
+}
+
+// AssertMetadataDoubleValueRequired checks if the required fields are not zero-ed
+func AssertMetadataDoubleValueRequired(obj model.MetadataDoubleValue) error {
+	elements := map[string]interface{}{
+		"double_value": obj.DoubleValue,
+		"metadataType": obj.MetadataType,
+	}
+	for name, el := range elements {
+		if isZero := IsZeroValue(el); isZero {
+			return &RequiredError{Field: name}
+		}
+	}
+
+	return nil
+}
+
+// AssertMetadataIntValueConstraints checks if the values respects the defined constraints
+func AssertMetadataIntValueConstraints(obj model.MetadataIntValue) error {
+	return nil
+}
+
+// AssertMetadataIntValueRequired checks if the required fields are not zero-ed
+func AssertMetadataIntValueRequired(obj model.MetadataIntValue) error {
+	elements := map[string]interface{}{
+		"int_value":    obj.IntValue,
+		"metadataType": obj.MetadataType,
+	}
+	for name, el := range elements {
+		if isZero := IsZeroValue(el); isZero {
+			return &RequiredError{Field: name}
+		}
+	}
+
+	return nil
+}
+
+// AssertMetadataProtoValueConstraints checks if the values respects the defined constraints
+func AssertMetadataProtoValueConstraints(obj model.MetadataProtoValue) error {
+	return nil
+}
+
+// AssertMetadataProtoValueRequired checks if the required fields are not zero-ed
+func AssertMetadataProtoValueRequired(obj model.MetadataProtoValue) error {
+	elements := map[string]interface{}{
+		"type":         obj.Type,
+		"proto_value":  obj.ProtoValue,
+		"metadataType": obj.MetadataType,
+	}
+	for name, el := range elements {
+		if isZero := IsZeroValue(el); isZero {
+			return &RequiredError{Field: name}
+		}
+	}
+
+	return nil
+}
+
+// AssertMetadataStringValueConstraints checks if the values respects the defined constraints
+func AssertMetadataStringValueConstraints(obj model.MetadataStringValue) error {
+	return nil
+}
+
+// AssertMetadataStringValueRequired checks if the required fields are not zero-ed
+func AssertMetadataStringValueRequired(obj model.MetadataStringValue) error {
+	elements := map[string]interface{}{
+		"string_value": obj.StringValue,
+		"metadataType": obj.MetadataType,
+	}
+	for name, el := range elements {
+		if isZero := IsZeroValue(el); isZero {
+			return &RequiredError{Field: name}
+		}
+	}
+
+	return nil
+}
+
+// AssertMetadataStructValueConstraints checks if the values respects the defined constraints
+func AssertMetadataStructValueConstraints(obj model.MetadataStructValue) error {
+	return nil
+}
+
+// AssertMetadataStructValueRequired checks if the required fields are not zero-ed
+func AssertMetadataStructValueRequired(obj model.MetadataStructValue) error {
+	elements := map[string]interface{}{
+		"struct_value": obj.StructValue,
+		"metadataType": obj.MetadataType,
+	}
+	for name, el := range elements {
+		if isZero := IsZeroValue(el); isZero {
+			return &RequiredError{Field: name}
+		}
+	}
+
+	return nil
+}
+
+// AssertOrderByFieldConstraints checks if the values respects the defined constraints
+func AssertOrderByFieldConstraints(obj model.OrderByField) error {
+	return nil
+}
+
+// AssertOrderByFieldRequired checks if the required fields are not zero-ed
+func AssertOrderByFieldRequired(obj model.OrderByField) error {
+	return nil
+}
+
+// AssertSortOrderConstraints checks if the values respects the defined constraints
+func AssertSortOrderConstraints(obj model.SortOrder) error {
+	return nil
+}
+
+// AssertSortOrderRequired checks if the required fields are not zero-ed
+func AssertSortOrderRequired(obj model.SortOrder) error {
+	return nil
+}

catalog/openapitools.json

@@ -0,0 +1,7 @@
+{
+  "$schema": "./node_modules/@openapitools/openapi-generator-cli/config.schema.json",
+  "spaces": 2,
+  "generator-cli": {
+    "version": "7.13.0"
+  }
+}

catalog/pkg/openapi/.openapi-generator/FILES

@@ -0,0 +1,25 @@
+api_model_catalog_service.go
+client.go
+configuration.go
+model_artifact_type_query_param.go
+model_base_model.go
+model_base_resource_dates.go
+model_base_resource_list.go
+model_catalog_model.go
+model_catalog_model_artifact.go
+model_catalog_model_artifact_list.go
+model_catalog_model_list.go
+model_catalog_source.go
+model_catalog_source_list.go
+model_error.go
+model_metadata_bool_value.go
+model_metadata_double_value.go
+model_metadata_int_value.go
+model_metadata_proto_value.go
+model_metadata_string_value.go
+model_metadata_struct_value.go
+model_metadata_value.go
+model_order_by_field.go
+model_sort_order.go
+response.go
+utils.go

catalog/pkg/openapi/.openapi-generator/VERSION

@@ -0,0 +1 @@
+7.0.1

catalog/pkg/openapi/api_model_catalog_service.go

@@ -0,0 +1,694 @@
+/*
+Model Catalog REST API
+
+REST API for Model Registry to create and manage ML model metadata
+
+API version: v1alpha1
+*/
+
+// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
+
+package openapi
+
+import (
+	"bytes"
+	"context"
+	"io"
+	"net/http"
+	"net/url"
+	"strings"
+)
+
+// ModelCatalogServiceAPIService ModelCatalogServiceAPI service
+type ModelCatalogServiceAPIService service
+
+type ApiFindModelsRequest struct {
+	ctx           context.Context
+	ApiService    *ModelCatalogServiceAPIService
+	source        *string
+	q             *string
+	pageSize      *string
+	orderBy       *OrderByField
+	sortOrder     *SortOrder
+	nextPageToken *string
+}
+
+// Filter models by source. This parameter is currently required and may only be specified once.
+func (r ApiFindModelsRequest) Source(source string) ApiFindModelsRequest {
+	r.source = &source
+	return r
+}
+
+// Free-form keyword search used to filter the response.
+func (r ApiFindModelsRequest) Q(q string) ApiFindModelsRequest {
+	r.q = &q
+	return r
+}
+
+// Number of entities in each page.
+func (r ApiFindModelsRequest) PageSize(pageSize string) ApiFindModelsRequest {
+	r.pageSize = &pageSize
+	return r
+}
+
+// Specifies the order by criteria for listing entities.
+func (r ApiFindModelsRequest) OrderBy(orderBy OrderByField) ApiFindModelsRequest {
+	r.orderBy = &orderBy
+	return r
+}
+
+// Specifies the sort order for listing entities, defaults to ASC.
+func (r ApiFindModelsRequest) SortOrder(sortOrder SortOrder) ApiFindModelsRequest {
+	r.sortOrder = &sortOrder
+	return r
+}
+
+// Token to use to retrieve next page of results.
+func (r ApiFindModelsRequest) NextPageToken(nextPageToken string) ApiFindModelsRequest {
+	r.nextPageToken = &nextPageToken
+	return r
+}
+
+func (r ApiFindModelsRequest) Execute() (*CatalogModelList, *http.Response, error) {
+	return r.ApiService.FindModelsExecute(r)
+}
+
+/*
+FindModels Search catalog models across sources.
+
+	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
+	@return ApiFindModelsRequest
+*/
+func (a *ModelCatalogServiceAPIService) FindModels(ctx context.Context) ApiFindModelsRequest {
+	return ApiFindModelsRequest{
+		ApiService: a,
+		ctx:        ctx,
+	}
+}
+
+// Execute executes the request
+//
+//	@return CatalogModelList
+func (a *ModelCatalogServiceAPIService) FindModelsExecute(r ApiFindModelsRequest) (*CatalogModelList, *http.Response, error) {
+	var (
+		localVarHTTPMethod  = http.MethodGet
+		localVarPostBody    interface{}
+		formFiles           []formFile
+		localVarReturnValue *CatalogModelList
+	)
+
+	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ModelCatalogServiceAPIService.FindModels")
+	if err != nil {
+		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
+	}
+
+	localVarPath := localBasePath + "/api/model_catalog/v1alpha1/models"
+
+	localVarHeaderParams := make(map[string]string)
+	localVarQueryParams := url.Values{}
+	localVarFormParams := url.Values{}
+	if r.source == nil {
+		return localVarReturnValue, nil, reportError("source is required and must be specified")
+	}
+
+	parameterAddToHeaderOrQuery(localVarQueryParams, "source", r.source, "")
+	if r.q != nil {
+		parameterAddToHeaderOrQuery(localVarQueryParams, "q", r.q, "")
+	}
+	if r.pageSize != nil {
+		parameterAddToHeaderOrQuery(localVarQueryParams, "pageSize", r.pageSize, "")
+	}
+	if r.orderBy != nil {
+		parameterAddToHeaderOrQuery(localVarQueryParams, "orderBy", r.orderBy, "")
+	}
+	if r.sortOrder != nil {
+		parameterAddToHeaderOrQuery(localVarQueryParams, "sortOrder", r.sortOrder, "")
+	}
+	if r.nextPageToken != nil {
+		parameterAddToHeaderOrQuery(localVarQueryParams, "nextPageToken", r.nextPageToken, "")
+	}
+	// to determine the Content-Type header
+	localVarHTTPContentTypes := []string{}
+
+	// set Content-Type header
+	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
+	if localVarHTTPContentType != "" {
+		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
+	}
+
+	// to determine the Accept header
+	localVarHTTPHeaderAccepts := []string{"application/json"}
+
+	// set Accept header
+	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
+	if localVarHTTPHeaderAccept != "" {
+		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
+	}
+	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
+	if err != nil {
+		return localVarReturnValue, nil, err
+	}
+
+	localVarHTTPResponse, err := a.client.callAPI(req)
+	if err != nil || localVarHTTPResponse == nil {
+		return localVarReturnValue, localVarHTTPResponse, err
+	}
+
+	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
+	localVarHTTPResponse.Body.Close()
+	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
+	if err != nil {
+		return localVarReturnValue, localVarHTTPResponse, err
+	}
+
+	if localVarHTTPResponse.StatusCode >= 300 {
+		newErr := &GenericOpenAPIError{
+			body:  localVarBody,
+			error: localVarHTTPResponse.Status,
+		}
+		if localVarHTTPResponse.StatusCode == 400 {
+			var v Error
+			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
+			if err != nil {
+				newErr.error = err.Error()
+				return localVarReturnValue, localVarHTTPResponse, newErr
+			}
+			newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
+			newErr.model = v
+			return localVarReturnValue, localVarHTTPResponse, newErr
+		}
+		if localVarHTTPResponse.StatusCode == 401 {
+			var v Error
+			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
+			if err != nil {
+				newErr.error = err.Error()
+				return localVarReturnValue, localVarHTTPResponse, newErr
+			}
+			newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
+			newErr.model = v
+			return localVarReturnValue, localVarHTTPResponse, newErr
+		}
+		if localVarHTTPResponse.StatusCode == 404 {
+			var v Error
+			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
+			if err != nil {
+				newErr.error = err.Error()
+				return localVarReturnValue, localVarHTTPResponse, newErr
+			}
+			newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
+			newErr.model = v
+			return localVarReturnValue, localVarHTTPResponse, newErr
+		}
+		if localVarHTTPResponse.StatusCode == 500 {
+			var v Error
+			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
+			if err != nil {
+				newErr.error = err.Error()
+				return localVarReturnValue, localVarHTTPResponse, newErr
+			}
+			newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
+			newErr.model = v
+		}
+		return localVarReturnValue, localVarHTTPResponse, newErr
+	}
+
+	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
+	if err != nil {
+		newErr := &GenericOpenAPIError{
+			body:  localVarBody,
+			error: err.Error(),
+		}
+		return localVarReturnValue, localVarHTTPResponse, newErr
+	}
+
+	return localVarReturnValue, localVarHTTPResponse, nil
+}
+
+type ApiFindSourcesRequest struct {
+	ctx           context.Context
+	ApiService    *ModelCatalogServiceAPIService
+	name          *string
+	pageSize      *string
+	orderBy       *OrderByField
+	sortOrder     *SortOrder
+	nextPageToken *string
+}
+
+// Name of entity to search.
+func (r ApiFindSourcesRequest) Name(name string) ApiFindSourcesRequest {
+	r.name = &name
+	return r
+}
+
+// Number of entities in each page.
+func (r ApiFindSourcesRequest) PageSize(pageSize string) ApiFindSourcesRequest {
+	r.pageSize = &pageSize
+	return r
+}
+
+// Specifies the order by criteria for listing entities.
+func (r ApiFindSourcesRequest) OrderBy(orderBy OrderByField) ApiFindSourcesRequest {
+	r.orderBy = &orderBy
+	return r
+}
+
+// Specifies the sort order for listing entities, defaults to ASC.
+func (r ApiFindSourcesRequest) SortOrder(sortOrder SortOrder) ApiFindSourcesRequest {
+	r.sortOrder = &sortOrder
+	return r
+}
+
+// Token to use to retrieve next page of results.
+func (r ApiFindSourcesRequest) NextPageToken(nextPageToken string) ApiFindSourcesRequest {
+	r.nextPageToken = &nextPageToken
+	return r
+}
+
+func (r ApiFindSourcesRequest) Execute() (*CatalogSourceList, *http.Response, error) {
+	return r.ApiService.FindSourcesExecute(r)
+}
+
+/*
+FindSources List All CatalogSources
+
+Gets a list of all `CatalogSource` entities.
+
+	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
+	@return ApiFindSourcesRequest
+*/
+func (a *ModelCatalogServiceAPIService) FindSources(ctx context.Context) ApiFindSourcesRequest {
+	return ApiFindSourcesRequest{
+		ApiService: a,
+		ctx:        ctx,
+	}
+}
+
+// Execute executes the request
+//
+//	@return CatalogSourceList
+func (a *ModelCatalogServiceAPIService) FindSourcesExecute(r ApiFindSourcesRequest) (*CatalogSourceList, *http.Response, error) {
+	var (
+		localVarHTTPMethod  = http.MethodGet
+		localVarPostBody    interface{}
+		formFiles           []formFile
+		localVarReturnValue *CatalogSourceList
+	)
+
+	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ModelCatalogServiceAPIService.FindSources")
+	if err != nil {
+		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
+	}
+
+	localVarPath := localBasePath + "/api/model_catalog/v1alpha1/sources"
+
+	localVarHeaderParams := make(map[string]string)
+	localVarQueryParams := url.Values{}
+	localVarFormParams := url.Values{}
+
+	if r.name != nil {
+		parameterAddToHeaderOrQuery(localVarQueryParams, "name", r.name, "")
+	}
+	if r.pageSize != nil {
+		parameterAddToHeaderOrQuery(localVarQueryParams, "pageSize", r.pageSize, "")
+	}
+	if r.orderBy != nil {
+		parameterAddToHeaderOrQuery(localVarQueryParams, "orderBy", r.orderBy, "")
+	}
+	if r.sortOrder != nil {
+		parameterAddToHeaderOrQuery(localVarQueryParams, "sortOrder", r.sortOrder, "")
+	}
+	if r.nextPageToken != nil {
+		parameterAddToHeaderOrQuery(localVarQueryParams, "nextPageToken", r.nextPageToken, "")
+	}
+	// to determine the Content-Type header
+	localVarHTTPContentTypes := []string{}
+
+	// set Content-Type header
+	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
+	if localVarHTTPContentType != "" {
+		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
+	}
+
+	// to determine the Accept header
+	localVarHTTPHeaderAccepts := []string{"application/json"}
+
+	// set Accept header
+	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
+	if localVarHTTPHeaderAccept != "" {
+		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
+	}
+	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
+	if err != nil {
+		return localVarReturnValue, nil, err
+	}
+
+	localVarHTTPResponse, err := a.client.callAPI(req)
+	if err != nil || localVarHTTPResponse == nil {
+		return localVarReturnValue, localVarHTTPResponse, err
+	}
+
+	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
+	localVarHTTPResponse.Body.Close()
+	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
+	if err != nil {
+		return localVarReturnValue, localVarHTTPResponse, err
+	}
+
+	if localVarHTTPResponse.StatusCode >= 300 {
+		newErr := &GenericOpenAPIError{
+			body:  localVarBody,
+			error: localVarHTTPResponse.Status,
+		}
+		if localVarHTTPResponse.StatusCode == 400 {
+			var v Error
+			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
+			if err != nil {
+				newErr.error = err.Error()
+				return localVarReturnValue, localVarHTTPResponse, newErr
+			}
+			newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
+			newErr.model = v
+			return localVarReturnValue, localVarHTTPResponse, newErr
+		}
+		if localVarHTTPResponse.StatusCode == 401 {
+			var v Error
+			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
+			if err != nil {
+				newErr.error = err.Error()
+				return localVarReturnValue, localVarHTTPResponse, newErr
+			}
+			newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
+			newErr.model = v
+			return localVarReturnValue, localVarHTTPResponse, newErr
+		}
+		if localVarHTTPResponse.StatusCode == 404 {
+			var v Error
+			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
+			if err != nil {
+				newErr.error = err.Error()
+				return localVarReturnValue, localVarHTTPResponse, newErr
+			}
+			newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
+			newErr.model = v
+			return localVarReturnValue, localVarHTTPResponse, newErr
+		}
+		if localVarHTTPResponse.StatusCode == 500 {
+			var v Error
+			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
+			if err != nil {
+				newErr.error = err.Error()
+				return localVarReturnValue, localVarHTTPResponse, newErr
+			}
+			newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
+			newErr.model = v
+		}
+		return localVarReturnValue, localVarHTTPResponse, newErr
+	}
+
+	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
+	if err != nil {
+		newErr := &GenericOpenAPIError{
+			body:  localVarBody,
+			error: err.Error(),
+		}
+		return localVarReturnValue, localVarHTTPResponse, newErr
+	}
+
+	return localVarReturnValue, localVarHTTPResponse, nil
+}
+
+type ApiGetAllModelArtifactsRequest struct {
+	ctx        context.Context
+	ApiService *ModelCatalogServiceAPIService
+	sourceId   string
+	modelName  string
+}
+
+func (r ApiGetAllModelArtifactsRequest) Execute() (*CatalogModelArtifactList, *http.Response, error) {
+	return r.ApiService.GetAllModelArtifactsExecute(r)
+}
+
+/*
+GetAllModelArtifacts List CatalogModelArtifacts.
+
+	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
+	@param sourceId A unique identifier for a `CatalogSource`.
+	@param modelName A unique identifier for the model.
+	@return ApiGetAllModelArtifactsRequest
+*/
+func (a *ModelCatalogServiceAPIService) GetAllModelArtifacts(ctx context.Context, sourceId string, modelName string) ApiGetAllModelArtifactsRequest {
+	return ApiGetAllModelArtifactsRequest{
+		ApiService: a,
+		ctx:        ctx,
+		sourceId:   sourceId,
+		modelName:  modelName,
+	}
+}
+
+// Execute executes the request
+//
+//	@return CatalogModelArtifactList
+func (a *ModelCatalogServiceAPIService) GetAllModelArtifactsExecute(r ApiGetAllModelArtifactsRequest) (*CatalogModelArtifactList, *http.Response, error) {
+	var (
+		localVarHTTPMethod  = http.MethodGet
+		localVarPostBody    interface{}
+		formFiles           []formFile
+		localVarReturnValue *CatalogModelArtifactList
+	)
+
+	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ModelCatalogServiceAPIService.GetAllModelArtifacts")
+	if err != nil {
+		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
+	}
+
+	localVarPath := localBasePath + "/api/model_catalog/v1alpha1/sources/{source_id}/models/{model_name}/artifacts"
+	localVarPath = strings.Replace(localVarPath, "{"+"source_id"+"}", url.PathEscape(parameterValueToString(r.sourceId, "sourceId")), -1)
+	localVarPath = strings.Replace(localVarPath, "{"+"model_name"+"}", url.PathEscape(parameterValueToString(r.modelName, "modelName")), -1)
+
+	localVarHeaderParams := make(map[string]string)
+	localVarQueryParams := url.Values{}
+	localVarFormParams := url.Values{}
+
+	// to determine the Content-Type header
+	localVarHTTPContentTypes := []string{}
+
+	// set Content-Type header
+	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
+	if localVarHTTPContentType != "" {
+		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
+	}
+
+	// to determine the Accept header
+	localVarHTTPHeaderAccepts := []string{"application/json"}
+
+	// set Accept header
+	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
+	if localVarHTTPHeaderAccept != "" {
+		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
+	}
+	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
+	if err != nil {
+		return localVarReturnValue, nil, err
+	}
+
+	localVarHTTPResponse, err := a.client.callAPI(req)
+	if err != nil || localVarHTTPResponse == nil {
+		return localVarReturnValue, localVarHTTPResponse, err
+	}
+
+	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
+	localVarHTTPResponse.Body.Close()
+	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
+	if err != nil {
+		return localVarReturnValue, localVarHTTPResponse, err
+	}
+
+	if localVarHTTPResponse.StatusCode >= 300 {
+		newErr := &GenericOpenAPIError{
+			body:  localVarBody,
+			error: localVarHTTPResponse.Status,
+		}
+		if localVarHTTPResponse.StatusCode == 401 {
+			var v Error
+			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
+			if err != nil {
+				newErr.error = err.Error()
+				return localVarReturnValue, localVarHTTPResponse, newErr
+			}
+			newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
+			newErr.model = v
+			return localVarReturnValue, localVarHTTPResponse, newErr
+		}
+		if localVarHTTPResponse.StatusCode == 404 {
+			var v Error
+			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
+			if err != nil {
+				newErr.error = err.Error()
+				return localVarReturnValue, localVarHTTPResponse, newErr
+			}
+			newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
+			newErr.model = v
+			return localVarReturnValue, localVarHTTPResponse, newErr
+		}
+		if localVarHTTPResponse.StatusCode == 500 {
+			var v Error
+			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
+			if err != nil {
+				newErr.error = err.Error()
+				return localVarReturnValue, localVarHTTPResponse, newErr
+			}
+			newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
+			newErr.model = v
+		}
+		return localVarReturnValue, localVarHTTPResponse, newErr
+	}
+
+	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
+	if err != nil {
+		newErr := &GenericOpenAPIError{
+			body:  localVarBody,
+			error: err.Error(),
+		}
+		return localVarReturnValue, localVarHTTPResponse, newErr
+	}
+
+	return localVarReturnValue, localVarHTTPResponse, nil
+}
+
+type ApiGetModelRequest struct {
+	ctx        context.Context
+	ApiService *ModelCatalogServiceAPIService
+	sourceId   string
+	modelName  string
+}
+
+func (r ApiGetModelRequest) Execute() (*CatalogModel, *http.Response, error) {
+	return r.ApiService.GetModelExecute(r)
+}
+
+/*
+GetModel Get a `CatalogModel`.
+
+	@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
+	@param sourceId A unique identifier for a `CatalogSource`.
+	@param modelName A unique identifier for the model.
+	@return ApiGetModelRequest
+*/
+func (a *ModelCatalogServiceAPIService) GetModel(ctx context.Context, sourceId string, modelName string) ApiGetModelRequest {
+	return ApiGetModelRequest{
+		ApiService: a,
+		ctx:        ctx,
+		sourceId:   sourceId,
+		modelName:  modelName,
+	}
+}
+
+// Execute executes the request
+//
+//	@return CatalogModel
+func (a *ModelCatalogServiceAPIService) GetModelExecute(r ApiGetModelRequest) (*CatalogModel, *http.Response, error) {
+	var (
+		localVarHTTPMethod  = http.MethodGet
+		localVarPostBody    interface{}
+		formFiles           []formFile
+		localVarReturnValue *CatalogModel
+	)
+
+	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "ModelCatalogServiceAPIService.GetModel")
+	if err != nil {
+		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
+	}
+
+	localVarPath := localBasePath + "/api/model_catalog/v1alpha1/sources/{source_id}/models/{model_name+}"
+	localVarPath = strings.Replace(localVarPath, "{"+"source_id"+"}", url.PathEscape(parameterValueToString(r.sourceId, "sourceId")), -1)
+	localVarPath = strings.Replace(localVarPath, "{"+"model_name+"+"}", url.PathEscape(parameterValueToString(r.modelName, "modelName")), -1)
+
+	localVarHeaderParams := make(map[string]string)
+	localVarQueryParams := url.Values{}
+	localVarFormParams := url.Values{}
+
+	// to determine the Content-Type header
+	localVarHTTPContentTypes := []string{}
+
+	// set Content-Type header
+	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
+	if localVarHTTPContentType != "" {
+		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
+	}
+
+	// to determine the Accept header
+	localVarHTTPHeaderAccepts := []string{"application/json"}
+
+	// set Accept header
+	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
+	if localVarHTTPHeaderAccept != "" {
+		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
+	}
+	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
+	if err != nil {
+		return localVarReturnValue, nil, err
+	}
+
+	localVarHTTPResponse, err := a.client.callAPI(req)
+	if err != nil || localVarHTTPResponse == nil {
+		return localVarReturnValue, localVarHTTPResponse, err
+	}
+
+	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
+	localVarHTTPResponse.Body.Close()
+	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
+	if err != nil {
+		return localVarReturnValue, localVarHTTPResponse, err
+	}
+
+	if localVarHTTPResponse.StatusCode >= 300 {
+		newErr := &GenericOpenAPIError{
+			body:  localVarBody,
+			error: localVarHTTPResponse.Status,
+		}
+		if localVarHTTPResponse.StatusCode == 401 {
+			var v Error
+			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
+			if err != nil {
+				newErr.error = err.Error()
+				return localVarReturnValue, localVarHTTPResponse, newErr
+			}
+			newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
+			newErr.model = v
+			return localVarReturnValue, localVarHTTPResponse, newErr
+		}
+		if localVarHTTPResponse.StatusCode == 404 {
+			var v Error
+			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
+			if err != nil {
+				newErr.error = err.Error()
+				return localVarReturnValue, localVarHTTPResponse, newErr
+			}
+			newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
+			newErr.model = v
+			return localVarReturnValue, localVarHTTPResponse, newErr
+		}
+		if localVarHTTPResponse.StatusCode == 500 {
+			var v Error
+			err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
+			if err != nil {
+				newErr.error = err.Error()
+				return localVarReturnValue, localVarHTTPResponse, newErr
+			}
+			newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
+			newErr.model = v
+		}
+		return localVarReturnValue, localVarHTTPResponse, newErr
+	}
+
+	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
+	if err != nil {
+		newErr := &GenericOpenAPIError{
+			body:  localVarBody,
+			error: err.Error(),
+		}
+		return localVarReturnValue, localVarHTTPResponse, newErr
+	}
+
+	return localVarReturnValue, localVarHTTPResponse, nil
+}

catalog/pkg/openapi/client.go

@@ -0,0 +1,666 @@
+/*
+Model Catalog REST API
+
+REST API for Model Registry to create and manage ML model metadata
+
+API version: v1alpha1
+*/
+
+// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
+
+package openapi
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"encoding/xml"
+	"errors"
+	"fmt"
+	"io"
+	"log"
+	"mime/multipart"
+	"net/http"
+	"net/http/httputil"
+	"net/url"
+	"os"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"strconv"
+	"strings"
+	"time"
+	"unicode/utf8"
+)
+
+var (
+	jsonCheck       = regexp.MustCompile(`(?i:(?:application|text)/(?:vnd\.[^;]+\+)?json)`)
+	xmlCheck        = regexp.MustCompile(`(?i:(?:application|text)/xml)`)
+	queryParamSplit = regexp.MustCompile(`(^|&)([^&]+)`)
+	queryDescape    = strings.NewReplacer("%5B", "[", "%5D", "]")
+)
+
+// APIClient manages communication with the Model Catalog REST API API vv1alpha1
+// In most cases there should be only one, shared, APIClient.
+type APIClient struct {
+	cfg    *Configuration
+	common service // Reuse a single struct instead of allocating one for each service on the heap.
+
+	// API Services
+
+	ModelCatalogServiceAPI *ModelCatalogServiceAPIService
+}
+
+type service struct {
+	client *APIClient
+}
+
+// NewAPIClient creates a new API client. Requires a userAgent string describing your application.
+// optionally a custom http.Client to allow for advanced features such as caching.
+func NewAPIClient(cfg *Configuration) *APIClient {
+	if cfg.HTTPClient == nil {
+		cfg.HTTPClient = http.DefaultClient
+	}
+
+	c := &APIClient{}
+	c.cfg = cfg
+	c.common.client = c
+
+	// API Services
+	c.ModelCatalogServiceAPI = (*ModelCatalogServiceAPIService)(&c.common)
+
+	return c
+}
+
+func atoi(in string) (int, error) {
+	return strconv.Atoi(in)
+}
+
+// selectHeaderContentType select a content type from the available list.
+func selectHeaderContentType(contentTypes []string) string {
+	if len(contentTypes) == 0 {
+		return ""
+	}
+	if contains(contentTypes, "application/json") {
+		return "application/json"
+	}
+	return contentTypes[0] // use the first content type specified in 'consumes'
+}
+
+// selectHeaderAccept join all accept types and return
+func selectHeaderAccept(accepts []string) string {
+	if len(accepts) == 0 {
+		return ""
+	}
+
+	if contains(accepts, "application/json") {
+		return "application/json"
+	}
+
+	return strings.Join(accepts, ",")
+}
+
+// contains is a case insensitive match, finding needle in a haystack
+func contains(haystack []string, needle string) bool {
+	for _, a := range haystack {
+		if strings.EqualFold(a, needle) {
+			return true
+		}
+	}
+	return false
+}
+
+// Verify optional parameters are of the correct type.
+func typeCheckParameter(obj interface{}, expected string, name string) error {
+	// Make sure there is an object.
+	if obj == nil {
+		return nil
+	}
+
+	// Check the type is as expected.
+	if reflect.TypeOf(obj).String() != expected {
+		return fmt.Errorf("expected %s to be of type %s but received %s", name, expected, reflect.TypeOf(obj).String())
+	}
+	return nil
+}
+
+func parameterValueToString(obj interface{}, key string) string {
+	if reflect.TypeOf(obj).Kind() != reflect.Ptr {
+		return fmt.Sprintf("%v", obj)
+	}
+	var param, ok = obj.(MappedNullable)
+	if !ok {
+		return ""
+	}
+	dataMap, err := param.ToMap()
+	if err != nil {
+		return ""
+	}
+	return fmt.Sprintf("%v", dataMap[key])
+}
+
+// parameterAddToHeaderOrQuery adds the provided object to the request header or url query
+// supporting deep object syntax
+func parameterAddToHeaderOrQuery(headerOrQueryParams interface{}, keyPrefix string, obj interface{}, collectionType string) {
+	var v = reflect.ValueOf(obj)
+	var value = ""
+	if v == reflect.ValueOf(nil) {
+		value = "null"
+	} else {
+		switch v.Kind() {
+		case reflect.Invalid:
+			value = "invalid"
+
+		case reflect.Struct:
+			if t, ok := obj.(MappedNullable); ok {
+				dataMap, err := t.ToMap()
+				if err != nil {
+					return
+				}
+				parameterAddToHeaderOrQuery(headerOrQueryParams, keyPrefix, dataMap, collectionType)
+				return
+			}
+			if t, ok := obj.(time.Time); ok {
+				parameterAddToHeaderOrQuery(headerOrQueryParams, keyPrefix, t.Format(time.RFC3339), collectionType)
+				return
+			}
+			value = v.Type().String() + " value"
+		case reflect.Slice:
+			var indValue = reflect.ValueOf(obj)
+			if indValue == reflect.ValueOf(nil) {
+				return
+			}
+			var lenIndValue = indValue.Len()
+			for i := 0; i < lenIndValue; i++ {
+				var arrayValue = indValue.Index(i)
+				parameterAddToHeaderOrQuery(headerOrQueryParams, keyPrefix, arrayValue.Interface(), collectionType)
+			}
+			return
+
+		case reflect.Map:
+			var indValue = reflect.ValueOf(obj)
+			if indValue == reflect.ValueOf(nil) {
+				return
+			}
+			iter := indValue.MapRange()
+			for iter.Next() {
+				k, v := iter.Key(), iter.Value()
+				parameterAddToHeaderOrQuery(headerOrQueryParams, fmt.Sprintf("%s[%s]", keyPrefix, k.String()), v.Interface(), collectionType)
+			}
+			return
+
+		case reflect.Interface:
+			fallthrough
+		case reflect.Ptr:
+			parameterAddToHeaderOrQuery(headerOrQueryParams, keyPrefix, v.Elem().Interface(), collectionType)
+			return
+
+		case reflect.Int, reflect.Int8, reflect.Int16,
+			reflect.Int32, reflect.Int64:
+			value = strconv.FormatInt(v.Int(), 10)
+		case reflect.Uint, reflect.Uint8, reflect.Uint16,
+			reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+			value = strconv.FormatUint(v.Uint(), 10)
+		case reflect.Float32, reflect.Float64:
+			value = strconv.FormatFloat(v.Float(), 'g', -1, 32)
+		case reflect.Bool:
+			value = strconv.FormatBool(v.Bool())
+		case reflect.String:
+			value = v.String()
+		default:
+			value = v.Type().String() + " value"
+		}
+	}
+
+	switch valuesMap := headerOrQueryParams.(type) {
+	case url.Values:
+		if collectionType == "csv" && valuesMap.Get(keyPrefix) != "" {
+			valuesMap.Set(keyPrefix, valuesMap.Get(keyPrefix)+","+value)
+		} else {
+			valuesMap.Add(keyPrefix, value)
+		}
+		break
+	case map[string]string:
+		valuesMap[keyPrefix] = value
+		break
+	}
+}
+
+// helper for converting interface{} parameters to json strings
+func parameterToJson(obj interface{}) (string, error) {
+	jsonBuf, err := json.Marshal(obj)
+	if err != nil {
+		return "", err
+	}
+	return string(jsonBuf), err
+}
+
+// callAPI do the request.
+func (c *APIClient) callAPI(request *http.Request) (*http.Response, error) {
+	if c.cfg.Debug {
+		dump, err := httputil.DumpRequestOut(request, true)
+		if err != nil {
+			return nil, err
+		}
+		log.Printf("\n%s\n", string(dump))
+	}
+
+	resp, err := c.cfg.HTTPClient.Do(request)
+	if err != nil {
+		return resp, err
+	}
+
+	if c.cfg.Debug {
+		dump, err := httputil.DumpResponse(resp, true)
+		if err != nil {
+			return resp, err
+		}
+		log.Printf("\n%s\n", string(dump))
+	}
+	return resp, err
+}
+
+// Allow modification of underlying config for alternate implementations and testing
+// Caution: modifying the configuration while live can cause data races and potentially unwanted behavior
+func (c *APIClient) GetConfig() *Configuration {
+	return c.cfg
+}
+
+type formFile struct {
+	fileBytes    []byte
+	fileName     string
+	formFileName string
+}
+
+// prepareRequest build the request
+func (c *APIClient) prepareRequest(
+	ctx context.Context,
+	path string, method string,
+	postBody interface{},
+	headerParams map[string]string,
+	queryParams url.Values,
+	formParams url.Values,
+	formFiles []formFile) (localVarRequest *http.Request, err error) {
+
+	var body *bytes.Buffer
+
+	// Detect postBody type and post.
+	if postBody != nil {
+		contentType := headerParams["Content-Type"]
+		if contentType == "" {
+			contentType = detectContentType(postBody)
+			headerParams["Content-Type"] = contentType
+		}
+
+		body, err = setBody(postBody, contentType)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	// add form parameters and file if available.
+	if strings.HasPrefix(headerParams["Content-Type"], "multipart/form-data") && len(formParams) > 0 || (len(formFiles) > 0) {
+		if body != nil {
+			return nil, errors.New("Cannot specify postBody and multipart form at the same time.")
+		}
+		body = &bytes.Buffer{}
+		w := multipart.NewWriter(body)
+
+		for k, v := range formParams {
+			for _, iv := range v {
+				if strings.HasPrefix(k, "@") { // file
+					err = addFile(w, k[1:], iv)
+					if err != nil {
+						return nil, err
+					}
+				} else { // form value
+					w.WriteField(k, iv)
+				}
+			}
+		}
+		for _, formFile := range formFiles {
+			if len(formFile.fileBytes) > 0 && formFile.fileName != "" {
+				w.Boundary()
+				part, err := w.CreateFormFile(formFile.formFileName, filepath.Base(formFile.fileName))
+				if err != nil {
+					return nil, err
+				}
+				_, err = part.Write(formFile.fileBytes)
+				if err != nil {
+					return nil, err
+				}
+			}
+		}
+
+		// Set the Boundary in the Content-Type
+		headerParams["Content-Type"] = w.FormDataContentType()
+
+		// Set Content-Length
+		headerParams["Content-Length"] = fmt.Sprintf("%d", body.Len())
+		w.Close()
+	}
+
+	if strings.HasPrefix(headerParams["Content-Type"], "application/x-www-form-urlencoded") && len(formParams) > 0 {
+		if body != nil {
+			return nil, errors.New("Cannot specify postBody and x-www-form-urlencoded form at the same time.")
+		}
+		body = &bytes.Buffer{}
+		body.WriteString(formParams.Encode())
+		// Set Content-Length
+		headerParams["Content-Length"] = fmt.Sprintf("%d", body.Len())
+	}
+
+	// Setup path and query parameters
+	url, err := url.Parse(path)
+	if err != nil {
+		return nil, err
+	}
+
+	// Override request host, if applicable
+	if c.cfg.Host != "" {
+		url.Host = c.cfg.Host
+	}
+
+	// Override request scheme, if applicable
+	if c.cfg.Scheme != "" {
+		url.Scheme = c.cfg.Scheme
+	}
+
+	// Adding Query Param
+	query := url.Query()
+	for k, v := range queryParams {
+		for _, iv := range v {
+			query.Add(k, iv)
+		}
+	}
+
+	// Encode the parameters.
+	url.RawQuery = queryParamSplit.ReplaceAllStringFunc(query.Encode(), func(s string) string {
+		pieces := strings.Split(s, "=")
+		pieces[0] = queryDescape.Replace(pieces[0])
+		return strings.Join(pieces, "=")
+	})
+
+	// Generate a new request
+	if body != nil {
+		localVarRequest, err = http.NewRequest(method, url.String(), body)
+	} else {
+		localVarRequest, err = http.NewRequest(method, url.String(), nil)
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	// add header parameters, if any
+	if len(headerParams) > 0 {
+		headers := http.Header{}
+		for h, v := range headerParams {
+			headers[h] = []string{v}
+		}
+		localVarRequest.Header = headers
+	}
+
+	// Add the user agent to the request.
+	localVarRequest.Header.Add("User-Agent", c.cfg.UserAgent)
+
+	if ctx != nil {
+		// add context to the request
+		localVarRequest = localVarRequest.WithContext(ctx)
+
+		// Walk through any authentication.
+
+		// AccessToken Authentication
+		if auth, ok := ctx.Value(ContextAccessToken).(string); ok {
+			localVarRequest.Header.Add("Authorization", "Bearer "+auth)
+		}
+
+	}
+
+	for header, value := range c.cfg.DefaultHeader {
+		localVarRequest.Header.Add(header, value)
+	}
+	return localVarRequest, nil
+}
+
+func (c *APIClient) decode(v interface{}, b []byte, contentType string) (err error) {
+	if len(b) == 0 {
+		return nil
+	}
+	if s, ok := v.(*string); ok {
+		*s = string(b)
+		return nil
+	}
+	if f, ok := v.(*os.File); ok {
+		f, err = os.CreateTemp("", "HttpClientFile")
+		if err != nil {
+			return
+		}
+		_, err = f.Write(b)
+		if err != nil {
+			return
+		}
+		_, err = f.Seek(0, io.SeekStart)
+		err = os.Remove(f.Name())
+		return
+	}
+	if f, ok := v.(**os.File); ok {
+		*f, err = os.CreateTemp("", "HttpClientFile")
+		if err != nil {
+			return
+		}
+		_, err = (*f).Write(b)
+		if err != nil {
+			return
+		}
+		_, err = (*f).Seek(0, io.SeekStart)
+		err = os.Remove((*f).Name())
+		return
+	}
+	if xmlCheck.MatchString(contentType) {
+		if err = xml.Unmarshal(b, v); err != nil {
+			return err
+		}
+		return nil
+	}
+	if jsonCheck.MatchString(contentType) {
+		if actualObj, ok := v.(interface{ GetActualInstance() interface{} }); ok { // oneOf, anyOf schemas
+			if unmarshalObj, ok := actualObj.(interface{ UnmarshalJSON([]byte) error }); ok { // make sure it has UnmarshalJSON defined
+				if err = unmarshalObj.UnmarshalJSON(b); err != nil {
+					return err
+				}
+			} else {
+				return errors.New("Unknown type with GetActualInstance but no unmarshalObj.UnmarshalJSON defined")
+			}
+		} else if err = json.Unmarshal(b, v); err != nil { // simple model
+			return err
+		}
+		return nil
+	}
+	return errors.New("undefined response type")
+}
+
+// Add a file to the multipart request
+func addFile(w *multipart.Writer, fieldName, path string) error {
+	file, err := os.Open(filepath.Clean(path))
+	if err != nil {
+		return err
+	}
+	err = file.Close()
+	if err != nil {
+		return err
+	}
+
+	part, err := w.CreateFormFile(fieldName, filepath.Base(path))
+	if err != nil {
+		return err
+	}
+	_, err = io.Copy(part, file)
+
+	return err
+}
+
+// Prevent trying to import "fmt"
+func reportError(format string, a ...interface{}) error {
+	return fmt.Errorf(format, a...)
+}
+
+// A wrapper for strict JSON decoding
+func newStrictDecoder(data []byte) *json.Decoder {
+	dec := json.NewDecoder(bytes.NewBuffer(data))
+	dec.DisallowUnknownFields()
+	return dec
+}
+
+// Set request body from an interface{}
+func setBody(body interface{}, contentType string) (bodyBuf *bytes.Buffer, err error) {
+	if bodyBuf == nil {
+		bodyBuf = &bytes.Buffer{}
+	}
+
+	if reader, ok := body.(io.Reader); ok {
+		_, err = bodyBuf.ReadFrom(reader)
+	} else if fp, ok := body.(*os.File); ok {
+		_, err = bodyBuf.ReadFrom(fp)
+	} else if b, ok := body.([]byte); ok {
+		_, err = bodyBuf.Write(b)
+	} else if s, ok := body.(string); ok {
+		_, err = bodyBuf.WriteString(s)
+	} else if s, ok := body.(*string); ok {
+		_, err = bodyBuf.WriteString(*s)
+	} else if jsonCheck.MatchString(contentType) {
+		err = json.NewEncoder(bodyBuf).Encode(body)
+	} else if xmlCheck.MatchString(contentType) {
+		var bs []byte
+		bs, err = xml.Marshal(body)
+		if err == nil {
+			bodyBuf.Write(bs)
+		}
+	}
+
+	if err != nil {
+		return nil, err
+	}
+
+	if bodyBuf.Len() == 0 {
+		err = fmt.Errorf("invalid body type %s\n", contentType)
+		return nil, err
+	}
+	return bodyBuf, nil
+}
+
+// detectContentType method is used to figure out `Request.Body` content type for request header
+func detectContentType(body interface{}) string {
+	contentType := "text/plain; charset=utf-8"
+	kind := reflect.TypeOf(body).Kind()
+
+	switch kind {
+	case reflect.Struct, reflect.Map, reflect.Ptr:
+		contentType = "application/json; charset=utf-8"
+	case reflect.String:
+		contentType = "text/plain; charset=utf-8"
+	default:
+		if b, ok := body.([]byte); ok {
+			contentType = http.DetectContentType(b)
+		} else if kind == reflect.Slice {
+			contentType = "application/json; charset=utf-8"
+		}
+	}
+
+	return contentType
+}
+
+// Ripped from https://github.com/gregjones/httpcache/blob/master/httpcache.go
+type cacheControl map[string]string
+
+func parseCacheControl(headers http.Header) cacheControl {
+	cc := cacheControl{}
+	ccHeader := headers.Get("Cache-Control")
+	for _, part := range strings.Split(ccHeader, ",") {
+		part = strings.Trim(part, " ")
+		if part == "" {
+			continue
+		}
+		if strings.ContainsRune(part, '=') {
+			keyval := strings.Split(part, "=")
+			cc[strings.Trim(keyval[0], " ")] = strings.Trim(keyval[1], ",")
+		} else {
+			cc[part] = ""
+		}
+	}
+	return cc
+}
+
+// CacheExpires helper function to determine remaining time before repeating a request.
+func CacheExpires(r *http.Response) time.Time {
+	// Figure out when the cache expires.
+	var expires time.Time
+	now, err := time.Parse(time.RFC1123, r.Header.Get("date"))
+	if err != nil {
+		return time.Now()
+	}
+	respCacheControl := parseCacheControl(r.Header)
+
+	if maxAge, ok := respCacheControl["max-age"]; ok {
+		lifetime, err := time.ParseDuration(maxAge + "s")
+		if err != nil {
+			expires = now
+		} else {
+			expires = now.Add(lifetime)
+		}
+	} else {
+		expiresHeader := r.Header.Get("Expires")
+		if expiresHeader != "" {
+			expires, err = time.Parse(time.RFC1123, expiresHeader)
+			if err != nil {
+				expires = now
+			}
+		}
+	}
+	return expires
+}
+
+func strlen(s string) int {
+	return utf8.RuneCountInString(s)
+}
+
+// GenericOpenAPIError Provides access to the body, error and model on returned errors.
+type GenericOpenAPIError struct {
+	body  []byte
+	error string
+	model interface{}
+}
+
+// Error returns non-empty string if there was an error.
+func (e GenericOpenAPIError) Error() string {
+	return e.error
+}
+
+// Body returns the raw bytes of the response
+func (e GenericOpenAPIError) Body() []byte {
+	return e.body
+}
+
+// Model returns the unpacked model of the error
+func (e GenericOpenAPIError) Model() interface{} {
+	return e.model
+}
+
+// format error message using title and detail when model implements rfc7807
+func formatErrorMessage(status string, v interface{}) string {
+	str := ""
+	metaValue := reflect.ValueOf(v).Elem()
+
+	if metaValue.Kind() == reflect.Struct {
+		field := metaValue.FieldByName("Title")
+		if field != (reflect.Value{}) {
+			str = fmt.Sprintf("%s", field.Interface())
+		}
+
+		field = metaValue.FieldByName("Detail")
+		if field != (reflect.Value{}) {
+			str = fmt.Sprintf("%s (%s)", str, field.Interface())
+		}
+	}
+
+	return strings.TrimSpace(fmt.Sprintf("%s %s", status, str))
+}

catalog/pkg/openapi/configuration.go

@@ -0,0 +1,221 @@
+/*
+Model Catalog REST API
+
+REST API for Model Registry to create and manage ML model metadata
+
+API version: v1alpha1
+*/
+
+// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
+
+package openapi
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"strings"
+)
+
+// contextKeys are used to identify the type of value in the context.
+// Since these are string, it is possible to get a short description of the
+// context key for logging and debugging using key.String().
+
+type contextKey string
+
+func (c contextKey) String() string {
+	return "auth " + string(c)
+}
+
+var (
+	// ContextAccessToken takes a string oauth2 access token as authentication for the request.
+	ContextAccessToken = contextKey("accesstoken")
+
+	// ContextServerIndex uses a server configuration from the index.
+	ContextServerIndex = contextKey("serverIndex")
+
+	// ContextOperationServerIndices uses a server configuration from the index mapping.
+	ContextOperationServerIndices = contextKey("serverOperationIndices")
+
+	// ContextServerVariables overrides a server configuration variables.
+	ContextServerVariables = contextKey("serverVariables")
+
+	// ContextOperationServerVariables overrides a server configuration variables using operation specific values.
+	ContextOperationServerVariables = contextKey("serverOperationVariables")
+)
+
+// BasicAuth provides basic http authentication to a request passed via context using ContextBasicAuth
+type BasicAuth struct {
+	UserName string `json:"userName,omitempty"`
+	Password string `json:"password,omitempty"`
+}
+
+// APIKey provides API key based authentication to a request passed via context using ContextAPIKey
+type APIKey struct {
+	Key    string
+	Prefix string
+}
+
+// ServerVariable stores the information about a server variable
+type ServerVariable struct {
+	Description  string
+	DefaultValue string
+	EnumValues   []string
+}
+
+// ServerConfiguration stores the information about a server
+type ServerConfiguration struct {
+	URL         string
+	Description string
+	Variables   map[string]ServerVariable
+}
+
+// ServerConfigurations stores multiple ServerConfiguration items
+type ServerConfigurations []ServerConfiguration
+
+// Configuration stores the configuration of the API client
+type Configuration struct {
+	Host             string            `json:"host,omitempty"`
+	Scheme           string            `json:"scheme,omitempty"`
+	DefaultHeader    map[string]string `json:"defaultHeader,omitempty"`
+	UserAgent        string            `json:"userAgent,omitempty"`
+	Debug            bool              `json:"debug,omitempty"`
+	Servers          ServerConfigurations
+	OperationServers map[string]ServerConfigurations
+	HTTPClient       *http.Client
+}
+
+// NewConfiguration returns a new Configuration object
+func NewConfiguration() *Configuration {
+	cfg := &Configuration{
+		DefaultHeader: make(map[string]string),
+		UserAgent:     "OpenAPI-Generator/1.0.0/go",
+		Debug:         false,
+		Servers: ServerConfigurations{
+			{
+				URL:         "https://localhost:8080",
+				Description: "No description provided",
+			},
+			{
+				URL:         "http://localhost:8080",
+				Description: "No description provided",
+			},
+		},
+		OperationServers: map[string]ServerConfigurations{},
+	}
+	return cfg
+}
+
+// AddDefaultHeader adds a new HTTP header to the default header in the request
+func (c *Configuration) AddDefaultHeader(key string, value string) {
+	c.DefaultHeader[key] = value
+}
+
+// URL formats template on a index using given variables
+func (sc ServerConfigurations) URL(index int, variables map[string]string) (string, error) {
+	if index < 0 || len(sc) <= index {
+		return "", fmt.Errorf("index %v out of range %v", index, len(sc)-1)
+	}
+	server := sc[index]
+	url := server.URL
+
+	// go through variables and replace placeholders
+	for name, variable := range server.Variables {
+		if value, ok := variables[name]; ok {
+			found := bool(len(variable.EnumValues) == 0)
+			for _, enumValue := range variable.EnumValues {
+				if value == enumValue {
+					found = true
+				}
+			}
+			if !found {
+				return "", fmt.Errorf("the variable %s in the server URL has invalid value %v. Must be %v", name, value, variable.EnumValues)
+			}
+			url = strings.Replace(url, "{"+name+"}", value, -1)
+		} else {
+			url = strings.Replace(url, "{"+name+"}", variable.DefaultValue, -1)
+		}
+	}
+	return url, nil
+}
+
+// ServerURL returns URL based on server settings
+func (c *Configuration) ServerURL(index int, variables map[string]string) (string, error) {
+	return c.Servers.URL(index, variables)
+}
+
+func getServerIndex(ctx context.Context) (int, error) {
+	si := ctx.Value(ContextServerIndex)
+	if si != nil {
+		if index, ok := si.(int); ok {
+			return index, nil
+		}
+		return 0, reportError("Invalid type %T should be int", si)
+	}
+	return 0, nil
+}
+
+func getServerOperationIndex(ctx context.Context, endpoint string) (int, error) {
+	osi := ctx.Value(ContextOperationServerIndices)
+	if osi != nil {
+		if operationIndices, ok := osi.(map[string]int); !ok {
+			return 0, reportError("Invalid type %T should be map[string]int", osi)
+		} else {
+			index, ok := operationIndices[endpoint]
+			if ok {
+				return index, nil
+			}
+		}
+	}
+	return getServerIndex(ctx)
+}
+
+func getServerVariables(ctx context.Context) (map[string]string, error) {
+	sv := ctx.Value(ContextServerVariables)
+	if sv != nil {
+		if variables, ok := sv.(map[string]string); ok {
+			return variables, nil
+		}
+		return nil, reportError("ctx value of ContextServerVariables has invalid type %T should be map[string]string", sv)
+	}
+	return nil, nil
+}
+
+func getServerOperationVariables(ctx context.Context, endpoint string) (map[string]string, error) {
+	osv := ctx.Value(ContextOperationServerVariables)
+	if osv != nil {
+		if operationVariables, ok := osv.(map[string]map[string]string); !ok {
+			return nil, reportError("ctx value of ContextOperationServerVariables has invalid type %T should be map[string]map[string]string", osv)
+		} else {
+			variables, ok := operationVariables[endpoint]
+			if ok {
+				return variables, nil
+			}
+		}
+	}
+	return getServerVariables(ctx)
+}
+
+// ServerURLWithContext returns a new server URL given an endpoint
+func (c *Configuration) ServerURLWithContext(ctx context.Context, endpoint string) (string, error) {
+	sc, ok := c.OperationServers[endpoint]
+	if !ok {
+		sc = c.Servers
+	}
+
+	if ctx == nil {
+		return sc.URL(0, nil)
+	}
+
+	index, err := getServerOperationIndex(ctx, endpoint)
+	if err != nil {
+		return "", err
+	}
+
+	variables, err := getServerOperationVariables(ctx, endpoint)
+	if err != nil {
+		return "", err
+	}
+
+	return sc.URL(index, variables)
+}

catalog/pkg/openapi/model_artifact_type_query_param.go

@@ -0,0 +1,116 @@
+/*
+Model Catalog REST API
+
+REST API for Model Registry to create and manage ML model metadata
+
+API version: v1alpha1
+*/
+
+// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
+
+package openapi
+
+import (
+	"encoding/json"
+	"fmt"
+)
+
+// ArtifactTypeQueryParam Supported artifact types for querying.
+type ArtifactTypeQueryParam string
+
+// List of ArtifactTypeQueryParam
+const (
+	ARTIFACTTYPEQUERYPARAM_MODEL_ARTIFACT   ArtifactTypeQueryParam = "model-artifact"
+	ARTIFACTTYPEQUERYPARAM_DOC_ARTIFACT     ArtifactTypeQueryParam = "doc-artifact"
+	ARTIFACTTYPEQUERYPARAM_DATASET_ARTIFACT ArtifactTypeQueryParam = "dataset-artifact"
+	ARTIFACTTYPEQUERYPARAM_METRIC           ArtifactTypeQueryParam = "metric"
+	ARTIFACTTYPEQUERYPARAM_PARAMETER        ArtifactTypeQueryParam = "parameter"
+)
+
+// All allowed values of ArtifactTypeQueryParam enum
+var AllowedArtifactTypeQueryParamEnumValues = []ArtifactTypeQueryParam{
+	"model-artifact",
+	"doc-artifact",
+	"dataset-artifact",
+	"metric",
+	"parameter",
+}
+
+func (v *ArtifactTypeQueryParam) UnmarshalJSON(src []byte) error {
+	var value string
+	err := json.Unmarshal(src, &value)
+	if err != nil {
+		return err
+	}
+	enumTypeValue := ArtifactTypeQueryParam(value)
+	for _, existing := range AllowedArtifactTypeQueryParamEnumValues {
+		if existing == enumTypeValue {
+			*v = enumTypeValue
+			return nil
+		}
+	}
+
+	return fmt.Errorf("%+v is not a valid ArtifactTypeQueryParam", value)
+}
+
+// NewArtifactTypeQueryParamFromValue returns a pointer to a valid ArtifactTypeQueryParam
+// for the value passed as argument, or an error if the value passed is not allowed by the enum
+func NewArtifactTypeQueryParamFromValue(v string) (*ArtifactTypeQueryParam, error) {
+	ev := ArtifactTypeQueryParam(v)
+	if ev.IsValid() {
+		return &ev, nil
+	} else {
+		return nil, fmt.Errorf("invalid value '%v' for ArtifactTypeQueryParam: valid values are %v", v, AllowedArtifactTypeQueryParamEnumValues)
+	}
+}
+
+// IsValid return true if the value is valid for the enum, false otherwise
+func (v ArtifactTypeQueryParam) IsValid() bool {
+	for _, existing := range AllowedArtifactTypeQueryParamEnumValues {
+		if existing == v {
+			return true
+		}
+	}
+	return false
+}
+
+// Ptr returns reference to ArtifactTypeQueryParam value
+func (v ArtifactTypeQueryParam) Ptr() *ArtifactTypeQueryParam {
+	return &v
+}
+
+type NullableArtifactTypeQueryParam struct {
+	value *ArtifactTypeQueryParam
+	isSet bool
+}
+
+func (v NullableArtifactTypeQueryParam) Get() *ArtifactTypeQueryParam {
+	return v.value
+}
+
+func (v *NullableArtifactTypeQueryParam) Set(val *ArtifactTypeQueryParam) {
+	v.value = val
+	v.isSet = true
+}
+
+func (v NullableArtifactTypeQueryParam) IsSet() bool {
+	return v.isSet
+}
+
+func (v *NullableArtifactTypeQueryParam) Unset() {
+	v.value = nil
+	v.isSet = false
+}
+
+func NewNullableArtifactTypeQueryParam(val *ArtifactTypeQueryParam) *NullableArtifactTypeQueryParam {
+	return &NullableArtifactTypeQueryParam{value: val, isSet: true}
+}
+
+func (v NullableArtifactTypeQueryParam) MarshalJSON() ([]byte, error) {
+	return json.Marshal(v.value)
+}
+
+func (v *NullableArtifactTypeQueryParam) UnmarshalJSON(src []byte) error {
+	v.isSet = true
+	return json.Unmarshal(src, &v.value)
+}

catalog/pkg/openapi/model_base_model.go

@@ -0,0 +1,494 @@
+/*
+Model Catalog REST API
+
+REST API for Model Registry to create and manage ML model metadata
+
+API version: v1alpha1
+*/
+
+// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
+
+package openapi
+
+import (
+	"encoding/json"
+)
+
+// checks if the BaseModel type satisfies the MappedNullable interface at compile time
+var _ MappedNullable = &BaseModel{}
+
+// BaseModel struct for BaseModel
+type BaseModel struct {
+	// Human-readable description of the model.
+	Description *string `json:"description,omitempty"`
+	// Model documentation in Markdown.
+	Readme *string `json:"readme,omitempty"`
+	// Maturity level of the model.
+	Maturity *string `json:"maturity,omitempty"`
+	// List of supported languages (https://en.wikipedia.org/wiki/List_of_ISO_639_language_codes).
+	Language []string `json:"language,omitempty"`
+	// List of tasks the model is designed for.
+	Tasks []string `json:"tasks,omitempty"`
+	// Name of the organization or entity that provides the model.
+	Provider *string `json:"provider,omitempty"`
+	// URL to the model's logo. A [data URL](https://developer.mozilla.org/en-US/docs/Web/URI/Schemes/data) is recommended.
+	Logo *string `json:"logo,omitempty"`
+	// Short name of the model's license.
+	License *string `json:"license,omitempty"`
+	// URL to the license text.
+	LicenseLink *string `json:"licenseLink,omitempty"`
+	LibraryName *string `json:"libraryName,omitempty"`
+	// User provided custom properties which are not defined by its type.
+	CustomProperties *map[string]MetadataValue `json:"customProperties,omitempty"`
+}
+
+// NewBaseModel instantiates a new BaseModel object
+// This constructor will assign default values to properties that have it defined,
+// and makes sure properties required by API are set, but the set of arguments
+// will change when the set of required properties is changed
+func NewBaseModel() *BaseModel {
+	this := BaseModel{}
+	return &this
+}
+
+// NewBaseModelWithDefaults instantiates a new BaseModel object
+// This constructor will only assign default values to properties that have it defined,
+// but it doesn't guarantee that properties required by API are set
+func NewBaseModelWithDefaults() *BaseModel {
+	this := BaseModel{}
+	return &this
+}
+
+// GetDescription returns the Description field value if set, zero value otherwise.
+func (o *BaseModel) GetDescription() string {
+	if o == nil || IsNil(o.Description) {
+		var ret string
+		return ret
+	}
+	return *o.Description
+}
+
+// GetDescriptionOk returns a tuple with the Description field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *BaseModel) GetDescriptionOk() (*string, bool) {
+	if o == nil || IsNil(o.Description) {
+		return nil, false
+	}
+	return o.Description, true
+}
+
+// HasDescription returns a boolean if a field has been set.
+func (o *BaseModel) HasDescription() bool {
+	if o != nil && !IsNil(o.Description) {
+		return true
+	}
+
+	return false
+}
+
+// SetDescription gets a reference to the given string and assigns it to the Description field.
+func (o *BaseModel) SetDescription(v string) {
+	o.Description = &v
+}
+
+// GetReadme returns the Readme field value if set, zero value otherwise.
+func (o *BaseModel) GetReadme() string {
+	if o == nil || IsNil(o.Readme) {
+		var ret string
+		return ret
+	}
+	return *o.Readme
+}
+
+// GetReadmeOk returns a tuple with the Readme field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *BaseModel) GetReadmeOk() (*string, bool) {
+	if o == nil || IsNil(o.Readme) {
+		return nil, false
+	}
+	return o.Readme, true
+}
+
+// HasReadme returns a boolean if a field has been set.
+func (o *BaseModel) HasReadme() bool {
+	if o != nil && !IsNil(o.Readme) {
+		return true
+	}
+
+	return false
+}
+
+// SetReadme gets a reference to the given string and assigns it to the Readme field.
+func (o *BaseModel) SetReadme(v string) {
+	o.Readme = &v
+}
+
+// GetMaturity returns the Maturity field value if set, zero value otherwise.
+func (o *BaseModel) GetMaturity() string {
+	if o == nil || IsNil(o.Maturity) {
+		var ret string
+		return ret
+	}
+	return *o.Maturity
+}
+
+// GetMaturityOk returns a tuple with the Maturity field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *BaseModel) GetMaturityOk() (*string, bool) {
+	if o == nil || IsNil(o.Maturity) {
+		return nil, false
+	}
+	return o.Maturity, true
+}
+
+// HasMaturity returns a boolean if a field has been set.
+func (o *BaseModel) HasMaturity() bool {
+	if o != nil && !IsNil(o.Maturity) {
+		return true
+	}
+
+	return false
+}
+
+// SetMaturity gets a reference to the given string and assigns it to the Maturity field.
+func (o *BaseModel) SetMaturity(v string) {
+	o.Maturity = &v
+}
+
+// GetLanguage returns the Language field value if set, zero value otherwise.
+func (o *BaseModel) GetLanguage() []string {
+	if o == nil || IsNil(o.Language) {
+		var ret []string
+		return ret
+	}
+	return o.Language
+}
+
+// GetLanguageOk returns a tuple with the Language field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *BaseModel) GetLanguageOk() ([]string, bool) {
+	if o == nil || IsNil(o.Language) {
+		return nil, false
+	}
+	return o.Language, true
+}
+
+// HasLanguage returns a boolean if a field has been set.
+func (o *BaseModel) HasLanguage() bool {
+	if o != nil && !IsNil(o.Language) {
+		return true
+	}
+
+	return false
+}
+
+// SetLanguage gets a reference to the given []string and assigns it to the Language field.
+func (o *BaseModel) SetLanguage(v []string) {
+	o.Language = v
+}
+
+// GetTasks returns the Tasks field value if set, zero value otherwise.
+func (o *BaseModel) GetTasks() []string {
+	if o == nil || IsNil(o.Tasks) {
+		var ret []string
+		return ret
+	}
+	return o.Tasks
+}
+
+// GetTasksOk returns a tuple with the Tasks field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *BaseModel) GetTasksOk() ([]string, bool) {
+	if o == nil || IsNil(o.Tasks) {
+		return nil, false
+	}
+	return o.Tasks, true
+}
+
+// HasTasks returns a boolean if a field has been set.
+func (o *BaseModel) HasTasks() bool {
+	if o != nil && !IsNil(o.Tasks) {
+		return true
+	}
+
+	return false
+}
+
+// SetTasks gets a reference to the given []string and assigns it to the Tasks field.
+func (o *BaseModel) SetTasks(v []string) {
+	o.Tasks = v
+}
+
+// GetProvider returns the Provider field value if set, zero value otherwise.
+func (o *BaseModel) GetProvider() string {
+	if o == nil || IsNil(o.Provider) {
+		var ret string
+		return ret
+	}
+	return *o.Provider
+}
+
+// GetProviderOk returns a tuple with the Provider field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *BaseModel) GetProviderOk() (*string, bool) {
+	if o == nil || IsNil(o.Provider) {
+		return nil, false
+	}
+	return o.Provider, true
+}
+
+// HasProvider returns a boolean if a field has been set.
+func (o *BaseModel) HasProvider() bool {
+	if o != nil && !IsNil(o.Provider) {
+		return true
+	}
+
+	return false
+}
+
+// SetProvider gets a reference to the given string and assigns it to the Provider field.
+func (o *BaseModel) SetProvider(v string) {
+	o.Provider = &v
+}
+
+// GetLogo returns the Logo field value if set, zero value otherwise.
+func (o *BaseModel) GetLogo() string {
+	if o == nil || IsNil(o.Logo) {
+		var ret string
+		return ret
+	}
+	return *o.Logo
+}
+
+// GetLogoOk returns a tuple with the Logo field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *BaseModel) GetLogoOk() (*string, bool) {
+	if o == nil || IsNil(o.Logo) {
+		return nil, false
+	}
+	return o.Logo, true
+}
+
+// HasLogo returns a boolean if a field has been set.
+func (o *BaseModel) HasLogo() bool {
+	if o != nil && !IsNil(o.Logo) {
+		return true
+	}
+
+	return false
+}
+
+// SetLogo gets a reference to the given string and assigns it to the Logo field.
+func (o *BaseModel) SetLogo(v string) {
+	o.Logo = &v
+}
+
+// GetLicense returns the License field value if set, zero value otherwise.
+func (o *BaseModel) GetLicense() string {
+	if o == nil || IsNil(o.License) {
+		var ret string
+		return ret
+	}
+	return *o.License
+}
+
+// GetLicenseOk returns a tuple with the License field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *BaseModel) GetLicenseOk() (*string, bool) {
+	if o == nil || IsNil(o.License) {
+		return nil, false
+	}
+	return o.License, true
+}
+
+// HasLicense returns a boolean if a field has been set.
+func (o *BaseModel) HasLicense() bool {
+	if o != nil && !IsNil(o.License) {
+		return true
+	}
+
+	return false
+}
+
+// SetLicense gets a reference to the given string and assigns it to the License field.
+func (o *BaseModel) SetLicense(v string) {
+	o.License = &v
+}
+
+// GetLicenseLink returns the LicenseLink field value if set, zero value otherwise.
+func (o *BaseModel) GetLicenseLink() string {
+	if o == nil || IsNil(o.LicenseLink) {
+		var ret string
+		return ret
+	}
+	return *o.LicenseLink
+}
+
+// GetLicenseLinkOk returns a tuple with the LicenseLink field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *BaseModel) GetLicenseLinkOk() (*string, bool) {
+	if o == nil || IsNil(o.LicenseLink) {
+		return nil, false
+	}
+	return o.LicenseLink, true
+}
+
+// HasLicenseLink returns a boolean if a field has been set.
+func (o *BaseModel) HasLicenseLink() bool {
+	if o != nil && !IsNil(o.LicenseLink) {
+		return true
+	}
+
+	return false
+}
+
+// SetLicenseLink gets a reference to the given string and assigns it to the LicenseLink field.
+func (o *BaseModel) SetLicenseLink(v string) {
+	o.LicenseLink = &v
+}
+
+// GetLibraryName returns the LibraryName field value if set, zero value otherwise.
+func (o *BaseModel) GetLibraryName() string {
+	if o == nil || IsNil(o.LibraryName) {
+		var ret string
+		return ret
+	}
+	return *o.LibraryName
+}
+
+// GetLibraryNameOk returns a tuple with the LibraryName field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *BaseModel) GetLibraryNameOk() (*string, bool) {
+	if o == nil || IsNil(o.LibraryName) {
+		return nil, false
+	}
+	return o.LibraryName, true
+}
+
+// HasLibraryName returns a boolean if a field has been set.
+func (o *BaseModel) HasLibraryName() bool {
+	if o != nil && !IsNil(o.LibraryName) {
+		return true
+	}
+
+	return false
+}
+
+// SetLibraryName gets a reference to the given string and assigns it to the LibraryName field.
+func (o *BaseModel) SetLibraryName(v string) {
+	o.LibraryName = &v
+}
+
+// GetCustomProperties returns the CustomProperties field value if set, zero value otherwise.
+func (o *BaseModel) GetCustomProperties() map[string]MetadataValue {
+	if o == nil || IsNil(o.CustomProperties) {
+		var ret map[string]MetadataValue
+		return ret
+	}
+	return *o.CustomProperties
+}
+
+// GetCustomPropertiesOk returns a tuple with the CustomProperties field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *BaseModel) GetCustomPropertiesOk() (*map[string]MetadataValue, bool) {
+	if o == nil || IsNil(o.CustomProperties) {
+		return nil, false
+	}
+	return o.CustomProperties, true
+}
+
+// HasCustomProperties returns a boolean if a field has been set.
+func (o *BaseModel) HasCustomProperties() bool {
+	if o != nil && !IsNil(o.CustomProperties) {
+		return true
+	}
+
+	return false
+}
+
+// SetCustomProperties gets a reference to the given map[string]MetadataValue and assigns it to the CustomProperties field.
+func (o *BaseModel) SetCustomProperties(v map[string]MetadataValue) {
+	o.CustomProperties = &v
+}
+
+func (o BaseModel) MarshalJSON() ([]byte, error) {
+	toSerialize, err := o.ToMap()
+	if err != nil {
+		return []byte{}, err
+	}
+	return json.Marshal(toSerialize)
+}
+
+func (o BaseModel) ToMap() (map[string]interface{}, error) {
+	toSerialize := map[string]interface{}{}
+	if !IsNil(o.Description) {
+		toSerialize["description"] = o.Description
+	}
+	if !IsNil(o.Readme) {
+		toSerialize["readme"] = o.Readme
+	}
+	if !IsNil(o.Maturity) {
+		toSerialize["maturity"] = o.Maturity
+	}
+	if !IsNil(o.Language) {
+		toSerialize["language"] = o.Language
+	}
+	if !IsNil(o.Tasks) {
+		toSerialize["tasks"] = o.Tasks
+	}
+	if !IsNil(o.Provider) {
+		toSerialize["provider"] = o.Provider
+	}
+	if !IsNil(o.Logo) {
+		toSerialize["logo"] = o.Logo
+	}
+	if !IsNil(o.License) {
+		toSerialize["license"] = o.License
+	}
+	if !IsNil(o.LicenseLink) {
+		toSerialize["licenseLink"] = o.LicenseLink
+	}
+	if !IsNil(o.LibraryName) {
+		toSerialize["libraryName"] = o.LibraryName
+	}
+	if !IsNil(o.CustomProperties) {
+		toSerialize["customProperties"] = o.CustomProperties
+	}
+	return toSerialize, nil
+}
+
+type NullableBaseModel struct {
+	value *BaseModel
+	isSet bool
+}
+
+func (v NullableBaseModel) Get() *BaseModel {
+	return v.value
+}
+
+func (v *NullableBaseModel) Set(val *BaseModel) {
+	v.value = val
+	v.isSet = true
+}
+
+func (v NullableBaseModel) IsSet() bool {
+	return v.isSet
+}
+
+func (v *NullableBaseModel) Unset() {
+	v.value = nil
+	v.isSet = false
+}
+
+func NewNullableBaseModel(val *BaseModel) *NullableBaseModel {
+	return &NullableBaseModel{value: val, isSet: true}
+}
+
+func (v NullableBaseModel) MarshalJSON() ([]byte, error) {
+	return json.Marshal(v.value)
+}
+
+func (v *NullableBaseModel) UnmarshalJSON(src []byte) error {
+	v.isSet = true
+	return json.Unmarshal(src, &v.value)
+}

catalog/pkg/openapi/model_base_resource_dates.go

@@ -0,0 +1,162 @@
+/*
+Model Catalog REST API
+
+REST API for Model Registry to create and manage ML model metadata
+
+API version: v1alpha1
+*/
+
+// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
+
+package openapi
+
+import (
+	"encoding/json"
+)
+
+// checks if the BaseResourceDates type satisfies the MappedNullable interface at compile time
+var _ MappedNullable = &BaseResourceDates{}
+
+// BaseResourceDates Common timestamp fields for resources
+type BaseResourceDates struct {
+	// Output only. Create time of the resource in millisecond since epoch.
+	CreateTimeSinceEpoch *string `json:"createTimeSinceEpoch,omitempty"`
+	// Output only. Last update time of the resource since epoch in millisecond since epoch.
+	LastUpdateTimeSinceEpoch *string `json:"lastUpdateTimeSinceEpoch,omitempty"`
+}
+
+// NewBaseResourceDates instantiates a new BaseResourceDates object
+// This constructor will assign default values to properties that have it defined,
+// and makes sure properties required by API are set, but the set of arguments
+// will change when the set of required properties is changed
+func NewBaseResourceDates() *BaseResourceDates {
+	this := BaseResourceDates{}
+	return &this
+}
+
+// NewBaseResourceDatesWithDefaults instantiates a new BaseResourceDates object
+// This constructor will only assign default values to properties that have it defined,
+// but it doesn't guarantee that properties required by API are set
+func NewBaseResourceDatesWithDefaults() *BaseResourceDates {
+	this := BaseResourceDates{}
+	return &this
+}
+
+// GetCreateTimeSinceEpoch returns the CreateTimeSinceEpoch field value if set, zero value otherwise.
+func (o *BaseResourceDates) GetCreateTimeSinceEpoch() string {
+	if o == nil || IsNil(o.CreateTimeSinceEpoch) {
+		var ret string
+		return ret
+	}
+	return *o.CreateTimeSinceEpoch
+}
+
+// GetCreateTimeSinceEpochOk returns a tuple with the CreateTimeSinceEpoch field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *BaseResourceDates) GetCreateTimeSinceEpochOk() (*string, bool) {
+	if o == nil || IsNil(o.CreateTimeSinceEpoch) {
+		return nil, false
+	}
+	return o.CreateTimeSinceEpoch, true
+}
+
+// HasCreateTimeSinceEpoch returns a boolean if a field has been set.
+func (o *BaseResourceDates) HasCreateTimeSinceEpoch() bool {
+	if o != nil && !IsNil(o.CreateTimeSinceEpoch) {
+		return true
+	}
+
+	return false
+}
+
+// SetCreateTimeSinceEpoch gets a reference to the given string and assigns it to the CreateTimeSinceEpoch field.
+func (o *BaseResourceDates) SetCreateTimeSinceEpoch(v string) {
+	o.CreateTimeSinceEpoch = &v
+}
+
+// GetLastUpdateTimeSinceEpoch returns the LastUpdateTimeSinceEpoch field value if set, zero value otherwise.
+func (o *BaseResourceDates) GetLastUpdateTimeSinceEpoch() string {
+	if o == nil || IsNil(o.LastUpdateTimeSinceEpoch) {
+		var ret string
+		return ret
+	}
+	return *o.LastUpdateTimeSinceEpoch
+}
+
+// GetLastUpdateTimeSinceEpochOk returns a tuple with the LastUpdateTimeSinceEpoch field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *BaseResourceDates) GetLastUpdateTimeSinceEpochOk() (*string, bool) {
+	if o == nil || IsNil(o.LastUpdateTimeSinceEpoch) {
+		return nil, false
+	}
+	return o.LastUpdateTimeSinceEpoch, true
+}
+
+// HasLastUpdateTimeSinceEpoch returns a boolean if a field has been set.
+func (o *BaseResourceDates) HasLastUpdateTimeSinceEpoch() bool {
+	if o != nil && !IsNil(o.LastUpdateTimeSinceEpoch) {
+		return true
+	}
+
+	return false
+}
+
+// SetLastUpdateTimeSinceEpoch gets a reference to the given string and assigns it to the LastUpdateTimeSinceEpoch field.
+func (o *BaseResourceDates) SetLastUpdateTimeSinceEpoch(v string) {
+	o.LastUpdateTimeSinceEpoch = &v
+}
+
+func (o BaseResourceDates) MarshalJSON() ([]byte, error) {
+	toSerialize, err := o.ToMap()
+	if err != nil {
+		return []byte{}, err
+	}
+	return json.Marshal(toSerialize)
+}
+
+func (o BaseResourceDates) ToMap() (map[string]interface{}, error) {
+	toSerialize := map[string]interface{}{}
+	if !IsNil(o.CreateTimeSinceEpoch) {
+		toSerialize["createTimeSinceEpoch"] = o.CreateTimeSinceEpoch
+	}
+	if !IsNil(o.LastUpdateTimeSinceEpoch) {
+		toSerialize["lastUpdateTimeSinceEpoch"] = o.LastUpdateTimeSinceEpoch
+	}
+	return toSerialize, nil
+}
+
+type NullableBaseResourceDates struct {
+	value *BaseResourceDates
+	isSet bool
+}
+
+func (v NullableBaseResourceDates) Get() *BaseResourceDates {
+	return v.value
+}
+
+func (v *NullableBaseResourceDates) Set(val *BaseResourceDates) {
+	v.value = val
+	v.isSet = true
+}
+
+func (v NullableBaseResourceDates) IsSet() bool {
+	return v.isSet
+}
+
+func (v *NullableBaseResourceDates) Unset() {
+	v.value = nil
+	v.isSet = false
+}
+
+func NewNullableBaseResourceDates(val *BaseResourceDates) *NullableBaseResourceDates {
+	return &NullableBaseResourceDates{value: val, isSet: true}
+}
+
+func (v NullableBaseResourceDates) MarshalJSON() ([]byte, error) {
+	return json.Marshal(v.value)
+}
+
+func (v *NullableBaseResourceDates) UnmarshalJSON(src []byte) error {
+	v.isSet = true
+	return json.Unmarshal(src, &v.value)
+}

catalog/pkg/openapi/model_base_resource_list.go

@@ -0,0 +1,172 @@
+/*
+Model Catalog REST API
+
+REST API for Model Registry to create and manage ML model metadata
+
+API version: v1alpha1
+*/
+
+// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
+
+package openapi
+
+import (
+	"encoding/json"
+)
+
+// checks if the BaseResourceList type satisfies the MappedNullable interface at compile time
+var _ MappedNullable = &BaseResourceList{}
+
+// BaseResourceList struct for BaseResourceList
+type BaseResourceList struct {
+	// Token to use to retrieve next page of results.
+	NextPageToken string `json:"nextPageToken"`
+	// Maximum number of resources to return in the result.
+	PageSize int32 `json:"pageSize"`
+	// Number of items in result list.
+	Size int32 `json:"size"`
+}
+
+// NewBaseResourceList instantiates a new BaseResourceList object
+// This constructor will assign default values to properties that have it defined,
+// and makes sure properties required by API are set, but the set of arguments
+// will change when the set of required properties is changed
+func NewBaseResourceList(nextPageToken string, pageSize int32, size int32) *BaseResourceList {
+	this := BaseResourceList{}
+	this.NextPageToken = nextPageToken
+	this.PageSize = pageSize
+	this.Size = size
+	return &this
+}
+
+// NewBaseResourceListWithDefaults instantiates a new BaseResourceList object
+// This constructor will only assign default values to properties that have it defined,
+// but it doesn't guarantee that properties required by API are set
+func NewBaseResourceListWithDefaults() *BaseResourceList {
+	this := BaseResourceList{}
+	return &this
+}
+
+// GetNextPageToken returns the NextPageToken field value
+func (o *BaseResourceList) GetNextPageToken() string {
+	if o == nil {
+		var ret string
+		return ret
+	}
+
+	return o.NextPageToken
+}
+
+// GetNextPageTokenOk returns a tuple with the NextPageToken field value
+// and a boolean to check if the value has been set.
+func (o *BaseResourceList) GetNextPageTokenOk() (*string, bool) {
+	if o == nil {
+		return nil, false
+	}
+	return &o.NextPageToken, true
+}
+
+// SetNextPageToken sets field value
+func (o *BaseResourceList) SetNextPageToken(v string) {
+	o.NextPageToken = v
+}
+
+// GetPageSize returns the PageSize field value
+func (o *BaseResourceList) GetPageSize() int32 {
+	if o == nil {
+		var ret int32
+		return ret
+	}
+
+	return o.PageSize
+}
+
+// GetPageSizeOk returns a tuple with the PageSize field value
+// and a boolean to check if the value has been set.
+func (o *BaseResourceList) GetPageSizeOk() (*int32, bool) {
+	if o == nil {
+		return nil, false
+	}
+	return &o.PageSize, true
+}
+
+// SetPageSize sets field value
+func (o *BaseResourceList) SetPageSize(v int32) {
+	o.PageSize = v
+}
+
+// GetSize returns the Size field value
+func (o *BaseResourceList) GetSize() int32 {
+	if o == nil {
+		var ret int32
+		return ret
+	}
+
+	return o.Size
+}
+
+// GetSizeOk returns a tuple with the Size field value
+// and a boolean to check if the value has been set.
+func (o *BaseResourceList) GetSizeOk() (*int32, bool) {
+	if o == nil {
+		return nil, false
+	}
+	return &o.Size, true
+}
+
+// SetSize sets field value
+func (o *BaseResourceList) SetSize(v int32) {
+	o.Size = v
+}
+
+func (o BaseResourceList) MarshalJSON() ([]byte, error) {
+	toSerialize, err := o.ToMap()
+	if err != nil {
+		return []byte{}, err
+	}
+	return json.Marshal(toSerialize)
+}
+
+func (o BaseResourceList) ToMap() (map[string]interface{}, error) {
+	toSerialize := map[string]interface{}{}
+	toSerialize["nextPageToken"] = o.NextPageToken
+	toSerialize["pageSize"] = o.PageSize
+	toSerialize["size"] = o.Size
+	return toSerialize, nil
+}
+
+type NullableBaseResourceList struct {
+	value *BaseResourceList
+	isSet bool
+}
+
+func (v NullableBaseResourceList) Get() *BaseResourceList {
+	return v.value
+}
+
+func (v *NullableBaseResourceList) Set(val *BaseResourceList) {
+	v.value = val
+	v.isSet = true
+}
+
+func (v NullableBaseResourceList) IsSet() bool {
+	return v.isSet
+}
+
+func (v *NullableBaseResourceList) Unset() {
+	v.value = nil
+	v.isSet = false
+}
+
+func NewNullableBaseResourceList(val *BaseResourceList) *NullableBaseResourceList {
+	return &NullableBaseResourceList{value: val, isSet: true}
+}
+
+func (v NullableBaseResourceList) MarshalJSON() ([]byte, error) {
+	return json.Marshal(v.value)
+}
+
+func (v *NullableBaseResourceList) UnmarshalJSON(src []byte) error {
+	v.isSet = true
+	return json.Unmarshal(src, &v.value)
+}

catalog/pkg/openapi/model_catalog_model.go

@@ -0,0 +1,633 @@
+/*
+Model Catalog REST API
+
+REST API for Model Registry to create and manage ML model metadata
+
+API version: v1alpha1
+*/
+
+// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
+
+package openapi
+
+import (
+	"encoding/json"
+)
+
+// checks if the CatalogModel type satisfies the MappedNullable interface at compile time
+var _ MappedNullable = &CatalogModel{}
+
+// CatalogModel A model in the model catalog.
+type CatalogModel struct {
+	// Output only. Create time of the resource in millisecond since epoch.
+	CreateTimeSinceEpoch *string `json:"createTimeSinceEpoch,omitempty"`
+	// Output only. Last update time of the resource since epoch in millisecond since epoch.
+	LastUpdateTimeSinceEpoch *string `json:"lastUpdateTimeSinceEpoch,omitempty"`
+	// Human-readable description of the model.
+	Description *string `json:"description,omitempty"`
+	// Model documentation in Markdown.
+	Readme *string `json:"readme,omitempty"`
+	// Maturity level of the model.
+	Maturity *string `json:"maturity,omitempty"`
+	// List of supported languages (https://en.wikipedia.org/wiki/List_of_ISO_639_language_codes).
+	Language []string `json:"language,omitempty"`
+	// List of tasks the model is designed for.
+	Tasks []string `json:"tasks,omitempty"`
+	// Name of the organization or entity that provides the model.
+	Provider *string `json:"provider,omitempty"`
+	// URL to the model's logo. A [data URL](https://developer.mozilla.org/en-US/docs/Web/URI/Schemes/data) is recommended.
+	Logo *string `json:"logo,omitempty"`
+	// Short name of the model's license.
+	License *string `json:"license,omitempty"`
+	// URL to the license text.
+	LicenseLink *string `json:"licenseLink,omitempty"`
+	LibraryName *string `json:"libraryName,omitempty"`
+	// User provided custom properties which are not defined by its type.
+	CustomProperties *map[string]MetadataValue `json:"customProperties,omitempty"`
+	// Name of the model. Must be unique within a source.
+	Name string `json:"name"`
+	// ID of the source this model belongs to.
+	SourceId *string `json:"source_id,omitempty"`
+}
+
+// NewCatalogModel instantiates a new CatalogModel object
+// This constructor will assign default values to properties that have it defined,
+// and makes sure properties required by API are set, but the set of arguments
+// will change when the set of required properties is changed
+func NewCatalogModel(name string) *CatalogModel {
+	this := CatalogModel{}
+	this.Name = name
+	return &this
+}
+
+// NewCatalogModelWithDefaults instantiates a new CatalogModel object
+// This constructor will only assign default values to properties that have it defined,
+// but it doesn't guarantee that properties required by API are set
+func NewCatalogModelWithDefaults() *CatalogModel {
+	this := CatalogModel{}
+	return &this
+}
+
+// GetCreateTimeSinceEpoch returns the CreateTimeSinceEpoch field value if set, zero value otherwise.
+func (o *CatalogModel) GetCreateTimeSinceEpoch() string {
+	if o == nil || IsNil(o.CreateTimeSinceEpoch) {
+		var ret string
+		return ret
+	}
+	return *o.CreateTimeSinceEpoch
+}
+
+// GetCreateTimeSinceEpochOk returns a tuple with the CreateTimeSinceEpoch field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *CatalogModel) GetCreateTimeSinceEpochOk() (*string, bool) {
+	if o == nil || IsNil(o.CreateTimeSinceEpoch) {
+		return nil, false
+	}
+	return o.CreateTimeSinceEpoch, true
+}
+
+// HasCreateTimeSinceEpoch returns a boolean if a field has been set.
+func (o *CatalogModel) HasCreateTimeSinceEpoch() bool {
+	if o != nil && !IsNil(o.CreateTimeSinceEpoch) {
+		return true
+	}
+
+	return false
+}
+
+// SetCreateTimeSinceEpoch gets a reference to the given string and assigns it to the CreateTimeSinceEpoch field.
+func (o *CatalogModel) SetCreateTimeSinceEpoch(v string) {
+	o.CreateTimeSinceEpoch = &v
+}
+
+// GetLastUpdateTimeSinceEpoch returns the LastUpdateTimeSinceEpoch field value if set, zero value otherwise.
+func (o *CatalogModel) GetLastUpdateTimeSinceEpoch() string {
+	if o == nil || IsNil(o.LastUpdateTimeSinceEpoch) {
+		var ret string
+		return ret
+	}
+	return *o.LastUpdateTimeSinceEpoch
+}
+
+// GetLastUpdateTimeSinceEpochOk returns a tuple with the LastUpdateTimeSinceEpoch field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *CatalogModel) GetLastUpdateTimeSinceEpochOk() (*string, bool) {
+	if o == nil || IsNil(o.LastUpdateTimeSinceEpoch) {
+		return nil, false
+	}
+	return o.LastUpdateTimeSinceEpoch, true
+}
+
+// HasLastUpdateTimeSinceEpoch returns a boolean if a field has been set.
+func (o *CatalogModel) HasLastUpdateTimeSinceEpoch() bool {
+	if o != nil && !IsNil(o.LastUpdateTimeSinceEpoch) {
+		return true
+	}
+
+	return false
+}
+
+// SetLastUpdateTimeSinceEpoch gets a reference to the given string and assigns it to the LastUpdateTimeSinceEpoch field.
+func (o *CatalogModel) SetLastUpdateTimeSinceEpoch(v string) {
+	o.LastUpdateTimeSinceEpoch = &v
+}
+
+// GetDescription returns the Description field value if set, zero value otherwise.
+func (o *CatalogModel) GetDescription() string {
+	if o == nil || IsNil(o.Description) {
+		var ret string
+		return ret
+	}
+	return *o.Description
+}
+
+// GetDescriptionOk returns a tuple with the Description field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *CatalogModel) GetDescriptionOk() (*string, bool) {
+	if o == nil || IsNil(o.Description) {
+		return nil, false
+	}
+	return o.Description, true
+}
+
+// HasDescription returns a boolean if a field has been set.
+func (o *CatalogModel) HasDescription() bool {
+	if o != nil && !IsNil(o.Description) {
+		return true
+	}
+
+	return false
+}
+
+// SetDescription gets a reference to the given string and assigns it to the Description field.
+func (o *CatalogModel) SetDescription(v string) {
+	o.Description = &v
+}
+
+// GetReadme returns the Readme field value if set, zero value otherwise.
+func (o *CatalogModel) GetReadme() string {
+	if o == nil || IsNil(o.Readme) {
+		var ret string
+		return ret
+	}
+	return *o.Readme
+}
+
+// GetReadmeOk returns a tuple with the Readme field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *CatalogModel) GetReadmeOk() (*string, bool) {
+	if o == nil || IsNil(o.Readme) {
+		return nil, false
+	}
+	return o.Readme, true
+}
+
+// HasReadme returns a boolean if a field has been set.
+func (o *CatalogModel) HasReadme() bool {
+	if o != nil && !IsNil(o.Readme) {
+		return true
+	}
+
+	return false
+}
+
+// SetReadme gets a reference to the given string and assigns it to the Readme field.
+func (o *CatalogModel) SetReadme(v string) {
+	o.Readme = &v
+}
+
+// GetMaturity returns the Maturity field value if set, zero value otherwise.
+func (o *CatalogModel) GetMaturity() string {
+	if o == nil || IsNil(o.Maturity) {
+		var ret string
+		return ret
+	}
+	return *o.Maturity
+}
+
+// GetMaturityOk returns a tuple with the Maturity field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *CatalogModel) GetMaturityOk() (*string, bool) {
+	if o == nil || IsNil(o.Maturity) {
+		return nil, false
+	}
+	return o.Maturity, true
+}
+
+// HasMaturity returns a boolean if a field has been set.
+func (o *CatalogModel) HasMaturity() bool {
+	if o != nil && !IsNil(o.Maturity) {
+		return true
+	}
+
+	return false
+}
+
+// SetMaturity gets a reference to the given string and assigns it to the Maturity field.
+func (o *CatalogModel) SetMaturity(v string) {
+	o.Maturity = &v
+}
+
+// GetLanguage returns the Language field value if set, zero value otherwise.
+func (o *CatalogModel) GetLanguage() []string {
+	if o == nil || IsNil(o.Language) {
+		var ret []string
+		return ret
+	}
+	return o.Language
+}
+
+// GetLanguageOk returns a tuple with the Language field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *CatalogModel) GetLanguageOk() ([]string, bool) {
+	if o == nil || IsNil(o.Language) {
+		return nil, false
+	}
+	return o.Language, true
+}
+
+// HasLanguage returns a boolean if a field has been set.
+func (o *CatalogModel) HasLanguage() bool {
+	if o != nil && !IsNil(o.Language) {
+		return true
+	}
+
+	return false
+}
+
+// SetLanguage gets a reference to the given []string and assigns it to the Language field.
+func (o *CatalogModel) SetLanguage(v []string) {
+	o.Language = v
+}
+
+// GetTasks returns the Tasks field value if set, zero value otherwise.
+func (o *CatalogModel) GetTasks() []string {
+	if o == nil || IsNil(o.Tasks) {
+		var ret []string
+		return ret
+	}
+	return o.Tasks
+}
+
+// GetTasksOk returns a tuple with the Tasks field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *CatalogModel) GetTasksOk() ([]string, bool) {
+	if o == nil || IsNil(o.Tasks) {
+		return nil, false
+	}
+	return o.Tasks, true
+}
+
+// HasTasks returns a boolean if a field has been set.
+func (o *CatalogModel) HasTasks() bool {
+	if o != nil && !IsNil(o.Tasks) {
+		return true
+	}
+
+	return false
+}
+
+// SetTasks gets a reference to the given []string and assigns it to the Tasks field.
+func (o *CatalogModel) SetTasks(v []string) {
+	o.Tasks = v
+}
+
+// GetProvider returns the Provider field value if set, zero value otherwise.
+func (o *CatalogModel) GetProvider() string {
+	if o == nil || IsNil(o.Provider) {
+		var ret string
+		return ret
+	}
+	return *o.Provider
+}
+
+// GetProviderOk returns a tuple with the Provider field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *CatalogModel) GetProviderOk() (*string, bool) {
+	if o == nil || IsNil(o.Provider) {
+		return nil, false
+	}
+	return o.Provider, true
+}
+
+// HasProvider returns a boolean if a field has been set.
+func (o *CatalogModel) HasProvider() bool {
+	if o != nil && !IsNil(o.Provider) {
+		return true
+	}
+
+	return false
+}
+
+// SetProvider gets a reference to the given string and assigns it to the Provider field.
+func (o *CatalogModel) SetProvider(v string) {
+	o.Provider = &v
+}
+
+// GetLogo returns the Logo field value if set, zero value otherwise.
+func (o *CatalogModel) GetLogo() string {
+	if o == nil || IsNil(o.Logo) {
+		var ret string
+		return ret
+	}
+	return *o.Logo
+}
+
+// GetLogoOk returns a tuple with the Logo field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *CatalogModel) GetLogoOk() (*string, bool) {
+	if o == nil || IsNil(o.Logo) {
+		return nil, false
+	}
+	return o.Logo, true
+}
+
+// HasLogo returns a boolean if a field has been set.
+func (o *CatalogModel) HasLogo() bool {
+	if o != nil && !IsNil(o.Logo) {
+		return true
+	}
+
+	return false
+}
+
+// SetLogo gets a reference to the given string and assigns it to the Logo field.
+func (o *CatalogModel) SetLogo(v string) {
+	o.Logo = &v
+}
+
+// GetLicense returns the License field value if set, zero value otherwise.
+func (o *CatalogModel) GetLicense() string {
+	if o == nil || IsNil(o.License) {
+		var ret string
+		return ret
+	}
+	return *o.License
+}
+
+// GetLicenseOk returns a tuple with the License field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *CatalogModel) GetLicenseOk() (*string, bool) {
+	if o == nil || IsNil(o.License) {
+		return nil, false
+	}
+	return o.License, true
+}
+
+// HasLicense returns a boolean if a field has been set.
+func (o *CatalogModel) HasLicense() bool {
+	if o != nil && !IsNil(o.License) {
+		return true
+	}
+
+	return false
+}
+
+// SetLicense gets a reference to the given string and assigns it to the License field.
+func (o *CatalogModel) SetLicense(v string) {
+	o.License = &v
+}
+
+// GetLicenseLink returns the LicenseLink field value if set, zero value otherwise.
+func (o *CatalogModel) GetLicenseLink() string {
+	if o == nil || IsNil(o.LicenseLink) {
+		var ret string
+		return ret
+	}
+	return *o.LicenseLink
+}
+
+// GetLicenseLinkOk returns a tuple with the LicenseLink field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *CatalogModel) GetLicenseLinkOk() (*string, bool) {
+	if o == nil || IsNil(o.LicenseLink) {
+		return nil, false
+	}
+	return o.LicenseLink, true
+}
+
+// HasLicenseLink returns a boolean if a field has been set.
+func (o *CatalogModel) HasLicenseLink() bool {
+	if o != nil && !IsNil(o.LicenseLink) {
+		return true
+	}
+
+	return false
+}
+
+// SetLicenseLink gets a reference to the given string and assigns it to the LicenseLink field.
+func (o *CatalogModel) SetLicenseLink(v string) {
+	o.LicenseLink = &v
+}
+
+// GetLibraryName returns the LibraryName field value if set, zero value otherwise.
+func (o *CatalogModel) GetLibraryName() string {
+	if o == nil || IsNil(o.LibraryName) {
+		var ret string
+		return ret
+	}
+	return *o.LibraryName
+}
+
+// GetLibraryNameOk returns a tuple with the LibraryName field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *CatalogModel) GetLibraryNameOk() (*string, bool) {
+	if o == nil || IsNil(o.LibraryName) {
+		return nil, false
+	}
+	return o.LibraryName, true
+}
+
+// HasLibraryName returns a boolean if a field has been set.
+func (o *CatalogModel) HasLibraryName() bool {
+	if o != nil && !IsNil(o.LibraryName) {
+		return true
+	}
+
+	return false
+}
+
+// SetLibraryName gets a reference to the given string and assigns it to the LibraryName field.
+func (o *CatalogModel) SetLibraryName(v string) {
+	o.LibraryName = &v
+}
+
+// GetCustomProperties returns the CustomProperties field value if set, zero value otherwise.
+func (o *CatalogModel) GetCustomProperties() map[string]MetadataValue {
+	if o == nil || IsNil(o.CustomProperties) {
+		var ret map[string]MetadataValue
+		return ret
+	}
+	return *o.CustomProperties
+}
+
+// GetCustomPropertiesOk returns a tuple with the CustomProperties field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *CatalogModel) GetCustomPropertiesOk() (*map[string]MetadataValue, bool) {
+	if o == nil || IsNil(o.CustomProperties) {
+		return nil, false
+	}
+	return o.CustomProperties, true
+}
+
+// HasCustomProperties returns a boolean if a field has been set.
+func (o *CatalogModel) HasCustomProperties() bool {
+	if o != nil && !IsNil(o.CustomProperties) {
+		return true
+	}
+
+	return false
+}
+
+// SetCustomProperties gets a reference to the given map[string]MetadataValue and assigns it to the CustomProperties field.
+func (o *CatalogModel) SetCustomProperties(v map[string]MetadataValue) {
+	o.CustomProperties = &v
+}
+
+// GetName returns the Name field value
+func (o *CatalogModel) GetName() string {
+	if o == nil {
+		var ret string
+		return ret
+	}
+
+	return o.Name
+}
+
+// GetNameOk returns a tuple with the Name field value
+// and a boolean to check if the value has been set.
+func (o *CatalogModel) GetNameOk() (*string, bool) {
+	if o == nil {
+		return nil, false
+	}
+	return &o.Name, true
+}
+
+// SetName sets field value
+func (o *CatalogModel) SetName(v string) {
+	o.Name = v
+}
+
+// GetSourceId returns the SourceId field value if set, zero value otherwise.
+func (o *CatalogModel) GetSourceId() string {
+	if o == nil || IsNil(o.SourceId) {
+		var ret string
+		return ret
+	}
+	return *o.SourceId
+}
+
+// GetSourceIdOk returns a tuple with the SourceId field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *CatalogModel) GetSourceIdOk() (*string, bool) {
+	if o == nil || IsNil(o.SourceId) {
+		return nil, false
+	}
+	return o.SourceId, true
+}
+
+// HasSourceId returns a boolean if a field has been set.
+func (o *CatalogModel) HasSourceId() bool {
+	if o != nil && !IsNil(o.SourceId) {
+		return true
+	}
+
+	return false
+}
+
+// SetSourceId gets a reference to the given string and assigns it to the SourceId field.
+func (o *CatalogModel) SetSourceId(v string) {
+	o.SourceId = &v
+}
+
+func (o CatalogModel) MarshalJSON() ([]byte, error) {
+	toSerialize, err := o.ToMap()
+	if err != nil {
+		return []byte{}, err
+	}
+	return json.Marshal(toSerialize)
+}
+
+func (o CatalogModel) ToMap() (map[string]interface{}, error) {
+	toSerialize := map[string]interface{}{}
+	if !IsNil(o.CreateTimeSinceEpoch) {
+		toSerialize["createTimeSinceEpoch"] = o.CreateTimeSinceEpoch
+	}
+	if !IsNil(o.LastUpdateTimeSinceEpoch) {
+		toSerialize["lastUpdateTimeSinceEpoch"] = o.LastUpdateTimeSinceEpoch
+	}
+	if !IsNil(o.Description) {
+		toSerialize["description"] = o.Description
+	}
+	if !IsNil(o.Readme) {
+		toSerialize["readme"] = o.Readme
+	}
+	if !IsNil(o.Maturity) {
+		toSerialize["maturity"] = o.Maturity
+	}
+	if !IsNil(o.Language) {
+		toSerialize["language"] = o.Language
+	}
+	if !IsNil(o.Tasks) {
+		toSerialize["tasks"] = o.Tasks
+	}
+	if !IsNil(o.Provider) {
+		toSerialize["provider"] = o.Provider
+	}
+	if !IsNil(o.Logo) {
+		toSerialize["logo"] = o.Logo
+	}
+	if !IsNil(o.License) {
+		toSerialize["license"] = o.License
+	}
+	if !IsNil(o.LicenseLink) {
+		toSerialize["licenseLink"] = o.LicenseLink
+	}
+	if !IsNil(o.LibraryName) {
+		toSerialize["libraryName"] = o.LibraryName
+	}
+	if !IsNil(o.CustomProperties) {
+		toSerialize["customProperties"] = o.CustomProperties
+	}
+	toSerialize["name"] = o.Name
+	if !IsNil(o.SourceId) {
+		toSerialize["source_id"] = o.SourceId
+	}
+	return toSerialize, nil
+}
+
+type NullableCatalogModel struct {
+	value *CatalogModel
+	isSet bool
+}
+
+func (v NullableCatalogModel) Get() *CatalogModel {
+	return v.value
+}
+
+func (v *NullableCatalogModel) Set(val *CatalogModel) {
+	v.value = val
+	v.isSet = true
+}
+
+func (v NullableCatalogModel) IsSet() bool {
+	return v.isSet
+}
+
+func (v *NullableCatalogModel) Unset() {
+	v.value = nil
+	v.isSet = false
+}
+
+func NewNullableCatalogModel(val *CatalogModel) *NullableCatalogModel {
+	return &NullableCatalogModel{value: val, isSet: true}
+}
+
+func (v NullableCatalogModel) MarshalJSON() ([]byte, error) {
+	return json.Marshal(v.value)
+}
+
+func (v *NullableCatalogModel) UnmarshalJSON(src []byte) error {
+	v.isSet = true
+	return json.Unmarshal(src, &v.value)
+}

catalog/pkg/openapi/model_catalog_model_artifact.go

@@ -0,0 +1,227 @@
+/*
+Model Catalog REST API
+
+REST API for Model Registry to create and manage ML model metadata
+
+API version: v1alpha1
+*/
+
+// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
+
+package openapi
+
+import (
+	"encoding/json"
+)
+
+// checks if the CatalogModelArtifact type satisfies the MappedNullable interface at compile time
+var _ MappedNullable = &CatalogModelArtifact{}
+
+// CatalogModelArtifact A single artifact for a catalog model.
+type CatalogModelArtifact struct {
+	// Output only. Create time of the resource in millisecond since epoch.
+	CreateTimeSinceEpoch *string `json:"createTimeSinceEpoch,omitempty"`
+	// Output only. Last update time of the resource since epoch in millisecond since epoch.
+	LastUpdateTimeSinceEpoch *string `json:"lastUpdateTimeSinceEpoch,omitempty"`
+	// URI where the artifact can be retrieved.
+	Uri string `json:"uri"`
+	// User provided custom properties which are not defined by its type.
+	CustomProperties *map[string]MetadataValue `json:"customProperties,omitempty"`
+}
+
+// NewCatalogModelArtifact instantiates a new CatalogModelArtifact object
+// This constructor will assign default values to properties that have it defined,
+// and makes sure properties required by API are set, but the set of arguments
+// will change when the set of required properties is changed
+func NewCatalogModelArtifact(uri string) *CatalogModelArtifact {
+	this := CatalogModelArtifact{}
+	this.Uri = uri
+	return &this
+}
+
+// NewCatalogModelArtifactWithDefaults instantiates a new CatalogModelArtifact object
+// This constructor will only assign default values to properties that have it defined,
+// but it doesn't guarantee that properties required by API are set
+func NewCatalogModelArtifactWithDefaults() *CatalogModelArtifact {
+	this := CatalogModelArtifact{}
+	return &this
+}
+
+// GetCreateTimeSinceEpoch returns the CreateTimeSinceEpoch field value if set, zero value otherwise.
+func (o *CatalogModelArtifact) GetCreateTimeSinceEpoch() string {
+	if o == nil || IsNil(o.CreateTimeSinceEpoch) {
+		var ret string
+		return ret
+	}
+	return *o.CreateTimeSinceEpoch
+}
+
+// GetCreateTimeSinceEpochOk returns a tuple with the CreateTimeSinceEpoch field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *CatalogModelArtifact) GetCreateTimeSinceEpochOk() (*string, bool) {
+	if o == nil || IsNil(o.CreateTimeSinceEpoch) {
+		return nil, false
+	}
+	return o.CreateTimeSinceEpoch, true
+}
+
+// HasCreateTimeSinceEpoch returns a boolean if a field has been set.
+func (o *CatalogModelArtifact) HasCreateTimeSinceEpoch() bool {
+	if o != nil && !IsNil(o.CreateTimeSinceEpoch) {
+		return true
+	}
+
+	return false
+}
+
+// SetCreateTimeSinceEpoch gets a reference to the given string and assigns it to the CreateTimeSinceEpoch field.
+func (o *CatalogModelArtifact) SetCreateTimeSinceEpoch(v string) {
+	o.CreateTimeSinceEpoch = &v
+}
+
+// GetLastUpdateTimeSinceEpoch returns the LastUpdateTimeSinceEpoch field value if set, zero value otherwise.
+func (o *CatalogModelArtifact) GetLastUpdateTimeSinceEpoch() string {
+	if o == nil || IsNil(o.LastUpdateTimeSinceEpoch) {
+		var ret string
+		return ret
+	}
+	return *o.LastUpdateTimeSinceEpoch
+}
+
+// GetLastUpdateTimeSinceEpochOk returns a tuple with the LastUpdateTimeSinceEpoch field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *CatalogModelArtifact) GetLastUpdateTimeSinceEpochOk() (*string, bool) {
+	if o == nil || IsNil(o.LastUpdateTimeSinceEpoch) {
+		return nil, false
+	}
+	return o.LastUpdateTimeSinceEpoch, true
+}
+
+// HasLastUpdateTimeSinceEpoch returns a boolean if a field has been set.
+func (o *CatalogModelArtifact) HasLastUpdateTimeSinceEpoch() bool {
+	if o != nil && !IsNil(o.LastUpdateTimeSinceEpoch) {
+		return true
+	}
+
+	return false
+}
+
+// SetLastUpdateTimeSinceEpoch gets a reference to the given string and assigns it to the LastUpdateTimeSinceEpoch field.
+func (o *CatalogModelArtifact) SetLastUpdateTimeSinceEpoch(v string) {
+	o.LastUpdateTimeSinceEpoch = &v
+}
+
+// GetUri returns the Uri field value
+func (o *CatalogModelArtifact) GetUri() string {
+	if o == nil {
+		var ret string
+		return ret
+	}
+
+	return o.Uri
+}
+
+// GetUriOk returns a tuple with the Uri field value
+// and a boolean to check if the value has been set.
+func (o *CatalogModelArtifact) GetUriOk() (*string, bool) {
+	if o == nil {
+		return nil, false
+	}
+	return &o.Uri, true
+}
+
+// SetUri sets field value
+func (o *CatalogModelArtifact) SetUri(v string) {
+	o.Uri = v
+}
+
+// GetCustomProperties returns the CustomProperties field value if set, zero value otherwise.
+func (o *CatalogModelArtifact) GetCustomProperties() map[string]MetadataValue {
+	if o == nil || IsNil(o.CustomProperties) {
+		var ret map[string]MetadataValue
+		return ret
+	}
+	return *o.CustomProperties
+}
+
+// GetCustomPropertiesOk returns a tuple with the CustomProperties field value if set, nil otherwise
+// and a boolean to check if the value has been set.
+func (o *CatalogModelArtifact) GetCustomPropertiesOk() (*map[string]MetadataValue, bool) {
+	if o == nil || IsNil(o.CustomProperties) {
+		return nil, false
+	}
+	return o.CustomProperties, true
+}
+
+// HasCustomProperties returns a boolean if a field has been set.
+func (o *CatalogModelArtifact) HasCustomProperties() bool {
+	if o != nil && !IsNil(o.CustomProperties) {
+		return true
+	}
+
+	return false
+}
+
+// SetCustomProperties gets a reference to the given map[string]MetadataValue and assigns it to the CustomProperties field.
+func (o *CatalogModelArtifact) SetCustomProperties(v map[string]MetadataValue) {
+	o.CustomProperties = &v
+}
+
+func (o CatalogModelArtifact) MarshalJSON() ([]byte, error) {
+	toSerialize, err := o.ToMap()
+	if err != nil {
+		return []byte{}, err
+	}
+	return json.Marshal(toSerialize)
+}
+
+func (o CatalogModelArtifact) ToMap() (map[string]interface{}, error) {
+	toSerialize := map[string]interface{}{}
+	if !IsNil(o.CreateTimeSinceEpoch) {
+		toSerialize["createTimeSinceEpoch"] = o.CreateTimeSinceEpoch
+	}
+	if !IsNil(o.LastUpdateTimeSinceEpoch) {
+		toSerialize["lastUpdateTimeSinceEpoch"] = o.LastUpdateTimeSinceEpoch
+	}
+	toSerialize["uri"] = o.Uri
+	if !IsNil(o.CustomProperties) {
+		toSerialize["customProperties"] = o.CustomProperties
+	}
+	return toSerialize, nil
+}
+
+type NullableCatalogModelArtifact struct {
+	value *CatalogModelArtifact
+	isSet bool
+}
+
+func (v NullableCatalogModelArtifact) Get() *CatalogModelArtifact {
+	return v.value
+}
+
+func (v *NullableCatalogModelArtifact) Set(val *CatalogModelArtifact) {
+	v.value = val
+	v.isSet = true
+}
+
+func (v NullableCatalogModelArtifact) IsSet() bool {
+	return v.isSet
+}
+
+func (v *NullableCatalogModelArtifact) Unset() {
+	v.value = nil
+	v.isSet = false
+}
+
+func NewNullableCatalogModelArtifact(val *CatalogModelArtifact) *NullableCatalogModelArtifact {
+	return &NullableCatalogModelArtifact{value: val, isSet: true}
+}
+
+func (v NullableCatalogModelArtifact) MarshalJSON() ([]byte, error) {
+	return json.Marshal(v.value)
+}
+
+func (v *NullableCatalogModelArtifact) UnmarshalJSON(src []byte) error {
+	v.isSet = true
+	return json.Unmarshal(src, &v.value)
+}

catalog/pkg/openapi/model_catalog_model_artifact_list.go

@@ -0,0 +1,200 @@
+/*
+Model Catalog REST API
+
+REST API for Model Registry to create and manage ML model metadata
+
+API version: v1alpha1
+*/
+
+// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
+
+package openapi
+
+import (
+	"encoding/json"
+)
+
+// checks if the CatalogModelArtifactList type satisfies the MappedNullable interface at compile time
+var _ MappedNullable = &CatalogModelArtifactList{}
+
+// CatalogModelArtifactList List of CatalogModel entities.
+type CatalogModelArtifactList struct {
+	// Token to use to retrieve next page of results.
+	NextPageToken string `json:"nextPageToken"`
+	// Maximum number of resources to return in the result.
+	PageSize int32 `json:"pageSize"`
+	// Number of items in result list.
+	Size int32 `json:"size"`
+	// Array of `CatalogModelArtifact` entities.
+	Items []CatalogModelArtifact `json:"items"`
+}
+
+// NewCatalogModelArtifactList instantiates a new CatalogModelArtifactList object
+// This constructor will assign default values to properties that have it defined,
+// and makes sure properties required by API are set, but the set of arguments
+// will change when the set of required properties is changed
+func NewCatalogModelArtifactList(nextPageToken string, pageSize int32, size int32, items []CatalogModelArtifact) *CatalogModelArtifactList {
+	this := CatalogModelArtifactList{}
+	this.NextPageToken = nextPageToken
+	this.PageSize = pageSize
+	this.Size = size
+	this.Items = items
+	return &this
+}
+
+// NewCatalogModelArtifactListWithDefaults instantiates a new CatalogModelArtifactList object
+// This constructor will only assign default values to properties that have it defined,
+// but it doesn't guarantee that properties required by API are set
+func NewCatalogModelArtifactListWithDefaults() *CatalogModelArtifactList {
+	this := CatalogModelArtifactList{}
+	return &this
+}
+
+// GetNextPageToken returns the NextPageToken field value
+func (o *CatalogModelArtifactList) GetNextPageToken() string {
+	if o == nil {
+		var ret string
+		return ret
+	}
+
+	return o.NextPageToken
+}
+
+// GetNextPageTokenOk returns a tuple with the NextPageToken field value
+// and a boolean to check if the value has been set.
+func (o *CatalogModelArtifactList) GetNextPageTokenOk() (*string, bool) {
+	if o == nil {
+		return nil, false
+	}
+	return &o.NextPageToken, true
+}
+
+// SetNextPageToken sets field value
+func (o *CatalogModelArtifactList) SetNextPageToken(v string) {
+	o.NextPageToken = v
+}
+
+// GetPageSize returns the PageSize field value
+func (o *CatalogModelArtifactList) GetPageSize() int32 {
+	if o == nil {
+		var ret int32
+		return ret
+	}
+
+	return o.PageSize
+}
+
+// GetPageSizeOk returns a tuple with the PageSize field value
+// and a boolean to check if the value has been set.
+func (o *CatalogModelArtifactList) GetPageSizeOk() (*int32, bool) {
+	if o == nil {
+		return nil, false
+	}
+	return &o.PageSize, true
+}
+
+// SetPageSize sets field value
+func (o *CatalogModelArtifactList) SetPageSize(v int32) {
+	o.PageSize = v
+}
+
+// GetSize returns the Size field value
+func (o *CatalogModelArtifactList) GetSize() int32 {
+	if o == nil {
+		var ret int32
+		return ret
+	}
+
+	return o.Size
+}
+
+// GetSizeOk returns a tuple with the Size field value
+// and a boolean to check if the value has been set.
+func (o *CatalogModelArtifactList) GetSizeOk() (*int32, bool) {
+	if o == nil {
+		return nil, false
+	}
+	return &o.Size, true
+}
+
+// SetSize sets field value
+func (o *CatalogModelArtifactList) SetSize(v int32) {
+	o.Size = v
+}
+
+// GetItems returns the Items field value
+func (o *CatalogModelArtifactList) GetItems() []CatalogModelArtifact {
+	if o == nil {
+		var ret []CatalogModelArtifact
+		return ret
+	}
+
+	return o.Items
+}
+
+// GetItemsOk returns a tuple with the Items field value
+// and a boolean to check if the value has been set.
+func (o *CatalogModelArtifactList) GetItemsOk() ([]CatalogModelArtifact, bool) {
+	if o == nil {
+		return nil, false
+	}
+	return o.Items, true
+}
+
+// SetItems sets field value
+func (o *CatalogModelArtifactList) SetItems(v []CatalogModelArtifact) {
+	o.Items = v
+}
+
+func (o CatalogModelArtifactList) MarshalJSON() ([]byte, error) {
+	toSerialize, err := o.ToMap()
+	if err != nil {
+		return []byte{}, err
+	}
+	return json.Marshal(toSerialize)
+}
+
+func (o CatalogModelArtifactList) ToMap() (map[string]interface{}, error) {
+	toSerialize := map[string]interface{}{}
+	toSerialize["nextPageToken"] = o.NextPageToken
+	toSerialize["pageSize"] = o.PageSize
+	toSerialize["size"] = o.Size
+	toSerialize["items"] = o.Items
+	return toSerialize, nil
+}
+
+type NullableCatalogModelArtifactList struct {
+	value *CatalogModelArtifactList
+	isSet bool
+}
+
+func (v NullableCatalogModelArtifactList) Get() *CatalogModelArtifactList {
+	return v.value
+}
+
+func (v *NullableCatalogModelArtifactList) Set(val *CatalogModelArtifactList) {
+	v.value = val
+	v.isSet = true
+}
+
+func (v NullableCatalogModelArtifactList) IsSet() bool {
+	return v.isSet
+}
+
+func (v *NullableCatalogModelArtifactList) Unset() {
+	v.value = nil
+	v.isSet = false
+}
+
+func NewNullableCatalogModelArtifactList(val *CatalogModelArtifactList) *NullableCatalogModelArtifactList {
+	return &NullableCatalogModelArtifactList{value: val, isSet: true}
+}
+
+func (v NullableCatalogModelArtifactList) MarshalJSON() ([]byte, error) {
+	return json.Marshal(v.value)
+}
+
+func (v *NullableCatalogModelArtifactList) UnmarshalJSON(src []byte) error {
+	v.isSet = true
+	return json.Unmarshal(src, &v.value)
+}